static struct target_event_callback *target_event_callbacks;
static struct target_timer_callback *target_timer_callbacks;
LIST_HEAD(target_reset_callback_list);
+LIST_HEAD(target_trace_callback_list);
static const int polling_interval = 100;
static const Jim_Nvp nvp_assert[] = {
{ .value = TARGET_EVENT_GDB_FLASH_ERASE_START, .name = "gdb-flash-erase-start" },
{ .value = TARGET_EVENT_GDB_FLASH_ERASE_END , .name = "gdb-flash-erase-end" },
+ { .value = TARGET_EVENT_TRACE_CONFIG, .name = "trace-config" },
+
{ .name = NULL, .value = -1 }
};
}
/* returns a pointer to the n-th configured target */
-static struct target *get_target_by_num(int num)
+struct target *get_target_by_num(int num)
{
struct target *target = all_targets;
break;
}
- if ((rp & (block_size - 1)) || rp < fifo_start_addr || rp >= fifo_end_addr) {
+ if (((rp - fifo_start_addr) & (block_size - 1)) || rp < fifo_start_addr || rp >= fifo_end_addr) {
LOG_ERROR("corrupted fifo read pointer 0x%" PRIx32, rp);
break;
}
LOG_ERROR("Target not examined yet");
return ERROR_FAIL;
}
+ if (!target->type->read_memory) {
+ LOG_ERROR("Target %s doesn't support read_memory", target_name(target));
+ return ERROR_FAIL;
+ }
return target->type->read_memory(target, address, size, count, buffer);
}
LOG_ERROR("Target not examined yet");
return ERROR_FAIL;
}
+ if (!target->type->read_phys_memory) {
+ LOG_ERROR("Target %s doesn't support read_phys_memory", target_name(target));
+ return ERROR_FAIL;
+ }
return target->type->read_phys_memory(target, address, size, count, buffer);
}
LOG_ERROR("Target not examined yet");
return ERROR_FAIL;
}
+ if (!target->type->write_memory) {
+ LOG_ERROR("Target %s doesn't support write_memory", target_name(target));
+ return ERROR_FAIL;
+ }
return target->type->write_memory(target, address, size, count, buffer);
}
LOG_ERROR("Target not examined yet");
return ERROR_FAIL;
}
+ if (!target->type->write_phys_memory) {
+ LOG_ERROR("Target %s doesn't support write_phys_memory", target_name(target));
+ return ERROR_FAIL;
+ }
return target->type->write_phys_memory(target, address, size, count, buffer);
}
target->examined = false;
}
-static int err_read_phys_memory(struct target *target, uint32_t address,
- uint32_t size, uint32_t count, uint8_t *buffer)
-{
- LOG_ERROR("Not implemented: %s", __func__);
- return ERROR_FAIL;
-}
-
-static int err_write_phys_memory(struct target *target, uint32_t address,
- uint32_t size, uint32_t count, const uint8_t *buffer)
-{
- LOG_ERROR("Not implemented: %s", __func__);
- return ERROR_FAIL;
-}
-
static int handle_target(void *priv);
static int target_init_one(struct command_context *cmd_ctx,
* implement it in stages, but warn if we need to do so.
*/
if (type->mmu) {
- if (type->write_phys_memory == NULL) {
- LOG_ERROR("type '%s' is missing write_phys_memory",
- type->name);
- type->write_phys_memory = err_write_phys_memory;
- }
- if (type->read_phys_memory == NULL) {
- LOG_ERROR("type '%s' is missing read_phys_memory",
- type->name);
- type->read_phys_memory = err_read_phys_memory;
- }
if (type->virt2phys == NULL) {
LOG_ERROR("type '%s' is missing virt2phys", type->name);
type->virt2phys = identity_virt2phys;
return ERROR_OK;
}
+int target_register_trace_callback(int (*callback)(struct target *target,
+ size_t len, uint8_t *data, void *priv), void *priv)
+{
+ struct target_trace_callback *entry;
+
+ if (callback == NULL)
+ return ERROR_COMMAND_SYNTAX_ERROR;
+
+ entry = malloc(sizeof(struct target_trace_callback));
+ if (entry == NULL) {
+ LOG_ERROR("error allocating buffer for trace callback entry");
+ return ERROR_COMMAND_SYNTAX_ERROR;
+ }
+
+ entry->callback = callback;
+ entry->priv = priv;
+ list_add(&entry->list, &target_trace_callback_list);
+
+
+ return ERROR_OK;
+}
+
int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
{
struct target_timer_callback **callbacks_p = &target_timer_callbacks;
return ERROR_OK;
}
+int target_unregister_trace_callback(int (*callback)(struct target *target,
+ size_t len, uint8_t *data, void *priv), void *priv)
+{
+ struct target_trace_callback *entry;
+
+ if (callback == NULL)
+ return ERROR_COMMAND_SYNTAX_ERROR;
+
+ list_for_each_entry(entry, &target_trace_callback_list, list) {
+ if (entry->callback == callback && entry->priv == priv) {
+ list_del(&entry->list);
+ free(entry);
+ break;
+ }
+ }
+
+ return ERROR_OK;
+}
+
int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
{
if (callback == NULL)
return ERROR_OK;
}
+int target_call_trace_callbacks(struct target *target, size_t len, uint8_t *data)
+{
+ struct target_trace_callback *callback;
+
+ list_for_each_entry(callback, &target_trace_callback_list, list)
+ callback->callback(target, len, data, callback->priv);
+
+ return ERROR_OK;
+}
+
static int target_timer_callback_periodic_restart(
struct target_timer_callback *cb, struct timeval *now)
{
return ERROR_OK;
}
- LOG_USER("target state: %s", target_state_name(target));
+ LOG_USER("%s: target state: %s", target_name(target),
+ target_state_name(target));
if (target->state != TARGET_HALTED)
return ERROR_OK;
target->backoff.times *= 2;
target->backoff.times++;
}
- LOG_USER("Polling target %s failed, GDB will be halted. Polling again in %dms",
- target_name(target),
- target->backoff.times * polling_interval);
/* Tell GDB to halt the debugger. This allows the user to
* run monitor commands to handle the situation.
*/
target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
- return retval;
}
- /* Since we succeeded, we reset backoff count */
if (target->backoff.times > 0) {
- LOG_USER("Polling target %s succeeded again, trying to reexamine", target_name(target));
+ LOG_USER("Polling target %s failed, trying to reexamine", target_name(target));
target_reset_examined(target);
retval = target_examine_one(target);
/* Target examination could have failed due to unstable connection,
* but we set the examined flag anyway to repoll it later */
if (retval != ERROR_OK) {
target->examined = true;
+ LOG_USER("Examination failed, GDB will be halted. Polling again in %dms",
+ target->backoff.times * polling_interval);
return retval;
}
}
+ /* Since we succeeded, we reset backoff count */
target->backoff.times = 0;
}
}
free(buffer);
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
- int filesize;
+ size_t filesize;
retval = fileio_size(&fileio, &filesize);
if (retval != ERROR_OK)
return retval;
command_print(CMD_CTX,
- "dumped %ld bytes in %fs (%0.3f KiB/s)", (long)filesize,
+ "dumped %zu bytes in %fs (%0.3f KiB/s)", filesize,
duration_elapsed(&bench), duration_kbps(&bench, filesize));
}