* Copyright (C) 2005 by Dominic Rath *
* Dominic.Rath@gmx.de *
* *
+ * Copyright (C) 2007,2008 Øyvind Harboe *
+ * oyvind.harboe@zylin.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 *
* however sometimes '-' is sent even though we've already received
* an ACK (+) for everything we've sent off.
*/
-#ifndef _WIN32
int gotdata;
for (;;)
{
return retval;
LOG_WARNING("Discard unexpected char %c", reply);
}
-#endif
#endif
while (1)
case '$':
break;
case '+':
+ /* gdb sends a dummy ack '+' at every remote connect - see remote_start_remote (remote.c)
+ * incase anyone tries to debug why they receive this warning every time */
LOG_WARNING("acknowledgment received, but no packet pending");
break;
case '-':
return ERROR_OK;
}
+static void gdb_frontend_halted(struct target_s *target, connection_t *connection)
+{
+ gdb_connection_t *gdb_connection = connection->priv;
+
+ /* In the GDB protocol when we are stepping or coninuing execution,
+ * we have a lingering reply. Upon receiving a halted event
+ * when we have that lingering packet, we reply to the original
+ * step or continue packet.
+ *
+ * Executing monitor commands can bring the target in and
+ * out of the running state so we'll see lots of TARGET_EVENT_XXX
+ * that are to be ignored.
+ */
+ if (gdb_connection->frontend_state == TARGET_RUNNING)
+ {
+ char sig_reply[4];
+ int signal;
+ /* stop forwarding log packets! */
+ log_remove_callback(gdb_log_callback, connection);
+
+ if (gdb_connection->ctrl_c)
+ {
+ signal = 0x2;
+ gdb_connection->ctrl_c = 0;
+ }
+ else
+ {
+ signal = gdb_last_signal(target);
+ }
+
+ snprintf(sig_reply, 4, "T%2.2x", signal);
+ gdb_put_packet(connection, sig_reply, 3);
+ gdb_connection->frontend_state = TARGET_HALTED;
+ }
+}
+
int gdb_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)
{
connection_t *connection = priv;
- gdb_connection_t *gdb_connection = connection->priv;
- char sig_reply[4];
- int signal;
switch (event)
{
case TARGET_EVENT_HALTED:
- /* In the GDB protocol when we are stepping or coninuing execution,
- * we have a lingering reply. Upon receiving a halted event
- * when we have that lingering packet, we reply to the original
- * step or continue packet.
- *
- * Executing monitor commands can bring the target in and
- * out of the running state so we'll see lots of TARGET_EVENT_XXX
- * that are to be ignored.
- */
- if (gdb_connection->frontend_state == TARGET_RUNNING)
- {
- /* stop forwarding log packets! */
- log_remove_callback(gdb_log_callback, connection);
-
- if (gdb_connection->ctrl_c)
- {
- signal = 0x2;
- gdb_connection->ctrl_c = 0;
- }
- else
- {
- signal = gdb_last_signal(target);
- }
-
- snprintf(sig_reply, 4, "T%2.2x", signal);
- gdb_put_packet(connection, sig_reply, 3);
- gdb_connection->frontend_state = TARGET_HALTED;
- }
+ gdb_frontend_halted(target, connection);
break;
case TARGET_EVENT_GDB_PROGRAM:
gdb_program_handler(target, event, connection->cmd_ctx);
* connect.
*/
target_halt(gdb_service->target);
+ /* FIX!!!! could extended-remote work better here?
+ *
+ * wait a tiny bit for halted state or we just continue. The
+ * GDB register packet will then contain garbage
+ */
+ target_wait_state(gdb_service->target, TARGET_HALTED, 500);
/* remove the initial ACK from the incoming buffer */
if ((retval = gdb_get_char(connection, &initial_ack)) != ERROR_OK)
return ERROR_OK;
}
-void gdb_step_continue_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
+int gdb_step_continue_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
{
int current = 0;
u32 address = 0x0;
+ int retval=ERROR_OK;
LOG_DEBUG("-");
{
LOG_DEBUG("continue");
target_invoke_script(connection->cmd_ctx, target, "pre_resume");
- target_resume(target, current, address, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
+ retval=target_resume(target, current, address, 0, 0); /* resume at current address, don't handle breakpoints, not debugging */
}
else if (packet[0] == 's')
{
LOG_DEBUG("step");
- target->type->step(target, current, address, 0); /* step at current or address, don't handle breakpoints */
+ retval=target->type->step(target, current, address, 0); /* step at current or address, don't handle breakpoints */
}
+ return retval;
}
int gdb_breakpoint_watchpoint_packet(connection_t *connection, target_t *target, char *packet, int packet_size)
xml_printf(&retval, &buffer, &pos, &size,
"PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read-",
- (GDB_BUFFER_SIZE - 1), gdb_use_memory_map == 1 ? '+' : '-');
+ (GDB_BUFFER_SIZE - 1), ((gdb_use_memory_map == 1)&&(flash_get_bank_count()>0)) ? '+' : '-');
if (retval != ERROR_OK)
{
return ERROR_OK;
}
- else if (strstr(packet, "qXfer:memory-map:read::"))
+ else if (strstr(packet, "qXfer:memory-map:read::")&&(flash_get_bank_count()>0))
{
/* 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
/* Do not allocate this on the stack */
char gdb_packet_buffer[GDB_BUFFER_SIZE];
+static void gdb_sig_halted(connection_t *connection)
+{
+ char sig_reply[4];
+ snprintf(sig_reply, 4, "T%2.2x", 2);
+ gdb_put_packet(connection, sig_reply, 3);
+
+}
+
int gdb_input_inner(connection_t *connection)
{
gdb_service_t *gdb_service = connection->service->priv;
/* If the target isn't in the halted state, then we can't
* step/continue. This might be early setup, etc.
*/
- char sig_reply[4];
- snprintf(sig_reply, 4, "T%2.2x", 2);
- gdb_put_packet(connection, sig_reply, 3);
+ gdb_sig_halted(connection);
} else
{
/* We're running/stepping, in which case we can
gdb_connection_t *gdb_con = connection->priv;
gdb_con->frontend_state = TARGET_RUNNING;
log_add_callback(gdb_log_callback, connection);
- gdb_step_continue_packet(connection, target, packet, packet_size);
+ int retval=gdb_step_continue_packet(connection, target, packet, packet_size);
+ if (retval!=ERROR_OK)
+ {
+ /* we'll never receive a halted condition... issue a false one.. */
+ gdb_frontend_halted(target, connection);
+ }
}
}
break;
break;
case 'R':
/* handle extended restart packet */
- command_run_linef(connection->cmd_ctx, "gdb_restart");
+ command_run_linef(connection->cmd_ctx, "ocd_gdb_restart %d", get_num_by_target(target));
break;
default:
/* ignore unkown packets */
return ERROR_OK;
}
-int gdb_init()
+int gdb_init(void)
{
gdb_service_t *gdb_service;
target_t *target = targets;