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.
 
 
 
 
 
 

487 lines
17 KiB

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