Commit | Line | Data |
---|---|---|
c906108c SS |
1 | /* |
2 | * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved. | |
3 | * | |
4 | * This software may be freely used, copied, modified, and distributed | |
5 | * provided that the above copyright notice is preserved in all copies of the | |
6 | * software. | |
7 | */ | |
8 | ||
9 | /* -*-C-*- | |
10 | * | |
11 | * $Revision$ | |
12 | * $Date$ | |
13 | * | |
14 | * | |
15 | * | |
16 | * INTRODUCTION | |
17 | * ------------ | |
18 | * The early RDP message definitions were held in an ARM Ltd "armdbg" | |
19 | * source file. Since the relevant header files were not exported | |
20 | * publicly as part of an ARM Ltd core tools release, it was a problem | |
21 | * for developers manipulating the target side of the protocol. | |
22 | * | |
23 | * For Angel, this new (ANSI 'C' clean) header file defines the ADP | |
24 | * protocol. The header should be useable by both host and target | |
25 | * systems, thus avoiding problems that can arise from duplicate | |
26 | * definitions. Care has been taken in the construction of this header | |
27 | * file to avoid any host/target differences. | |
28 | * | |
29 | * MESSAGE FORMAT | |
30 | * -------------- | |
31 | * Format of the "data" section of debug and boot agent messages. This is | |
32 | * the standard ADP (Angel Debug Protocol) message format: | |
33 | * | |
34 | * unsigned32 reason - Main debug reason code. | |
35 | * unsigned32 debugID - Information describing host debug world; | |
36 | * - private to host and used in any target initiated | |
37 | * messages. | |
38 | * unsigned32 OSinfo1 \ Target OS information to identify process/thread | |
39 | * unsigned32 OSinfo2 / memory/world, etc. These two fields are target | |
40 | * defined. | |
41 | * byte args[n] - Data for message "reason" code. | |
42 | * | |
43 | * NOTE: The message format is the same for single threaded debugging, | |
44 | * except that the "OSinfo" fields should be -1 (0xFFFFFFFF). Even | |
45 | * single-threaded debugging *MAY* have different host specified | |
46 | * debugID values, so the Angel debug system will preserve the "debugID" | |
47 | * information for replies, and the relevant asynchronous target-to-host | |
48 | * messages. The "debugID" is defined by the host-end of the | |
49 | * protocol, and is used by the host to ensure that messages are | |
50 | * routed to the correct handler program/veneer. | |
51 | * | |
52 | * The reason there are two target specified "OSinfo" words is because | |
53 | * thread identifiers may not be unique when processes/tasks have | |
54 | * private virtual address spaces. It allows more flexibility when | |
55 | * supporting multi-threaded or O/S aware debugging. | |
56 | * | |
57 | * NOTE: The reason that there is no "size" information, is that the | |
58 | * message IDs themselves encode the format of any arguments. Also it | |
59 | * would be a duplication of information used by the physical | |
60 | * transport layer (which is distinct from this logical message | |
61 | * layer). Any routing of messages through programs, hosts, | |
62 | * etc. should be performed at the physical layer, or the boundaries | |
63 | * between physical layers. i.e. packet received on socket in host, | |
64 | * and transferred to serial packet for passing on down the line. | |
65 | * | |
66 | * NOTE: Pointers aren't passed in messages because they are dangerous in | |
67 | * a multi-threaded environment. | |
68 | * | |
69 | * ADP REASON CODE | |
70 | * --------------- | |
71 | * The message reason codes contain some information that ties them to | |
72 | * the channel and direction that the message will be used with. This | |
73 | * will ensure that even if the message "#define name" is not | |
74 | * completely descriptive, the message reason code is. | |
75 | * | |
76 | * b31 = direction. 0=Host-to-Target; 1=Target-to-Host; | |
77 | * b30-28 = debug agent multi-threaded control (see below) | |
78 | * b27-24 = reserved. should be zero. | |
79 | * b23-16 = channelid. The fixed Angel channel number | |
80 | * (see "channels.h"). | |
81 | * b15-0 = message reason code. | |
82 | * | |
83 | * It is unfortunate that to aid the error-checking capabilities of | |
84 | * the Angel communications we have changed the message numbers from | |
85 | * the original ARM Ltd RDP. However this also has benefits, in that | |
86 | * the Angel work is meant to be a clean break. | |
87 | * | |
88 | * However, it isn't so bad since even though the numbers are | |
89 | * different, the majority of the reason codes have exactly the same | |
90 | * functionality as the original RDP messages. | |
91 | * | |
92 | * NOTES | |
93 | * ----- | |
94 | * It would be ideal to use "rpcgen" (or some equivalent) to | |
95 | * automatically maintain compatibility between the target and host | |
96 | * ends of the protocol. However, ARM Ltd expressed that the message | |
97 | * handling should be hand-coded, to avoid dependance on external | |
98 | * tools. | |
99 | * | |
100 | * All other channels have undefined data formats and are purely | |
101 | * application defined. The C library "_sys_" support will provide a | |
102 | * veneer to perform message block operations as required. | |
103 | * | |
104 | * It is IMPLIED that all of the ADP messages will fit within the | |
105 | * buffer DATASIZE. This has a minimum value, calculated from | |
106 | * BUFFERMINSIZE. | |
107 | * | |
108 | * All messages are passed and received to the channel system in little | |
109 | * endian order (ie. use little endian order when writing a word as | |
110 | * a sequence of bytes within a message). | |
111 | * | |
112 | * A reply / acknowledgement to an ADP message is always sent and has the | |
113 | * same reason code as the original except that the TtoH / HtoT bit is | |
114 | * reversed. This makes it simple to check that the reply really | |
115 | * is a reply to the message which was just sent! [Boot Channel messages | |
116 | * also require that this protocol is used]. | |
117 | */ | |
118 | ||
119 | #ifndef angel_adp_h | |
120 | #define angel_adp_h | |
121 | ||
122 | #include "chandefs.h" | |
123 | ||
124 | ||
125 | /* | |
126 | * Buffer minimum sizes | |
127 | */ | |
128 | ||
129 | /* the minimum target internal size */ | |
130 | #define ADP_BUFFER_MIN_SIZE (256) | |
131 | ||
132 | /* a word is always reserved for internal use in the target */ | |
133 | #define ADP_BUFFER_MAX_INTERNAL (sizeof(word)) | |
134 | ||
135 | /* the minimum available data portion */ | |
136 | #define ADP_BUFFER_MIN_DATASIZE \ | |
137 | (ADP_BUFFER_MIN_SIZE - ADP_BUFFER_MAX_INTERNAL - CHAN_HEADER_SIZE) | |
138 | ||
139 | /* | |
140 | * the space taken up by the standard ADP header | |
141 | * (reason, debugID, OSinfo1, OSinfo2) | |
142 | */ | |
143 | #define ADP_DEFAULT_HEADER_SIZE (4*sizeof(word)) | |
144 | ||
145 | ||
146 | /* 8bit ADP version identification */ | |
147 | #define ADPVSN (0x03) | |
148 | /* This value can be used to identify the protocol version supported | |
149 | * by target or host systems. This version number should only be | |
150 | * changed if the protocol undergoes a non-backward compatible | |
151 | * change. It should *NOT* be used to reflect extensions to the | |
152 | * protocol. Such extensions can be added to the existing protocol | |
153 | * version by allocating new reason codes, and by extending the | |
154 | * ADP_Info message to identify new features. | |
155 | */ | |
156 | ||
157 | /* The following value is used in the OSinfo fields for | |
158 | * single-threaded messages, or where the host wants to alter the | |
159 | * global CPU state. NOTE: The "debugID" field should always be | |
160 | * defined by the host, and returned in target initiated messages. The | |
161 | * only exception to this rule is the ADP_Booted message at the | |
162 | * start-of-day. | |
163 | */ | |
164 | #define ADP_HandleUnknown (-1) | |
165 | ||
166 | /****************************************************************** | |
167 | * | |
168 | * ADP reason code subfields | |
169 | * | |
170 | */ | |
171 | ||
172 | /* The following bits are used to describe the basic direction of | |
173 | * messages. This allows some extra checking of message validity to be | |
174 | * performed, as well as providing a description of the message that | |
175 | * may not be available in the "cpp" macro: | |
176 | */ | |
177 | #define HtoT ((unsigned)0 << 31) /* Host-to-Target message */ | |
178 | #define TtoH ((unsigned)1 << 31) /* Target-to-Host message */ | |
179 | ||
180 | /* The following bits are used to control how the target system | |
181 | * executes whilst processing messages. This allows for O/S specific | |
182 | * host-based debug programs to interrogate system structures whilst | |
183 | * ensuring that the access is atomic within the constraints imposed | |
184 | * by the target O/S. | |
185 | * | |
186 | * NOTE: That only the channel is inserted into the reason code | |
187 | * automatically. Thus both direction and multi thread control bits | |
188 | * must be added by the host / target. | |
189 | */ | |
190 | /* Disable FIQ whilst processing message */ | |
191 | #define DisableFIQ (1 << 30) | |
192 | /* Disable IRQ whilst processing message */ | |
193 | #define DisableIRQ (1 << 29) | |
194 | /* Disable O/S pre-emption whilst processing message */ | |
195 | #define DisablePreemption (1 << 28) | |
196 | ||
197 | /* The channel identification number is held in the reason code as a | |
198 | * check: | |
199 | */ | |
200 | #define ADPCHANNEL(b) (((b) & 0xFF) << 16) | |
201 | ||
202 | /* The following macro constructs the reason code number, from the | |
203 | * various fields - note that the direction is NOT inlcuded since | |
204 | * this depends on whether the Host or Target system is including | |
205 | * this file! | |
206 | */ | |
207 | #define ADPREASON(c,r) (ADPCHANNEL(c) | ((r) & 0xFFFF)) | |
208 | ||
209 | /* This macros is used when constructing manifests for sub-reason | |
210 | * codes. At the moment it is identical to the main reason macro. If | |
211 | * desired we could add a new bit that explicitly identifies the value | |
212 | * as a sub-reason code, where the corresponding bit in the main | |
213 | * message ID would be zero. | |
214 | */ | |
215 | #define ADPSUBREASON(c,r) (ADPCHANNEL(c) | ((r) & 0xFFFF)) | |
216 | ||
217 | /* All other undefined bits are reserved, and should be zero. */ | |
218 | ||
219 | ||
220 | ||
221 | /***************************************************************** | |
222 | * | |
223 | * channel_BOOT messages | |
224 | * | |
225 | */ | |
226 | ||
227 | /* The BOOT agent only supports a few messages. They are used purely | |
228 | * to control the "start-of-day" connection to a host program. All | |
229 | * Angel systems with host communications *MUST* provide the BOOT | |
230 | * agent, even if they don't have support for either the single- or | |
231 | * multi-threaded debug agents. | |
232 | * | |
233 | * The way the BOOT channel will be used on startup will be as follows: | |
234 | * | |
235 | * a) Target board is powered up before host debugger is invoked | |
236 | * | |
237 | * After switching on the target and initialisation is completed the | |
238 | * target will send an ADP_Booted or ADP_Reset message. The debugger | |
239 | * has not been started yet so this message will not be received. In | |
240 | * a serial world this makes it important that any buffers on the host | |
241 | * side are flushed during initialisation of the debugger, and in an | |
242 | * Ethernet world it makes it important that the target can cope with the | |
243 | * message not being received. | |
244 | * | |
245 | * Eventually the Debugger will be started up and will send an | |
246 | * ADP_Reboot or ADP_Reset request. The target will respond to this with | |
247 | * an ADP_Reboot or ADP_Reset acknowldege and will then reboot, finally | |
248 | * sending an ADP_Rebooted when it has done all it needs to do (very little | |
249 | * in the case of ADP_Reset, but completely rebooting in the case of | |
250 | * ADP_Reboot). Note that it is important that an ADP_Rebooted message is | |
251 | * sent so that the Debugger does not attempt to send any data after it has | |
252 | * made a request to ADP_Reboot and before it receives an ADP_Rebooted, as | |
253 | * data can be lost be the target during this time. | |
254 | * | |
255 | * The target and host are now ready to start a debug session. | |
256 | * | |
257 | * b) Target board is powered up after host debugger is invoked | |
258 | * | |
259 | * The debugger will send an ADP_Reboot or ADP_Reset request, but will | |
260 | * receive no reply until the target is powered up. | |
261 | / * | |
262 | * When the target is powered up then it will send an ADP_Rebooted | |
263 | * message to the debugger. The debugger should accept this message | |
264 | * even though it has received no ADP_Reboot or ADP_Reset acknowldege message | |
265 | * from the target. | |
266 | * | |
267 | * The target and host are now ready to start a debug session. | |
268 | * | |
269 | * | |
270 | * If at any point during the bootup sequence and ADP messages are | |
271 | * sent down the S_DBG channel then they should be responded to with a | |
272 | * RDI_NotInitialised error. [This should never happen however]. | |
273 | * | |
274 | * An ADP_Boot or ADP Rebooted message should be accepted at | |
275 | * any point, since it is possible for a catastrophe to occur (such as | |
276 | * disconnecteing the host and target during a debug message) which | |
277 | * requires that one or other end be reset. | |
278 | * | |
279 | */ | |
280 | ||
281 | /* | |
282 | * A list of parameter types - for now just baud rate | |
283 | */ | |
284 | typedef enum ADP_Parameter { | |
285 | AP_PARAMS_START = 0xC000, | |
286 | AP_BAUD_RATE = AP_PARAMS_START, | |
287 | /* extra parameters go in here */ | |
288 | #ifdef TEST_PARAMS | |
289 | AP_CAFE_MENU, /* extra just for testing */ | |
290 | #endif | |
291 | AP_PARAMS_END | |
292 | } ADP_Parameter; | |
293 | ||
294 | #define AP_NUM_PARAMS (AP_PARAMS_END - AP_PARAMS_START) | |
295 | ||
296 | /* | |
297 | * Parameter types should have associated semantics which can be represented | |
298 | * within one word per parameter, or an associated enum for choices. | |
299 | * | |
300 | * AP_BAUD_RATE: the word contains the exact baud rate, eg. 9600, 38400. | |
301 | */ | |
302 | ||
303 | /* this is not strictly necessary, but it's an example */ | |
304 | typedef enum ADP_BaudRate { | |
305 | AB_9600 = 9600, | |
306 | AB_19200 = 19200, | |
307 | AB_38400 = 38400, | |
308 | AB_57600 = 57600, | |
309 | AB_115200 = 115200 | |
310 | } ADP_BaudRate; | |
311 | ||
312 | #define AB_NUM_BAUD_RATES 5 /* this is more useful, for sizing arrays */ | |
313 | ||
314 | /* This must be set to the max number of options per parameter type */ | |
315 | #define AP_MAX_OPTIONS (AB_NUM_BAUD_RATES) | |
316 | ||
317 | ||
318 | #define ADP_Booted ADPREASON(CI_TBOOT,0) | |
319 | /* This message is sent by the target after the Angel system has been | |
320 | * initialised. This message also contains information describing the | |
321 | * Angel world. The information can then be used to check that the | |
322 | * target debug agent and source debugger are compatible. | |
323 | * | |
324 | * Message arguments: | |
325 | * word Angel message default buffer size. | |
326 | * word Angel message large buffer size (may be same as default) | |
327 | * word Angel version ; inc. type (e.g. boot ROM) See (1) | |
328 | * word ADP version. See (2) | |
329 | * word ARM Architecture info See (3) | |
330 | * word ARM CPU information ; including target endianness. See (4) | |
331 | * word Target hardware status. See (5) | |
332 | * word Number of bytes in banner message | |
333 | * bytes Startup banner message (single-threaded readable | |
334 | * descriptive text - NOT NULL terminated). | |
335 | * | |
336 | * Reply: | |
337 | * word status | |
338 | * | |
339 | * 'status' returns RDIError_NoError for success, and otherwise | |
340 | * indicates an error. | |
341 | */ | |
342 | ||
343 | /* Angel version word [Reference(1)] : */ | |
344 | /* Angel version number is a 16bit BCD value */ | |
345 | #define ADP_ANGELVSN_MASK (0x0000FFFF) | |
346 | #define ADP_ANGELVSN_SHIFT (0) | |
347 | ||
348 | /* Type of Angel system */ | |
349 | #define ADP_ANGELVSN_TYPE_MASK (0x00FF0000) | |
350 | #define ADP_ANGELVSN_TYPE_SHIFT (16) | |
351 | ||
352 | typedef enum { | |
353 | ADP_AngelType_bootROM, /* Simple ROM system providing download capability */ | |
354 | ADP_AngelType_appROM, /* ROM based application */ | |
355 | ADP_AngelType_appDLOAD,/* Downloaded Angel based application */ | |
356 | ADP_AngelType_Last /* Unknown type. This typedef can be extended */ | |
357 | /* but if the host and target vsns differ */ | |
358 | /* Then one will spot that it dies not understand */ | |
359 | } ADP_Angel_Types ; /* this field and can whinge appropriately */ | |
360 | ||
361 | /* First unknown ADP_AngelType */ | |
362 | #define ADP_ANGELVSN_UNKTYPE_MASK (0xFF000000) | |
363 | #define ADP_ANGELVSN_UNKYPE_SHIFT (24) | |
364 | ||
365 | /* Currently only 8 bits are used in the word: */ | |
366 | /* ADP protocol supported by target [Reference (2)] */ | |
367 | #define ADP_ANGELVSN_ADP_MASK (0x000000FF) | |
368 | #define ADP_ANGELVSN_ADP_SHIFT (0) | |
369 | ||
370 | /* ARM Architecture info: [Reference (3)] */ | |
371 | /* ARM Architecture Verson of target CPU */ | |
372 | #define ADP_ARM_ARCH_VSN_MASK (0x000000FF) | |
373 | #define ADP_ARM_ARCH_VSN_SHIFT (0) | |
374 | /* Does the processor support the Thumb Instruction Set */ | |
375 | #define ADP_ARM_ARCH_THUMB (0x80000000) | |
376 | /* Does the processor support Long Multiplies */ | |
377 | #define ADP_ARM_ARCH_LONGMUL (0x40000000) | |
378 | /* All other flags are current undefined, and should be zero. */ | |
379 | ||
380 | /* The following flags describe the feature set of the processor: */ | |
381 | /* Set if cpu supports little-endian model [Reference (4)] */ | |
382 | #define ADP_CPU_LE (1 << 0) | |
383 | /* Set if cpu supports big-endian model */ | |
384 | #define ADP_CPU_BE (1 << 1) | |
385 | /* Set if processor has a cache */ | |
386 | #define ADP_CPU_CACHE (1 << 2) | |
387 | /* Set if processor has a MMU */ | |
388 | #define ADP_CPU_MMU (1 << 3) | |
389 | /* All other flags are current undefined, and should be zero. */ | |
390 | ||
391 | /* The following flags reflect current Target hardware status: */ | |
392 | /* [Reference (5)] */ | |
393 | /* 0 = no MMU or MMU off; 1 = MMU on */ | |
394 | #define ADP_CPU_MMUOn (1 << 29) | |
395 | /* 0 = no cache or cache off; 1 = cache on */ | |
396 | #define ADP_CPU_CacheOn (1 << 30) | |
397 | /* 0 = little-endian; 1 = big-endian */ | |
398 | #define ADP_CPU_BigEndian (1U << 31) | |
399 | /* All other flags are current undefined, and should be zero. */ | |
400 | ||
401 | ||
402 | #ifdef LINK_RECOVERY | |
403 | ||
404 | #define ADP_TargetResetIndication ADPREASON(CI_TBOOT, 1) | |
405 | /* | |
406 | * If parameter negotiation is enabled at the target, it configures itself | |
407 | * to various likely parameter settings and sends this message at each | |
408 | * configuration. The message describes the default settings, and after | |
409 | * sending at each configuration the target sets itself to the defaults | |
410 | * it has just broadcast, to await either an ack on TBOOT or a request | |
411 | * or reset indication on HBOOT. | |
412 | * | |
413 | * If the host receives this message successfully, it should reset to the | |
414 | * indicated parameters and send a reply. | |
415 | * | |
416 | * Message arguments: | |
417 | * word status (always 0, makes body same as | |
418 | * ADP_ParamNegotiate response) | |
419 | * word n-parameters | |
420 | * n-parameters * { | |
421 | * word ADP_Parameter | |
422 | * word parameter-value | |
423 | * } | |
424 | * | |
425 | * Reply: | |
426 | * - empty acknowledgement | |
427 | */ | |
428 | ||
429 | #endif /* def LINK_RECOVERY */ | |
430 | ||
431 | typedef enum ADP_Boot_Ack { | |
432 | AB_NORMAL_ACK, /* will comply, immediate booted message */ | |
433 | AB_LATE_ACK, /* will comply, late startup */ | |
434 | AB_ERROR /* cannot comply */ | |
435 | } ADP_Boot_Ack; | |
436 | ||
437 | /* If the host sets neither of these in the word sent on a Reset / Reboot | |
438 | * then it doesn;t care about the endianess of the target | |
439 | */ | |
440 | #define ADP_BootHostFeature_LittleEnd 0x80000000 | |
441 | #define ADP_BootHostFeature_BigEnd 0x40000000 | |
442 | ||
443 | #define ADP_Reboot ADPREASON(CI_HBOOT,2) | |
444 | /* This message is sent when the host wants the target system to be | |
445 | * completely reset, back to the boot monitor Angel. This is the | |
446 | * method of the host forcing a cold-reboot. | |
447 | * Note that an acknowledgement message will be sent immediately and | |
448 | * that this must be sent before the target can reset. | |
449 | * | |
450 | * The parameter to this function is a bitset of host supported | |
451 | * features. (in fact the same as ADP_Reset below. This can be used by | |
452 | * the target system to avoid using debug channel bandwidth raising | |
453 | * messages that will be ignored by the host. | |
454 | * | |
455 | * Parameters: | |
456 | * word host supported features (see above) | |
457 | * | |
458 | * Reply: | |
459 | * word status, one of enum ADP_Boot_Ack above. | |
460 | * | |
461 | * Currently there are no such features defined, so the word indicating | |
462 | * host supported features should be set to 0. | |
463 | */ | |
464 | ||
465 | ||
466 | ||
467 | #define ADP_Reset ADPREASON(CI_HBOOT,3) | |
468 | /* This message is a request from the host, which should eventually | |
469 | * result in the "ADP_Booted" message being sent by the target. | |
470 | * Note that an acknowledgement message will be sent immediately and | |
471 | * that this must be sent before the target can reset. | |
472 | * This reset message is *ALWAYS* treated as a warm boot, with the target | |
473 | * preserving as much state as possible. | |
474 | * | |
475 | * The parameter to this function is a bitset of host supported | |
476 | * features. This can be used by the target system to avoid using | |
477 | * debug channel bandwitdth raising messages that will be ignored by | |
478 | * the host. | |
479 | * | |
480 | * Parameters: | |
481 | * word host supported features (see above) | |
482 | * | |
483 | * Reply: | |
484 | * word status, one of enum ADP_Boot_Ack above. | |
485 | * | |
486 | * Currently there are no such features defined, so the word indicating | |
487 | * host supported features should be set to 0. | |
488 | */ | |
489 | ||
490 | ||
491 | #ifdef LINK_RECOVERY | |
492 | ||
493 | #define ADP_HostResetIndication ADPREASON(CI_HBOOT, 4) | |
494 | /* | |
495 | * This is as for ADP_TargetResetIndication, but is sent by the host when | |
496 | * it first starts up in case the target is listening at a non-default | |
497 | * setting. Having sent at various configurations, the host then listens | |
498 | * at the defaults it has just broadcast, to await either an ack on HBOOT | |
499 | * or a reset indication on TBOOT. | |
500 | * | |
501 | * For arguments and reply, see ADP_TargetResetIndication. | |
502 | */ | |
503 | ||
504 | #endif /* def LINK_RECOVERY */ | |
505 | ||
506 | ||
507 | #define ADP_ParamNegotiate ADPREASON(CI_HBOOT, 5) | |
508 | /* | |
509 | * The host sends this messages to negotiate new parameters with the target. | |
510 | * For each parameter the host specifies a range of possibilities, starting | |
511 | * with the most favoured. All possible combinations of parameters | |
512 | * must be valid. | |
513 | * | |
514 | * If the target can operate at a combination of the offered parameters, | |
515 | * it will reply with the parameters it is willing to use. AFTER sending | |
516 | * the reply, the target switches to this combination. On receiving the | |
517 | * reply, the host will switch to the new combination and send a LinkCheck | |
518 | * message (see below). | |
519 | * | |
520 | * If the target cannot operate at any combination of the offered parameters, | |
521 | * it will reply with an error status. | |
522 | * | |
523 | * Message arguments: | |
524 | * word n-parameter-blocks | |
525 | * n-parameter-blocks * { | |
526 | * word ADP_Parameter | |
527 | * word n-options | |
528 | * n-options * { word parameter-value } | |
529 | * } | |
530 | * | |
531 | * Reply: | |
532 | * word status | |
533 | * if (status == RDIError_NoError) { | |
534 | * word n-parameters | |
535 | * n-parameters * { | |
536 | * word ADP_Parameter | |
537 | * word chosen-value | |
538 | * } | |
539 | * } | |
540 | */ | |
541 | ||
542 | #define ADP_LinkCheck ADPREASON(CI_HBOOT, 6) | |
543 | /* | |
544 | * This should be the first message that the host sends after a successful | |
545 | * parameter negotiation. It is really just a 'ping'. | |
546 | * | |
547 | * Message arguments: | |
548 | * - empty message | |
549 | * | |
550 | * Reply: | |
551 | * - empty acknowledgement | |
552 | */ | |
553 | ||
554 | ||
555 | /******************************************************************** | |
556 | * | |
557 | * CI_HADP messages | |
558 | * | |
559 | */ | |
560 | ||
561 | #define ADP_HADPUnrecognised ADPREASON(CI_HADP,0) | |
562 | /* This message is unusual in that it is normally sent in reply to | |
563 | * another message which is not understood. This is an exception | |
564 | * to the normal protocol which says that a reply must have the | |
565 | * same base reason code as the original. There is a single reply | |
566 | * parameter which is the reason code which was not understood. | |
567 | * | |
568 | * As well as being a reply this message can also be sent and will | |
569 | * return as if this message were unrecognised! | |
570 | * | |
571 | * Parameters: | |
572 | * none | |
573 | * | |
574 | * Reply: | |
575 | * word reason code which was not recognised | |
576 | */ | |
577 | ||
578 | ||
579 | #define ADP_Info ADPREASON(CI_HADP,1) | |
580 | /* This is the new ADP information message. It is used to interrogate | |
581 | * the target debug agent. It provides information on the processor, | |
582 | * as well as the state of the debug world. This allows the host to | |
583 | * configure itself to the capabilities of the target. | |
584 | * | |
585 | * We try not to use feature bitsets, since we could quickly run out | |
586 | * of known bits. Thus when the feature set is extended, this can be | |
587 | * done in a couple of supported ways: | |
588 | * | |
589 | * If an undivided reason code is to be added (no reason subcodes) | |
590 | * then add a new ADP_Info code which responds with a flag indicating | |
591 | * whether that feature is supported by the target. If this has not | |
592 | * even been implemented then the reply will be ADP_HADPUnrecognised | |
593 | * | |
594 | * If a reason code which is subdivided into reason subcodes is | |
595 | * added then reason subcode 0 should be set aside to indicate | |
596 | * whether the functionality of that reason code is supported | |
597 | * by the target. If it is not even implemented then the reply will | |
598 | * be ADP_Unrecognised. | |
599 | * | |
600 | * The first parameter to ADP_Info is a reason subcode, and subsequent | |
601 | * parameters are defined by that subcode | |
602 | * | |
603 | * Parameters: | |
604 | * word reason subcode | |
605 | * other arguments as reason subcode determines. | |
606 | * | |
607 | * Reply: | |
608 | * word reason subcode | |
609 | * other argument as reason subcode determines | |
610 | */ | |
611 | ||
612 | /* ADP_Info reason subcodes: */ | |
613 | ||
614 | ||
615 | ||
616 | #define ADP_Info_NOP ADPSUBREASON(CI_HADP,0) | |
617 | /* ADP_Info_NOP | |
618 | * ------------ | |
619 | * Summary: This message is used to check for ADP_Info being supported. | |
620 | * | |
621 | * Arguments: | |
622 | * Send: () | |
623 | * Return: (word status) | |
624 | * | |
625 | * 'status' returns RDIError_NoError for success, non-zero indicates an error. | |
626 | * If an error is returned then there is no handler for the ADP_Info | |
627 | * message. The normal action will be to return an OK status. | |
628 | */ | |
629 | ||
630 | ||
631 | #define ADP_Info_Target ADPSUBREASON(CI_HADP,1) | |
632 | /* ADP_Info_Target | |
633 | * --------------- | |
634 | * Summary: | |
635 | * This reason code is used to interrogate target system details. | |
636 | * | |
637 | * Arguments: | |
638 | * Send: () | |
639 | * Return: (word status, word bitset, word model) | |
640 | * | |
641 | * 'status' is RDIError_NoError to indicate OK, or non-zero to indicate | |
642 | * some sort of error. | |
643 | * 'bitset' is described in more detail below, and is mostly compatible | |
644 | * with the old RDI/RDP system to avoid gratuitous changes to the debugger | |
645 | * toolbox. | |
646 | * 'model' is the target hardware ID word, as returned by the ADP_Booted | |
647 | * message. | |
648 | * | |
649 | * NOTE: The minimum and maximum protocol levels are no longer supported. | |
650 | * It is the Angel view that debugging complexity should be shifted to the | |
651 | * host if at all possible. This means that the host debugger should | |
652 | * always try to configure itself to the features available in the target | |
653 | * debug agent. This can be done by checking individual messages, rather | |
654 | * than by a blanket version number dictating the feature set. | |
655 | */ | |
656 | ||
657 | /* 'bitset':- */ | |
658 | /* Target speed in instructions per second = 10**(bits0..3). */ | |
659 | #define ADP_Info_Target_LogSpeedMask (0xF) | |
660 | ||
661 | /* Target is running on [0 = emulator / 1 = hardware] */ | |
662 | #define ADP_Info_Target_HW (1 << 4) | |
663 | ||
664 | /* Bits 5..10 are currently undefined and should be zero. */ | |
665 | /* Other bis are kept the same as the RDP in order to */ | |
666 | /* eliminate the need to change the position of some bits */ | |
667 | ||
668 | /* If set then the debug agent can be reloaded. */ | |
669 | #define ADP_Info_Target_CanReloadAgent (1 << 11) | |
670 | ||
671 | /* Can request AngelBufferSize information. */ | |
672 | #define ADP_Info_Target_CanInquireBufferSize (1 << 12) | |
673 | ||
674 | /* Bit 13 is no longer required as it inquired whether | |
675 | * a special RDP Interrupt code was supported | |
676 | */ | |
677 | ||
678 | /* Debug agent can perform profiling. */ | |
679 | #define ADP_Info_Target_Profiling (1 << 14) | |
680 | ||
681 | /* Debug agent can support Thumb code. */ | |
682 | #define ADP_Info_Target_Thumb (1 << 15) | |
683 | ||
684 | /* Bit 16 was the communications channel check. | |
685 | * This is always available on Angel systems. | |
686 | */ | |
687 | ||
688 | #define ADP_Info_Points ADPSUBREASON(CI_HADP,2) | |
689 | /* ADP_Info_Points | |
690 | * --------------- | |
691 | * Summary: Returns a 32bit wide bitset of break- and watch-point | |
692 | * features supported by the target debug agent. | |
693 | * | |
694 | * Arguments: | |
695 | * Send: () | |
696 | * Return: (word status, word breakinfo) | |
697 | * | |
698 | * 'status' returns RDIError_NoError on success or non-zero to indicate | |
699 | * some sort of error. | |
700 | * 'breakinfo' is a 32bit wide bitset described in detail below. Note | |
701 | * that only bits 1..12 are used. | |
702 | */ | |
703 | ||
704 | /* 'breakinfo':- */ | |
705 | /* Can trap on address equality. */ | |
706 | #define ADP_Info_Points_Comparison (1 << 0) | |
707 | ||
708 | /* Can trap on address range. */ | |
709 | #define ADP_Info_Points_Range (1 << 1) | |
710 | ||
711 | /* Can trap on 8bit memory reads. */ | |
712 | #define ADP_Info_Points_ReadByteWatch (1 << 2) | |
713 | ||
714 | /* Can trap on 16bit memory reads. */ | |
715 | #define ADP_Info_Points_ReadHalfWatch (1 << 3) | |
716 | ||
717 | /* Can trap on 32bit memory reads. */ | |
718 | #define ADP_Info_Points_ReadWordWatch (1 << 4) | |
719 | ||
720 | /* Can trap on 8bit write accesses. */ | |
721 | #define ADP_Info_Points_WriteByteWatch (1 << 5) | |
722 | ||
723 | /* Can trap on 16bit write accesses. */ | |
724 | #define ADP_Info_Points_WriteHalfWatch (1 << 6) | |
725 | ||
726 | /* Can trap on 32bit write accesses. */ | |
727 | #define ADP_Info_Points_WriteWordWatch (1 << 7) | |
728 | ||
729 | /* Like range, but based on address bitmask<. */ | |
730 | #define ADP_Info_Points_Mask (1 << 8) | |
731 | ||
732 | /* Multi-threaded support only - thread specific breakpoints. */ | |
733 | #define ADP_Info_Points_ThreadBreak (1 << 9) | |
734 | ||
735 | /* Multi-threaded support only - thread specific watchpoints. */ | |
736 | #define ADP_Info_Points_ThreadWatch (1 << 10) | |
737 | ||
738 | /* Allows conditional breakpoints. */ | |
739 | #define ADP_Info_Points_Conditionals (1 << 11) | |
740 | ||
741 | /* Break- and watch-points can be interrogated */ | |
742 | #define ADP_Info_Points_Status (1 << 12) | |
743 | ||
744 | ||
745 | #define ADP_Info_Step ADPSUBREASON(CI_HADP,3) | |
746 | /* ADP_Info_Step | |
747 | * ------------- | |
748 | * Summary: Returns a 32bit wide bitmask of the single-stepping | |
749 | * capabilities of the target debug agent. | |
750 | * | |
751 | * Arguments: | |
752 | * Send: () | |
753 | * Return: (word status, word stepinfo) | |
754 | * | |
755 | * 'status' returns RDIError_NoError on success, or non-zero to indicate | |
756 | * some kind of error. | |
757 | * 'stepinfo' is a 32bit wide bitmask described in detail below. Note that | |
758 | * only 3 bits are used. | |
759 | */ | |
760 | ||
761 | /* 'stepinfo':- */ | |
762 | /* Single-stepping of more than one instruction is possible. */ | |
763 | #define ADP_Info_Step_Multiple (1 << 0) | |
764 | ||
765 | /* Single-stepping until next direct PC change is possible. */ | |
766 | #define ADP_Info_Step_PCChange (1 << 1) | |
767 | ||
768 | /* Single-stepping of a single instruction is possible. */ | |
769 | #define ADP_Info_Step_Single (1 << 2) | |
770 | ||
771 | ||
772 | #define ADP_Info_MMU ADPSUBREASON(CI_HADP,4) | |
773 | /* ADP_Info_MMU | |
774 | * ------------ | |
775 | * Summary: Returns information about the memory management system (if | |
776 | * any). | |
777 | * | |
778 | * Arguments: | |
779 | * Send: () | |
780 | * Return: (word status, word meminfo) | |
781 | * | |
782 | * 'status' returns RDIError_NoError to indicate success or non-zero to | |
783 | * indicate some kind of error. | |
784 | * 'meminfo' should be a 32bit unique ID, or zero if there is no MMU | |
785 | * support on the target. | |
786 | */ | |
787 | ||
788 | ||
789 | #define ADP_Info_SemiHosting ADPSUBREASON(CI_HADP,5) | |
790 | /* ADP_Info_SemiHosting | |
791 | * -------------------- | |
792 | * Summary: This message is used to check whether semi-hosting info calls | |
793 | * are available on the target. | |
794 | * | |
795 | * Arguments: | |
796 | * Send: () | |
797 | * Return: (word status) | |
798 | * | |
799 | * 'status' returns RDIError_NoError if semi-hosting info calls are available, | |
800 | * non-zero otherwise. | |
801 | */ | |
802 | ||
803 | ||
804 | #define ADP_Info_CoPro ADPSUBREASON(CI_HADP,6) | |
805 | /* ADP_Info_CoPro | |
806 | * -------------- | |
807 | * Summary: This message checks whether CoProcessor info calls are | |
808 | * supported. | |
809 | * | |
810 | * Arguments: | |
811 | * Send: () | |
812 | * Return: (word status) | |
813 | * | |
814 | * 'status' returns RDIError_NoError to indicate these facilities | |
815 | * are supported, non-zero otherwise. | |
816 | */ | |
817 | ||
818 | ||
819 | #define ADP_Info_Cycles ADPSUBREASON(CI_HADP,7) | |
820 | /* ADP_Info_Cycles | |
821 | * --------------- | |
822 | * Summary: Returns the number of instructions and cycles executed since | |
823 | * the target was initialised. | |
824 | * | |
825 | * Arguments: | |
826 | * Send: () | |
827 | * Return: (word status, word ninstr, word Scycles, word Ncycles, | |
828 | * word Icycles, word Ccycles, word Fcycles) | |
829 | * | |
830 | * 'status' is RDIError_NoError to indicate success, or non-zero if there | |
831 | * is no target support for gathering cycle count information. | |
832 | * 'ninstr' is the number of instructions executed. | |
833 | * 'Scycles' is the number of S-cycles executed. | |
834 | * 'Ncycles' is the number of N-cycles executed. | |
835 | * 'Icycles' is the number of I-cycles executed. | |
836 | * 'Ccycles' is the number of C-cycles executed. | |
837 | * 'Fcycles' is the number of F-cycles executed. | |
838 | */ | |
839 | ||
840 | ||
841 | #define ADP_Info_DescribeCoPro ADPSUBREASON(CI_HADP,8) | |
842 | /* ADP_Info_DescribeCoPro | |
843 | * ---------------------- | |
844 | * Summary: Describe the registers of a coprocessor. Use only if | |
845 | * ADP_Info_CoPro return RDIError_NoError. | |
846 | * | |
847 | * Arguments: | |
848 | * Send: Arguments of the form: | |
849 | * (byte cpno, byte rmin, byte rmax, byte nbytes, byte access, | |
850 | * byte cprt_r_b0, byte cprt_r_b1, byte cprt_w_b0, byte cprt_w_b1) | |
851 | * And a terminating byte = 0xff. Must be within maximum buffer size. | |
852 | * Return: (word status) | |
853 | * | |
854 | * 'cpno' is the number of the coprocessor to be described. | |
855 | * 'rmin' is the bottom of a range of registers with the same description. | |
856 | * 'rmax' is the top of a range of registers with the same description. | |
857 | * 'nbytes' is the size of the register. | |
858 | * 'access' describes access to the register and is described in more detail | |
859 | * below. | |
860 | * | |
861 | * If bit 2 of access is set:- | |
862 | * 'cprt_r0' provides bits 0 to 7, and | |
863 | * 'cprt_r1' provides bits 16 to 23 of a CPRT instruction to read the | |
864 | * register. | |
865 | * 'cprt_w0' provides bits 0 to 7, and | |
866 | * 'cprt_w1' provides bits 16 to 23 of a CPRT instruction to write the | |
867 | * register. | |
868 | * | |
869 | * Otherwise, 'cprt_r0' provides bits 12 to 15, and 'cprt_r1' bit 22 of CPDT | |
870 | * instructions to read and write the register ('cprt_w0' and 'cprt_w1' are | |
871 | * junk). | |
872 | */ | |
873 | ||
874 | /* 'access':- */ | |
875 | /* Readable. */ | |
876 | #define ADP_Info_DescribeCoPro_Readable (1 << 0) | |
877 | ||
878 | /* Writeable. */ | |
879 | #define ADP_Info_DescribeCoPro_Writeable (1 << 1) | |
880 | ||
881 | /* Registers read or written via CPDT instructions (else CPRT) with this | |
882 | bit set. */ | |
883 | #define ADP_Info_DescribeCoPro_CPDT (1 << 2) | |
884 | ||
885 | #define ADP_Info_RequestCoProDesc ADPSUBREASON(CI_HADP,9) | |
886 | /* ADP_Info_RequestCoProDesc | |
887 | * ------------------------- | |
888 | * Summary: Requests a description of the registers of a coprocessor. Use | |
889 | * only if ADP_Info_CoPro return RDIError_NoError. | |
890 | * | |
891 | * Arguments: | |
892 | * Send: (byte cpno) | |
893 | * Return: Arguments of the form:- | |
894 | * (word status, byte rmin, byte rmax, byte nbytes, byte access) | |
895 | * Followed by a terminating byte = 0xFF. Must be within maximum | |
896 | * buffer size. | |
897 | * 'cpno' is the number of the coprocessor to describe. | |
898 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
899 | * 'rmin' is the bottom of a range of registers with the same description. | |
900 | * 'rmax' is the top of a range of registers with the same description. | |
901 | * 'nbytes' is the size in bytes of the register(s). | |
902 | * 'access' is as above in ADP_Info_DescribeCoPro. | |
903 | */ | |
904 | ||
905 | ||
906 | #define ADP_Info_AngelBufferSize ADPSUBREASON(CI_HADP,10) | |
907 | /* ADP_Info_AngelBufferSize | |
908 | * ------------------------ | |
909 | * Summary: Returns the Angel buffer sizes. | |
910 | * | |
911 | * Arguments: | |
912 | * Send: () | |
913 | * Return: (word status, word defaultsize, word maxsize) | |
914 | * | |
915 | * 'status' returns RDIError_NoError to indicate success or non-zero to | |
916 | * indicate some kind of error. | |
917 | * 'defaultsize' is the default Angel ADP buffer size in bytes. This is | |
918 | * at least 256 bytes. | |
919 | * 'maxsize' is the largest Angel ADP buffer size in bytes. This will be | |
920 | * greater than or equal to defaultsize. The target will accept ADP messages | |
921 | * of up to this length for download, etc. | |
922 | * | |
923 | * Was DownLoadSize in RDP/RDI world. This is the amount that the target | |
924 | * should transmit in a single operation. This should now be the Angel | |
925 | * buffer size. This information is also given in the ADP_Booted message. | |
926 | * | |
927 | * NOTE: The value returned should be the DATASIZE and *NOT* BUFFERDEFSIZE. | |
928 | * This is needed to ensure that the transport protocol information | |
929 | * can be wrapped around the data. | |
930 | */ | |
931 | ||
932 | #define ADP_Info_ChangeableSHSWI ADPSUBREASON(CI_HADP,11) | |
933 | /* ADP_Info_ChangeableSHSWI | |
934 | * ------------------------ | |
935 | * Summary: This message is used to check whether it is possible to change | |
936 | * which SWI's are used for semihosting. | |
937 | * | |
938 | * Arguments: | |
939 | * Send: () | |
940 | * Return: (word status) | |
941 | * | |
942 | * 'status' returns RDIError_NoError if semi-hosting info calls are available, | |
943 | * non-zero otherwise. | |
944 | */ | |
945 | ||
946 | #define ADP_Info_CanTargetExecute ADPSUBREASON(CI_HADP,12) | |
947 | /* ADP_Info_CanTargetExecute | |
948 | * ------------------------- | |
949 | * Summary: This message is used to see if the target is currently in | |
950 | * an executable state. Typically this is called after the debugger | |
951 | * initialises. If a non-error statis is returned then the user is | |
952 | * allowed to 'go' immediately. | |
953 | * | |
954 | * Arguments: | |
955 | * Send: () | |
956 | * Return: (word status) | |
957 | * | |
958 | * 'status' returns RDIError_NoError if target is ready to execute. | |
959 | * other values indicate why it cannot execute. | |
960 | */ | |
961 | ||
962 | #define ADP_Info_AgentEndianess ADPSUBREASON(CI_HADP,13) | |
963 | /* ADP_Info_AgentEndianess | |
964 | * ------------------------- | |
965 | * Summary: This message is used to determine the endianess of the | |
966 | * debug agent | |
967 | * Arguments: | |
968 | * Send: () | |
969 | * Return: (word status) | |
970 | * | |
971 | * status should be RDIError_LittleEndian or RDIError_BigEndian | |
972 | * any other value indicates the target does not support this | |
973 | * request, so the debugger will have to make a best guess, which | |
974 | * probably means only allow little endian loadagenting. | |
975 | */ | |
976 | ||
977 | ||
978 | #define ADP_Control ADPREASON(CI_HADP,2) | |
979 | /* This message allows for the state of the debug agent to be | |
980 | * manipulated by the host. | |
981 | */ | |
982 | ||
983 | /* The following are sub reason codes to ADP control, the first parameter | |
984 | * is the sub reason code which defines the format of subsequent parameters. | |
985 | * | |
986 | * word sub reason code | |
987 | */ | |
988 | ||
989 | #define ADP_Ctrl_NOP ADPSUBREASON(CI_HADP,0) | |
990 | /* ADP_Ctrl_NOP | |
991 | * ------------ | |
992 | * Summary: This message is used to check that ADP_Ctrl messages are | |
993 | * supported. | |
994 | * | |
995 | * Arguments: | |
996 | * Send: () | |
997 | * Return: (word status) | |
998 | * | |
999 | * 'status' is RDIError_NoError to indicate ADP_Ctrl messages are | |
1000 | * supported, non-zero otherwise. | |
1001 | */ | |
1002 | ||
1003 | #define ADP_Ctrl_VectorCatch ADPSUBREASON(CI_HADP,1) | |
1004 | /* ADP_Ctrl_VectorCatch | |
1005 | * -------------------- | |
1006 | * Summary: Specifies which hardware exceptions should be reported to the | |
1007 | * debugger. | |
1008 | * | |
1009 | * Arguments: | |
1010 | * Send: (word bitmap) | |
1011 | * Return: (word status) | |
1012 | * | |
1013 | * 'bitmap' is a bit-mask of exceptions to be reported, described in more | |
1014 | * detail below. A set bit indicates that the exception should be | |
1015 | * reported to the debugger, a clear bit indicates that the corresponding | |
1016 | * exception vector should be taken. | |
1017 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1018 | */ | |
1019 | ||
1020 | /* 'bitmap':- */ | |
1021 | /* Reset(branch through zero). */ | |
1022 | #define ADP_Ctrl_VectorCatch_BranchThroughZero (1 << 0) | |
1023 | ||
1024 | /* Undefined Instruction. */ | |
1025 | #define ADP_Ctrl_VectorCatch_UndefinedInstr (1 << 1) | |
1026 | ||
1027 | /* Software Interrupt. */ | |
1028 | #define ADP_Ctrl_VectorCatch_SWI (1 << 2) | |
1029 | ||
1030 | /* Prefetch Abort. */ | |
1031 | #define ADP_Ctrl_VectorCatch_PrefetchAbort (1 << 3) | |
1032 | ||
1033 | /* Data Abort. */ | |
1034 | #define ADP_Ctrl_VectorCatch_DataAbort (1 << 4) | |
1035 | ||
1036 | /* Address Exception. */ | |
1037 | #define ADP_Ctrl_VectorCatch_AddressException (1 << 5) | |
1038 | ||
1039 | /* Interrupt Request. */ | |
1040 | #define ADP_Ctrl_VectorCatch_IRQ (1 << 6) | |
1041 | ||
1042 | /* Fast Interrupt Request. */ | |
1043 | #define ADP_Ctrl_VectorCatch_FIQ (1 << 7) | |
1044 | ||
1045 | /* Error. */ | |
1046 | #define ADP_Ctrl_VectorCatch_Error (1 << 8) | |
1047 | ||
1048 | ||
1049 | #define ADP_Ctrl_PointStatus_Watch ADPSUBREASON(CI_HADP,2) | |
1050 | /* ADP_Ctrl_PointStatus_Watch | |
1051 | * -------------------------- | |
1052 | * Summary: Returns the hardware resource number and the type of that | |
1053 | * resource when given a watchpoint handle. Should only be called if | |
1054 | * the value returned by ADP_Info_Points had ADP_Info_Points_Status set. | |
1055 | * | |
1056 | * Arguments: | |
1057 | * Send: (word handle) | |
1058 | * Return: (word status, word hwresource, word type) | |
1059 | * | |
1060 | * 'handle' is a handle to a watchpoint. | |
1061 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1062 | * 'hwresource' is the hardware resource number. !!!!! | |
1063 | * 'type' is the type of the resource. | |
1064 | */ | |
1065 | ||
1066 | ||
1067 | #define ADP_Ctrl_PointStatus_Break ADPSUBREASON(CI_HADP,3) | |
1068 | /* ADP_Ctrl_PointStatus_Break | |
1069 | * -------------------------- | |
1070 | * Summary: Returns the hardware resource number and the type of that | |
1071 | * resource when given a breakpoint handle. Should only be called if | |
1072 | * the value returned by ADP_Info_Points had ADP_Info_Points_Status set. | |
1073 | * | |
1074 | * Arguments: | |
1075 | * Send: (word handle) | |
1076 | * Return: (word status, word hwresource, word type) | |
1077 | * | |
1078 | * 'handle' is a handle to a breakpoint. | |
1079 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1080 | * 'hwresource' is the hardware resource number. | |
1081 | * 'type' is the type of the resource. | |
1082 | */ | |
1083 | ||
1084 | #define ADP_Ctrl_SemiHosting_SetState ADPSUBREASON(CI_HADP,4) | |
1085 | /* ADP_Ctrl_SemiHosting_SetState | |
1086 | * ----------------------------- | |
1087 | * Summary: Sets whether or not semi-hosting is enabled. | |
1088 | * | |
1089 | * Arguments: | |
1090 | * Send: (word semihostingstate) | |
1091 | * Return: (word status) | |
1092 | * | |
1093 | * 'semihostingstate' sets semi-hosting to enabled if zero, otherwise | |
1094 | * it disables semi-hosting. | |
1095 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1096 | * | |
1097 | * NOTE: This should only be called if ADP_Info_SemiHosting didn't return | |
1098 | * an error. | |
1099 | */ | |
1100 | ||
1101 | ||
1102 | #define ADP_Ctrl_SemiHosting_GetState ADPSUBREASON(CI_HADP,5) | |
1103 | /* ADP_Ctrl_SemiHosting_GetState | |
1104 | * ----------------------------- | |
1105 | * Summary: Reads whether or not semi-hosting is enabled. | |
1106 | * | |
1107 | * Arguments: | |
1108 | * Send: () | |
1109 | * Return: (word status, word semihostingstate) | |
1110 | * | |
1111 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1112 | * 'semihostingstate' is zero if semi-hosting is enabled, non-zero otherwise. | |
1113 | * | |
1114 | * NOTE: This should only be called if ADP_Info_SemiHosting didn't return | |
1115 | * an error. | |
1116 | */ | |
1117 | ||
1118 | ||
1119 | #define ADP_Ctrl_SemiHosting_SetVector ADPSUBREASON(CI_HADP,6) | |
1120 | /* ADP_Ctrl_SemiHosting_SetVector | |
1121 | * ------------------------------ | |
1122 | * Summary: Sets the semi-hosting vector. | |
1123 | * | |
1124 | * Arguments: | |
1125 | * Send: (word semihostingvector) | |
1126 | * Return: (word status) | |
1127 | * | |
1128 | * 'semihostingvector' holds the value the vector is to be set to. | |
1129 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1130 | * | |
1131 | * NOTE: This should only be called if ADP_Info_SemiHosting didn't return | |
1132 | * an error. | |
1133 | */ | |
1134 | ||
1135 | ||
1136 | #define ADP_Ctrl_SemiHosting_GetVector ADPSUBREASON(CI_HADP,7) | |
1137 | /* ADP_Ctrl_SemiHosting_GetVector | |
1138 | * ------------------------------ | |
1139 | * Summary: Gets the value of the semi-hosting vector. | |
1140 | * | |
1141 | * Arguments: | |
1142 | * Send: () | |
1143 | * Return: (word status, word semihostingvector) | |
1144 | * | |
1145 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1146 | * 'semihostingvector' holds the value of the vector. | |
1147 | * | |
1148 | * NOTE: This should only be called if ADP_Info_SemiHosting didn't return | |
1149 | * an error. | |
1150 | */ | |
1151 | ||
1152 | ||
1153 | #define ADP_Ctrl_Log ADPSUBREASON(CI_HADP,8) | |
1154 | /* ADP_Ctrl_Log | |
1155 | * ------------ | |
1156 | * Summary: Returns the logging state. | |
1157 | * | |
1158 | * Arguments: | |
1159 | * Send: () | |
1160 | * Return: (word status, word logsetting) | |
1161 | * | |
1162 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1163 | * 'logsetting' is a bitmap specifying the level of logging desired, | |
1164 | * described in more detail below. The bits can be ORed together | |
1165 | */ | |
1166 | ||
1167 | /* 'logsetting':- */ | |
1168 | ||
1169 | /* No logging. */ | |
1170 | #define ADP_Ctrl_Log_NoLogging (0) | |
1171 | /* RDI level logging. */ | |
1172 | #define ADP_Ctrl_Log_RDI (1 << 0) | |
1173 | /* ADP byte level logging. */ | |
1174 | #define ADP_Ctrl_Log_ADP (1 << 1) | |
1175 | ||
1176 | ||
1177 | #define ADP_Ctrl_SetLog ADPSUBREASON(CI_HADP,9) | |
1178 | /* ADP_Ctrl_SetLog | |
1179 | * --------------- | |
1180 | * Summary: Sets the logging state. | |
1181 | * | |
1182 | * Arguments: | |
1183 | * Send: (word logsetting) | |
1184 | * Return: (word status) | |
1185 | * | |
1186 | * 'logsetting' is the same as in ADP_Ctrl_Log above. | |
1187 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1188 | */ | |
1189 | ||
1190 | #define ADP_Ctrl_SemiHosting_SetARMSWI ADPSUBREASON(CI_HADP,10) | |
1191 | /* ADP_Ctrl_SemiHosting_SetARMSWI | |
1192 | * ------------------------------ | |
1193 | * Summary: Sets the number of the ARM SWI used for semihosting | |
1194 | * | |
1195 | * Arguments: | |
1196 | * Send: (word ARM_SWI_number) | |
1197 | * Return: (word status) | |
1198 | * | |
1199 | * The debug agent will interpret ARM SWI's with the SWI number specified | |
1200 | * as semihosting SWI's. | |
1201 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1202 | * | |
1203 | * NOTE: This should only be called if ADP_Info_ChangeableSHSWI didn't return | |
1204 | * an error. | |
1205 | */ | |
1206 | ||
1207 | ||
1208 | #define ADP_Ctrl_SemiHosting_GetARMSWI ADPSUBREASON(CI_HADP,11) | |
1209 | /* ADP_Ctrl_SemiHosting_GetARMSWI | |
1210 | * ------------------------------ | |
1211 | * Summary: Reads the number of the ARM SWI used for semihosting | |
1212 | * | |
1213 | * Arguments: | |
1214 | * Send: () | |
1215 | * Return: (word status, word ARM_SWI_number) | |
1216 | * | |
1217 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1218 | * ARM_SWI_number is the SWI number which is used for semihosting. | |
1219 | * | |
1220 | * NOTE: This should only be called if ADP_Info_SemiHosting didn't return | |
1221 | * an error. | |
1222 | */ | |
1223 | ||
1224 | #define ADP_Ctrl_SemiHosting_SetThumbSWI ADPSUBREASON(CI_HADP,12) | |
1225 | /* ADP_Ctrl_SemiHosting_SetThumbSWI | |
1226 | * -------------------------------- | |
1227 | * Summary: Sets the number of the Thumb SWI used for semihosting | |
1228 | * | |
1229 | * Arguments: | |
1230 | * Send: (word Thumb_SWI_number) | |
1231 | * Return: (word status) | |
1232 | * | |
1233 | * The debug agent will interpret Thumb SWI's with the SWI number specified | |
1234 | * as semihosting SWI's. | |
1235 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1236 | * | |
1237 | * NOTE: This should only be called if ADP_Info_ChangeableSHSWI didn't return | |
1238 | * an error. | |
1239 | */ | |
1240 | ||
1241 | ||
1242 | #define ADP_Ctrl_SemiHosting_GetThumbSWI ADPSUBREASON(CI_HADP,13) | |
1243 | /* ADP_Ctrl_SemiHosting_GetThumbSWI | |
1244 | * -------------------------------- | |
1245 | * Summary: Reads the number of the Thumb SWI used for semihosting | |
1246 | * | |
1247 | * Arguments: | |
1248 | * Send: () | |
1249 | * Return: (word status, word ARM_Thumb_number) | |
1250 | * | |
1251 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1252 | * Thumb_SWI_number is the SWI number which is used for semihosting. | |
1253 | * | |
1254 | * NOTE: This should only be called if ADP_Info_SemiHosting didn't return | |
1255 | * an error. | |
1256 | */ | |
1257 | ||
1258 | ||
1259 | #define ADP_Ctrl_Download_Supported ADPSUBREASON(CI_HADP,14) | |
1260 | /* ADP_Ctrl_Download_Supported | |
1261 | * --------------------------- | |
1262 | * Summary: Can configuration be downloaded? | |
1263 | * | |
1264 | * Arguments: | |
1265 | * Send: () | |
1266 | * Return: (word status) | |
1267 | * | |
1268 | * 'status' is RDIError_NoError if the configuration can be downloaded, | |
1269 | * non-zero otherwise. | |
1270 | * | |
1271 | * NOTE: Equivalent to RDIInfo_DownLoad. | |
1272 | */ | |
1273 | ||
1274 | ||
1275 | #define ADP_Ctrl_Download_Data ADPSUBREASON(CI_HADP,15) | |
1276 | /* ADP_Ctrl_Download_Data | |
1277 | * ---------------------- | |
1278 | * Summary: Loads configuration data. | |
1279 | * | |
1280 | * Arguments: | |
1281 | * Send: (word nbytes, words data) | |
1282 | * Return: (word status) | |
1283 | * | |
1284 | * 'nbytes' is the number of *bytes* being sent. | |
1285 | * 'data' is the configuration data. NOTE: data must not cause the buffer | |
1286 | * size to exceed the maximum allowed buffer size. | |
1287 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1288 | * | |
1289 | * NOTE: Equivalent to RDP_LoadConfigData. Should only be used if | |
1290 | * ADP_ICEM_AddConfig didn't return an error. | |
1291 | */ | |
1292 | ||
1293 | ||
1294 | #define ADP_Ctrl_Download_Agent ADPSUBREASON(CI_HADP,16) | |
1295 | /* ADP_Ctrl_Download_Agent | |
1296 | * ----------------------- | |
1297 | * Summary: Prepares Debug Agent to receive configuration data which it | |
1298 | * should interpret as a new version of the Debug Agent code. | |
1299 | * | |
1300 | * Arguments: | |
1301 | * Send: (word loadaddress, word size) | |
1302 | * Return: (word status) | |
1303 | * | |
1304 | * 'loadaddress' is the address where the new Debug Agent code should be | |
1305 | * loaded. | |
1306 | * 'size' is the number of bytes of Debug Agent code to be loaded. | |
1307 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1308 | * | |
1309 | * NOTE: Equivalent to RDP_LoadAgent. The data will be downloaded using | |
1310 | * ADP_Ctrl_Download_Data. The new agent is started with ADP_Ctrl_Start_Agent | |
1311 | */ | |
1312 | ||
1313 | ||
1314 | #define ADP_Ctrl_Start_Agent ADPSUBREASON(CI_HADP,17) | |
1315 | /* ADP_Ctrl_Start_Agent | |
1316 | * ----------------------- | |
1317 | * Summary: Instruct Debug Agent to begin execution of new agent, | |
1318 | * which has been downloaded by ADP_Ctrl_Download_Agent. | |
1319 | * | |
1320 | * Arguments: | |
1321 | * Send: (word startaddress) | |
1322 | * Return: (word status) | |
1323 | * | |
1324 | * 'startaddress' is the address where the new Debug Agent code should be | |
1325 | * entered, and must satisfy: | |
1326 | * (loadaddress <= startaddress <= (loadaddress + size)) | |
1327 | * where 'loadaddress' and 'size' were specified in the | |
1328 | * ADP_Ctrl_Download_Agent message. | |
1329 | * | |
1330 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1331 | */ | |
1332 | ||
1333 | ||
1334 | #define ADP_Ctrl_SetTopMem ADPSUBREASON(CI_HADP,18) | |
1335 | /* ADP_Ctrl_SetTopMem | |
1336 | * ------------------ | |
1337 | * Summary: Sets the top of memory for ICEman2 systems, so that the C Library | |
1338 | * can allocate the stack in the correct place on startup. | |
1339 | * | |
1340 | * Arguments: | |
1341 | * Send: (word mem_top) | |
1342 | * Return: (word status) | |
1343 | * | |
1344 | * This request should only be supported by ICEman2. Standard Angel systems | |
1345 | * should return an error (unrecognised is fine). | |
1346 | */ | |
1347 | ||
1348 | ||
1349 | #define ADP_Read ADPREASON(CI_HADP,3) | |
1350 | #define ADP_ReadHeaderSize (ADP_DEFAULT_HEADER_SIZE + 2*sizeof(word)) | |
1351 | ||
1352 | /* ADP_Read | |
1353 | * -------- | |
1354 | * Summary: Request for a transer of memory contents from the target to the | |
1355 | * debugger. | |
1356 | * | |
1357 | * Arguments: | |
1358 | * Send: (word address, word nbytes) | |
1359 | * Return: (word status, word rnbytes [, bytes data]) | |
1360 | * | |
1361 | * 'address' is the address from which memory transer should start. | |
1362 | * 'nbytes' is the number of bytes to transfer. | |
1363 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1364 | * 'rnbytes' holds the number of requested bytes NOT read (i.e. zero | |
1365 | * indicates success, non-zero indicates an error). | |
1366 | * 'data' is the number of bytes requested minus 'rnbytes'. | |
1367 | */ | |
1368 | ||
1369 | ||
1370 | ||
1371 | #define ADP_Write ADPREASON(CI_HADP,4) | |
1372 | #define ADP_WriteHeaderSize (ADP_DEFAULT_HEADER_SIZE + 2*sizeof(word)) | |
1373 | ||
1374 | /* ADP_Write | |
1375 | * --------- | |
1376 | * Summary: Request for a transfer of memory contents from the debugger to | |
1377 | * the target. | |
1378 | * | |
1379 | * Arguments: | |
1380 | * Send: (word address, word nbytes, bytes data) | |
1381 | * Return: (word status [, word rnbytes]) | |
1382 | * | |
1383 | * 'address' is the address from which memory transer should start. | |
1384 | * 'nbytes' is the number of bytes to transfer. | |
1385 | * 'data' holds the bytes to be transferred. | |
1386 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1387 | * 'rnbytes' holds the number of requested bytes NOT written (i.e. zero | |
1388 | * indicates success, non-zero indicates an error) if status indicated an | |
1389 | * error. | |
1390 | */ | |
1391 | ||
1392 | ||
1393 | ||
1394 | #define ADP_CPUread ADPREASON(CI_HADP,5) | |
1395 | /* ADP_CPUread | |
1396 | * ----------- | |
1397 | * Summary: This is a request to read values in the CPU. | |
1398 | * | |
1399 | * Arguments: | |
1400 | * Send: (byte mode, word mask) | |
1401 | * Return: (word status, words data) | |
1402 | * | |
1403 | * 'mode' defines the processor mode from which the transfer should be made. | |
1404 | * It is described in more detail below. | |
1405 | * 'mask' indicates which registers should be transferred. Setting a bit to | |
1406 | * one will cause the designated register to be transferred. The details | |
1407 | * of mask are specified below. | |
1408 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1409 | * 'data' holds the values of the registers on successful completion, | |
1410 | * otherwise it just holds rubbish. The lowest numbered register is | |
1411 | * transferred first. NOTE: data must not cause the buffer size to exceed | |
1412 | * the maximum allowed buffer size. | |
1413 | */ | |
1414 | ||
1415 | /* 'mode':- */ | |
1416 | /* The mode number is the same as the mode number used by an ARM; a value of | |
1417 | 255 indicates the current mode. */ | |
1418 | #define ADP_CPUmode_Current (255) | |
1419 | ||
1420 | /* 26bit user mode. */ | |
1421 | #define ADP_CPUread_26bitUser (0x0) | |
1422 | ||
1423 | /* 26bit FIQ mode. */ | |
1424 | #define ADP_CPUread_26bitFIQ (0x1) | |
1425 | ||
1426 | /* 26bit IRQ mode. */ | |
1427 | #define ADP_CPUread_26bitIRQ (0x2) | |
1428 | ||
1429 | /* 26bit Supervisor mode. */ | |
1430 | #define ADP_CPUread_26bitSVC (0x3) | |
1431 | ||
1432 | /* 32bit user mode. */ | |
1433 | #define ADP_CPUread_32bitUser (0x10) | |
1434 | ||
1435 | /* 32bit FIQ mode. */ | |
1436 | #define ADP_CPUread_32bitFIQ (0x11) | |
1437 | ||
1438 | /* 32bit IRQ mode. */ | |
1439 | #define ADP_CPUread_32bitIRQ (0x12) | |
1440 | ||
1441 | /* 32bit Supervisor mode. */ | |
1442 | #define ADP_CPUread_32bitSVC (0x13) | |
1443 | ||
1444 | /* 32bit Abort mode. */ | |
1445 | #define ADP_CPUread_32bitAbort (0x17) | |
1446 | ||
1447 | /* 32bit Undefined mode. */ | |
1448 | #define ADP_CPUread_32bitUndef (0x1B) | |
1449 | ||
1450 | /* #32bit System mode - Added in Architecture 4 ARMs e.g.ARM7TDMI */ | |
1451 | #define ADP_CPUread_32bitSystem (0x1F) | |
1452 | ||
1453 | /* 'mask':- */ | |
1454 | /* Request registers RO-R14. */ | |
1455 | #define ADP_CPUread_RegsMask (0x7FFF) | |
1456 | ||
1457 | /* Request Program Counter (including mode and flag bits in 26-bit modes. */ | |
1458 | #define ADP_CPUread_PCmode (1 << 15) | |
1459 | ||
1460 | /* Request Program Counter (without mode and flag bits in 26-bit modes. */ | |
1461 | #define ADP_CPUread_PCnomode (1 << 16) | |
1462 | ||
1463 | /* Requests the transfer of the CPSR */ | |
1464 | #define ADP_CPUread_CPSR (1 << 17) | |
1465 | ||
1466 | /* In processor modes with an SPSR(non-user modes), bit 19 requests its | |
1467 | transfer */ | |
1468 | #define ADP_CPUread_SPSR (1 << 18) | |
1469 | ||
1470 | ||
1471 | ||
1472 | #define ADP_CPUwrite ADPREASON(CI_HADP,6) | |
1473 | /* ADP_CPUwrite | |
1474 | * ------------ | |
1475 | * Summary: This is a request to write values to the CPU. | |
1476 | * | |
1477 | * Arguments: | |
1478 | * Send: (byte mode, word mask, words data) | |
1479 | * Return: (word status) | |
1480 | * | |
1481 | * 'mode' defines the processor mode to which the transfer should be made. | |
1482 | * The mode number is the same as the mode number used by ARM; a value of | |
1483 | * 255 indicates the current mode. See ADP_CPUread above for more detail. | |
1484 | * 'mask' indicates which registers should be transferred. Setting a bit to | |
1485 | * one will cause the designated register to be transferred. The details | |
1486 | * of mask are specified above in ADP_CPUread. | |
1487 | * 'data' holds the values of the registers to be transferred. The first | |
1488 | * value is written to the lowest numbered register. NOTE: data must not | |
1489 | * cause the buffer size to exceed the maximum allowed buffer size. | |
1490 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1491 | */ | |
1492 | ||
1493 | ||
1494 | ||
1495 | #define ADP_CPread ADPREASON(CI_HADP,7) | |
1496 | /* ADP_CPread | |
1497 | * ---------- | |
1498 | * Summary: This message requests a co-processors internal state. | |
1499 | * | |
1500 | * Arguments: | |
1501 | * Send: (byte CPnum, word mask) | |
1502 | * Return: (word status, words data) | |
1503 | * | |
1504 | * 'CPnum' is the number of the co-processor to transfer values from. | |
1505 | * 'mask' specifies which registers to transfer and is co-processor | |
1506 | * specific. | |
1507 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1508 | * 'data' holds the registers specified in 'mask' if successful, otherwise | |
1509 | * just rubbish. The lowest numbered register is transferred first. | |
1510 | * NOTE: data must not cause the buffer size to exceed the maximum allowed | |
1511 | * buffer size. | |
1512 | */ | |
1513 | ||
1514 | ||
1515 | ||
1516 | #define ADP_CPwrite ADPREASON(CI_HADP,8) | |
1517 | /* ADP_CPwrite | |
1518 | * ----------- | |
1519 | * Summary: This message requests a write to a co-processors internal state. | |
1520 | * | |
1521 | * Arguments: | |
1522 | * Send: (byte CPnum, word mask, words data) | |
1523 | * Return: (word status) | |
1524 | * | |
1525 | * 'CPnum' is the number of the co-processor to transfer values to. | |
1526 | * 'mask' specifies which registers to transfer and is co-processor | |
1527 | * specific. | |
1528 | * 'data' holds the values to transfer to the registers specified in 'mask'. | |
1529 | * The first value is written to the lowest numbered register. | |
1530 | * NOTE: data must not cause the buffer size to exceed the maximum allowed | |
1531 | * buffer size. | |
1532 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1533 | */ | |
1534 | ||
1535 | ||
1536 | ||
1537 | #define ADP_SetBreak ADPREASON(CI_HADP,9) | |
1538 | /* ADP_SetBreak | |
1539 | * ------------ | |
1540 | * Summary: Sets a breakpoint. | |
1541 | * | |
1542 | * Arguments: | |
1543 | * Send: (word address, byte type [, word bound]) | |
1544 | * Return: (word status, word pointhandle, word raddress, word rbound) | |
1545 | * | |
1546 | * 'address' is the address of the instruction to set the breakpoint on. | |
1547 | * 'type' specifies the sort of breakpoint and is described in more detail | |
1548 | * below. | |
1549 | * 'bound' is included if the least significant 4 bits of type are set to | |
1550 | * 5 or above (see below for more detail). | |
1551 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1552 | * 'pointhandle' returns a handle to the breakpoint, it will be valid if bit | |
1553 | * 7 of 'type' is set. See below for more detail. | |
1554 | * 'raddress' is valid depending on 'type', see below for more detail. | |
1555 | * 'rbound' is valid depending on 'type', see below for more detail. | |
1556 | */ | |
1557 | ||
1558 | /* 'type':- */ | |
1559 | /* The least significant 4 bits define the sort of breakpoint to set:- */ | |
1560 | /* Halt if the pc is equal to 'address'. */ | |
1561 | #define ADP_SetBreak_EqualsAddress (0) | |
1562 | ||
1563 | /* Halt if the pc is greater than 'address'. */ | |
1564 | #define ADP_SetBreak_GreaterAddress (1) | |
1565 | ||
1566 | /* Halt if the pc is greater than or equal to 'address'. */ | |
1567 | #define ADP_SetBreak_GEqualsAddress (2) | |
1568 | ||
1569 | /* Halt if the pc is less than 'address'. */ | |
1570 | #define ADP_SetBreak_LessAddress (3) | |
1571 | ||
1572 | /* Halt if the pc is less than or equal to 'address'. */ | |
1573 | #define ADP_SetBreak_LEqualsAddress (4) | |
1574 | ||
1575 | /* Halt if the pc is in the range from 'address' to 'bound' inclusive. */ | |
1576 | #define ADP_SetBreak_Range (5) | |
1577 | ||
1578 | /* Halt if the pc is not in the range from 'address' to 'bound' inclusive. */ | |
1579 | #define ADP_SetBreak_NotRange (6) | |
1580 | ||
1581 | /* Halt if (pc & 'bound') = 'address'. */ | |
1582 | #define ADP_SetBreak_AndBound (7) | |
1583 | ||
1584 | /* Bits 5,6 and 7 are used as follows :- */ | |
1585 | /* If set this indicates that the breakpoint is on a 16bit (Thumb) | |
1586 | instruction rather than a 32bit (ARM) instruction. */ | |
1587 | #define ADP_SetBreak_Thumb (1 << 4) | |
1588 | ||
1589 | /* This requests that the breakpoint should be conditional (execution halts | |
1590 | only if the breakpointed instruction is executed, not if it is | |
1591 | conditionally skipped). If bit 5 is not set, execution halts whenever | |
1592 | the breakpointed instruction is reached (whether executed or skipped). */ | |
1593 | #define ADP_SetBreak_Cond (1 << 5) | |
1594 | ||
1595 | /* This requests a dry run: the breakpoint is not set and the 'raddress', and | |
1596 | if appropriate the 'rbound', that would be used, are returned (for | |
1597 | comparison and range breakpoints the address and bound used need not be | |
1598 | exactly as requested). A RDIError_NoError 'status' byte indicates that | |
1599 | resources are currently available to set the breakpoint, non-zero | |
1600 | indicates an error. RDIError_NoMorePoints indicates that the required | |
1601 | breakpoint resources are not currently available. */ | |
1602 | #define ADP_SetBreak_DryRun (1 << 6) | |
1603 | ||
1604 | /* If the request is successful, but there are no more breakpoint registers | |
1605 | (of the requested type), then the value RDIError_NoMorePoints is | |
1606 | returned. */ | |
1607 | ||
1608 | /* If a breakpoint is set on a location which already has a breakpoint, the | |
1609 | first breakpoint will be removed before the new breakpoint is set. */ | |
1610 | ||
1611 | ||
1612 | ||
1613 | #define ADP_ClearBreak ADPREASON(CI_HADP,10) | |
1614 | /* ADP_ClearBreak | |
1615 | * -------------- | |
1616 | * Summary: Clears a breakpoint. | |
1617 | * | |
1618 | * Arguments: | |
1619 | * Send: (word pointhandle) | |
1620 | * Return: (word status) | |
1621 | * | |
1622 | * 'pointhandle' is a handle returned by a previous ADP_SetBreak. | |
1623 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1624 | */ | |
1625 | ||
1626 | ||
1627 | #define ADP_SetWatch ADPREASON(CI_HADP,11) | |
1628 | /* ADP_SetWatch | |
1629 | * ------------ | |
1630 | * Summary: Sets a watchpoint. | |
1631 | * | |
1632 | * Arguments: | |
1633 | * Send: (word address, byte type, byte datatype [,word bound]) | |
1634 | * Return: (word status, word pointhandle, word raddress, word rbound) | |
1635 | * | |
1636 | * 'address' is the address at which to set the watchpoint. | |
1637 | * 'type' is the type of watchpoint to set and is described in detail below. | |
1638 | * 'datatype' defines the sort of data access to watch for and is described | |
1639 | * in more detail below. | |
1640 | * 'bound' is included depending on the value of type (see description of | |
1641 | * type below). | |
1642 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1643 | * 'pointhandle' is valid depending on the value of type (see description | |
1644 | * of type below). | |
1645 | * 'raddress' is valid depending on the value of type (see description | |
1646 | * of type below). | |
1647 | * 'rbound' is valid depending on the value of type (see description | |
1648 | * of type below). | |
1649 | */ | |
1650 | ||
1651 | /* 'type':- */ | |
1652 | /* The least significant 4 bits of 'type' define the sort of watchpoint to | |
1653 | set:- */ | |
1654 | /* Halt on a data access to the address equal to 'address'. */ | |
1655 | #define ADP_SetWatch_EqualsAddress (0) | |
1656 | ||
1657 | /* Halt on a data access to an address greater than 'address'. */ | |
1658 | #define ADP_SetWatch_GreaterAddress (1) | |
1659 | ||
1660 | /* Halt on a data access to an address greater than or equal to 'address'. */ | |
1661 | #define ADP_SetWatch_GEqualsAddress (2) | |
1662 | ||
1663 | /* Halt on a data access to an address less than 'address'. */ | |
1664 | #define ADP_SetWatch_LessAddress (3) | |
1665 | ||
1666 | /* Halt on a data access to an address less than or equal to 'address'. */ | |
1667 | #define ADP_SetWatch_LEqualsAddress (4) | |
1668 | ||
1669 | /* Halt on a data access to an address in the range from 'address' to | |
1670 | 'bound' inclusive. */ | |
1671 | #define ADP_SetWatch_Range (5) | |
1672 | ||
1673 | /* Halt on a data access to an address not in the range from 'address' to | |
1674 | 'bound' inclusive. */ | |
1675 | #define ADP_SetWatch_NotRange (6) | |
1676 | ||
1677 | /* Halt if (data-access-address & 'bound')='address'. */ | |
1678 | #define ADP_SetWatch_AndBound (7) | |
1679 | ||
1680 | /* Bits 6 and 7 of 'type' also have further significance:- | |
1681 | NOTE: they must not be simulataneously set. */ | |
1682 | ||
1683 | /* Bit 6 of 'type' set: Requests a dry run: the watchpoint is not set and | |
1684 | the 'address' and, if appropriate, the 'bound', that would be used are | |
1685 | returned (for range and comparison watchpoints, the 'address' and 'bound' | |
1686 | used need not be exactly as requested). A RDIError_NoError status byte | |
1687 | indicates that resources are currently available to set the watchpoint; | |
1688 | RDIError_NoMorePoints indicates that the required watchpoint resources | |
1689 | are not currently available. */ | |
1690 | ||
1691 | /* Bit 7 of 'type' set: Requests that a handle should be returned for the | |
1692 | watchpoint by which it will be identified subsequently. If bit 7 is | |
1693 | set, a handle will be returned ('pointhandle'), whether or not the | |
1694 | request succeeds or fails (but, obviously, it will only be meaningful | |
1695 | if the request succeesd). */ | |
1696 | ||
1697 | /* 'datatype':- */ | |
1698 | /* The 'datatype' argument defines the sort of data access to watch for, | |
1699 | values can be summed or ORed together to halt on any set of sorts of | |
1700 | memory access. */ | |
1701 | ||
1702 | /* Watch for byte reads. */ | |
1703 | #define ADP_SetWatch_ByteReads (1) | |
1704 | ||
1705 | /* Watch for half-word reads. */ | |
1706 | #define ADP_SetWatch_HalfWordReads (2) | |
1707 | ||
1708 | /* Watch for word reads. */ | |
1709 | #define ADP_SetWatch_WordReads (4) | |
1710 | ||
1711 | /* Watch for half-word reads. */ | |
1712 | #define ADP_SetWatch_ByteWrites (8) | |
1713 | ||
1714 | /* Watch for half-word reads. */ | |
1715 | #define ADP_SetWatch_HalfWordWrites (16) | |
1716 | ||
1717 | /* Watch for half-word reads. */ | |
1718 | #define ADP_SetWatch_WordWrites (32) | |
1719 | ||
1720 | /* On successful completion a RDIError_NoError 'status' byte is returned. On | |
1721 | unsuccessful completion, a non-zero error code byte is returned. If the | |
1722 | request is successful, but there are now no more watchpoint registers | |
1723 | (of the requested type), then the value RDIError_NoMorePoints is | |
1724 | returned. */ | |
1725 | ||
1726 | /* If a watchpoint is set on a location which already has a watchpoint, the | |
1727 | first watchpoint will be removed before the new watchpoint is set. */ | |
1728 | ||
1729 | ||
1730 | #define ADP_ClearWatch ADPREASON(CI_HADP,12) | |
1731 | /* ADP_ClearWatch | |
1732 | * -------------- | |
1733 | * Summary: Clears a watchpoint. | |
1734 | * | |
1735 | * Arguments: | |
1736 | * Send: (word pointhandle) | |
1737 | * Return: (word status) | |
1738 | * | |
1739 | * 'pointhandle' is a handle to a watchpoint returned by a previous | |
1740 | * ADP_SetWatch. | |
1741 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1742 | */ | |
1743 | ||
1744 | ||
1745 | ||
1746 | #define ADP_Execute ADPREASON(CI_HADP,13) | |
1747 | /* ADP_Execute | |
1748 | * ----------- | |
1749 | * Summary: This message requests that the target starts executing from | |
1750 | * the stored CPU state. | |
1751 | * | |
1752 | * Arguments: | |
1753 | * Send: () | |
1754 | * Return: (word status) | |
1755 | * | |
1756 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1757 | * The message will *ALWAYS* respond immediately with an ACK (unlike the | |
1758 | * old RDI definition, which allowed asynchronous message replies). | |
1759 | * | |
1760 | * Execution will stop when allowed system events occur. The host will | |
1761 | * be notified via a ADP_Stopped message (described below). | |
1762 | */ | |
1763 | ||
1764 | ||
1765 | ||
1766 | #define ADP_Step ADPREASON(CI_HADP,14) | |
1767 | /* ADP_Step | |
1768 | * -------- | |
1769 | * Summary: Execute 'ninstr' instructions. | |
1770 | * | |
1771 | * Arguments: | |
1772 | * Send: (word ninstr) | |
1773 | * Return: (word status) | |
1774 | * | |
1775 | * 'ninstr' is the number of instructions to execute, starting at the | |
1776 | * address currently loaded into the CPU program counter. If it is zero, | |
1777 | * the target should execute instructions upto the next instruction that | |
1778 | * explicitly alters the Program Counter. i.e. a branch or ALU operation | |
1779 | * with the PC as the destination. | |
1780 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1781 | * | |
1782 | * The ADP_Step function (unlike the earlier RDI system) will *ALWAYS* | |
1783 | * return an ACK immediately. A subsequent ADP_Stopped message will be | |
1784 | * delivered from the target to the host when the ADP_Step operation | |
1785 | * has completed. | |
1786 | */ | |
1787 | ||
1788 | ||
1789 | ||
1790 | #define ADP_InterruptRequest ADPREASON(CI_HADP,15) | |
1791 | /* ADP_InterruptRequest | |
1792 | * -------------------- | |
1793 | * Summary: Interrupt execution. | |
1794 | * | |
1795 | * Arguments: | |
1796 | * Send: () | |
1797 | * Return: (word status) | |
1798 | * | |
1799 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1800 | * On receiving this message the target should attempt to stop execution. | |
1801 | */ | |
1802 | ||
1803 | ||
1804 | ||
1805 | #define ADP_HW_Emulation ADPREASON(CI_HADP,16) | |
1806 | /* ADP_HW_Emulation | |
1807 | * ---------------- | |
1808 | * The first parameter to ADP_HW_Emulation is a Reason Subcode, and | |
1809 | * subsequent parameters are defined by that subcode | |
1810 | * | |
1811 | * word reason subcode | |
1812 | * other arguments as reason subcode determines | |
1813 | * | |
1814 | */ | |
1815 | ||
1816 | /* ADP__HW_Emulation sub-reason codes: */ | |
1817 | ||
1818 | #define ADP_HW_Emul_Supported ADPSUBREASON(CI_HADP,0) | |
1819 | /* ADP_HW_Emul_Supported | |
1820 | * --------------------- | |
1821 | * Summary: Enquires whether calls to the next 4 messages are available | |
1822 | * (MemoryAccess, MemoryMap, Set_CPUspeed, ReadClock). | |
1823 | * | |
1824 | * Arguments: | |
1825 | * Send: () | |
1826 | * Return: (word status) | |
1827 | * | |
1828 | * 'status' is RDIError_NoError to indicate the messages are available, | |
1829 | * non-zero otherwise. | |
1830 | * | |
1831 | * NOTE: Equivalent to RDI_Info_Memory_Stats. | |
1832 | */ | |
1833 | ||
1834 | ||
1835 | #define ADP_HW_Emul_MemoryAccess ADPSUBREASON(CI_HADP,1) | |
1836 | /* ADP_HW_Emul_MemoryAccess | |
1837 | * ------------------------ | |
1838 | * Summary: Get memory access information for memory block with specified | |
1839 | * handle. | |
1840 | * | |
1841 | * Arguments: | |
1842 | * Send: (word handle) | |
1843 | * Return: (word status, word nreads, word nwrites, word sreads, | |
1844 | * word swrites, word ns, word s) | |
1845 | * | |
1846 | * 'handle' is a handle to a memory block. | |
1847 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1848 | * 'nreads' is the number of non-sequential reads. | |
1849 | * 'nwrites' is the number of non-sequential writes. | |
1850 | * 'sreads' is the number of sequential reads. | |
1851 | * 'swrites' is the number of sequential writes. | |
1852 | * 'ns' is time in nano seconds. | |
1853 | * 's' is time in seconds. | |
1854 | * | |
1855 | * NOTE: Equivalent to RDIMemory_Access. | |
1856 | */ | |
1857 | ||
1858 | ||
1859 | #define ADP_HW_Emul_MemoryMap ADPSUBREASON(CI_HADP,2) | |
1860 | /* ADP_HW_Emul_MemoryMap | |
1861 | * --------------------- | |
1862 | * Summary: Sets memory characteristics. | |
1863 | * | |
1864 | * Arguments: | |
1865 | * Send: (word n, | |
1866 | Then 'n' sets of arguments of the form:- | |
1867 | word handle, word start, word limit, byte width, | |
1868 | byte access, word Nread_ns, word Nwrite_ns, word Sread_ns, | |
1869 | word Swrite_ns) | |
1870 | * Return: (word status) | |
1871 | * | |
1872 | * 'n' is the number of sets of arguments. | |
1873 | * 'handle' is a handle to the region. | |
1874 | * 'start' is the start of this region. | |
1875 | * 'limit' is the limit of this region. | |
1876 | * 'width' is the memory width, described in detail below. | |
1877 | * 'access' is described in detail below. | |
1878 | * 'Nread_ns' is the access time for N read cycles in nano seconds. | |
1879 | * 'Nwrite_ns' is the access time for N write cycles in nano seconds. | |
1880 | * 'Sread_ns' is the access time for S read cycles in nano seconds. | |
1881 | * 'Swrite_ns' is the access time for S write cycles in nano seconds. | |
1882 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1883 | * NOTE: Equivalent to RDIMemory_Map. | |
1884 | */ | |
1885 | ||
1886 | /* 'width':- */ | |
1887 | /* 8 bit memory width. */ | |
1888 | #define ADP_HW_Emul_MemoryMap_Width8 (0) | |
1889 | ||
1890 | /* 16 bit memory width. */ | |
1891 | #define ADP_HW_Emul_MemoryMap_Width16 (1) | |
1892 | ||
1893 | /* 32 bit memory width. */ | |
1894 | #define ADP_HW_Emul_MemoryMap_Width32 (2) | |
1895 | ||
1896 | /* 'access':- */ | |
1897 | /* Bit 0 - read access. */ | |
1898 | #define ADP_HW_Emul_MemoryMap_Access_Read (1 << 0) | |
1899 | ||
1900 | /* Bit 1 - write access. */ | |
1901 | #define ADP_HW_Emul_MemoryMap_Access_Write (1 << 1) | |
1902 | ||
1903 | /* Bit 2 - latched 32 bit memory. */ | |
1904 | #define ADP_HW_Emul_MemoryMap_Access_Latched (1 << 2) | |
1905 | ||
1906 | ||
1907 | #define ADP_HW_Emul_SetCPUSpeed ADPSUBREASON(CI_HADP,3) | |
1908 | /* ADP_HW_Emul_SetCPUSpeed | |
1909 | * ----------------------- | |
1910 | * Summary: Sets the speed of the CPU. | |
1911 | * | |
1912 | * Arguments: | |
1913 | * Send: (word speed) | |
1914 | * Return: (word status) | |
1915 | * | |
1916 | * 'speed' is the CPU speed in nano seconds. | |
1917 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1918 | * | |
1919 | * NOTE: Equivalent to RDISet_CPUSpeed. | |
1920 | */ | |
1921 | ||
1922 | ||
1923 | #define ADP_HW_Emul_ReadClock ADPSUBREASON(CI_HADP,4) | |
1924 | /* ADP_HW_Emul_ReadClock | |
1925 | * --------------------- | |
1926 | * Summary: Reads simulated time. | |
1927 | * | |
1928 | * Arguments: | |
1929 | * Send: () | |
1930 | * Return: (word status, word ns, word s) | |
1931 | * | |
1932 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1933 | * 'ns' is time in nano seconds. | |
1934 | * 's' is time in seconds. | |
1935 | * | |
1936 | * NOTE: Equivalent to RDIRead_Clock. | |
1937 | */ | |
1938 | ||
1939 | ||
1940 | #define ADP_ICEbreakerHADP ADPREASON(CI_HADP,17) | |
1941 | ||
1942 | /* The first parameter to ADP_ICEbreaker is a Reason Subcode, and | |
1943 | * subsequent parameters are defined by that subcode | |
1944 | * | |
1945 | * word reason subcode | |
1946 | * other arguments as reason subcode determines | |
1947 | * | |
1948 | */ | |
1949 | ||
1950 | /* ADP_ICEbreaker sub-reason codes: */ | |
1951 | ||
1952 | #define ADP_ICEB_Exists ADPSUBREASON(CI_HADP,0) | |
1953 | /* ADP_ICEB_Exists | |
1954 | * --------------- | |
1955 | * Summary: Is there an ICEbreaker in the system? | |
1956 | * | |
1957 | * Arguments: | |
1958 | * Send: () | |
1959 | * Return: (word status) | |
1960 | * | |
1961 | * 'status' is RDIError_NoError to indicate there is an ICEbreaker, | |
1962 | * non-zero otherwise. | |
1963 | */ | |
1964 | ||
1965 | ||
1966 | #define ADP_ICEB_GetLocks ADPSUBREASON(CI_HADP,1) | |
1967 | /* ADP_ICEB_GetLocks | |
1968 | * ----------------- | |
1969 | * Summary: Returns which ICEbreaker registers are locked. | |
1970 | * | |
1971 | * Arguments: | |
1972 | * Send: () | |
1973 | * Return: (word status, word lockedstate) | |
1974 | * | |
1975 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1976 | * 'lockedstate' is a bitmap if the ICEbreaker registers locked against use | |
1977 | * by IceMan (because explicitly written by the user). Bit n represents | |
1978 | * hardware breakpoint n, and if set the register is locked. | |
1979 | * | |
1980 | * NOTE: Equivalent to RDIIcebreaker_GetLocks. Should only be used if | |
1981 | * ADP_ICEB_Exists didn't return an error. | |
1982 | */ | |
1983 | ||
1984 | ||
1985 | #define ADP_ICEB_SetLocks ADPSUBREASON(CI_HADP,2) | |
1986 | /* ADP_ICEB_SetLocks | |
1987 | * ----------------- | |
1988 | * Summary: Sets which ICEbreaker registers are locked. | |
1989 | * | |
1990 | * Arguments: | |
1991 | * Send: (word lockedstate) | |
1992 | * Return: (word status) | |
1993 | * | |
1994 | * 'lockedstate' is the same as in ADP_ICEB_GetLocks above. | |
1995 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
1996 | * | |
1997 | * NOTE: Equivalent to RDIIcebreaker_SetLocks. Should only be used if | |
1998 | * ADP_ICEB_Exists didn't return an error. | |
1999 | */ | |
2000 | ||
2001 | ||
2002 | #define ADP_ICEB_CC_Exists ADPSUBREASON(CI_HADP,3) | |
2003 | /* ADP_ICEB_CC_Exists | |
2004 | * ------------------ | |
2005 | * Summary: Is there an ICEbreaker Comms Channel? | |
2006 | * | |
2007 | * Arguments: | |
2008 | * Send: () | |
2009 | * Return: (word status) | |
2010 | * | |
2011 | * 'status' is RDIError_NoError to indicate there is a Comms Channel, | |
2012 | * non-zero otherwise. | |
2013 | * | |
2014 | * NOTE: Should only be used if ADP_ICEB_Exists didn't return an error. | |
2015 | */ | |
2016 | ||
2017 | ||
2018 | #define ADP_ICEB_CC_Connect_ToHost ADPSUBREASON(CI_HADP,4) | |
2019 | /* ADP_ICEB_CC_Connect_ToHost | |
2020 | * -------------------------- | |
2021 | * Summary: Connect Comms Channel in ToHost direction. | |
2022 | * | |
2023 | * Arguments: | |
2024 | * Send: (byte connect) | |
2025 | * Return: (word status) | |
2026 | * | |
2027 | * 'connect' !!!!! | |
2028 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2029 | * | |
2030 | * NOTE: Equivalent to RDICommsChannel_ToHost. Should only be used if | |
2031 | * ADP_ICEB_CC_Exists didn't return an error. | |
2032 | */ | |
2033 | ||
2034 | ||
2035 | #define ADP_ICEB_CC_Connect_FromHost ADPSUBREASON(CI_HADP,5) | |
2036 | /* ADP_ICEB_CC_Connect_FromHost | |
2037 | * ---------------------------- | |
2038 | * Summary: Connect Comms Channel in FromHost direction. | |
2039 | * | |
2040 | * Arguments: | |
2041 | * Send: (byte connect) | |
2042 | * Return: (word status) | |
2043 | * | |
2044 | * 'connect' is the same as in ADP_ICEB_CC_Connect_ToHost above. | |
2045 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2046 | * | |
2047 | * NOTE: Equivalent to RDICommsChannel_FromHost. Should only be used if | |
2048 | * ADP_ICEB_CC_Exists didn't return an error. | |
2049 | */ | |
2050 | ||
2051 | ||
2052 | #define ADP_ICEman ADPREASON(CI_HADP,18) | |
2053 | ||
2054 | /* The first parameter to ADP_ICEman is a Reason Subcode, and | |
2055 | * subsequent parameters are defined by that subcode | |
2056 | * | |
2057 | * word reason subcode | |
2058 | * other arguments as reason subcode determines | |
2059 | * | |
2060 | */ | |
2061 | ||
2062 | /* ADP_ICEman sub-reason codes: */ | |
2063 | ||
2064 | ||
2065 | #define ADP_ICEM_AddConfig ADPSUBREASON(CI_HADP,0) | |
2066 | /* ADP_ICEM_AddConfig | |
2067 | * ------------------ | |
2068 | * Summary: Prepares target to receive configuration data block. | |
2069 | * | |
2070 | * Arguments: | |
2071 | * Send: (word nbytes) | |
2072 | * Return: (word status) | |
2073 | * | |
2074 | * 'nbytes' is the number of bytes in the configuration block. | |
2075 | * 'status' is RDIError_NoError to indicate success, non-zero if a | |
2076 | * configuration block of this size can't be accepted. | |
2077 | * | |
2078 | * NOTE: Equivalent to RDP_AddConfig. | |
2079 | */ | |
2080 | ||
2081 | ||
2082 | #define ADP_ICEM_SelectConfig ADPSUBREASON(CI_HADP,1) | |
2083 | /* ADP_ICEM_SelectConfig | |
2084 | * --------------------- | |
2085 | * Summary: Selects one of the sets of configuration data blocks and | |
2086 | * reinitialises to use the new configuration. | |
2087 | * | |
2088 | * Arguments: | |
2089 | * Send: (byte aspect, byte namelen, byte matchtype, word vsn_req, | |
2090 | bytes name) | |
2091 | * Return: (word status, word vsn_sel) | |
2092 | * | |
2093 | * 'aspect' is one of two values defined below. | |
2094 | * 'namelen' is the number of bytes in 'name'. | |
2095 | * 'matchtype' specifies how the selected version must match that specified, | |
2096 | * and takes one of the values defined below. | |
2097 | * 'vsn_req' is the requested version of the named configuration. | |
2098 | * 'name' is the name of the configuration. | |
2099 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2100 | * 'vsn_sel' is the version number of the configuration selected on success. | |
2101 | * | |
2102 | * NOTE: Equivalent to RDP_SelectConfig. | |
2103 | */ | |
2104 | ||
2105 | /* 'aspect':- */ | |
2106 | #define ADP_ICEM_SelectConfig_ConfigCPU (0) | |
2107 | #define ADP_ICEM_SelectConfig_ConfigSystem (1) | |
2108 | ||
2109 | /* 'matchtype':- */ | |
2110 | #define ADP_ICEM_SelectConfig_MatchAny (0) | |
2111 | #define ADP_ICEM_SelectConfig_MatchExactly (1) | |
2112 | #define ADP_ICEM_SelectConfig_MatchNoEarlier (2) | |
2113 | ||
2114 | ||
2115 | #define ADP_ICEM_ConfigCount ADPSUBREASON(CI_HADP,2) | |
2116 | /* ADP_ICEM_ConfigCount | |
2117 | * -------------------- | |
2118 | * Summary: Return number of configurations. | |
2119 | * | |
2120 | * Arguments: | |
2121 | * Send: () | |
2122 | * Return: (word status [, word count]) | |
2123 | * | |
2124 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2125 | * 'count' returns the number of configurations if status is zero. | |
2126 | * | |
2127 | * NOTE: Equivalent to RDIConfig_Count. | |
2128 | */ | |
2129 | ||
2130 | ||
2131 | #define ADP_ICEM_ConfigNth ADPSUBREASON(CI_HADP,3) | |
2132 | /* ADP_ICEM_ConfigNth | |
2133 | * ------------------ | |
2134 | * Summary: Gets the nth configuration details. | |
2135 | * | |
2136 | * Arguments: | |
2137 | * Send: (word confign) | |
2138 | * Return: (word status, word version, byte namelen, bytes name) | |
2139 | * | |
2140 | * 'confign' is the number of the configuration. | |
2141 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2142 | * 'version' is the configuration version number. | |
2143 | * 'namelen' is the number of bytes in 'name'. | |
2144 | * 'name' is the name of the configuration. | |
2145 | * | |
2146 | * NOTE: Equivalent to RDIConfig_Nth. | |
2147 | */ | |
2148 | ||
2149 | ||
2150 | ||
2151 | #define ADP_Profile ADPREASON(CI_HADP,19) | |
2152 | ||
2153 | /* The first parameter to ADP_Profile is a Reason Subcode, and | |
2154 | * subsequent parameters are defined by that subcode | |
2155 | * | |
2156 | * word reason subcode | |
2157 | * other arguments as reason subcode determines | |
2158 | * | |
2159 | */ | |
2160 | ||
2161 | /* ADP_Profile sub-reason codes: */ | |
2162 | ||
2163 | ||
2164 | #define ADP_Profile_Supported ADPSUBREASON(CI_HADP,0) | |
2165 | /* ADP_Profile_Supported | |
2166 | * --------------------- | |
2167 | * Summary: Checks whether profiling is supported. | |
2168 | * | |
2169 | * Arguments: | |
2170 | * Send: () | |
2171 | * Return: (word status) | |
2172 | * | |
2173 | * 'status' is RDIError_NoError if profiling is supported, non-zero otherwise. | |
2174 | * | |
2175 | * NOTE: Can also be determined using Info_Target. | |
2176 | */ | |
2177 | ||
2178 | ||
2179 | #define ADP_Profile_Stop ADPSUBREASON(CI_HADP,1) | |
2180 | /* ADP_Profile_Stop | |
2181 | * ---------------- | |
2182 | * Summary: Stops profiling. | |
2183 | * | |
2184 | * Arguments: | |
2185 | * Send: () | |
2186 | * Return: (word status) | |
2187 | * | |
2188 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2189 | * | |
2190 | * NOTE: Equivalent to RDIProfile_Stop. | |
2191 | */ | |
2192 | ||
2193 | ||
2194 | #define ADP_Profile_Start ADPSUBREASON(CI_HADP,2) | |
2195 | /* ADP_Profile_Start | |
2196 | * ----------------- | |
2197 | * Summary: Starts profiling (PC sampling). | |
2198 | * | |
2199 | * Arguments: | |
2200 | * Send: (word interval) | |
2201 | * Return: (word status) | |
2202 | * | |
2203 | * 'interval' is the period of PC sampling in micro seconds. | |
2204 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2205 | * | |
2206 | * NOTE: Equivalent to RDIProfile_Start. | |
2207 | */ | |
2208 | ||
2209 | ||
2210 | #define ADP_Profile_WriteMap ADPSUBREASON(CI_HADP,3) | |
2211 | #define ADP_ProfileWriteHeaderSize (ADP_DEFAULT_HEADER_SIZE + 4*sizeof(word)) | |
2212 | ||
2213 | /* ADP_Profile_WriteMap | |
2214 | * -------------------- | |
2215 | * Summary: Downloads a map array, which describes the PC ranges for profiling. | |
2216 | * | |
2217 | * Arguments: A number of messages each of form:- | |
2218 | * Send: (word len, word size, word offset, words map_data) | |
2219 | * Return: (word status) | |
2220 | * | |
2221 | * 'len' is the number of elements in the entire map array being downloaded. | |
2222 | * 'size' is the number of words being downloaded in this message, i.e. the | |
2223 | * length of 'map_data'. | |
2224 | * 'offset' is the offset into the entire map array which this message starts | |
2225 | * from, in words. | |
2226 | * 'map_data' consists of 'size' words of map data. | |
2227 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2228 | * | |
2229 | * NOTE: Equivalent to RDIProfile_WriteMap. | |
2230 | */ | |
2231 | ||
2232 | ||
2233 | #define ADP_Profile_ReadMap ADPSUBREASON(CI_HADP,4) | |
2234 | #define ADP_ProfileReadHeaderSize (ADP_DEFAULT_HEADER_SIZE + 2*sizeof(word)) | |
2235 | ||
2236 | /* ADP_Profile_ReadMap | |
2237 | * ------------------- | |
2238 | * Summary: Uploads a set of profile counts which correspond to the current | |
2239 | * profile map. | |
2240 | * | |
2241 | * Arguments: A number of messages, each of the form: | |
2242 | * Send: (word offset, word size) | |
2243 | * Return: (word status, words counts) | |
2244 | * | |
2245 | * 'offset' is the offset in the entire array of counts that this message | |
2246 | * starts from, in words. | |
2247 | * 'size' is the number of words uploaded in this message (in counts). | |
2248 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2249 | * 'counts' is 'size' words of profile counts. | |
2250 | * | |
2251 | * NOTE: Equivalent to RDIProfile_ReadMap. | |
2252 | */ | |
2253 | ||
2254 | ||
2255 | #define ADP_Profile_ClearCounts ADPSUBREASON(CI_HADP,5) | |
2256 | /* ADP_Profile_ClearCounts | |
2257 | * ----------------------- | |
2258 | * Summary: Requests that PC sample counts be set to zero. | |
2259 | * | |
2260 | * Arguments: | |
2261 | * Send: () | |
2262 | * Return: (word status) | |
2263 | * | |
2264 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2265 | * | |
2266 | * NOTE: Equivalent to RDIProfile_ClearCounts. | |
2267 | */ | |
2268 | ||
2269 | #define ADP_InitialiseApplication ADPREASON(CI_HADP,20) | |
2270 | /* ADP_InitialiseApplication | |
2271 | * ------------------------- | |
2272 | * Summary: Requests that OS setup up the thread/task so that it can be | |
2273 | * executed. | |
2274 | * | |
2275 | * Arguments: | |
2276 | * Send: () | |
2277 | * Return: (word status) | |
2278 | * | |
2279 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2280 | */ | |
2281 | ||
2282 | #define ADP_End ADPREASON(CI_HADP,21) | |
2283 | /* ADP_End | |
2284 | * ------- | |
2285 | * Summary: Sent by the host debugger to tell angel this debugging session | |
2286 | * is is finished | |
2287 | * Arguments: | |
2288 | * Send: () | |
2289 | * Return: (word status) | |
2290 | * status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2291 | */ | |
2292 | ||
2293 | /****************************************************************** | |
2294 | * | |
2295 | * CI_TADP messages | |
2296 | * | |
2297 | */ | |
2298 | ||
2299 | #define ADP_TADPUnrecognised ADPREASON(CI_TADP,0) | |
2300 | /* This message is unusual in that it is normally sent in reply to | |
2301 | * another message which is not understood. This is an exception | |
2302 | * to the normal protocol which says that a reply must have the | |
2303 | * same base reason code as the original. There is a single reply | |
2304 | * parameter which is the reason code which was not understood. | |
2305 | * | |
2306 | * As well as being a reply this message can also be sent and will | |
2307 | * return as if this message were unrecognised! | |
2308 | * | |
2309 | * Parameters: | |
2310 | * none | |
2311 | * | |
2312 | * Reply: | |
2313 | * word reason code which was not recognised | |
2314 | */ | |
2315 | ||
2316 | /*-------------------------------------------------------------------------*/ | |
2317 | ||
2318 | #define ADP_Stopped ADPREASON(CI_TADP,1) | |
2319 | /* ADP_Stopped | |
2320 | * ----------- | |
2321 | * Summary: This message is sent to the host when the application stops, | |
2322 | * either naturally or due to an exception. | |
2323 | * | |
2324 | * Parameters: | |
2325 | * word reason subcode | |
2326 | * other arguments as reason subcode determines. | |
2327 | * Unless stated otherwise (below) there will be none. | |
2328 | * | |
2329 | * Reply: | |
2330 | * word status unless reason subcode says otherwise | |
2331 | * | |
2332 | * This message is sent to the host when execution has stopped. This | |
2333 | * can be when the end of the application has been reached, or as the | |
2334 | * result of an exception. It can also be the return from an ADP_Step | |
2335 | * process, when the requested number of instructions have been | |
2336 | * executed., or a breakpoint or watchpoint has been hit etc. | |
2337 | */ | |
2338 | ||
2339 | /* The first set of Stopped subreason codes are for the ARM hardware | |
2340 | * vectors. These events will be raised if the | |
2341 | * ADP_Control_Vector_Catch allows, or if the target application has | |
2342 | * not provided its own handlers. | |
2343 | */ | |
2344 | #define ADP_Stopped_BranchThroughZero ADPSUBREASON(CI_TADP,0) | |
2345 | #define ADP_Stopped_UndefinedInstr ADPSUBREASON(CI_TADP,1) | |
2346 | #define ADP_Stopped_SoftwareInterrupt ADPSUBREASON(CI_TADP,2) | |
2347 | #define ADP_Stopped_PrefetchAbort ADPSUBREASON(CI_TADP,3) | |
2348 | #define ADP_Stopped_DataAbort ADPSUBREASON(CI_TADP,4) | |
2349 | #define ADP_Stopped_AddressException ADPSUBREASON(CI_TADP,5) | |
2350 | #define ADP_Stopped_IRQ ADPSUBREASON(CI_TADP,6) | |
2351 | #define ADP_Stopped_FIQ ADPSUBREASON(CI_TADP,7) | |
2352 | ||
2353 | /* We leave the rest of what would be the bits in the VectorCatch | |
2354 | * bitmask free for future expansion. | |
2355 | */ | |
2356 | ||
2357 | /* The following are software reasons for execution stopping: */ | |
2358 | #define ADP_Stopped_BreakPoint ADPSUBREASON(CI_TADP,32) | |
2359 | /* Breakpoint was reached | |
2360 | * extra send parameter: word handle - indicates which breakpoint | |
2361 | */ | |
2362 | ||
2363 | #define ADP_Stopped_WatchPoint ADPSUBREASON(CI_TADP,33) | |
2364 | /* Watchpoint was triggered | |
2365 | * extra send parameter: word handle - indicates which watchpoint | |
2366 | */ | |
2367 | ||
2368 | #define ADP_Stopped_StepComplete ADPSUBREASON(CI_TADP,34) | |
2369 | /* End of ADP_Step request */ | |
2370 | ||
2371 | #define ADP_Stopped_RunTimeErrorUnknown ADPSUBREASON(CI_TADP,35) | |
2372 | /* | |
2373 | * non-specific fatal runtime support error | |
2374 | */ | |
2375 | ||
2376 | #define ADP_Stopped_InternalError ADPSUBREASON(CI_TADP,36) | |
2377 | /* extra send parameter: word error - indicates the nature of the error | |
2378 | * | |
2379 | * An Angel internal error has happened. The error number should be | |
2380 | * displayed for the user to report to his software supplier. Once | |
2381 | * this error has been received the internal state of Angel can no longer | |
2382 | * be trusted. | |
2383 | */ | |
2384 | ||
2385 | #define ADP_Stopped_UserInterruption ADPSUBREASON(CI_TADP,37) | |
2386 | /* Host requested interruption */ | |
2387 | ||
2388 | #define ADP_Stopped_ApplicationExit ADPSUBREASON(CI_TADP,38) | |
2389 | /* extra send parameter: word exitcode | |
2390 | * This indicates that the application has exited via exit(), an exitcode | |
2391 | * of zero indiactes successful termination. | |
2392 | */ | |
2393 | ||
2394 | #define ADP_Stopped_StackOverflow ADPSUBREASON(CI_TADP, 39) | |
2395 | /* | |
2396 | * Software stack overflow has occurred | |
2397 | */ | |
2398 | ||
2399 | #define ADP_Stopped_DivisionByZero ADPSUBREASON(CI_TADP, 40) | |
2400 | /* | |
2401 | * Division by zero has occurred | |
2402 | */ | |
2403 | ||
2404 | #define ADP_Stopped_OSSpecific ADPSUBREASON(CI_TADP, 41) | |
2405 | /* | |
2406 | * The OS has requested that execution stops. The OS will know | |
2407 | * why this has happened. | |
2408 | */ | |
2409 | ||
2410 | ||
2411 | ||
2412 | /****************************************************************** | |
2413 | * | |
2414 | * CI_TTDCC messages (Target-initiated debug comms channel) | |
2415 | * | |
2416 | */ | |
2417 | ||
2418 | #define ADP_TDCC_ToHost ADPREASON(CI_TTDCC,0) | |
2419 | /* ADP_TDCC_ToHost | |
2420 | * ------------------ | |
2421 | * Summary: Send Data down Comms Channel in ToHost direction. | |
2422 | * | |
2423 | * Arguments: | |
2424 | * Send: (word nbytes, words data) | |
2425 | * Return: (word status) | |
2426 | * | |
2427 | * 'nbytes' is number of BYTES to be transferred from the target to the | |
2428 | * host via the Debug Comms channel. | |
2429 | * 'data' is (nbytes/sizeof(word)) WORDS of data to be transferred from | |
2430 | * the target to the host via the Debug Comms channel. | |
2431 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2432 | * | |
2433 | * NOTE: Equivalent to RDP_CCToHost and RDP_CCToHostReply (just set the | |
2434 | * direction bit). | |
2435 | * NOTE II: Current implementations only support single word transfers | |
2436 | * (nbytes = 4). | |
2437 | */ | |
2438 | ||
2439 | ||
2440 | #define ADP_TDCC_FromHost ADPREASON(CI_TTDCC,1) | |
2441 | /* ADP_TDCC_FromHost | |
2442 | * -------------------- | |
2443 | * Summary: Send Data down Comms Channel in FromHost direction. | |
2444 | * | |
2445 | * Arguments: | |
2446 | * Send: () | |
2447 | * Return: (word status, word nbytes, words data) | |
2448 | * | |
2449 | * 'status' is RDIError_NoError to indicate success, non-zero otherwise. | |
2450 | * 'nbytes' is number of BYTES to be transferred from the host to the | |
2451 | * target via the Debug Comms channel, or zero if the host has no data | |
2452 | * to transfer. | |
2453 | * 'data' is (nbytes/sizeof(word)) WORDS of transferred data. | |
2454 | * | |
2455 | * NOTE: Equivalent to RDP_CCFromHost and RDP_CCFromHostReply (just set the | |
2456 | * direction bit). | |
2457 | * NOTE II: Current implementations only support single word transfers | |
2458 | * (nbytes = 4). | |
2459 | */ | |
2460 | ||
2461 | ||
2462 | /******************************************************************* | |
2463 | * | |
2464 | * Error Codes | |
2465 | * | |
2466 | */ | |
2467 | ||
2468 | #define RDIError_NoError 0 | |
2469 | ||
2470 | #define RDIError_Reset 1 | |
2471 | #define RDIError_UndefinedInstruction 2 | |
2472 | #define RDIError_SoftwareInterrupt 3 | |
2473 | #define RDIError_PrefetchAbort 4 | |
2474 | #define RDIError_DataAbort 5 | |
2475 | #define RDIError_AddressException 6 | |
2476 | #define RDIError_IRQ 7 | |
2477 | #define RDIError_FIQ 8 | |
2478 | #define RDIError_Error 9 | |
2479 | #define RDIError_BranchThrough0 10 | |
2480 | ||
2481 | #define RDIError_NotInitialised 128 | |
2482 | #define RDIError_UnableToInitialise 129 | |
2483 | #define RDIError_WrongByteSex 130 | |
2484 | #define RDIError_UnableToTerminate 131 | |
2485 | #define RDIError_BadInstruction 132 | |
2486 | #define RDIError_IllegalInstruction 133 | |
2487 | #define RDIError_BadCPUStateSetting 134 | |
2488 | #define RDIError_UnknownCoPro 135 | |
2489 | #define RDIError_UnknownCoProState 136 | |
2490 | #define RDIError_BadCoProState 137 | |
2491 | #define RDIError_BadPointType 138 | |
2492 | #define RDIError_UnimplementedType 139 | |
2493 | #define RDIError_BadPointSize 140 | |
2494 | #define RDIError_UnimplementedSize 141 | |
2495 | #define RDIError_NoMorePoints 142 | |
2496 | #define RDIError_BreakpointReached 143 | |
2497 | #define RDIError_WatchpointAccessed 144 | |
2498 | #define RDIError_NoSuchPoint 145 | |
2499 | #define RDIError_ProgramFinishedInStep 146 | |
2500 | #define RDIError_UserInterrupt 147 | |
2501 | #define RDIError_CantSetPoint 148 | |
2502 | #define RDIError_IncompatibleRDILevels 149 | |
2503 | ||
2504 | #define RDIError_CantLoadConfig 150 | |
2505 | #define RDIError_BadConfigData 151 | |
2506 | #define RDIError_NoSuchConfig 152 | |
2507 | #define RDIError_BufferFull 153 | |
2508 | #define RDIError_OutOfStore 154 | |
2509 | #define RDIError_NotInDownload 155 | |
2510 | #define RDIError_PointInUse 156 | |
2511 | #define RDIError_BadImageFormat 157 | |
2512 | #define RDIError_TargetRunning 158 | |
2513 | #define RDIError_DeviceWouldNotOpen 159 | |
2514 | #define RDIError_NoSuchHandle 160 | |
2515 | #define RDIError_ConflictingPoint 161 | |
2516 | ||
2517 | #define RDIError_LittleEndian 240 | |
2518 | #define RDIError_BigEndian 241 | |
2519 | #define RDIError_SoftInitialiseError 242 | |
2520 | ||
2521 | #define RDIError_InsufficientPrivilege 253 | |
2522 | #define RDIError_UnimplementedMessage 254 | |
2523 | #define RDIError_UndefinedMessage 255 | |
2524 | ||
2525 | ||
2526 | #endif | |
2527 | ||
2528 | /* EOF adp_h */ |