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[] = {
}
/* 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;
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;
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));
}