auracaster/sw_openocd
3
0
Fork 0
forked from auracaster/openocd
Code Pull Requests Activity

- minimum autoconf 2.59 is now required and verified - due to issues with AS_HELP_STRING

Browse Source 
- native win32 now handles WSAECONNRESET - no longer exits openocd
- qCRC packet now works correctly under cygwin (gdb compare-sections command)
- removed __USE_GNU define from gdbserver.c
- gdb qSupported packet is now handled, with this we are able to tell gdb packet size, memory map of target
- added new target script gdb_program_config - called before gdb flash programming
- new gdb server command gdb_memory_map (enable|disable> - default is disable
- new gdb server command gdb_flash_program (enable|disable> - default is disable
- gdb flash programming supported - vFlash packets
- image_elf_read_section now does not clear any remaining data, this was causing the gdb checksum to fail with certain files
- reformat of usbprog.c
- memory leak in command_print fixed
- updated texi doc to include new commands
- added gdb programming section to docs

git-svn-id: svn://svn.berlios.de/openocd/trunk@246 b42882b7-edfa-0310-969c-e2dbd0fdcd60
This commit is contained in:
ntfreak
2007-12-29 13:51:48 +00:00
parent 2ec5bd2864
commit 6c9b804d61
12 changed files with 791 additions and 373 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/flash/flash.c
+20 -8
View File
@@ -393,6 +393,9 @@ int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *
return ERROR_INVALID_ARGUMENTS;
}
/* We can't know if we did a resume + halt, in which case we no longer know the erased state */
flash_set_dirty();
duration_start_measure(&duration);
if ((retval = flash_erase(target, address, length)) != ERROR_OK)
@@ -766,6 +769,21 @@ int handle_flash_write_binary_command(struct command_context_s *cmd_ctx, char *c
return ERROR_OK;
}
void flash_set_dirty(void)
{
flash_bank_t *c;
int i;
/* set all flash to require erasing */
for (c = flash_banks; c; c = c->next)
{
for (i = 0; i < c->num_sectors; i++)
{
c->sectors[i].is_erased = 0;
}
}
}
/* lookup flash bank by address */
flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
{
@@ -852,14 +870,8 @@ int flash_write(target_t *target, image_t *image, u32 *written, char **error_str
{
/* assume all sectors need erasing - stops any problems
* when flash_write is called multiple times */
for (c = flash_banks; c; c = c->next)
{
for (i = 0; i < c->num_sectors; i++)
{
c->sectors[i].is_erased = 0;
}
}
flash_set_dirty();
}
/* loop until we reach end of the image */
src/flash/flash.h
+1
View File
@@ -68,6 +68,7 @@ extern int flash_init(struct command_context_s *cmd_ctx);
extern int flash_erase(target_t *target, u32 addr, u32 length);
extern int flash_write(target_t *target, image_t *image, u32 *written, char **error, int *failed, int erase);
extern void flash_set_dirty(void);
extern flash_bank_t *get_flash_bank_by_num(int num);
extern flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr);
src/helper/command.c
+29 -21
View File
@@ -200,25 +200,24 @@ int parse_line(char *line, char *words[], int max_words)
/* we're inside a word or quote, and reached its end*/
if (word_start)
{
int len;
char *word_end=p;
/* This will handle extra whitespace within quotes */
while (isspace(*word_start)&&(word_start<word_end))
word_start++;
while (isspace(*(word_end-1))&&(word_start<word_end))
word_end--;
len = word_end - word_start;
if (len>0)
{
/* copy the word */
memcpy(words[nwords] = malloc(len + 1), word_start, len);
/* add terminating NUL */
words[nwords++][len] = 0;
}
int len;
char *word_end=p;
/* This will handle extra whitespace within quotes */
while (isspace(*word_start)&&(word_start<word_end))
word_start++;
while (isspace(*(word_end-1))&&(word_start<word_end))
word_end--;
len = word_end - word_start;
if (len>0)
{
/* copy the word */
memcpy(words[nwords] = malloc(len + 1), word_start, len);
/* add terminating NUL */
words[nwords++][len] = 0;
}
}
/* we're done parsing the line */
if (!*p)
break;
@@ -226,9 +225,9 @@ int parse_line(char *line, char *words[], int max_words)
/* skip over trailing quote or whitespace*/
if (inquote || isspace(*p))
p++;
while (isspace(*p))
p++;
while (isspace(*p))
p++;
inquote = 0;
word_start = 0;
}
@@ -267,14 +266,23 @@ void command_print(command_context_t *context, char *format, ...)
{
/* increase buffer until it fits the whole string */
if (!(p = realloc(buffer, size += 4096)))
{
/* gotta free up */
if (buffer)
free(buffer);
return;
}
buffer = p;
}
/* vsnprintf failed */
if (n < 0)
{
if (buffer)
free(buffer);
return;
}
p = buffer;
src/jtag/usbprog.c
+302 -296
View File
@@ -1,14 +1,14 @@
/***************************************************************************
* Copyright (C) 2007 by Benedikt Sauter sauter@ixbat.de *
* based on Dominic Rath's amt_jtagaccel.c *
* *
* usbprog is a free programming adapter. You can easily install *
* different firmware versions from an "online pool" over USB. *
* The adapter can be used for programming and debugging AVR and ARM *
* processors, as USB to RS232 converter, as JTAG interface or as *
* simple I/O interface (5 lines). *
* *
* http://www.embedded-projects.net/usbprog *
* Copyright (C) 2007 by Benedikt Sauter sauter@ixbat.de *
* based on Dominic Rath's amt_jtagaccel.c *
* *
* usbprog is a free programming adapter. You can easily install *
* different firmware versions from an "online pool" over USB. *
* The adapter can be used for programming and debugging AVR and ARM *
* processors, as USB to RS232 converter, as JTAG interface or as *
* simple I/O interface (5 lines). *
* *
* http://www.embedded-projects.net/usbprog *
* *
* 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 *
@@ -42,7 +42,7 @@
#define VID 0x1781
#define PID 0x0c63
// Pins at usbprog
/* Pins at usbprog */
#define TDO_BIT 0
#define TDI_BIT 3
#define TCK_BIT 2
@@ -54,7 +54,6 @@ int usbprog_register_commands(struct command_context_s *cmd_ctx);
int usbprog_init(void);
int usbprog_quit(void);
void usbprog_end_state(enum tap_state state);
void usbprog_state_move(void);
void usbprog_path_move(pathmove_command_t *cmd);
@@ -96,7 +95,6 @@ void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag);
void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag);
unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen);
void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
@@ -126,111 +124,110 @@ int usbprog_register_commands(struct command_context_s *cmd_ctx)
return ERROR_OK;
}
int usbprog_execute_queue(void)
{
jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
int scan_size;
enum scan_type type;
u8 *buffer;
while (cmd)
{
switch (cmd->type)
{
case JTAG_END_STATE:
jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
int scan_size;
enum scan_type type;
u8 *buffer;
while (cmd)
{
switch (cmd->type)
{
case JTAG_END_STATE:
#ifdef _DEBUG_JTAG_IO_
DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
#endif
if (cmd->cmd.end_state->end_state != -1)
usbprog_end_state(cmd->cmd.end_state->end_state);
break;
case JTAG_RESET:
if (cmd->cmd.end_state->end_state != -1)
usbprog_end_state(cmd->cmd.end_state->end_state);
break;
case JTAG_RESET:
#ifdef _DEBUG_JTAG_IO_
DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
#endif
if (cmd->cmd.reset->trst == 1)
{
cur_state = TAP_TLR;
}
usbprog_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
break;
case JTAG_RUNTEST:
if (cmd->cmd.reset->trst == 1)
{
cur_state = TAP_TLR;
}
usbprog_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
break;
case JTAG_RUNTEST:
#ifdef _DEBUG_JTAG_IO_
DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
#endif
if (cmd->cmd.runtest->end_state != -1)
usbprog_end_state(cmd->cmd.runtest->end_state);
usbprog_runtest(cmd->cmd.runtest->num_cycles);
break;
case JTAG_STATEMOVE:
if (cmd->cmd.runtest->end_state != -1)
usbprog_end_state(cmd->cmd.runtest->end_state);
usbprog_runtest(cmd->cmd.runtest->num_cycles);
break;
case JTAG_STATEMOVE:
#ifdef _DEBUG_JTAG_IO_
DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
#endif
if (cmd->cmd.statemove->end_state != -1)
usbprog_end_state(cmd->cmd.statemove->end_state);
usbprog_state_move();
break;
case JTAG_PATHMOVE:
if (cmd->cmd.statemove->end_state != -1)
usbprog_end_state(cmd->cmd.statemove->end_state);
usbprog_state_move();
break;
case JTAG_PATHMOVE:
#ifdef _DEBUG_JTAG_IO_
DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states,
cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states,
cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
#endif
usbprog_path_move(cmd->cmd.pathmove);
break;
case JTAG_SCAN:
usbprog_path_move(cmd->cmd.pathmove);
break;
case JTAG_SCAN:
#ifdef _DEBUG_JTAG_IO_
DEBUG("scan end in %i", cmd->cmd.scan->end_state);
DEBUG("scan end in %i", cmd->cmd.scan->end_state);
#endif
if (cmd->cmd.scan->end_state != -1)
usbprog_end_state(cmd->cmd.scan->end_state);
scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
type = jtag_scan_type(cmd->cmd.scan);
usbprog_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
return ERROR_JTAG_QUEUE_FAILED;
if (buffer)
free(buffer);
break;
case JTAG_SLEEP:
if (cmd->cmd.scan->end_state != -1)
usbprog_end_state(cmd->cmd.scan->end_state);
scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
type = jtag_scan_type(cmd->cmd.scan);
usbprog_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
return ERROR_JTAG_QUEUE_FAILED;
if (buffer)
free(buffer);
break;
case JTAG_SLEEP:
#ifdef _DEBUG_JTAG_IO_
DEBUG("sleep %i", cmd->cmd.sleep->us);
DEBUG("sleep %i", cmd->cmd.sleep->us);
#endif
jtag_sleep(cmd->cmd.sleep->us);
break;
default:
ERROR("BUG: unknown JTAG command type encountered");
exit(-1);
}
cmd = cmd->next;
}
return ERROR_OK;
jtag_sleep(cmd->cmd.sleep->us);
break;
default:
ERROR("BUG: unknown JTAG command type encountered");
exit(-1);
}
cmd = cmd->next;
}
return ERROR_OK;
}
int usbprog_init(void)
{
usbprog_jtag_handle = usbprog_jtag_open();
tms_chain_index=0;
if(usbprog_jtag_handle==0){
tms_chain_index = 0;
if (usbprog_jtag_handle == 0)
{
ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
return ERROR_JTAG_INIT_FAILED;
}
INFO("USB JTAG Interface ready!");
usbprog_jtag_init(usbprog_jtag_handle);
usbprog_reset(0, 0);
usbprog_write(0, 0, 0);
return ERROR_OK;
}
int usbprog_quit(void)
{
return ERROR_OK;
}
@@ -246,200 +243,194 @@ void usbprog_end_state(enum tap_state state)
}
}
void usbprog_state_move(void) {
int i=0, tms=0;
u8 tms_scan = TAP_MOVE(cur_state, end_state);
usbprog_jtag_write_tms(usbprog_jtag_handle,(char)tms_scan);
for (i = 0; i < 7; i++)
{
tms = (tms_scan >> i) & 1;
}
void usbprog_state_move(void)
{
int i = 0, tms = 0;
u8 tms_scan = TAP_MOVE(cur_state, end_state);
cur_state = end_state;
usbprog_jtag_write_tms(usbprog_jtag_handle, (char)tms_scan);
for (i = 0; i < 7; i++)
{
tms = (tms_scan >> i) & 1;
}
cur_state = end_state;
}
void usbprog_path_move(pathmove_command_t *cmd)
{
int num_states = cmd->num_states;
int state_count;
state_count = 0;
while (num_states)
{
if (tap_transitions[cur_state].low == cmd->path[state_count])
{
int num_states = cmd->num_states;
int state_count;
state_count = 0;
while (num_states)
{
if (tap_transitions[cur_state].low == cmd->path[state_count])
{
//INFO("1");
usbprog_write(0, 0, 0);
usbprog_write(1, 0, 0);
}
else if (tap_transitions[cur_state].high == cmd->path[state_count])
{
usbprog_write(0, 0, 0);
usbprog_write(1, 0, 0);
}
else if (tap_transitions[cur_state].high == cmd->path[state_count])
{
//INFO("2");
usbprog_write(0, 1, 0);
usbprog_write(1, 1, 0);
}
else
{
ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);
exit(-1);
}
cur_state = cmd->path[state_count];
state_count++;
num_states--;
}
end_state = cur_state;
usbprog_write(0, 1, 0);
usbprog_write(1, 1, 0);
}
else
{
ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);
exit(-1);
}
cur_state = cmd->path[state_count];
state_count++;
num_states--;
}
end_state = cur_state;
}
void usbprog_runtest(int num_cycles)
{
int i;
enum tap_state saved_end_state = end_state;
int i;
/* only do a state_move when we're not already in RTI */
if (cur_state != TAP_RTI)
{
usbprog_end_state(TAP_RTI);
usbprog_state_move();
}
/* execute num_cycles */
if(num_cycles>0)
if (cur_state != TAP_RTI)
{
usbprog_end_state(TAP_RTI);
usbprog_state_move();
}
/* execute num_cycles */
if (num_cycles > 0)
{
usbprog_jtag_tms_send(usbprog_jtag_handle);
usbprog_write(0, 0, 0);
}
else {
else
{
usbprog_jtag_tms_send(usbprog_jtag_handle);
//INFO("NUM CYCLES %i",num_cycles);
}
for (i = 0; i < num_cycles; i++)
{
usbprog_write(1, 0, 0);
usbprog_write(0, 0, 0);
}
/* finish in end_state */
for (i = 0; i < num_cycles; i++)
{
usbprog_write(1, 0, 0);
usbprog_write(0, 0, 0);
}
/* finish in end_state */
/*
usbprog_end_state(saved_end_state);
if (cur_state != end_state)
usbprog_state_move();
usbprog_end_state(saved_end_state);
if (cur_state != end_state)
usbprog_state_move();
*/
}
void usbprog_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
{
enum tap_state saved_end_state = end_state;
int bit_cnt;
if (ir_scan)
usbprog_end_state(TAP_SI);
else
usbprog_end_state(TAP_SD);
enum tap_state saved_end_state = end_state;
if (ir_scan)
usbprog_end_state(TAP_SI);
else
usbprog_end_state(TAP_SD);
//usbprog_jtag_tms_send(usbprog_jtag_handle);
usbprog_state_move();
usbprog_end_state(saved_end_state);
usbprog_state_move();
usbprog_end_state(saved_end_state);
usbprog_jtag_tms_send(usbprog_jtag_handle);
if (type == SCAN_OUT) {
usbprog_jtag_write_tdi(usbprog_jtag_handle,buffer, scan_size);
}
if (type == SCAN_IN) {
usbprog_jtag_read_tdo(usbprog_jtag_handle,buffer, scan_size);
}
if (type == SCAN_IO) {
usbprog_jtag_write_and_read(usbprog_jtag_handle,buffer, scan_size);
}
if (ir_scan)
cur_state = TAP_PI;
else
cur_state = TAP_PD;
if (cur_state != end_state)
usbprog_state_move();
if (type == SCAN_OUT)
{
usbprog_jtag_write_tdi(usbprog_jtag_handle,buffer, scan_size);
}
if (type == SCAN_IN)
{
usbprog_jtag_read_tdo(usbprog_jtag_handle,buffer, scan_size);
}
if (type == SCAN_IO)
{
usbprog_jtag_write_and_read(usbprog_jtag_handle,buffer, scan_size);
}
if (ir_scan)
cur_state = TAP_PI;
else
cur_state = TAP_PD;
if (cur_state != end_state)
usbprog_state_move();
}
/*************** jtag wrapper functions *********************/
void usbprog_write(int tck, int tms, int tdi)
{
unsigned char output_value=0x00;
if (tms)
output_value |= (1<<TMS_BIT);
if (tdi)
output_value |= (1<<TDI_BIT);
if (tck)
output_value |= (1<<TCK_BIT);
usbprog_jtag_write_slice(usbprog_jtag_handle,output_value);
unsigned char output_value=0x00;
if (tms)
output_value |= (1<<TMS_BIT);
if (tdi)
output_value |= (1<<TDI_BIT);
if (tck)
output_value |= (1<<TCK_BIT);
usbprog_jtag_write_slice(usbprog_jtag_handle,output_value);
}
/* (1) assert or (0) deassert reset lines */
void usbprog_reset(int trst, int srst)
{
DEBUG("trst: %i, srst: %i", trst, srst);
if(trst)
usbprog_jtag_set_bit(usbprog_jtag_handle,5,0);
else
usbprog_jtag_set_bit(usbprog_jtag_handle,5,1);
if(srst)
usbprog_jtag_set_bit(usbprog_jtag_handle,4,0);
else
usbprog_jtag_set_bit(usbprog_jtag_handle,4,1);
DEBUG("trst: %i, srst: %i", trst, srst);
if (trst)
usbprog_jtag_set_bit(usbprog_jtag_handle, 5, 0);
else
usbprog_jtag_set_bit(usbprog_jtag_handle, 5, 1);
if (srst)
usbprog_jtag_set_bit(usbprog_jtag_handle, 4, 0);
else
usbprog_jtag_set_bit(usbprog_jtag_handle, 4, 1);
}
/*************** jtag lowlevel functions ********************/
struct usb_bus *busses;
struct usb_bus *busses;
struct usbprog_jtag* usbprog_jtag_open()
{
struct usb_dev_handle* usb_handle;
struct usb_bus *bus;
struct usb_device *dev;
struct usbprog_jtag * tmp;
struct usbprog_jtag *tmp;
tmp = (struct usbprog_jtag*)malloc(sizeof(struct usbprog_jtag));
usb_set_debug(10);
usb_set_debug(10);
usb_init();
usb_find_busses();
usb_find_devices();
busses = usb_get_busses();
/* find usbprog_jtag device in usb bus */
for (bus = busses; bus; bus = bus->next){
for (dev = bus->devices; dev; dev = dev->next){
for (bus = busses; bus; bus = bus->next)
{
for (dev = bus->devices; dev; dev = dev->next)
{
/* condition for sucessfully hit (too bad, I only check the vendor id)*/
if (dev->descriptor.idVendor == VID && dev->descriptor.idProduct == PID) {
if (dev->descriptor.idVendor == VID && dev->descriptor.idProduct == PID)
{
tmp->usb_handle = usb_open(dev);
usb_set_configuration (tmp->usb_handle,1);
usb_set_configuration(tmp->usb_handle, 1);
usb_claim_interface(tmp->usb_handle, 0);
usb_set_altinterface(tmp->usb_handle,0);
usb_set_altinterface(tmp->usb_handle, 0);
return tmp;
}
}
@@ -447,22 +438,22 @@ usb_set_debug(10);
return 0;
}
void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag)
{
usb_close(usbprog_jtag->usb_handle);
free(usbprog_jtag);
}
unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen)
{
int res = usb_bulk_write(usbprog_jtag->usb_handle,3,msg,msglen,100);
if(msg[0]==2||msg[0]==1||msg[0]==4||msg[0]==0||msg[0]==6||msg[0]==0x0A||msg[0]==9)
int res = usb_bulk_write(usbprog_jtag->usb_handle, 3, msg,msglen, 100);
if ((msg[0] == 2) || (msg[0] == 1) || (msg[0] == 4) || (msg[0] == 0) || \
(msg[0] == 6) || (msg[0] == 0x0A) || (msg[0] == 9))
return 1;
if(res == msglen) {
if (res == msglen)
{
//INFO("HALLLLOOO %i",(int)msg[0]);
res = usb_bulk_read(usbprog_jtag->usb_handle,0x82, msg, 2, 100);
res = usb_bulk_read(usbprog_jtag->usb_handle, 0x82, msg, 2, 100);
if (res > 0)
return (unsigned char)msg[1];
else
@@ -478,92 +469,103 @@ void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag)
usbprog_jtag_set_direction(usbprog_jtag, 0xFE);
}
void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
{
char tmp[64]; // fastes packet size for usb controller
int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
int send_bits, bufindex = 0, fillindex = 0, i, loops;
char swap;
// 61 byte can be transfered (488 bit)
while(size > 0) {
if(size > 488) {
while (size > 0)
{
if (size > 488)
{
send_bits = 488;
size = size - 488;
loops = 61;
} else {
}
else
{
send_bits = size;
loops = size/8;
loops = size / 8;
loops++;
size = 0;
}
tmp[0] = WRITE_AND_READ;
tmp[1] = (char)(send_bits>>8); // high
tmp[2] = (char)(send_bits); // low
i=0;
for(i=0;i < loops ;i++) {
tmp[3+i]=buffer[bufindex];
tmp[1] = (char)(send_bits >> 8); // high
tmp[2] = (char)(send_bits); // low
i = 0;
for (i = 0; i < loops; i++)
{
tmp[3 + i] = buffer[bufindex];
bufindex++;
}
if(usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,64,1000)==64)
if (usb_bulk_write(usbprog_jtag->usb_handle, 3, tmp, 64, 1000) == 64)
{
//INFO("HALLLLOOO2 %i",(int)tmp[0]);
usleep(1);
int timeout=0;
while(usb_bulk_read(usbprog_jtag->usb_handle,0x82, tmp, 64, 1000) < 1){
int timeout = 0;
while (usb_bulk_read(usbprog_jtag->usb_handle, 0x82, tmp, 64, 1000) < 1)
{
timeout++;
if(timeout>10)
if (timeout > 10)
break;
}
for(i=0;i<loops ;i++) {
swap = tmp[3+i];
for (i = 0; i < loops; i++)
{
swap = tmp[3 + i];
buffer[fillindex++] = swap;
}
}
}
}
void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
{
char tmp[64]; // fastes packet size for usb controller
int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
int send_bits, fillindex = 0, i, loops;
char swap;
// 61 byte can be transfered (488 bit)
while(size > 0) {
if(size > 488) {
while (size > 0)
{
if (size > 488)
{
send_bits = 488;
size = size - 488;
loops = 61;
} else {
}
else
{
send_bits = size;
loops = size/8;
loops = size / 8;
loops++;
size = 0;
}
tmp[0] = WRITE_AND_READ;
tmp[1] = (char)(send_bits>>8); // high
tmp[2] = (char)(send_bits); // low
tmp[1] = (char)(send_bits >> 8); // high
tmp[2] = (char)(send_bits); // low
usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,3,1000);
usb_bulk_write(usbprog_jtag->usb_handle, 3, tmp, 3, 1000);
//INFO("HALLLLOOO3 %i",(int)tmp[0]);
int timeout=0;
int timeout = 0;
usleep(1);
while(usb_bulk_read(usbprog_jtag->usb_handle,0x82, tmp, 64, 10) < 1){
while (usb_bulk_read(usbprog_jtag->usb_handle, 0x82, tmp, 64, 10) < 1)
{
timeout++;
if(timeout>10)
if (timeout > 10)
break;
}
for(i=0;i<loops ;i++) {
swap = tmp[3+i];
for (i = 0; i < loops; i++)
{
swap = tmp[3 + i];
buffer[fillindex++] = swap;
}
}
@@ -572,15 +574,19 @@ void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int
void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
{
char tmp[64]; // fastes packet size for usb controller
int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
char swap;
int send_bits, bufindex = 0, i, loops;
// 61 byte can be transfered (488 bit)
while(size > 0) {
if(size > 488) {
while (size > 0)
{
if (size > 488)
{
send_bits = 488;
size = size - 488;
loops = 61;
} else {
}
else
{
send_bits = size;
loops = size/8;
//if(loops==0)
@@ -588,31 +594,30 @@ void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, in
size = 0;
}
tmp[0] = WRITE_TDI;
tmp[1] = (char)(send_bits>>8); // high
tmp[2] = (char)(send_bits); // low
i=0;
for(i=0;i < loops ;i++) {
tmp[3+i]=buffer[bufindex];
tmp[1] = (char)(send_bits >> 8); // high
tmp[2] = (char)(send_bits); // low
i = 0;
for (i = 0; i < loops; i++)
{
tmp[3 + i] = buffer[bufindex];
bufindex++;
}
usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,64,1000);
usb_bulk_write(usbprog_jtag->usb_handle, 3, tmp, 64, 1000);
}
}
void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan)
{
usbprog_jtag_tms_collect(tms_scan);
}
void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction)
{
char tmp[2];
tmp[0] = PORT_DIRECTION;
tmp[1] = (char)direction;
usbprog_jtag_message(usbprog_jtag,tmp,2);
usbprog_jtag_message(usbprog_jtag, tmp, 2);
}
void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value)
@@ -620,7 +625,7 @@ void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char va
char tmp[2];
tmp[0] = PORT_SET;
tmp[1] = (char)value;
usbprog_jtag_message(usbprog_jtag,tmp,2);
usbprog_jtag_message(usbprog_jtag, tmp, 2);
}
unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag)
@@ -628,20 +633,19 @@ unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag)
char tmp[2];
tmp[0] = PORT_GET;
tmp[1] = 0x00;
return usbprog_jtag_message(usbprog_jtag,tmp,2);
return usbprog_jtag_message(usbprog_jtag, tmp, 2);
}
void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value)
{
char tmp[3];
tmp[0] = PORT_SETBIT;
tmp[1] = (char)bit;
if(value==1)
if (value == 1)
tmp[2] = 0x01;
else
tmp[2] = 0x00;
usbprog_jtag_message(usbprog_jtag,tmp,3);
usbprog_jtag_message(usbprog_jtag, tmp, 3);
}
int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit)
@@ -649,29 +653,31 @@ int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit)
char tmp[2];
tmp[0] = PORT_GETBIT;
tmp[1] = (char)bit;
if(usbprog_jtag_message(usbprog_jtag,tmp,2)>0)
if (usbprog_jtag_message(usbprog_jtag, tmp, 2) > 0)
return 1;
else
return 0;
}
void usbprog_jtag_tms_collect(char tms_scan){
tms_chain[tms_chain_index]=tms_scan;
void usbprog_jtag_tms_collect(char tms_scan)
{
tms_chain[tms_chain_index] = tms_scan;
tms_chain_index++;
}
void usbprog_jtag_tms_send(struct usbprog_jtag *usbprog_jtag){
void usbprog_jtag_tms_send(struct usbprog_jtag *usbprog_jtag)
{
int i;
//INFO("TMS SEND");
if(tms_chain_index>0) {
char tmp[tms_chain_index+2];
if (tms_chain_index > 0)
{
char tmp[tms_chain_index + 2];
tmp[0] = WRITE_TMS_CHAIN;
tmp[1] = (char)(tms_chain_index);
for(i=0;i<tms_chain_index+1;i++)
tmp[2+i] = tms_chain[i];
usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,tms_chain_index+2,1000);
tms_chain_index=0;
for (i = 0; i < tms_chain_index + 1; i++)
tmp[2 + i] = tms_chain[i];
usb_bulk_write(usbprog_jtag->usb_handle, 3, tmp, tms_chain_index + 2, 1000);
tms_chain_index = 0;
}
}
src/server/Makefile.am
+1 -1
View File
@@ -1,4 +1,4 @@
INCLUDES = -I$(top_srcdir)/src/helper -I$(top_srcdir)/src/target -I$(top_srcdir)/src/flash $(all_includes)
INCLUDES = -I$(top_srcdir)/src/helper -I$(top_srcdir)/src/target -I$(top_srcdir)/src/flash -I$(top_srcdir)/src/jtag $(all_includes)
METASOURCES = AUTO
noinst_LIBRARIES = libserver.a
noinst_HEADERS = server.h telnet_server.h gdb_server.h
src/server/gdb_server.c
+318 -12
View File
@@ -28,11 +28,11 @@
#include "server.h"
#include "log.h"
#include "binarybuffer.h"
#include "jtag.h"
#include "breakpoints.h"
#include "flash.h"
#include "target_request.h"
#define __USE_GNU
#include <string.h>
#include <errno.h>
#include <unistd.h>
@@ -52,8 +52,14 @@ enum gdb_detach_mode
GDB_DETACH_NOTHING
};
/* target behaviour on gdb detach */
enum gdb_detach_mode detach_mode = GDB_DETACH_RESUME;
/* set if we are sending a memory map to gdb
* via qXfer:memory-map:read packet */
int gdb_use_memory_map = 0;
int gdb_flash_program = 0;
int gdb_last_signal(target_t *target)
{
switch (target->debug_reason)
@@ -77,7 +83,10 @@ int gdb_last_signal(target_t *target)
int gdb_get_char(connection_t *connection, int* next_char)
{
gdb_connection_t *gdb_con = connection->priv;
#ifdef _DEBUG_GDB_IO_
char *debug_buffer;
#endif
if (gdb_con->buf_cnt-- > 0)
{
@@ -109,6 +118,8 @@ int gdb_get_char(connection_t *connection, int* next_char)
break;
case WSAECONNABORTED:
return ERROR_SERVER_REMOTE_CLOSED;
case WSAECONNRESET:
return ERROR_SERVER_REMOTE_CLOSED;
default:
ERROR("read: %d", errno);
exit(-1);
@@ -130,11 +141,13 @@ int gdb_get_char(connection_t *connection, int* next_char)
#endif
}
#ifdef _DEBUG_GDB_IO_
debug_buffer = malloc(gdb_con->buf_cnt + 1);
memcpy(debug_buffer, gdb_con->buffer, gdb_con->buf_cnt);
debug_buffer[gdb_con->buf_cnt] = 0;
DEBUG("received '%s'", debug_buffer);
free(debug_buffer);
#endif
gdb_con->buf_p = gdb_con->buffer;
gdb_con->buf_cnt--;
@@ -245,7 +258,9 @@ int gdb_get_packet(connection_t *connection, char *buffer, int *len)
if ((retval = gdb_get_char(connection, &character)) != ERROR_OK)
return retval;
#ifdef _DEBUG_GDB_IO_
DEBUG("character: '%c'", character);
#endif
switch (character)
{
@@ -325,9 +340,17 @@ int gdb_get_packet(connection_t *connection, char *buffer, int *len)
int gdb_output(struct command_context_s *context, char* line)
{
connection_t *connection = context->output_handler_priv;
gdb_connection_t *gdb_connection = connection->priv;
char *hex_buffer;
int i, bin_size;
/* check if output is enabled */
if (gdb_connection->output_disable)
{
return ERROR_OK;
}
bin_size = strlen(line);
hex_buffer = malloc(bin_size*2 + 4);
@@ -345,6 +368,30 @@ int gdb_output(struct command_context_s *context, char* line)
return ERROR_OK;
}
int gdb_program_handler(struct target_s *target, enum target_event event, void *priv)
{
FILE *script;
struct command_context_s *cmd_ctx = priv;
if (target->gdb_program_script)
{
script = fopen(target->gdb_program_script, "r");
if (!script)
{
ERROR("couldn't open script file %s", target->gdb_program_script);
return ERROR_OK;
}
INFO("executing gdb_program script '%s'", target->gdb_program_script);
command_run_file(cmd_ctx, script, COMMAND_EXEC);
fclose(script);
jtag_execute_queue();
}
return ERROR_OK;
}
int gdb_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)
{
connection_t *connection = priv;
@@ -378,6 +425,9 @@ int gdb_target_callback_event_handler(struct target_s *target, enum target_event
gdb_connection->frontend_state = TARGET_RUNNING;
}
break;
case TARGET_EVENT_GDB_PROGRAM:
gdb_program_handler(target, event, connection->cmd_ctx);
break;
default:
break;
}
@@ -400,7 +450,8 @@ int gdb_new_connection(connection_t *connection)
gdb_connection->ctrl_c = 0;
gdb_connection->frontend_state = TARGET_HALTED;
gdb_connection->vflash_image = NULL;
gdb_connection->output_disable = 0;
/* output goes through gdb connection */
command_set_output_handler(connection->cmd_ctx, gdb_output, connection);
@@ -1172,10 +1223,76 @@ int gdb_breakpoint_watchpoint_packet(connection_t *connection, target_t *target,
return ERROR_OK;
}
/* print out XML and allocate more space as needed */
void xml_printf(int *retval, char **xml, int *pos, int *size, const char *fmt, ...)
{
if (*retval != ERROR_OK)
{
return;
}
int first = 1;
for (;;)
{
if ((*xml == NULL) || (!first))
{
/* start by 0 to exercise all the code paths.
* Need minimum 2 bytes to fit 1 char and 0 terminator. */
*size = *size * 2 + 2;
*xml = realloc(*xml, *size);
if (*xml == NULL)
{
*retval = 1;
return;
}
}
va_list ap;
int ret;
va_start(ap, fmt);
ret = vsnprintf(*xml + *pos, *size - *pos, fmt, ap);
va_end(ap);
if ((ret > 0) && ((ret + 1) < *size - *pos))
{
*pos += ret;
return;
}
/* there was just enough or not enough space, allocate more. */
first = 0;
}
}
static int decode_xfer_read (char *buf, char **annex, int *ofs, unsigned int *len)
{
char *separator;
/* Extract and NUL-terminate the annex. */
*annex = buf;
while (*buf && *buf != ':')
buf++;
if (*buf == '\0')
return -1;
*buf++ = 0;
/* After the read marker and annex, qXfer looks like a
* traditional 'm' packet. */
*ofs = strtoul(buf, &separator, 16);
if (*separator != ',')
return -1;
*len = strtoul(separator+1, NULL, 16);
return 0;
}
int gdb_query_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
char buffer[GDB_BUFFER_SIZE];
command_context_t *cmd_ctx = connection->cmd_ctx;
if (strstr(packet, "qRcmd,"))
{
if (packet_size > 6)
@@ -1196,13 +1313,12 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i
gdb_put_packet(connection, "OK", 2);
return ERROR_OK;
}
if (strstr(packet, "qCRC:"))
else if (strstr(packet, "qCRC:"))
{
if (packet_size > 5)
{
int retval;
u8 gdb_reply[9];
u8 gdb_reply[10];
char *separator;
u32 checksum;
u32 addr = 0;
@@ -1219,13 +1335,13 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i
return ERROR_SERVER_REMOTE_CLOSED;
}
len = strtoul(separator+1, NULL, 16);
len = strtoul(separator + 1, NULL, 16);
retval = target_checksum_memory(target, addr, len, &checksum);
if (retval == ERROR_OK)
{
snprintf(gdb_reply, 9, "C%2.2x", checksum);
snprintf(gdb_reply, 10, "C%8.8x", checksum);
gdb_put_packet(connection, gdb_reply, 9);
}
else
@@ -1237,6 +1353,119 @@ int gdb_query_packet(connection_t *connection, target_t *target, char *packet, i
return ERROR_OK;
}
}
else if (strstr(packet, "qSupported"))
{
/* we currently support packet size and qXfer:memory-map:read (if enabled)
* disable qXfer:features:read for the moment */
sprintf(buffer, "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-",
(GDB_BUFFER_SIZE - 1), gdb_use_memory_map == 1 ? '+' : '-');
gdb_put_packet(connection, buffer, strlen(buffer));
return ERROR_OK;
}
else if (strstr(packet, "qXfer:memory-map:read::"))
{
/* We get away with only specifying flash here. Regions that are not
* specified are treated as if we provided no memory map(if not we
* could detect the holes and mark them as RAM).
* Normally we only execute this code once, but no big deal if we
* have to regenerate it a couple of times. */
flash_bank_t *p;
char *xml = NULL;
int size = 0;
int pos = 0;
int retval = ERROR_OK;
int offset;
int length;
char *separator;
/* skip command character */
packet += 23;
offset = strtoul(packet, &separator, 16);
length = strtoul(separator + 1, &separator, 16);
xml_printf(&retval, &xml, &pos, &size, "<memory-map>\n");
int i = 0;
for (;;)
{
p = get_flash_bank_by_num(i);
if (p == NULL)
break;
xml_printf(&retval, &xml, &pos, &size, "<memory type=\"flash\" start=\"0x%x\" length=\"0x%x\">\n" \
"<property name=\"blocksize\">0x%x</property>\n" \
"</memory>\n", \
p->base, p->size, p->size/p->num_sectors);
i++;
}
xml_printf(&retval, &xml, &pos, &size, "</memory-map>\n");
if (retval != ERROR_OK)
{
gdb_send_error(connection, retval);
return retval;
}
if (offset + length > pos)
{
length = pos - offset;
}
char *t = malloc(length + 1);
t[0] = 'l';
memcpy(t + 1, xml + offset, length);
gdb_put_packet(connection, t, length + 1);
free(t);
free(xml);
return ERROR_OK;
}
else if (strstr(packet, "qXfer:features:read:"))
{
char *xml = NULL;
int size = 0;
int pos = 0;
int retval = ERROR_OK;
int offset;
int length;
char *annex;
/* skip command character */
packet += 20;
if (decode_xfer_read( packet, &annex, &offset, &length ) < 0)
{
gdb_send_error(connection, 01);
return ERROR_OK;
}
if (strcmp(annex, "target.xml") != 0)
{
gdb_send_error(connection, 01);
return ERROR_OK;
}
xml_printf(&retval, &xml, &pos, &size, \
"l<target version=\"1.0\">\n<architecture>arm</architecture>\n</target>\n");
if (retval != ERROR_OK)
{
gdb_send_error(connection, retval);
return retval;
}
gdb_put_packet(connection, xml, strlen(xml) + 1);
free(xml);
return ERROR_OK;
}
gdb_put_packet(connection, "", 0);
return ERROR_OK;
@@ -1248,10 +1477,19 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p
gdb_service_t *gdb_service = connection->service->priv;
int result;
/* if flash programming disabled - send a empty reply */
if (gdb_flash_program == 0)
{
gdb_put_packet(connection, "", 0);
return ERROR_OK;
}
if (strstr(packet, "vFlashErase:"))
{
unsigned long addr;
unsigned long length;
char *parse = packet + 12;
if (*parse == '\0')
{
@@ -1274,7 +1512,17 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p
ERROR("incomplete vFlashErase packet received, dropping connection");
return ERROR_SERVER_REMOTE_CLOSED;
}
/* disable gdb output while programming */
gdb_connection->output_disable = 1;
/* assume all sectors need erasing - stops any problems
* when flash_write is called multiple times */
flash_set_dirty();
/* perform any target specific operations before the erase */
target_call_event_callbacks(gdb_service->target, TARGET_EVENT_GDB_PROGRAM);
/* perform erase */
if ((result = flash_erase(gdb_service->target, addr, length)) != ERROR_OK)
{
@@ -1286,7 +1534,10 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p
}
else
gdb_put_packet(connection, "OK", 2);
/* reenable gdb output */
gdb_connection->output_disable = 0;
return ERROR_OK;
}
@@ -1309,6 +1560,9 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p
}
length = packet_size - (parse - packet);
/* disable gdb output while programming */
gdb_connection->output_disable = 1;
/* create a new image if there isn't already one */
if (gdb_connection->vflash_image == NULL)
{
@@ -1321,6 +1575,9 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p
gdb_put_packet(connection, "OK", 2);
/* reenable gdb output */
gdb_connection->output_disable = 0;
return ERROR_OK;
}
@@ -1329,6 +1586,9 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p
u32 written;
char *error_str;
/* disable gdb output while programming */
gdb_connection->output_disable = 1;
/* process the flashing buffer */
if ((result = flash_write(gdb_service->target, gdb_connection->vflash_image, &written, &error_str, NULL, 0)) != ERROR_OK)
{
@@ -1352,7 +1612,10 @@ int gdb_v_packet(connection_t *connection, target_t *target, char *packet, int p
image_close(gdb_connection->vflash_image);
free(gdb_connection->vflash_image);
gdb_connection->vflash_image = NULL;
/* reenable gdb output */
gdb_connection->output_disable = 0;
return ERROR_OK;
}
@@ -1580,12 +1843,55 @@ int handle_gdb_detach_command(struct command_context_s *cmd_ctx, char *cmd, char
return ERROR_OK;
}
int handle_gdb_memory_map_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
if (argc == 1)
{
if (strcmp(args[0], "enable") == 0)
{
gdb_use_memory_map = 1;
return ERROR_OK;
}
else if (strcmp(args[0], "disable") == 0)
{
gdb_use_memory_map = 0;
return ERROR_OK;
}
}
WARNING("invalid gdb_memory_map configuration directive: %s", args[0]);
return ERROR_OK;
}
int handle_gdb_flash_program_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
if (argc == 1)
{
if (strcmp(args[0], "enable") == 0)
{
gdb_flash_program = 1;
return ERROR_OK;
}
else if (strcmp(args[0], "disable") == 0)
{
gdb_flash_program = 0;
return ERROR_OK;
}
}
WARNING("invalid gdb_memory_map configuration directive: %s", args[0]);
return ERROR_OK;
}
int gdb_register_commands(command_context_t *command_context)
{
register_command(command_context, NULL, "gdb_port", handle_gdb_port_command,
COMMAND_CONFIG, "");
register_command(command_context, NULL, "gdb_detach", handle_gdb_detach_command,
COMMAND_CONFIG, "");
register_command(command_context, NULL, "gdb_memory_map", handle_gdb_memory_map_command,
COMMAND_CONFIG, "");
register_command(command_context, NULL, "gdb_flash_program", handle_gdb_flash_program_command,
COMMAND_CONFIG, "");
return ERROR_OK;
}
src/server/gdb_server.h
+1
View File
@@ -34,6 +34,7 @@ typedef struct gdb_connection_s
int ctrl_c;
enum target_state frontend_state;
image_t *vflash_image;
int output_disable;
} gdb_connection_t;
typedef struct gdb_service_s
src/target/image.c
+16 -25
View File
@@ -360,12 +360,12 @@ int image_elf_read_headers(image_t *image)
return ERROR_FILEIO_OPERATION_FAILED;
}
if (strncmp((char*)elf->header->e_ident,ELFMAG,SELFMAG)!=0)
if (strncmp((char*)elf->header->e_ident,ELFMAG,SELFMAG) != 0)
{
ERROR("invalid ELF file, bad magic number");
return ERROR_IMAGE_FORMAT_ERROR;
}
if (elf->header->e_ident[EI_CLASS]!=ELFCLASS32)
if (elf->header->e_ident[EI_CLASS] != ELFCLASS32)
{
ERROR("invalid ELF file, only 32bits files are supported");
return ERROR_IMAGE_FORMAT_ERROR;
@@ -373,28 +373,28 @@ int image_elf_read_headers(image_t *image)
elf->endianness = elf->header->e_ident[EI_DATA];
if ((elf->endianness!=ELFDATA2LSB)
&&(elf->endianness!=ELFDATA2MSB))
if ((elf->endianness != ELFDATA2LSB)
&&(elf->endianness != ELFDATA2MSB))
{
ERROR("invalid ELF file, unknown endianess setting");
return ERROR_IMAGE_FORMAT_ERROR;
}
elf->segment_count = field16(elf,elf->header->e_phnum);
if (elf->segment_count==0)
elf->segment_count = field16(elf, elf->header->e_phnum);
if (elf->segment_count == 0)
{
ERROR("invalid ELF file, no program headers");
return ERROR_IMAGE_FORMAT_ERROR;
}
elf->segments = malloc(elf->segment_count*sizeof(Elf32_Phdr));
elf->segments = malloc(elf->segment_count * sizeof(Elf32_Phdr));
if ((retval = fileio_read(&elf->fileio, elf->segment_count*sizeof(Elf32_Phdr), (u8*)elf->segments, &read_bytes)) != ERROR_OK)
if ((retval = fileio_read(&elf->fileio, elf->segment_count * sizeof(Elf32_Phdr), (u8*)elf->segments, &read_bytes)) != ERROR_OK)
{
ERROR("cannot read ELF segment headers, read failed");
return retval;
}
if (read_bytes != elf->segment_count*sizeof(Elf32_Phdr))
if (read_bytes != elf->segment_count * sizeof(Elf32_Phdr))
{
ERROR("cannot read ELF segment headers, only partially read");
return ERROR_FILEIO_OPERATION_FAILED;
@@ -411,16 +411,16 @@ int image_elf_read_headers(image_t *image)
{
if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
{
image->sections[j].size = field32(elf,elf->segments[i].p_memsz);
image->sections[j].base_address = field32(elf,elf->segments[i].p_paddr);
image->sections[j].size = field32(elf, elf->segments[i].p_memsz);
image->sections[j].base_address = field32(elf, elf->segments[i].p_paddr);
image->sections[j].private = &elf->segments[i];
image->sections[j].flags = field32(elf,elf->segments[i].p_flags);
image->sections[j].flags = field32(elf, elf->segments[i].p_flags);
j++;
}
}
image->start_address_set = 1;
image->start_address = field32(elf,elf->header->e_entry);
image->start_address = field32(elf, elf->header->e_entry);
return ERROR_OK;
}
@@ -442,9 +442,9 @@ int image_elf_read_section(image_t *image, int section, u32 offset, u32 size, u8
/* maximal size present in file for the current segment */
read_size = MIN(size, field32(elf, segment->p_filesz) - offset);
DEBUG("read elf: size = 0x%x at 0x%x", read_size,
field32(elf,segment->p_offset) + offset);
field32(elf, segment->p_offset) + offset);
/* read initialized area of the segment */
if ((retval = fileio_seek(&elf->fileio, field32(elf,segment->p_offset) + offset)) != ERROR_OK)
if ((retval = fileio_seek(&elf->fileio, field32(elf, segment->p_offset) + offset)) != ERROR_OK)
{
ERROR("cannot find ELF segment content, seek failed");
return retval;
@@ -462,16 +462,7 @@ int image_elf_read_section(image_t *image, int section, u32 offset, u32 size, u8
if (!size)
return ERROR_OK;
}
/* if there is remaining zeroed area in current segment */
if (offset < field32(elf, segment->p_memsz))
{
/* fill zeroed part (BSS) of the segment */
read_size = MIN(size, field32(elf, segment->p_memsz) - offset);
DEBUG("zero fill: size = 0x%x", read_size);
memset(buffer, 0, read_size);
*size_read += read_size;
}
return ERROR_OK;
}
src/target/target.c
+7
View File
@@ -1040,6 +1040,7 @@ int handle_target_command(struct command_context_s *cmd_ctx, char *cmd, char **a
(*last_target_p)->reset_script = NULL;
(*last_target_p)->post_halt_script = NULL;
(*last_target_p)->pre_resume_script = NULL;
(*last_target_p)->gdb_program_script = NULL;
(*last_target_p)->working_area = 0x0;
(*last_target_p)->working_area_size = 0x0;
@@ -1120,6 +1121,12 @@ int handle_target_script_command(struct command_context_s *cmd_ctx, char *cmd, c
free(target->pre_resume_script);
target->pre_resume_script = strdup(args[2]);
}
else if (strcmp(args[1], "gdb_program_config") == 0)
{
if (target->gdb_program_script)
free(target->gdb_program_script);
target->gdb_program_script = strdup(args[2]);
}
else
{
ERROR("unknown event type: '%s", args[1]);
src/target/target.h
+2
View File
@@ -157,6 +157,7 @@ typedef struct target_s
char *reset_script; /* script file to initialize the target after a reset */
char *post_halt_script; /* script file to execute after the target halted */
char *pre_resume_script; /* script file to execute before the target resumed */
char *gdb_program_script; /* script file to execute before programming vis gdb */
u32 working_area; /* working area (initialized RAM) */
u32 working_area_size; /* size in bytes */
u32 backup_working_area; /* whether the content of the working area has to be preserved */
@@ -180,6 +181,7 @@ enum target_event
TARGET_EVENT_RESET, /* target entered reset */
TARGET_EVENT_DEBUG_HALTED, /* target entered debug state, but was executing on behalf of the debugger */
TARGET_EVENT_DEBUG_RESUMED, /* target resumed to execute on behalf of the debugger */
TARGET_EVENT_GDB_PROGRAM /* target about to be be programmed by gdb */
};
typedef struct target_event_callback_s