You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

457 lines
17 KiB

  1. /***************************************************************************
  2. * Copyright (C) 2005 by Dominic Rath *
  3. * Dominic.Rath@gmx.de *
  4. * *
  5. * Copyright (C) 2007,2008 √ėyvind Harboe *
  6. * oyvind.harboe@zylin.com *
  7. * *
  8. * Copyright (C) 2008 by Spencer Oliver *
  9. * spen@spen-soft.co.uk *
  10. * *
  11. * This program is free software; you can redistribute it and/or modify *
  12. * it under the terms of the GNU General Public License as published by *
  13. * the Free Software Foundation; either version 2 of the License, or *
  14. * (at your option) any later version. *
  15. * *
  16. * This program is distributed in the hope that it will be useful, *
  17. * but WITHOUT ANY WARRANTY; without even the implied warranty of *
  18. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
  19. * GNU General Public License for more details. *
  20. * *
  21. * You should have received a copy of the GNU General Public License *
  22. * along with this program; if not, write to the *
  23. * Free Software Foundation, Inc., *
  24. * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
  25. ***************************************************************************/
  26. #ifndef TARGET_H
  27. #define TARGET_H
  28. #include "breakpoints.h"
  29. #include "algorithm.h"
  30. #include "command.h"
  31. struct reg_s;
  32. struct trace_s;
  33. struct command_context_s;
  34. /*
  35. * TARGET_UNKNOWN = 0: we don't know anything about the target yet
  36. * TARGET_RUNNING = 1: the target is executing user code
  37. * TARGET_HALTED = 2: the target is not executing code, and ready to talk to the
  38. * debugger. on an xscale it means that the debug handler is executing
  39. * TARGET_RESET = 3: the target is being held in reset (only a temporary state,
  40. * not sure how this is used with all the recent changes)
  41. * TARGET_DEBUG_RUNNING = 4: the target is running, but it is executing code on
  42. * behalf of the debugger (e.g. algorithm for flashing)
  43. *
  44. * also see: target_state_name();
  45. */
  46. enum target_state
  47. {
  48. TARGET_UNKNOWN = 0,
  49. TARGET_RUNNING = 1,
  50. TARGET_HALTED = 2,
  51. TARGET_RESET = 3,
  52. TARGET_DEBUG_RUNNING = 4,
  53. };
  54. extern const Jim_Nvp nvp_target_state[];
  55. enum nvp_assert {
  56. NVP_DEASSERT,
  57. NVP_ASSERT,
  58. };
  59. extern const Jim_Nvp nvp_assert[];
  60. enum target_reset_mode
  61. {
  62. RESET_UNKNOWN = 0,
  63. RESET_RUN = 1, /* reset and let target run */
  64. RESET_HALT = 2, /* reset and halt target out of reset */
  65. RESET_INIT = 3, /* reset and halt target out of reset, then run init script */
  66. };
  67. extern const Jim_Nvp nvp_reset_mode[];
  68. enum target_debug_reason
  69. {
  70. DBG_REASON_DBGRQ = 0,
  71. DBG_REASON_BREAKPOINT = 1,
  72. DBG_REASON_WATCHPOINT = 2,
  73. DBG_REASON_WPTANDBKPT = 3,
  74. DBG_REASON_SINGLESTEP = 4,
  75. DBG_REASON_NOTHALTED = 5,
  76. DBG_REASON_UNDEFINED = 6
  77. };
  78. extern const Jim_Nvp nvp_target_debug_reason[];
  79. enum target_endianess
  80. {
  81. TARGET_ENDIAN_UNKNOWN = 0,
  82. TARGET_BIG_ENDIAN = 1, TARGET_LITTLE_ENDIAN = 2
  83. };
  84. extern const Jim_Nvp nvp_target_endian[];
  85. struct target_s;
  86. typedef struct working_area_s
  87. {
  88. uint32_t address;
  89. uint32_t size;
  90. int free;
  91. uint8_t *backup;
  92. struct working_area_s **user;
  93. struct working_area_s *next;
  94. } working_area_t;
  95. // target_type.h contains the full definitionof struct target_type_s
  96. struct target_type_s;
  97. typedef struct target_type_s target_type_t;
  98. /* forward decloration */
  99. typedef struct target_event_action_s target_event_action_t;
  100. typedef struct target_s
  101. {
  102. target_type_t *type; /* target type definition (name, access functions) */
  103. const char *cmd_name; /* tcl Name of target */
  104. int target_number; /* DO NOT USE! field to be removed in 2010 */
  105. jtag_tap_t *tap; /* where on the jtag chain is this */
  106. const char *variant; /* what varient of this chip is it? */
  107. target_event_action_t *event_action;
  108. int reset_halt; /* attempt resetting the CPU into the halted mode? */
  109. uint32_t working_area; /* working area (initialized RAM). Evaluated
  110. * upon first allocation from virtual/physical address. */
  111. uint32_t working_area_virt; /* virtual address */
  112. uint32_t working_area_phys; /* physical address */
  113. uint32_t working_area_size; /* size in bytes */
  114. uint32_t backup_working_area; /* whether the content of the working area has to be preserved */
  115. struct working_area_s *working_areas;/* list of allocated working areas */
  116. enum target_debug_reason debug_reason;/* reason why the target entered debug state */
  117. enum target_endianess endianness; /* target endianess */
  118. // also see: target_state_name()
  119. enum target_state state; /* the current backend-state (running, halted, ...) */
  120. struct reg_cache_s *reg_cache; /* the first register cache of the target (core regs) */
  121. struct breakpoint_s *breakpoints; /* list of breakpoints */
  122. struct watchpoint_s *watchpoints; /* list of watchpoints */
  123. struct trace_s *trace_info; /* generic trace information */
  124. struct debug_msg_receiver_s *dbgmsg;/* list of debug message receivers */
  125. uint32_t dbg_msg_enabled; /* debug message status */
  126. void *arch_info; /* architecture specific information */
  127. struct target_s *next; /* next target in list */
  128. int display; /* display async info in telnet session. Do not display
  129. * lots of halted/resumed info when stepping in debugger. */
  130. bool halt_issued; /* did we transition to halted state? */
  131. long long halt_issued_time; /* Note time when halt was issued */
  132. } target_t;
  133. enum target_event
  134. {
  135. /* LD historical names
  136. * - Prior to the great TCL change
  137. * - June/July/Aug 2008
  138. * - Duane Ellis */
  139. TARGET_EVENT_OLD_gdb_program_config,
  140. TARGET_EVENT_OLD_pre_reset,
  141. TARGET_EVENT_OLD_post_reset,
  142. TARGET_EVENT_OLD_pre_resume,
  143. /* allow GDB to do stuff before others handle the halted event,
  144. * this is in lieu of defining ordering of invocation of events,
  145. * which would be more complicated
  146. *
  147. * Telling GDB to halt does not mean that the target stopped running,
  148. * simply that we're dropping out of GDB's waiting for step or continue.
  149. *
  150. * This can be useful when e.g. detecting power dropout.
  151. */
  152. TARGET_EVENT_GDB_HALT,
  153. TARGET_EVENT_HALTED, /* target entered debug state from normal execution or reset */
  154. TARGET_EVENT_RESUMED, /* target resumed to normal execution */
  155. TARGET_EVENT_RESUME_START,
  156. TARGET_EVENT_RESUME_END,
  157. TARGET_EVENT_GDB_START, /* debugger started execution (step/run) */
  158. TARGET_EVENT_GDB_END, /* debugger stopped execution (step/run) */
  159. TARGET_EVENT_RESET_START,
  160. TARGET_EVENT_RESET_ASSERT_PRE,
  161. TARGET_EVENT_RESET_ASSERT_POST,
  162. TARGET_EVENT_RESET_DEASSERT_PRE,
  163. TARGET_EVENT_RESET_DEASSERT_POST,
  164. TARGET_EVENT_RESET_HALT_PRE,
  165. TARGET_EVENT_RESET_HALT_POST,
  166. TARGET_EVENT_RESET_WAIT_PRE,
  167. TARGET_EVENT_RESET_WAIT_POST,
  168. TARGET_EVENT_RESET_INIT,
  169. TARGET_EVENT_RESET_END,
  170. TARGET_EVENT_DEBUG_HALTED, /* target entered debug state, but was executing on behalf of the debugger */
  171. TARGET_EVENT_DEBUG_RESUMED, /* target resumed to execute on behalf of the debugger */
  172. TARGET_EVENT_EXAMINE_START,
  173. TARGET_EVENT_EXAMINE_END,
  174. TARGET_EVENT_GDB_ATTACH,
  175. TARGET_EVENT_GDB_DETACH,
  176. TARGET_EVENT_GDB_FLASH_ERASE_START,
  177. TARGET_EVENT_GDB_FLASH_ERASE_END,
  178. TARGET_EVENT_GDB_FLASH_WRITE_START,
  179. TARGET_EVENT_GDB_FLASH_WRITE_END,
  180. };
  181. struct target_event_action_s {
  182. enum target_event event;
  183. Jim_Obj *body;
  184. int has_percent;
  185. target_event_action_t *next;
  186. };
  187. typedef struct target_event_callback_s
  188. {
  189. int (*callback)(struct target_s *target, enum target_event event, void *priv);
  190. void *priv;
  191. struct target_event_callback_s *next;
  192. } target_event_callback_t;
  193. typedef struct target_timer_callback_s
  194. {
  195. int (*callback)(void *priv);
  196. int time_ms;
  197. int periodic;
  198. struct timeval when;
  199. void *priv;
  200. struct target_timer_callback_s *next;
  201. } target_timer_callback_t;
  202. extern int target_register_commands(struct command_context_s *cmd_ctx);
  203. extern int target_register_user_commands(struct command_context_s *cmd_ctx);
  204. extern int target_init(struct command_context_s *cmd_ctx);
  205. extern int target_examine(void);
  206. extern int handle_target(void *priv);
  207. extern int target_process_reset(struct command_context_s *cmd_ctx, enum target_reset_mode reset_mode);
  208. extern int target_register_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv);
  209. extern int target_unregister_event_callback(int (*callback)(struct target_s *target, enum target_event event, void *priv), void *priv);
  210. extern int target_poll(target_t *target);
  211. extern int target_resume(target_t *target, int current, uint32_t address, int handle_breakpoints, int debug_execution);
  212. extern int target_halt(target_t *target);
  213. extern int target_call_event_callbacks(target_t *target, enum target_event event);
  214. /* The period is very approximate, the callback can happen much more often
  215. * or much more rarely than specified
  216. */
  217. extern int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv);
  218. extern int target_unregister_timer_callback(int (*callback)(void *priv), void *priv);
  219. extern int target_call_timer_callbacks(void);
  220. /* invoke this to ensure that e.g. polling timer callbacks happen before
  221. * a syncrhonous command completes.
  222. */
  223. extern int target_call_timer_callbacks_now(void);
  224. extern target_t* get_current_target(struct command_context_s *cmd_ctx);
  225. extern target_t *get_target(const char *id);
  226. /**
  227. * Get the target name.
  228. *
  229. * This routine is a wrapper for the target->type->name field.
  230. */
  231. extern const char *target_get_name(struct target_s *target);
  232. /**
  233. * Examine the specified @a target.
  234. *
  235. * This routine is a wrapper for target->type->examine.
  236. */
  237. extern int target_examine_one(struct target_s *target);
  238. /// @returns @c true if the target has been examined.
  239. extern bool target_was_examined(struct target_s *target);
  240. /// Sets the @c examined flag for the given target.
  241. extern void target_set_examined(struct target_s *target);
  242. /// Reset the @c examined flag for the given target.
  243. extern void target_reset_examined(struct target_s *target);
  244. /**
  245. * Add the @a breakpoint for @a target.
  246. *
  247. * This routine is a wrapper for target->type->add_breakpoint.
  248. */
  249. extern int target_add_breakpoint(struct target_s *target,
  250. struct breakpoint_s *breakpoint);
  251. /**
  252. * Remove the @a breakpoint for @a target.
  253. *
  254. * This routine is a wrapper for target->type->remove_breakpoint.
  255. */
  256. extern int target_remove_breakpoint(struct target_s *target,
  257. struct breakpoint_s *breakpoint);
  258. /**
  259. * Add the @a watchpoint for @a target.
  260. *
  261. * This routine is a wrapper for target->type->add_watchpoint.
  262. */
  263. extern int target_add_watchpoint(struct target_s *target,
  264. struct watchpoint_s *watchpoint);
  265. /**
  266. * Remove the @a watchpoint for @a target.
  267. *
  268. * This routine is a wrapper for target->type->remove_watchpoint.
  269. */
  270. extern int target_remove_watchpoint(struct target_s *target,
  271. struct watchpoint_s *watchpoint);
  272. /**
  273. * Obtain the registers for GDB.
  274. *
  275. * This routine is a wrapper for target->type->get_gdb_reg_list.
  276. */
  277. extern int target_get_gdb_reg_list(struct target_s *target,
  278. struct reg_s **reg_list[], int *reg_list_size);
  279. /**
  280. * Step the target.
  281. *
  282. * This routine is a wrapper for target->type->step.
  283. */
  284. int target_step(struct target_s *target,
  285. int current, uint32_t address, int handle_breakpoints);
  286. /**
  287. * Run an algorithm on the @a target given.
  288. *
  289. * This routine is a wrapper for target->type->run_algorithm.
  290. */
  291. extern int target_run_algorithm(struct target_s *target,
  292. int num_mem_params, mem_param_t *mem_params,
  293. int num_reg_params, reg_param_t *reg_param,
  294. uint32_t entry_point, uint32_t exit_point,
  295. int timeout_ms, void *arch_info);
  296. /**
  297. * Read @a count items of @a size bytes from the memory of @a target at
  298. * the @a address given.
  299. *
  300. * This routine is a wrapper for target->type->read_memory.
  301. */
  302. extern int target_read_memory(struct target_s *target,
  303. uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
  304. /**
  305. * Write @a count items of @a size bytes to the memory of @a target at
  306. * the @a address given.
  307. *
  308. * This routine is wrapper for target->type->write_memory.
  309. */
  310. extern int target_write_memory(struct target_s *target,
  311. uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
  312. /**
  313. * Write @a count items of 4 bytes to the memory of @a target at
  314. * the @a address given. Because it operates only on whole words,
  315. * this should be faster than target_write_memory().
  316. *
  317. * This routine is wrapper for target->type->bulk_write_memory.
  318. */
  319. extern int target_bulk_write_memory(struct target_s *target,
  320. uint32_t address, uint32_t count, uint8_t *buffer);
  321. /*
  322. * Write to target memory using the virtual address.
  323. *
  324. * Note that this fn is used to implement software breakpoints. Targets
  325. * can implement support for software breakpoints to memory marked as read
  326. * only by making this fn write to ram even if it is read only(MMU or
  327. * MPUs).
  328. *
  329. * It is sufficient to implement for writing a single word(16 or 32 in
  330. * ARM32/16 bit case) to write the breakpoint to ram.
  331. *
  332. * The target should also take care of "other things" to make sure that
  333. * software breakpoints can be written using this function. E.g.
  334. * when there is a separate instruction and data cache, this fn must
  335. * make sure that the instruction cache is synced up to the potential
  336. * code change that can happen as a result of the memory write(typically
  337. * by invalidating the cache).
  338. *
  339. * The high level wrapper fn in target.c will break down this memory write
  340. * request to multiple write requests to the target driver to e.g. guarantee
  341. * that writing 4 bytes to an aligned address happens with a single 32 bit
  342. * write operation, thus making this fn suitable to e.g. write to special
  343. * peripheral registers which do not support byte operations.
  344. */
  345. extern int target_write_buffer(struct target_s *target, uint32_t address, uint32_t size, uint8_t *buffer);
  346. extern int target_read_buffer(struct target_s *target, uint32_t address, uint32_t size, uint8_t *buffer);
  347. extern int target_checksum_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t* crc);
  348. extern int target_blank_check_memory(struct target_s *target, uint32_t address, uint32_t size, uint32_t* blank);
  349. extern int target_wait_state(target_t *target, enum target_state state, int ms);
  350. /** Return the *name* of this targets current state */
  351. const char *target_state_name( target_t *target );
  352. /* DANGER!!!!!
  353. *
  354. * if "area" passed in to target_alloc_working_area() points to a memory
  355. * location that goes out of scope (e.g. a pointer on the stack), then
  356. * the caller of target_alloc_working_area() is responsible for invoking
  357. * target_free_working_area() before "area" goes out of scope.
  358. *
  359. * target_free_all_working_areas() will NULL out the "area" pointer
  360. * upon resuming or resetting the CPU.
  361. *
  362. */
  363. extern int target_alloc_working_area(struct target_s *target, uint32_t size, working_area_t **area);
  364. extern int target_free_working_area(struct target_s *target, working_area_t *area);
  365. extern int target_free_working_area_restore(struct target_s *target, working_area_t *area, int restore);
  366. extern void target_free_all_working_areas(struct target_s *target);
  367. extern void target_free_all_working_areas_restore(struct target_s *target, int restore);
  368. extern target_t *all_targets;
  369. extern target_event_callback_t *target_event_callbacks;
  370. extern target_timer_callback_t *target_timer_callbacks;
  371. extern uint32_t target_buffer_get_u32(target_t *target, const uint8_t *buffer);
  372. extern uint16_t target_buffer_get_u16(target_t *target, const uint8_t *buffer);
  373. extern uint8_t target_buffer_get_u8 (target_t *target, const uint8_t *buffer);
  374. extern void target_buffer_set_u32(target_t *target, uint8_t *buffer, uint32_t value);
  375. extern void target_buffer_set_u16(target_t *target, uint8_t *buffer, uint16_t value);
  376. extern void target_buffer_set_u8 (target_t *target, uint8_t *buffer, uint8_t value);
  377. int target_read_u32(struct target_s *target, uint32_t address, uint32_t *value);
  378. int target_read_u16(struct target_s *target, uint32_t address, uint16_t *value);
  379. int target_read_u8(struct target_s *target, uint32_t address, uint8_t *value);
  380. int target_write_u32(struct target_s *target, uint32_t address, uint32_t value);
  381. int target_write_u16(struct target_s *target, uint32_t address, uint16_t value);
  382. int target_write_u8(struct target_s *target, uint32_t address, uint8_t value);
  383. /* Issues USER() statements with target state information */
  384. int target_arch_state(struct target_s *target);
  385. void target_handle_event(target_t *t, enum target_event e);
  386. void target_all_handle_event(enum target_event e);
  387. #define ERROR_TARGET_INVALID (-300)
  388. #define ERROR_TARGET_INIT_FAILED (-301)
  389. #define ERROR_TARGET_TIMEOUT (-302)
  390. #define ERROR_TARGET_NOT_HALTED (-304)
  391. #define ERROR_TARGET_FAILURE (-305)
  392. #define ERROR_TARGET_UNALIGNED_ACCESS (-306)
  393. #define ERROR_TARGET_DATA_ABORT (-307)
  394. #define ERROR_TARGET_RESOURCE_NOT_AVAILABLE (-308)
  395. #define ERROR_TARGET_TRANSLATION_FAULT (-309)
  396. #define ERROR_TARGET_NOT_RUNNING (-310)
  397. #define ERROR_TARGET_NOT_EXAMINED (-311)
  398. extern const Jim_Nvp nvp_error_target[];
  399. extern const char *target_strerror_safe(int err);
  400. #endif /* TARGET_H */