projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
* h8300-dis.c: Fix formatting.
[binutils-gdb.git] / gdb / rdi-share / ardi.c
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 /*
10 * ARDI.c
11 * Angel Remote Debug Interface
12 *
13 *
14 * $Revision$
15 * $Date$
16 *
17 * This file is based on /plg/pisd/rdi.c, but instead of using RDP it uses
18 * ADP messages.
19 */
20
21 #include <stdarg.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #define uint HIDE_HPs_uint
26 #include <signal.h>
27 #undef uint
28
29
30 #include "angel_endian.h"
31 #include "ardi.h"
32 #include "buffers.h"
33 #include "channels.h"
34 #include "hostchan.h"
35 #include "host.h"
36 #include "angel_bytesex.h"
37 #include "dbg_cp.h"
38 #include "adp.h"
39 #include "hsys.h"
40 #include "logging.h"
41 #include "msgbuild.h"
42 #include "rxtx.h"
43 #include "devsw.h"
44 #include "params.h"
45
46 #ifdef COMPILING_ON_WINDOWS
47 # define IGNORE(x) (x = x) /* must go after #includes to work on Windows */
48 #endif
49 #define NOT(x) (!(x))
50
51 #define ADP_INITIAL_TIMEOUT_PERIOD 5
52
53 static volatile int executing;
54 static int rdi_log = 0 ; /* debugging ? */
55
56 /* we need a starting point for our first buffers, this is a safe one */
57 int Armsd_BufferSize = ADP_BUFFER_MIN_SIZE;
58 int Armsd_LongBufSize = ADP_BUFFER_MIN_SIZE;
59
60 #ifdef WIN32
61 extern int interrupted;
62 extern int swiprocessing;
63 #endif
64
65 static char dummycline = 0;
66 char *ardi_commandline = &dummycline ; /* exported in ardi.h */
67
68 extern unsigned int heartbeat_enabled;
69
70 static unsigned char *cpwords[16];
71
72 typedef struct stoppedProcListElement {
73 struct stoppedProcListElement *next;
74 angel_RDI_TargetStoppedProc *fn;
75 void *arg;
76 } stoppedProcListElement;
77
78 static stoppedProcListElement *stopped_proc_list=NULL;
79
80 const struct Dbg_HostosInterface *angel_hostif;
81 static hsys_state *hstate;
82
83 static void angel_DebugPrint(const char *format, ...)
84 { va_list ap;
85 va_start(ap, format);
86 angel_hostif->dbgprint(angel_hostif->dbgarg, format, ap);
87 va_end(ap);
88 }
89
90 #ifdef RDI_VERBOSE
91 #define TracePrint(s) \
92 if (rdi_log & 2) angel_DebugPrint("\n"); \
93 if (rdi_log & 1) angel_DebugPrint s
94 #else
95 #define TracePrint(s)
96 #endif
97
98 typedef struct receive_dbgmsg_state {
99 volatile int received;
100 Packet *packet;
101 } receive_dbgmsg_state;
102
103 static receive_dbgmsg_state dbgmsg_state;
104
105 static void receive_debug_packet(Packet *packet, void *stateptr)
106 {
107 receive_dbgmsg_state *state = stateptr;
108
109 state->packet = packet;
110 state->received = 1;
111 }
112
113 static int register_debug_message_handler(void)
114 {
115 int err;
116 dbgmsg_state.received = 0;
117
118 err = Adp_ChannelRegisterRead(CI_HADP, receive_debug_packet, &dbgmsg_state);
119 #ifdef DEBUG
120 if (err!=adp_ok) angel_DebugPrint("register_debug_message_handler failed %i\n", err);
121 #endif
122 return err;
123 }
124
125
126 static int wait_for_debug_message(int *rcode, int *debugID,
127 int *OSinfo1, int *OSinfo2,
128 int *status, Packet **packet)
129 {
130 unsigned int reason;
131
132 #ifdef DEBUG
133 angel_DebugPrint("wait_for_debug_message waiting for %X\n", *rcode);
134 #endif
135
136 for ( ; dbgmsg_state.received == 0 ; )
137 Adp_AsynchronousProcessing(async_block_on_read);
138
139 #ifdef DEBUG
140 angel_DebugPrint("wait_for_debug_message got packet\n");
141 #endif
142
143 *packet = dbgmsg_state.packet;
144
145 Adp_ChannelRegisterRead(CI_HADP, NULL, NULL);
146
147 /*
148 * TODO:
149 * If ADP_Unrecognised return error.
150 * If ADP_Acknowledge - handle appropriately.
151 * If expected message read arguments and return RDIError_NoError.
152 * Note: if RDIError occurs then the data values returned are junk
153 */
154
155 unpack_message(BUFFERDATA((*packet)->pk_buffer), "%w%w%w%w%w", &reason, debugID,
156 OSinfo1, OSinfo2, status);
157 if (reason&0xffffff == ADP_HADPUnrecognised)
158 return RDIError_UnimplementedMessage;
159 if (reason != (unsigned ) *rcode) {
160 if((reason&0xffffff) == ADP_HADPUnrecognised)
161 return RDIError_UnimplementedMessage;
162 else {
163 angel_DebugPrint("ARDI ERROR: Expected reasoncode %x got reasoncode %x.\n",
164 *rcode, reason);
165 return RDIError_Error;
166 }
167 }
168 else
169 return RDIError_NoError;
170 return RDIError_Error; /* stop a pesky ANSI compiler warning */
171 }
172
173
174 /*
175 * Handler and registration for logging messages from target
176 */
177 static void TargetLogCallback( Packet *packet, void *state )
178 {
179 p_Buffer reply = BUFFERDATA(packet->pk_buffer);
180 unsigned int len = packet->pk_length;
181 IGNORE(state);
182 angel_hostif->write(angel_hostif->hostosarg,
183 (char *)reply, len - CHAN_HEADER_SIZE);
184 DevSW_FreePacket(packet);
185
186 packet = DevSW_AllocatePacket(4); /* better not ask for 0 */
187 /* the reply is the ACK - any contents are ignored */
188 if (packet != NULL)
189 Adp_ChannelWrite( CI_TLOG, packet );
190 }
191
192 static void TargetLogInit( void )
193 {
194 AdpErrs err = Adp_ChannelRegisterRead( CI_TLOG, TargetLogCallback, NULL );
195
196 #ifdef DEBUG
197 if (err != adp_ok)
198 angel_DebugPrint("CI_TLOG RegisterRead failed %d\n", err);
199 #else
200 IGNORE(err);
201 #endif
202 }
203
204 /*----------------------------------------------------------------------*/
205 /*----angel_RDI_open-----------------------------------------------------*/
206 /*----------------------------------------------------------------------*/
207
208 typedef struct NegotiateState {
209 bool negotiate_resp;
210 bool negotiate_ack;
211 bool link_check_resp;
212 ParameterConfig *accepted_config;
213 } NegotiateState;
214
215 static void receive_negotiate(Packet *packet, void *stateptr)
216 {
217 unsigned reason, debugID, OSinfo1, OSinfo2, status;
218 NegotiateState *n_state = (NegotiateState *)stateptr;
219 p_Buffer reply = BUFFERDATA(packet->pk_buffer);
220
221 unpack_message( reply, "%w%w%w%w",
222 &reason, &debugID, &OSinfo1, &OSinfo2 );
223 reply += ADP_DEFAULT_HEADER_SIZE;
224
225 #ifdef DEBUG
226 angel_DebugPrint( "receive_negotiate: reason %x\n", reason );
227 #endif
228
229 switch ( reason )
230 {
231 case ADP_ParamNegotiate | TtoH:
232 {
233 n_state->negotiate_resp = TRUE;
234
235 status = GET32LE( reply );
236 reply += sizeof(word);
237 #ifdef DEBUG
238 angel_DebugPrint( "ParamNegotiate status %u\n", status );
239 #endif
240 if ( status == RDIError_NoError )
241 {
242 if ( Angel_ReadParamConfigMessage(
243 reply, n_state->accepted_config ) )
244 n_state->negotiate_ack = TRUE;
245 }
246 break;
247 }
248
249 case ADP_LinkCheck | TtoH:
250 {
251 #ifdef DEBUG
252 angel_DebugPrint( "PONG!\n" );
253 #endif
254 n_state->link_check_resp = TRUE;
255 break;
256 }
257
258 default:
259 {
260 #ifdef DEBUG
261 angel_DebugPrint( "Unexpected!\n" );
262 #endif
263 break;
264 }
265 }
266 DevSW_FreePacket( packet );
267 }
268
269 # include <sys/types.h>
270 #ifdef __unix
271 # include <sys/time.h>
272 #else
273 # include <time.h>
274 #endif
275
276 /*
277 * convert a config into a single-valued options list
278 */
279 static ParameterOptions *config_to_options( const ParameterConfig *config )
280 {
281 unsigned int num_params;
282 size_t size;
283 ParameterOptions *base_p;
284
285 num_params = config->num_parameters;
286 size =
287 sizeof(ParameterOptions)
288 + num_params*(sizeof(ParameterList) + sizeof(unsigned int));
289 base_p = malloc( size );
290
291 if ( base_p != NULL )
292 {
293 unsigned int u;
294 ParameterList *list_p =
295 (ParameterList *)((char *)base_p + sizeof(ParameterOptions));
296 unsigned int *option_p =
297 (unsigned int *)(list_p + num_params);
298
299 base_p->num_param_lists = num_params;
300 base_p->param_list = list_p;
301
302 for ( u = 0; u < num_params; ++u )
303 {
304 option_p[u] = config->param[u].value;
305 list_p[u].type = config->param[u].type;
306 list_p[u].num_options = 1;
307 list_p[u].option = &option_p[u];
308 }
309 }
310
311 return base_p;
312 }
313
314 static AdpErrs negotiate_params( const ParameterOptions *user_options )
315 {
316 Packet *packet;
317 unsigned int count;
318 static Parameter params[AP_NUM_PARAMS];
319 static ParameterConfig accepted_config = { AP_NUM_PARAMS, params };
320
321 time_t t;
322
323 static volatile NegotiateState n_state;
324 n_state.negotiate_resp = FALSE;
325 n_state.negotiate_ack = FALSE;
326 n_state.link_check_resp = FALSE;
327 n_state.accepted_config = &accepted_config;
328
329 #ifdef DEBUG
330 angel_DebugPrint( "negotiate_params\n" );
331 #endif
332
333 Adp_ChannelRegisterRead( CI_HBOOT, receive_negotiate, (void *)&n_state );
334
335 packet = (Packet *)DevSW_AllocatePacket(Armsd_BufferSize);
336 count = msgbuild( BUFFERDATA(packet->pk_buffer), "%w%w%w%w",
337 ADP_ParamNegotiate | HtoT, 0,
338 ADP_HandleUnknown, ADP_HandleUnknown );
339 count += Angel_BuildParamOptionsMessage(
340 BUFFERDATA(packet->pk_buffer) + count, user_options );
341 packet->pk_length = count;
342 Adp_ChannelWriteAsync( CI_HBOOT, packet );
343
344 #ifdef DEBUG
345 angel_DebugPrint( "sent negotiate packet\n" );
346 #endif
347
348 t=time(NULL);
349
350 do {
351 Adp_AsynchronousProcessing(async_block_on_nothing);
352
353 if ((time(NULL)-t) > ADP_INITIAL_TIMEOUT_PERIOD) {
354 return adp_timeout_on_open;
355 }
356 } while ( ! n_state.negotiate_resp );
357
358 if ( n_state.negotiate_ack )
359 {
360 /* select accepted config */
361 Adp_Ioctl( DC_SET_PARAMS, (void *)n_state.accepted_config );
362
363 /*
364 * 960430 KWelton
365 *
366 * There is a race in the renegotiation protocol: the
367 * target has to have had time to load new config before
368 * we send the link check packet - insert a deliberate
369 * pause (100ms) to give the target some time
370 */
371 Adp_delay(100000);
372
373 /* do link check */
374 msgsend( CI_HBOOT, "%w%w%w%w", ADP_LinkCheck | HtoT, 0,
375 ADP_HandleUnknown, ADP_HandleUnknown );
376 #ifdef DEBUG
377 angel_DebugPrint("sent link check\n");
378 #endif
379
380 do {
381 Adp_AsynchronousProcessing(async_block_on_read);
382 } while ( ! n_state.link_check_resp );
383 Adp_initSeq();
384 }
385 return adp_ok;
386 }
387
388 static int late_booted = FALSE;
389 static bool ardi_handler_installed = FALSE;
390
391 #ifdef __unix
392 static struct sigaction old_action;
393 #else
394 static void (*old_handler)();
395 #endif
396
397 static bool boot_interrupted = FALSE;
398 static volatile bool interrupt_request = FALSE;
399
400 static void ardi_sigint_handler(int sig) {
401 #ifdef DEBUG
402 if (sig != SIGINT)
403 angel_DebugPrint("Expecting SIGINT got %d.\n", sig);
404 #else
405 IGNORE(sig);
406 #endif
407 boot_interrupted = TRUE;
408 interrupt_request = TRUE;
409 #ifndef __unix
410 signal(SIGINT, ardi_sigint_handler);
411 #endif
412 }
413
414 static void install_ardi_handler( void ) {
415 if (!ardi_handler_installed) {
416 /* install a new Ctrl-C handler so we can abandon waiting */
417 #ifdef __unix
418 struct sigaction new_action;
419 sigemptyset(&new_action.sa_mask);
420 new_action.sa_handler = ardi_sigint_handler;
421 new_action.sa_flags = 0;
422 sigaction(SIGINT, &new_action, &old_action);
423 #else
424 old_handler = signal(SIGINT, ardi_sigint_handler);
425 #endif
426 ardi_handler_installed = TRUE;
427 }
428 }
429
430 static int angel_RDI_errmess(char *buf, int blen, int errnum);
431
432 static void receive_reset_acknowledge(Packet *packet, void *stateptr) {
433 unsigned reason, debugID, OSinfo1, OSinfo2, status;
434 IGNORE(stateptr);
435
436 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", &reason, &debugID,
437 &OSinfo1, &OSinfo2, &status);
438 if (reason==(ADP_Reset | TtoH) && status==AB_NORMAL_ACK) {
439 #ifdef DEBUG
440 angel_DebugPrint("DEBUG: Successfully received normal reset acknowledgement\n");
441 late_booted = FALSE;
442 #endif
443 } else if (reason==(ADP_Reset | TtoH) && status==AB_LATE_ACK) {
444 char late_msg[AdpMessLen_LateStartup];
445 int late_len;
446 #ifdef DEBUG
447 angel_DebugPrint("DEBUG: Successfully received LATE reset acknowledgement\n");
448 #endif
449 late_booted = TRUE;
450 install_ardi_handler();
451 late_len = angel_RDI_errmess(late_msg,
452 AdpMessLen_LateStartup, adp_late_startup);
453 angel_hostif->write(angel_hostif->hostosarg, late_msg, late_len);
454 } else {
455 #ifdef DEBUG
456 angel_DebugPrint("DEBUG: Bad reset ack: reason=%8X, status=%8X\n", reason, status);
457 #endif
458 }
459 DevSW_FreePacket(packet);
460 }
461
462 static int booted_not_received;
463 static unsigned int angel_version;
464 static unsigned int adp_version;
465 static unsigned int arch_info;
466 static unsigned int cpu_info;
467 static unsigned int hw_status;
468
469 static void receive_booted(Packet *packet, void *stateptr) {
470 unsigned reason, debugID, OSinfo1, OSinfo2, banner_length, bufsiz, longsiz;
471 unsigned i, count;
472
473 IGNORE(stateptr);
474
475 count = unpack_message(BUFFERDATA(packet->pk_buffer),
476 "%w%w%w%w%w%w%w%w%w%w%w%w",
477 &reason, &debugID, &OSinfo1, &OSinfo2, &bufsiz, &longsiz,
478 &angel_version, &adp_version,
479 &arch_info, &cpu_info, &hw_status, &banner_length);
480 if (reason==(ADP_Booted | TtoH)) {
481 #ifdef MONITOR_DOWNLOAD_PACKETS
482 angel_DebugPrint("DEBUG: Successfully received Booted\n");
483 angel_DebugPrint(" cpu_info=%8X, hw_status=%8X, bufsiz=%d, longsiz=%d\n",
484 cpu_info, hw_status, bufsiz, longsiz);
485 #endif
486 /* Get the banner from the booted message */
487 for (i=0; i<banner_length; i++)
488 angel_hostif->writec(angel_hostif->hostosarg,
489 (BUFFERDATA(packet->pk_buffer)+count)[i]);
490
491 booted_not_received=0;
492 #ifndef NO_HEARTBEAT
493 heartbeat_enabled = TRUE;
494 #endif
495 Armsd_BufferSize = bufsiz + CHAN_HEADER_SIZE;
496 Armsd_LongBufSize = longsiz + CHAN_HEADER_SIZE;
497 } else {
498 #ifdef DEBUG
499 angel_DebugPrint("DEBUG: Bad Booted msg: reason=%8X\n", reason);
500 #endif
501 }
502 DevSW_FreePacket(packet);
503 }
504
505
506 /* forward declaration */
507 static int angel_negotiate_defaults( void );
508
509 /* Open communications. */
510 int angel_RDI_open(
511 unsigned type, Dbg_ConfigBlock const *config,
512 Dbg_HostosInterface const *hostif, struct Dbg_MCState *dbg_state)
513 {
514 Packet *packet;
515 int status, reasoncode, debugID, OSinfo1, OSinfo2, err;
516 ParameterOptions *user_options = NULL;
517
518 time_t t;
519
520 IGNORE( dbg_state );
521
522 if ((type & 1) == 0) {
523 /* cold start */
524 if (hostif != NULL) {
525 angel_hostif = hostif;
526 err = HostSysInit(hostif, &ardi_commandline, &hstate);
527 if (err != RDIError_NoError) {
528 #ifdef DEBUG
529 angel_DebugPrint("DEBUG: HostSysInit error %i\n",err);
530 #endif
531 return err;
532 }
533 }
534 TargetLogInit();
535 }
536
537 #ifdef DEBUG
538 angel_DebugPrint("DEBUG: Buffer allocated in angel_RDI_open(type=%i).\n",type);
539 #endif
540
541 if ((type & 1) == 0) {
542 /* cold start */
543 unsigned endian;
544 Adp_Ioctl( DC_GET_USER_PARAMS, (void *)&user_options );
545 if ( user_options != NULL ) {
546 err = negotiate_params( user_options );
547 if (err != adp_ok) return err;
548 }
549 else {
550 ParameterConfig *default_config = NULL;
551 Adp_Ioctl( DC_GET_DEFAULT_PARAMS, (void *)&default_config );
552 if ( default_config != NULL ) {
553 ParameterOptions *default_options = config_to_options(default_config);
554 err = negotiate_params( default_options );
555 if (err != adp_ok) return err;
556 }
557 }
558
559 /* Register handlers before sending any messages */
560 booted_not_received=1;
561 Adp_ChannelRegisterRead(CI_HBOOT, receive_reset_acknowledge, NULL);
562 Adp_ChannelRegisterRead(CI_TBOOT, receive_booted, NULL);
563 endian = 0;
564 if (config!=NULL) {
565 if (config->bytesex & RDISex_Little) endian |= ADP_BootHostFeature_LittleEnd;
566 if (config->bytesex & RDISex_Big) endian |= ADP_BootHostFeature_BigEnd;
567 }
568 msgsend(CI_HBOOT,"%w%w%w%w%w", ADP_Reset | HtoT, 0,
569 ADP_HandleUnknown, ADP_HandleUnknown, endian);
570 #ifdef DEBUG
571 angel_DebugPrint("DEBUG: Transmitted Reset message in angel_RDI_open.\n");
572 #endif
573
574 /* We will now either get an acknowledgement for the Reset message
575 * or if the target was started after the host, we will get a
576 * rebooted message first.
577 */
578
579 #ifdef DEBUG
580 angel_DebugPrint("DEBUG: waiting for a booted message\n");
581 #endif
582
583 {
584 boot_interrupted = FALSE;
585
586 if (late_booted)
587 install_ardi_handler();
588
589 t=time(NULL);
590
591 do {
592 Adp_AsynchronousProcessing(async_block_on_nothing);
593 if ((time(NULL)-t) > ADP_INITIAL_TIMEOUT_PERIOD && !late_booted) {
594 return adp_timeout_on_open;
595 }
596 } while (booted_not_received && !boot_interrupted);
597
598 if (ardi_handler_installed)
599 {
600 /* uninstall our Ctrl-C handler */
601 #ifdef __unix
602 sigaction(SIGINT, &old_action, NULL);
603 #else
604 signal(SIGINT, old_handler);
605 #endif
606 }
607
608 if (boot_interrupted) {
609 angel_negotiate_defaults();
610 return adp_abandon_boot_wait;
611 }
612 }
613
614 booted_not_received=1;
615 Adp_ChannelRegisterRead(CI_HBOOT, NULL, NULL);
616
617 /* Leave the booted handler installed */
618 msgsend(CI_TBOOT, "%w%w%w%w%w", ADP_Booted | HtoT, 0,
619 ADP_HandleUnknown, ADP_HandleUnknown, 0);
620 Adp_initSeq();
621 #ifdef DEBUG
622 angel_DebugPrint("DEBUG: Transmitted ADP_Booted acknowledgement.\n");
623 angel_DebugPrint("DEBUG: Boot sequence completed, leaving angel_RDI_open.\n");
624 #endif
625
626 return (hw_status & ADP_CPU_BigEndian )? RDIError_BigEndian :
627 RDIError_LittleEndian;
628 }
629 else {
630 /* warm start */
631 register_debug_message_handler();
632
633 msgsend(CI_HADP, "%w%w%w%w",
634 ADP_InitialiseApplication | HtoT, 0,
635 ADP_HandleUnknown, ADP_HandleUnknown);
636 #ifdef DEBUG
637 angel_DebugPrint("DEBUG: Transmitted Initialise Application\n");
638 #endif
639 reasoncode=ADP_InitialiseApplication | TtoH;
640 err = wait_for_debug_message(&reasoncode, &debugID, &OSinfo1, &OSinfo2,
641 &status, &packet);
642 if (err != RDIError_NoError) return err;
643 return status;
644 }
645 return -1;
646 }
647
648
649 /*----------------------------------------------------------------------*/
650 /*----angel_RDI_close----------------------------------------------------*/
651 /*----------------------------------------------------------------------*/
652
653 static int angel_negotiate_defaults( void ) {
654 int err = adp_ok;
655 ParameterConfig *default_config = NULL;
656 Adp_Ioctl( DC_GET_DEFAULT_PARAMS, (void *)&default_config );
657 if ( default_config != NULL ) {
658 ParameterOptions *default_options = config_to_options(default_config);
659 err = negotiate_params( default_options );
660 free( default_options );
661 }
662 return err;
663 }
664
665 int angel_RDI_close(void) {
666 /*Angel host exit */
667 int err;
668 int status,debugID, OSinfo1,OSinfo2;
669 int reason;
670 Packet *packet = NULL;;
671 #ifdef DEBUG
672 angel_DebugPrint("DEBUG: Entered angel_RDI_Close.\n");
673 #endif
674
675 register_debug_message_handler();
676
677 heartbeat_enabled = FALSE;
678
679 err = msgsend(CI_HADP,"%w%w%w%w",ADP_End | HtoT,0,
680 ADP_HandleUnknown, ADP_HandleUnknown);
681 if (err != RDIError_NoError) return err;
682 reason = ADP_End | TtoH;
683 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
684 &status, &packet);
685 DevSW_FreePacket(packet);
686 if (err != RDIError_NoError) return err;
687 if (status == RDIError_NoError) {
688 err = angel_negotiate_defaults();
689 if (err != adp_ok) return err;
690 Adp_Ioctl( DC_RESET, NULL ); /* just to be safe */
691 return HostSysExit(hstate);
692 }
693 else
694 return status;
695 }
696
697
698 /*----------------------------------------------------------------------*/
699 /*----angel_RDI_read-----------------------------------------------------*/
700 /*----------------------------------------------------------------------*/
701
702 /* Read memory contents from target to host: use ADP_Read */
703 int angel_RDI_read(ARMword source, void *dest, unsigned *nbytes)
704 {
705 Packet *packet=NULL;
706 int len; /* Integer to hold message length. */
707 unsigned int nbtogo = *nbytes, nbinpacket, nbdone=0;
708 int rnbytes = 0, status, reason, debugID, OSinfo1, OSinfo2, err;
709 unsigned int maxlen = Armsd_BufferSize-CHAN_HEADER_SIZE-ADP_ReadHeaderSize;
710
711 /* Print debug trace information, this is just copied straight from rdi.c
712 and I can see no reason why it should have to be changed. */
713 TracePrint(("angel_RDI_read: source=%.8lx dest=%p nbytes=%.8x\n",
714 (unsigned long)source, dest, *nbytes));
715 if (*nbytes == 0) return RDIError_NoError; /* Read nothing - easy! */
716 /* check the buffer size */
717 while (nbtogo >0) {
718 register_debug_message_handler();
719
720 nbinpacket = (nbtogo <= maxlen) ? nbtogo : maxlen;
721 len = msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Read | HtoT, 0,
722 ADP_HandleUnknown, ADP_HandleUnknown, source+nbdone,
723 nbinpacket);
724 reason=ADP_Read | TtoH;
725 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
726 &status, &packet);
727 TracePrint(("angel_RDI_read: nbinpacket =%d status=%08x err = %d\n",
728 nbinpacket,status,err));
729 if (err != RDIError_NoError) return err; /* Was there an error? */
730 if (status == RDIError_NoError){
731 rnbytes += PREAD(LE,(unsigned int *)(BUFFERDATA(packet->pk_buffer)+20));
732 TracePrint(("angel_RDI_read: rnbytes = %d\n",rnbytes));
733 memcpy(((unsigned char *)dest)+nbdone, BUFFERDATA(packet->pk_buffer)+24,
734 nbinpacket);
735 }
736 nbdone += nbinpacket;
737 nbtogo -= nbinpacket;
738 }
739 *nbytes -= rnbytes;
740 return status;
741 }
742
743
744 /*----------------------------------------------------------------------*/
745 /*----angel_RDI_write----------------------------------------------------*/
746 /*----------------------------------------------------------------------*/
747
748 /* Transfer memory block from host to target. Use ADP_Write>. */
749 int angel_RDI_write(const void *source, ARMword dest, unsigned *nbytes)
750 {
751 Packet *packet;/* Message buffers. */
752 unsigned int len, nbtogo = *nbytes, nboffset = 0, nbinpacket;
753 int status, reason, debugID, OSinfo1, OSinfo2, err;
754 unsigned int maxlen = Armsd_LongBufSize-CHAN_HEADER_SIZE-ADP_WriteHeaderSize;
755
756 TracePrint(("angel_RDI_write: source=%p dest=%.8lx nbytes=%.8x\n",
757 source, (unsigned long)dest, *nbytes));
758
759 if (*nbytes == 0) return RDIError_NoError;
760
761 *nbytes = 0;
762 while (nbtogo > 0) {
763 packet = (Packet *) DevSW_AllocatePacket(Armsd_LongBufSize);
764 nbinpacket = (nbtogo <= maxlen) ? nbtogo : maxlen;
765 len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w",
766 ADP_Write | HtoT, 0, ADP_HandleUnknown,
767 ADP_HandleUnknown, dest+nboffset, nbinpacket);
768 /* Copy the data into the packet. */
769
770 memcpy(BUFFERDATA(packet->pk_buffer)+len,
771 ((const unsigned char *) source)+nboffset, nbinpacket);
772 nboffset += nbinpacket;
773 packet->pk_length = nbinpacket+len;
774
775 #ifdef MONITOR_DOWNLOAD_PACKETS
776 angel_DebugPrint("angel_RDI_write packet size=%i, bytes done=%i\n",
777 nbinpacket, nboffset);
778 #endif
779
780 register_debug_message_handler();
781 Adp_ChannelWrite(CI_HADP, packet);
782 reason=ADP_Write | TtoH;
783 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
784 &status, &packet);
785 nbtogo -= nbinpacket;
786 if (err != RDIError_NoError) return err;
787 if (status == RDIError_NoError)
788 *nbytes += nbinpacket;
789
790 DevSW_FreePacket(packet);
791 }
792 return status;
793 }
794
795
796 /*----------------------------------------------------------------------*/
797 /*----angel_RDI_CPUread--------------------------------------------------*/
798 /*----------------------------------------------------------------------*/
799
800 /* Reads the values of registers in the CPU, uses ADP_CPUwrite. */
801 int angel_RDI_CPUread(unsigned mode, unsigned long mask, ARMword *buffer)
802 {
803 unsigned int i, j;
804 Packet *packet = NULL;
805 int err, status, reason, debugID, OSinfo1, OSinfo2;
806 #ifdef DEBUG
807 angel_DebugPrint("DEBUG: Entered angel_RDI_CPUread.\n");
808 #endif
809 for (i=0, j=0 ; i < RDINumCPURegs ; i++)
810 if (mask & (1L << i)) j++; /* Count the number of registers. */
811
812 register_debug_message_handler();
813 msgsend(CI_HADP, "%w%w%w%w%c%w", ADP_CPUread | HtoT, 0,
814 ADP_HandleUnknown, ADP_HandleUnknown, mode, mask);
815 reason = ADP_CPUread | TtoH;
816 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
817 &status, &packet);
818 if (err != RDIError_NoError) {
819 DevSW_FreePacket(packet);
820 return err;
821 }
822 if(status == RDIError_NoError) {
823 for (i=0; i<j; i++)
824 buffer[i] = GET32LE(BUFFERDATA(packet->pk_buffer)+20+(i*4));
825 TracePrint(("angel_RDI_CPUread: mode=%.8x mask=%.8lx", mode, mask));
826 DevSW_FreePacket(packet);
827 #ifdef RDI_VERBOSE
828 if (rdi_log & 1) {
829 unsigned k;
830 for (k = 0, j = 0 ; j <= 20 ; j++)
831 if (mask & (1L << j)) {
832 angel_DebugPrint("%c%.8lx",k%4==0?'\n':' ',
833 (unsigned long)buffer[k]);
834 k++ ;
835 }
836 angel_DebugPrint("\n") ;
837 }
838 #endif
839
840 }
841 return status;
842 }
843
844 /*----------------------------------------------------------------------*/
845 /*----angel_RDI_CPUwrite-------------------------------------------------*/
846 /*----------------------------------------------------------------------*/
847
848 /* Write CPU registers: use ADP_CPUwrite. */
849 int angel_RDI_CPUwrite(unsigned mode, unsigned long mask,
850 ARMword const *buffer){
851
852 unsigned i, j, c;
853 Packet *packet;
854 int status, reason, debugID, OSinfo1, OSinfo2, err, len;
855
856 TracePrint(("angel_RDI_CPUwrite: mode=%.8x mask=%.8lx", mode, mask));
857 #ifdef RDI_VERBOSE
858 if (rdi_log & 1) {
859 for (j = 0, i = 0 ; i <= 20 ; i++)
860 if (mask & (1L << i)) {
861 angel_DebugPrint("%c%.8lx",j%4==0?'\n':' ',
862 (unsigned long)buffer[j]);
863 j++ ;
864 }
865 angel_DebugPrint("\n") ;
866 }
867 #endif
868 packet = (Packet *)DevSW_AllocatePacket(Armsd_BufferSize);
869 for (i=0, j=0; i < RDINumCPURegs ; i++)
870 if (mask & (1L << i)) j++; /* count the number of registers */
871
872 len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%b%w",
873 ADP_CPUwrite | HtoT, 0,
874 ADP_HandleUnknown, ADP_HandleUnknown, mode, mask);
875 for(c=0; c<j; c++)
876 PUT32LE(BUFFERDATA(packet->pk_buffer)+len+(c*4), buffer[c]);
877 packet->pk_length = len+(j*4);
878 register_debug_message_handler();
879
880 Adp_ChannelWrite(CI_HADP, packet);
881 reason = ADP_CPUwrite | TtoH;
882 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
883 &status, &packet);
884 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", &reason, &debugID,
885 &OSinfo1, &OSinfo2, &status);
886 DevSW_FreePacket(packet);
887 if (err != RDIError_NoError)
888 return err; /* Was there an error? */
889 else
890 return status;
891 }
892
893
894 /*----------------------------------------------------------------------*/
895 /*----angel_RDI_CPread---------------------------------------------------*/
896 /*----------------------------------------------------------------------*/
897
898 /* Read coprocessor's internal state. See dbg_cp.h for help.
899 * Use ADP_CPRead.
900 * It would appear that the correct behaviour at this point is to leave
901 * the unpacking to a the caller and to simply copy the stream of data
902 * words into the buffer
903 */
904
905 int angel_RDI_CPread(unsigned CPnum, unsigned long mask, ARMword *buffer){
906 Packet *packet = NULL;
907 int i, j, status, reasoncode, OSinfo1, OSinfo2, err, debugID;
908 unsigned char *rmap = cpwords[CPnum];
909 int n;
910 #ifdef DEBUG
911 angel_DebugPrint("DEBUG: Entered angel_RDI_CPread.\n");
912 #endif
913 if (rmap == NULL) return RDIError_UnknownCoPro;
914
915 register_debug_message_handler();
916 n = rmap[-1];
917 msgsend(CI_HADP, "%w%w%w%w%b%w", ADP_CPread | HtoT, 0,
918 ADP_HandleUnknown, ADP_HandleUnknown, CPnum, mask);
919 reasoncode=ADP_CPread | TtoH;
920 err = wait_for_debug_message(&reasoncode, &debugID, &OSinfo1, &OSinfo2,
921 &status, &packet);
922 if (err != RDIError_NoError) {
923 DevSW_FreePacket(packet);
924 return err; /* Was there an error? */
925 }
926 for (j=i=0; i < n ; i++) /* count the number of registers */
927 if (mask & (1L << i)) {
928 j++;
929 }
930 for (i=0; i<j; i++)
931 buffer[i] = PREAD32(LE, BUFFERDATA(packet->pk_buffer) + 20 + (i*4));
932 DevSW_FreePacket(packet);
933 TracePrint(("angel_RDI_CPread: CPnum=%.8x mask=%.8lx\n", CPnum, mask));
934 #ifdef RDI_VERBOSE
935 if (rdi_log & 1) {
936 for (i = 0, j = 0; j < n ; j++) {
937 if (mask & (1L << j)) {
938 int nw = rmap[j];
939 angel_DebugPrint("%2d ", j);
940 while (--nw > 0)
941 angel_DebugPrint("%.8lx ", (unsigned long)buffer[i++]);
942 angel_DebugPrint("%.8lx\n", (unsigned long)buffer[i++]);
943 }
944 }
945 }
946 #endif
947 return status;
948 }
949
950
951 /*----------------------------------------------------------------------*/
952 /*----angel_RDI_CPwrite--------------------------------------------------*/
953 /*----------------------------------------------------------------------*/
954
955 /* Write coprocessor's internal state. See dbg_cp.h for help. Use
956 * ADP_CPwrite.
957 */
958
959 int angel_RDI_CPwrite(unsigned CPnum, unsigned long mask,
960 ARMword const *buffer)
961 {
962 Packet *packet = NULL;
963 int i, j, len, status, reason, OSinfo1, OSinfo2, err, debugID;
964 unsigned char *rmap = cpwords[CPnum];
965 int n;
966
967 if (rmap == NULL) return RDIError_UnknownCoPro;
968 n = rmap[-1];
969
970 TracePrint(("angel_RDI_CPwrite: CPnum=%d mask=%.8lx\n", CPnum, mask));
971
972 #ifdef RDI_VERBOSE
973 if (rdi_log & 1) {
974 for (i = 0, j = 0; j < n ; j++)
975 if (mask & (1L << j)) {
976 int nw = rmap[j];
977 angel_DebugPrint("%2d ", j);
978 while (--nw > 0)
979 angel_DebugPrint("%.8lx ", (unsigned long)buffer[i++]);
980 angel_DebugPrint("%.8lx\n", (unsigned long)buffer[i++]);
981 }
982 }
983 #endif
984
985 for (j=i=0; i < n ; i++) /* Count the number of registers. */
986 if (mask & (1L << i)) j++;
987 packet = DevSW_AllocatePacket(Armsd_BufferSize);
988 len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%c%w",
989 ADP_CPwrite | HtoT, 0,
990 ADP_HandleUnknown, ADP_HandleUnknown, CPnum, mask);
991 for(i=0; i<j; i++)
992 len+=msgbuild(BUFFERDATA(packet->pk_buffer) + len, "%w", buffer[i]);
993 packet->pk_length = len;
994 register_debug_message_handler();
995 Adp_ChannelWrite(CI_HADP, packet); /* Transmit message. */
996 reason=ADP_CPwrite | TtoH;
997 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
998 &status, &packet);
999 DevSW_FreePacket(packet);
1000 if (err != RDIError_NoError)
1001 return err;
1002 else
1003 return status;
1004 }
1005
1006
1007 /*----------------------------------------------------------------------*/
1008 /*----angel_RDI_pointinq-------------------------------------------------*/
1009 /*----------------------------------------------------------------------*/
1010
1011 /* Do test calls to ADP_SetBreak/ADP_SetWatch to see if resources exist to
1012 carry out request. */
1013 int angel_RDI_pointinq(ARMword *address, unsigned type, unsigned datatype,
1014 ARMword *bound)
1015 {
1016 Packet *packet = NULL;
1017 int len, status, reason, OSinfo1, OSinfo2, err=RDIError_NoError;
1018 /* stop a compiler warning */
1019 int debugID, pointhandle;
1020 TracePrint(
1021 ("angel_RDI_pointinq: address=%.8lx type=%d datatype=%d bound=%.8lx ",
1022 (unsigned long)*address, type, datatype, (unsigned long)*bound));
1023 /* for a buffer. */
1024 packet = DevSW_AllocatePacket(Armsd_BufferSize);
1025 len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%b",
1026 ((datatype == 0) ? ADP_SetBreak : ADP_SetWatch) | HtoT, 0,
1027 ADP_HandleUnknown, ADP_HandleUnknown, address, type);
1028 if (datatype == 0)
1029 len += msgbuild(BUFFERDATA(packet->pk_buffer) + 21, "%w", bound);
1030 else
1031 len += msgbuild(BUFFERDATA(packet->pk_buffer) + 21, "%b%w", datatype, bound);
1032
1033 register_debug_message_handler();
1034 packet->pk_length = len;
1035 Adp_ChannelWrite(CI_HADP, packet);
1036 reason = ((datatype == 0) ? ADP_SetBreak : ADP_SetWatch | TtoH);
1037 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1038 &status, &packet);
1039 if (err != RDIError_NoError) {
1040 DevSW_FreePacket(packet);
1041 return err; /* Was there an error? */
1042 }
1043 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w",
1044 &reason, &debugID, &OSinfo1, &OSinfo2, &status,
1045 &pointhandle, &address, &bound);
1046 DevSW_FreePacket(packet);
1047 return err;
1048 }
1049
1050
1051 /*----------------------------------------------------------------------*/
1052 /*----angel_RDI_setbreak-------------------------------------------------*/
1053 /*----------------------------------------------------------------------*/
1054
1055 /* Set a breakpoint: Use ADP_SetBreak */
1056 int angel_RDI_setbreak(ARMword address, unsigned type, ARMword bound,
1057 PointHandle *handle)
1058 {
1059 int status, reason, OSinfo1, OSinfo2, err, debugID;
1060 int tmpval, tmpaddr, tmpbnd;
1061 Packet *packet;
1062 TracePrint(("angel_RDI_setbreak address=%.8lx type=%d bound=%.8lx \n",
1063 (unsigned long)address, type, (unsigned long)bound));
1064
1065 register_debug_message_handler();
1066 msgsend(CI_HADP, "%w%w%w%w%w%b%w",
1067 ADP_SetBreak| HtoT, 0, ADP_HandleUnknown,
1068 ADP_HandleUnknown, address, type, bound);
1069 reason = ADP_SetBreak |TtoH;
1070 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1071 &status, &packet);
1072 if (err != RDIError_NoError) {
1073 DevSW_FreePacket(packet);
1074 return err; /* Was there an error? */
1075 }
1076 /* Work around varargs problem... -sts */
1077 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w",
1078 &reason, &debugID, &OSinfo1, &OSinfo2, &status,
1079 &tmpval, &tmpaddr, &tmpbnd);
1080 *handle = tmpval;
1081 address = tmpaddr;
1082 bound = tmpbnd;
1083 DevSW_FreePacket(packet);
1084 if (status != RDIError_NoError) return status;
1085 TracePrint(("returns handle %.8lx\n", (unsigned long)*handle));
1086 return RDIError_NoError;
1087 }
1088
1089
1090 /*----------------------------------------------------------------------*/
1091 /*----angel_RDI_clearbreak-----------------------------------------------*/
1092 /*----------------------------------------------------------------------*/
1093
1094 /* Clear a breakpoint: Use ADP_ClearBreak. */
1095 int angel_RDI_clearbreak(PointHandle handle)
1096 {
1097 Packet *packet = NULL;
1098 int status, reason, OSinfo1, OSinfo2, err, debugID;
1099
1100 TracePrint(("angel_RDI_clearbreak: handle=%.8lx\n", (unsigned long)handle));
1101
1102 register_debug_message_handler();
1103 msgsend(CI_HADP, "%w%w%w%w%w",
1104 ADP_ClearBreak| HtoT, 0, ADP_HandleUnknown,
1105 ADP_HandleUnknown, handle);
1106 reason = ADP_ClearBreak|TtoH;
1107 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1108 &status, &packet);
1109 if (err != RDIError_NoError) {
1110 DevSW_FreePacket(packet);
1111 angel_DebugPrint("***RECEIVE DEBUG MESSAGE RETURNED ERR = %d.\n", err);
1112 return err; /* Was there an error? */
1113 }
1114 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", &reason,
1115 &debugID, &OSinfo1, &OSinfo2, &status);
1116 DevSW_FreePacket(packet);
1117 #ifdef DEBUG
1118 angel_DebugPrint("DEBUG: Clear Break completed OK.\n");
1119 #endif
1120 return RDIError_NoError;
1121 }
1122
1123
1124 /*----------------------------------------------------------------------*/
1125 /*----angel_RDI_setwatch-------------------------------------------------*/
1126 /*----------------------------------------------------------------------*/
1127
1128 /* Set a watchpoint: use ADP_SetWatch. */
1129 int angel_RDI_setwatch(ARMword address, unsigned type, unsigned datatype,
1130 ARMword bound, PointHandle *handle)
1131 {
1132 Packet *packet = NULL;
1133 int status, reason, OSinfo1, OSinfo2, err, debugID;
1134
1135 TracePrint(("angel_RDI_setwatch: address=%.8lx type=%d bound=%.8lx ",
1136 (unsigned long)address, type, (unsigned long)bound));
1137
1138 register_debug_message_handler();
1139 msgsend(CI_HADP, "%w%w%w%w%w%b%b%w",
1140 ADP_SetWatch| HtoT, 0, ADP_HandleUnknown,
1141 ADP_HandleUnknown, address, type, datatype, bound);
1142
1143 reason = ADP_SetWatch | TtoH;
1144 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1145 &status, &packet);
1146 if (err != RDIError_NoError) {
1147 DevSW_FreePacket(packet);
1148 return err; /* Was there an error? */
1149 }
1150 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w",
1151 &reason, &debugID, &OSinfo1, &OSinfo2, &status,
1152 handle, &address, &bound);
1153 DevSW_FreePacket(packet);
1154 TracePrint(("returns handle %.8lx\n", (unsigned long)*handle));
1155 return RDIError_NoError;
1156 }
1157
1158 /*----------------------------------------------------------------------*/
1159 /*----angel_RDI_clearwatch-----------------------------------------------*/
1160 /*----------------------------------------------------------------------*/
1161
1162 /* Clear a watchpoint: use ADP_ClearWatch. */
1163 int angel_RDI_clearwatch(PointHandle handle) {
1164
1165 int status, reason, OSinfo1, OSinfo2, err, debugID;
1166 Packet *packet = NULL;
1167
1168 TracePrint(("angel_RDI_clearwatch: handle=%.8lx\n", (unsigned long)handle));
1169
1170 register_debug_message_handler();
1171 msgsend(CI_HADP, "%w%w%w%w%w",
1172 ADP_ClearWatch| HtoT, 0, ADP_HandleUnknown,
1173 ADP_HandleUnknown, handle);
1174 reason = ADP_ClearWatch|TtoH;
1175 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1176 &status, &packet);
1177 if (err != RDIError_NoError) {
1178 DevSW_FreePacket(packet);
1179 return err; /* Was there an error? */
1180 }
1181 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", &reason, &debugID,
1182 &OSinfo1, &OSinfo2, &status);
1183 DevSW_FreePacket(packet);
1184 return RDIError_NoError;
1185 }
1186
1187 typedef struct {
1188 unsigned stopped_reason;
1189 int stopped_status;
1190 int data;
1191 } adp_stopped_struct;
1192
1193
1194 int angel_RDI_OnTargetStopping(angel_RDI_TargetStoppedProc *fn,
1195 void *arg)
1196 {
1197 stoppedProcListElement **lptr = &stopped_proc_list;
1198
1199 /* Find the address of the NULL ptr at the end of the list */
1200 for (; *lptr!=NULL ; lptr = &((*lptr)->next))
1201 ; /* Do nothing */
1202
1203 *lptr = (stoppedProcListElement *) malloc(sizeof(stoppedProcListElement));
1204 if (*lptr == NULL) return RDIError_OutOfStore;
1205 (*lptr)->fn = fn;
1206 (*lptr)->arg = arg;
1207
1208 return RDIError_NoError;
1209 }
1210
1211 static int CallStoppedProcs(unsigned reason)
1212 {
1213 stoppedProcListElement *p = stopped_proc_list;
1214 int err=RDIError_NoError;
1215
1216 for (; p!=NULL ; p=p->next) {
1217 int local_err = p->fn(reason, p->arg);
1218 if (local_err != RDIError_NoError) err=local_err;
1219 }
1220
1221 return err;
1222 }
1223
1224 /*----------------------------------------------------------------------*/
1225 /*----angel_RDI_execute--------------------------------------------------*/
1226 /*----------------------------------------------------------------------*/
1227
1228 static int HandleStoppedMessage(Packet *packet, void *stateptr) {
1229 unsigned int err, reason, debugID, OSinfo1, OSinfo2, count;
1230 adp_stopped_struct *stopped_info;
1231 stopped_info = (adp_stopped_struct *) stateptr;
1232 IGNORE(stateptr);
1233 count = unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w",
1234 &reason, &debugID,
1235 &OSinfo1, &OSinfo2,
1236 &stopped_info->stopped_reason, &stopped_info->data);
1237 DevSW_FreePacket(packet);
1238
1239 if (reason != (ADP_Stopped | TtoH)) {
1240 #ifdef DEBUG
1241 angel_DebugPrint("Expecting stopped message, got %x", reason);
1242 #endif
1243 return RDIError_Error;
1244 }
1245 else {
1246 executing = FALSE;
1247 #ifdef DEBUG
1248 angel_DebugPrint("Received stopped message.\n");
1249 #endif
1250 }
1251
1252 err = msgsend(CI_TADP, "%w%w%w%w%w", (ADP_Stopped | HtoT), 0,
1253 ADP_HandleUnknown, ADP_HandleUnknown, RDIError_NoError);
1254 #ifdef DEBUG
1255 angel_DebugPrint("Transmiting stopped acknowledge.\n");
1256 #endif
1257 if (err != RDIError_NoError) angel_DebugPrint("Transmit failed.\n");
1258 #ifdef DEBUG
1259 angel_DebugPrint("DEBUG: Stopped reason : %x\n", stopped_info->stopped_reason);
1260 #endif
1261 switch (stopped_info->stopped_reason) {
1262 case ADP_Stopped_BranchThroughZero:
1263 stopped_info->stopped_status = RDIError_BranchThrough0;
1264 break;
1265 case ADP_Stopped_UndefinedInstr:
1266 stopped_info->stopped_status = RDIError_UndefinedInstruction;
1267 break;
1268 case ADP_Stopped_SoftwareInterrupt:
1269 stopped_info->stopped_status = RDIError_SoftwareInterrupt;
1270 break;
1271 case ADP_Stopped_PrefetchAbort:
1272 stopped_info->stopped_status = RDIError_PrefetchAbort;
1273 break;
1274 case ADP_Stopped_DataAbort:
1275 stopped_info->stopped_status = RDIError_DataAbort;
1276 break;
1277 case ADP_Stopped_AddressException:
1278 stopped_info->stopped_status = RDIError_AddressException;
1279 break;
1280 case ADP_Stopped_IRQ:
1281 stopped_info->stopped_status = RDIError_IRQ;
1282 break;
1283 case ADP_Stopped_BreakPoint:
1284 stopped_info->stopped_status = RDIError_BreakpointReached;
1285 break;
1286 case ADP_Stopped_WatchPoint:
1287 stopped_info->stopped_status = RDIError_WatchpointAccessed;
1288 break;
1289 case ADP_Stopped_StepComplete:
1290 stopped_info->stopped_status = RDIError_ProgramFinishedInStep;
1291 break;
1292 case ADP_Stopped_RunTimeErrorUnknown:
1293 case ADP_Stopped_StackOverflow:
1294 case ADP_Stopped_DivisionByZero:
1295 stopped_info->stopped_status = RDIError_Error;
1296 break;
1297 case ADP_Stopped_FIQ:
1298 stopped_info->stopped_status = RDIError_FIQ;
1299 break;
1300 case ADP_Stopped_UserInterruption:
1301 case ADP_Stopped_OSSpecific:
1302 stopped_info->stopped_status = RDIError_UserInterrupt;
1303 break;
1304 case ADP_Stopped_ApplicationExit:
1305 stopped_info->stopped_status = RDIError_NoError;
1306 break;
1307 default:
1308 stopped_info->stopped_status = RDIError_Error;
1309 break;
1310 }
1311 return RDIError_NoError;
1312 }
1313
1314
1315 static void interrupt_target( void )
1316 {
1317 Packet *packet = NULL;
1318 int err;
1319 int reason, debugID, OSinfo1, OSinfo2, status;
1320
1321 #ifdef DEBUG
1322 angel_DebugPrint("DEBUG: interrupt_target.\n");
1323 #endif
1324
1325 register_debug_message_handler();
1326 msgsend(CI_HADP, "%w%w%w%w", ADP_InterruptRequest | HtoT, 0,
1327 ADP_HandleUnknown, ADP_HandleUnknown);
1328
1329 reason = ADP_InterruptRequest |TtoH;
1330 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1331 &status, &packet);
1332 DevSW_FreePacket(packet);
1333 #ifdef DEBUG
1334 angel_DebugPrint("DEBUG: got interrupt ack ok err = %d, status=%i\n",
1335 err, status);
1336 #endif
1337
1338 return;
1339 }
1340
1341 #ifdef TEST_DC_APPL
1342 extern void test_dc_appl_handler( const DeviceDescr *device,
1343 Packet *packet );
1344 #endif
1345
1346 /* Core functionality for execute and step */
1347 static int angel_RDI_ExecuteOrStep(PointHandle *handle, word type,
1348 unsigned ninstr)
1349 {
1350 int err;
1351 adp_stopped_struct stopped_info;
1352 void* stateptr = (void *)&stopped_info;
1353 ChannelCallback HandleStoppedMessageFPtr=(ChannelCallback) HandleStoppedMessage;
1354 int status, reasoncode, debugID, OSinfo1, OSinfo2;
1355 Packet *packet = NULL;
1356
1357 TracePrint(("angel_RDI_ExecuteOrStep\n"));
1358
1359 err = Adp_ChannelRegisterRead(CI_TADP,
1360 HandleStoppedMessageFPtr, stateptr);
1361 if (err != RDIError_NoError) {
1362 #ifdef DEBUG
1363 angel_DebugPrint("TADP Register failed.\n");
1364 #endif
1365 return err;
1366 }
1367 /* Set executing TRUE here, as it must be set up before the target has
1368 * had any chance at all to execute, or it may send its stopped message
1369 * before we get round to setting executing = TRUE !!!
1370 */
1371 executing = TRUE;
1372
1373 register_debug_message_handler();
1374
1375 #ifdef TEST_DC_APPL
1376 Adp_Install_DC_Appl_Handler( test_dc_appl_handler );
1377 #endif
1378
1379 #ifdef DEBUG
1380 angel_DebugPrint("Transmiting %s message.\n",
1381 type == ADP_Execute ? "execute": "step");
1382 #endif
1383
1384 register_debug_message_handler();
1385 /* Extra ninstr parameter for execute message will simply be ignored */
1386 err = msgsend(CI_HADP,"%w%w%w%w%w", type | HtoT, 0,
1387 ADP_HandleUnknown, ADP_HandleUnknown, ninstr);
1388 #if DEBUG
1389 if (err != RDIError_NoError) angel_DebugPrint("Transmit failed.\n");
1390 #endif
1391
1392 reasoncode = type | TtoH;
1393 err = wait_for_debug_message( &reasoncode, &debugID, &OSinfo1, &OSinfo2,
1394 &status, &packet );
1395 if (err != RDIError_NoError)
1396 return err;
1397 else if (status != RDIError_NoError)
1398 return status;
1399
1400 #ifdef DEBUG
1401 angel_DebugPrint("Waiting for program to finish...\n");
1402 #endif
1403
1404 signal(SIGINT, ardi_sigint_handler);
1405 while( executing )
1406 {
1407 if (interrupt_request)
1408 {
1409 interrupt_target();
1410 interrupt_request = FALSE;
1411 }
1412 Adp_AsynchronousProcessing( async_block_on_nothing );
1413 }
1414 signal(SIGINT, SIG_IGN);
1415
1416
1417 #ifdef TEST_DC_APPL
1418 Adp_Install_DC_Appl_Handler( NULL );
1419 #endif
1420
1421 (void)Adp_ChannelRegisterRead(CI_TADP, NULL, NULL);
1422
1423 *handle = (PointHandle)stopped_info.data;
1424
1425 CallStoppedProcs(stopped_info.stopped_reason);
1426
1427 return stopped_info.stopped_status;
1428 }
1429
1430 /* Request that the target starts executing from the stored CPU state: use
1431 ADP_Execute. */
1432 int angel_RDI_execute(PointHandle *handle)
1433 {
1434 return angel_RDI_ExecuteOrStep(handle, ADP_Execute, 0);
1435 }
1436
1437 #ifdef __WATCOMC__
1438 typedef void handlertype(int);
1439
1440 static int interrupted=0;
1441
1442 static void myhandler(int sig) {
1443 IGNORE(sig);
1444 interrupted=1;
1445 signal(SIGINT, myhandler);
1446 }
1447 #endif
1448
1449 /*----------------------------------------------------------------------*/
1450 /*----angel_RDI_step-----------------------------------------------------*/
1451 /*----------------------------------------------------------------------*/
1452
1453 /* Step 'ninstr' through the code: use ADP_Step. */
1454 int angel_RDI_step(unsigned ninstr, PointHandle *handle)
1455 {
1456 int err = angel_RDI_ExecuteOrStep(handle, ADP_Step, ninstr);
1457 if (err == RDIError_ProgramFinishedInStep)
1458 return RDIError_NoError;
1459 else
1460 return err;
1461 }
1462
1463
1464 static void SetCPWords(int cpnum, struct Dbg_CoProDesc const *cpd) {
1465 int i, rmax = 0;
1466 for (i = 0; i < cpd->entries; i++)
1467 if (cpd->regdesc[i].rmax > rmax)
1468 rmax = cpd->regdesc[i].rmax;
1469
1470 { unsigned char *rmap = (unsigned char *)malloc(rmax + 2);
1471 *rmap++ = rmax + 1;
1472 for (i = 0; i < cpd->entries; i++) {
1473 int r;
1474 for (r = cpd->regdesc[i].rmin; r <= cpd->regdesc[i].rmax; r++)
1475 rmap[r] = (cpd->regdesc[i].nbytes+3) / 4;
1476 }
1477 /* if (cpwords[cpnum] != NULL) free(cpwords[cpnum]); */
1478 cpwords[cpnum] = rmap;
1479 }
1480 }
1481
1482 /*----------------------------------------------------------------------*/
1483 /*----angel_RDI_info-----------------------------------------------------*/
1484 /*----------------------------------------------------------------------*/
1485
1486 /* Use ADP_Info, ADP_Ctrl and ADP_Profile calls to implement these,
1487 see adp.h for more details. */
1488
1489 static int angel_cc_exists( void )
1490 {
1491 Packet *packet = NULL;
1492 int err;
1493 int reason, debugID, OSinfo1, OSinfo2, subreason, status;
1494
1495 #ifdef DEBUG
1496 angel_DebugPrint("DEBUG: ADP_ICEB_CC_Exists.\n");
1497 #endif
1498
1499 if ( angel_RDI_info( RDIInfo_Icebreaker, NULL, NULL ) == RDIError_NoError ) {
1500 register_debug_message_handler();
1501 msgsend(CI_HADP, "%w%w%w%w%w", ADP_ICEbreakerHADP | HtoT, 0,
1502 ADP_HandleUnknown, ADP_HandleUnknown,
1503 ADP_ICEB_CC_Exists );
1504 reason = ADP_ICEbreakerHADP |TtoH;
1505 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1506 &status, &packet);
1507 if (err != RDIError_NoError) {
1508 DevSW_FreePacket(packet);
1509 return err;
1510 }
1511 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
1512 &debugID, &OSinfo1, &OSinfo2, &subreason, &status);
1513 if (subreason != ADP_ICEB_CC_Exists) {
1514 DevSW_FreePacket(packet);
1515 return RDIError_Error;
1516 }
1517 else
1518 return status;
1519 }
1520 else
1521 return RDIError_UnimplementedMessage;
1522 }
1523
1524 typedef struct {
1525 RDICCProc_ToHost *tohost; void *tohostarg;
1526 RDICCProc_FromHost *fromhost; void *fromhostarg;
1527 bool registered;
1528 } CCState;
1529 static CCState ccstate = { NULL, NULL, NULL, NULL, FALSE };
1530
1531 static void HandleDCCMessage( Packet *packet, void *stateptr )
1532 {
1533 unsigned int reason, debugID, OSinfo1, OSinfo2;
1534 int count;
1535 CCState *ccstate_p = (CCState *)stateptr;
1536
1537 count = unpack_message( BUFFERDATA(packet->pk_buffer), "%w%w%w%w",
1538 &reason, &debugID, &OSinfo1, &OSinfo2 );
1539 switch ( reason )
1540 {
1541 case ADP_TDCC_ToHost | TtoH:
1542 {
1543 /* only handles a single word of data, for now */
1544
1545 unsigned int nbytes, data;
1546
1547 unpack_message( BUFFERDATA(packet->pk_buffer)+count, "%w%w",
1548 &nbytes, &data );
1549 #ifdef DEBUG
1550 angel_DebugPrint( "DEBUG: received CC_ToHost message: nbytes %d data %08x.\n",
1551 nbytes, data );
1552 #endif
1553 ccstate_p->tohost( ccstate_p->tohostarg, data );
1554 msgsend(CI_TTDCC, "%w%w%w%w%w",
1555 ADP_TDCC_ToHost | HtoT, debugID, OSinfo1, OSinfo2,
1556 RDIError_NoError );
1557 break;
1558 }
1559
1560 case ADP_TDCC_FromHost | TtoH:
1561 {
1562 /* only handles a single word of data, for now */
1563
1564 int valid;
1565 ARMword data;
1566
1567 ccstate_p->fromhost( ccstate_p->fromhostarg, &data, &valid );
1568 #ifdef DEBUG
1569 angel_DebugPrint( "DEBUG: received CC_FromHost message, returning: %08x %s.\n",
1570 data, valid ? "VALID" : "INvalid" );
1571 #endif
1572 msgsend(CI_TTDCC, "%w%w%w%w%w%w%w",
1573 ADP_TDCC_FromHost | HtoT, debugID, OSinfo1, OSinfo2,
1574 RDIError_NoError, valid ? 1 : 0, data );
1575 break;
1576 }
1577
1578 default:
1579 #ifdef DEBUG
1580 angel_DebugPrint( "Unexpected TDCC message %08x received\n", reason );
1581 #endif
1582 break;
1583 }
1584 DevSW_FreePacket(packet);
1585 return;
1586 }
1587
1588 static void angel_check_DCC_handler( CCState *ccstate_p )
1589 {
1590 int err;
1591
1592 if ( ccstate_p->tohost != NULL || ccstate_p->fromhost != NULL )
1593 {
1594 /* doing DCC, so need a handler */
1595 if ( ! ccstate_p->registered )
1596 {
1597 #ifdef DEBUG
1598 angel_DebugPrint( "Registering handler for TTDCC channel.\n" );
1599 #endif
1600 err = Adp_ChannelRegisterRead( CI_TTDCC, HandleDCCMessage,
1601 ccstate_p );
1602 if ( err == adp_ok )
1603 ccstate_p->registered = TRUE;
1604 #ifdef DEBUG
1605 else
1606 angel_DebugPrint( "angel_check_DCC_handler: register failed!\n" );
1607 #endif
1608 }
1609 }
1610 else
1611 {
1612 /* not doing DCC, so don't need a handler */
1613 if ( ccstate_p->registered )
1614 {
1615 #ifdef DEBUG
1616 angel_DebugPrint( "Unregistering handler for TTDCC channel.\n" );
1617 #endif
1618 err = Adp_ChannelRegisterRead( CI_TTDCC, NULL, NULL );
1619 if ( err == adp_ok )
1620 ccstate_p->registered = FALSE;
1621 #ifdef DEBUG
1622 else
1623 angel_DebugPrint( "angel_check_DCC_handler: unregister failed!\n" );
1624 #endif
1625 }
1626 }
1627 }
1628
1629
1630 static int CheckSubMessageReply(int reason, int subreason) {
1631 Packet *packet = NULL;
1632 int status, debugID, OSinfo1, OSinfo2;
1633 int err = RDIError_NoError;
1634 reason |= TtoH;
1635 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1636 &status, &packet);
1637 if (err != RDIError_NoError) {
1638 status = err;
1639 } else {
1640 int sr;
1641 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
1642 &OSinfo1, &OSinfo2, &sr, &status);
1643 if (subreason != sr) status = RDIError_Error;
1644 }
1645 DevSW_FreePacket(packet);
1646 return status;
1647 }
1648
1649 static int SendSubMessageAndCheckReply(int reason, int subreason) {
1650 register_debug_message_handler();
1651 msgsend(CI_HADP, "%w%w%w%w%w", reason | HtoT, 0,
1652 ADP_HandleUnknown, ADP_HandleUnknown,
1653 subreason);
1654 return CheckSubMessageReply(reason, subreason);
1655 }
1656
1657 static int SendSubMessageWordAndCheckReply(int reason, int subreason, ARMword word) {
1658 register_debug_message_handler();
1659 msgsend(CI_HADP, "%w%w%w%w%w%w", reason | HtoT, 0,
1660 ADP_HandleUnknown, ADP_HandleUnknown,
1661 subreason, word);
1662 return CheckSubMessageReply(reason, subreason);
1663 }
1664
1665 static int SendSubMessageGetWordAndCheckReply(int reason, int subreason, ARMword *resp) {
1666 Packet *packet = NULL;
1667 int status, debugID, OSinfo1, OSinfo2;
1668 int err = RDIError_NoError;
1669
1670 register_debug_message_handler();
1671 msgsend(CI_HADP, "%w%w%w%w%w", reason | HtoT, 0,
1672 ADP_HandleUnknown, ADP_HandleUnknown,
1673 subreason);
1674 reason |= TtoH;
1675 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1676 &status, &packet);
1677 if (err != RDIError_NoError) {
1678 status = err;
1679 } else {
1680 int sr;
1681 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w", &reason, &debugID,
1682 &OSinfo1, &OSinfo2, &sr, &status, resp);
1683 if (subreason != sr) status = RDIError_Error;
1684 }
1685 DevSW_FreePacket(packet);
1686 return status;
1687 }
1688
1689 static int const hostsex = 1;
1690
1691 int angel_RDI_info(unsigned type, ARMword *arg1, ARMword *arg2) {
1692 Packet *packet = NULL;
1693 int len, status, c, reason, subreason, debugID, OSinfo1, OSinfo2;
1694 int err=RDIError_NoError, cpnum=0;
1695 struct Dbg_CoProDesc *cpd;
1696 int count, i;
1697 unsigned char *bp;
1698
1699 #ifdef DEBUG
1700 angel_DebugPrint("DEBUG: Entered angel_RDI_info.\n");
1701 #endif
1702 switch (type) {
1703 case RDIInfo_Target:
1704 #ifdef DEBUG
1705 angel_DebugPrint("DEBUG: RDIInfo_Target.\n");
1706 #endif
1707
1708 register_debug_message_handler();
1709 msgsend(CI_HADP, "%w%w%w%w%w", ADP_Info | HtoT, 0,
1710 ADP_HandleUnknown, ADP_HandleUnknown, ADP_Info_Target);
1711 reason = ADP_Info |TtoH;
1712 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1713 &status, &packet);
1714 if (err != RDIError_NoError) {
1715 DevSW_FreePacket(packet);
1716 return err;
1717 }
1718 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", &reason,
1719 &debugID, &OSinfo1, &OSinfo2, &subreason, &status,
1720 arg1, arg2);
1721 DevSW_FreePacket(packet);
1722
1723 if (subreason != ADP_Info_Target)
1724 return RDIError_Error;
1725 else
1726 return status;
1727
1728 case RDISignal_Stop:
1729 #ifdef DEBUG
1730 angel_DebugPrint("DEBUG: RDISignal_Stop.\n");
1731 if (interrupt_request)
1732 angel_DebugPrint(" STILL WAITING to send previous interrupt request\n");
1733 #endif
1734 interrupt_request = TRUE;
1735 return RDIError_NoError;
1736
1737 case RDIInfo_Points:
1738 #ifdef DEBUG
1739 angel_DebugPrint("DEBUG: RDIInfo_Points.\n");
1740 #endif
1741 return SendSubMessageGetWordAndCheckReply(ADP_Info, ADP_Info_Points, arg1);
1742
1743 case RDIInfo_Step:
1744 #ifdef DEBUG
1745 angel_DebugPrint("DEBUG: RDIInfo_Step.\n");
1746 #endif
1747 return SendSubMessageGetWordAndCheckReply(ADP_Info, ADP_Info_Step, arg1);
1748
1749 case RDISet_Cmdline:
1750 #ifdef DEBUG
1751 angel_DebugPrint("DEBUG: RDISet_Cmdline.\n");
1752 #endif
1753 if (ardi_commandline != &dummycline)
1754 free(ardi_commandline);
1755 ardi_commandline = (char *)malloc(strlen((char*)arg1) + 1) ;
1756 (void)strcpy(ardi_commandline, (char *)arg1) ;
1757 return RDIError_NoError;
1758
1759 case RDIInfo_SetLog:
1760 #ifdef DEBUG
1761 angel_DebugPrint("DEBUG: RDIInfo_SetLog.\n");
1762 #endif
1763 rdi_log = (int) *arg1;
1764 return RDIError_NoError;
1765
1766 case RDIInfo_Log:
1767 #ifdef DEBUG
1768 angel_DebugPrint("DEBUG: RDIInfo_Log.\n");
1769 #endif
1770 *arg1 = rdi_log;
1771 return RDIError_NoError;
1772
1773
1774 case RDIInfo_MMU:
1775 #ifdef DEBUG
1776 angel_DebugPrint("DEBUG: RDIInfo_MMU.\n");
1777 #endif
1778 return SendSubMessageGetWordAndCheckReply(ADP_Info, ADP_Info_MMU, arg1);
1779
1780 case RDIInfo_SemiHosting:
1781 #ifdef DEBUG
1782 angel_DebugPrint("DEBUG: RDIInfo_SemiHosting.\n");
1783 #endif
1784 return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_SemiHosting);
1785
1786 case RDIInfo_CoPro:
1787 #ifdef DEBUG
1788 angel_DebugPrint("DEBUG: RDIInfo_CoPro.\n");
1789 #endif
1790 return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_CoPro);
1791
1792 case RDICycles:
1793 #ifdef DEBUG
1794 angel_DebugPrint("DEBUG: RDICycles.\n");
1795 #endif
1796 register_debug_message_handler();
1797 msgsend(CI_HADP, "%w%w%w%w%w", ADP_Info | HtoT, 0,
1798 ADP_HandleUnknown, ADP_HandleUnknown, ADP_Info_Cycles);
1799 reason = ADP_Info |TtoH;
1800 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1801 &status, &packet);
1802 if (err != RDIError_NoError) {
1803 DevSW_FreePacket(packet);
1804 return err;
1805 }
1806 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
1807 &OSinfo1, &OSinfo2, &subreason, &status);
1808 DevSW_FreePacket(packet);
1809 if (subreason != ADP_Info_Cycles)
1810 return RDIError_Error;
1811 if (status != RDIError_NoError) return status;
1812 for (c=0; c<12; c++)
1813 arg1[c]=GET32LE(BUFFERDATA(packet->pk_buffer)+24+(c*4));
1814 return status;
1815
1816 case RDIInfo_DescribeCoPro:
1817 #ifdef DEBUG
1818 angel_DebugPrint("DEBUG: RDIInfo_DescribeCoPro.\n");
1819 #endif
1820 cpnum = *(int *)arg1;
1821 cpd = (struct Dbg_CoProDesc *)arg2;
1822 packet = DevSW_AllocatePacket(Armsd_BufferSize);
1823 if (angel_RDI_info(ADP_Info_CoPro, NULL, NULL) != RDIError_NoError)
1824 return RDIError_Error;
1825 len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", ADP_Info | HtoT, 0,
1826 ADP_HandleUnknown, ADP_HandleUnknown,
1827 ADP_Info_DescribeCoPro);
1828 len +=msgbuild(BUFFERDATA(packet->pk_buffer)+20, "%b%b%b%b%b", cpnum,
1829 cpd->regdesc[cpnum].rmin, cpd->regdesc[cpnum].rmax,
1830 cpd->regdesc[cpnum].nbytes, cpd->regdesc[cpnum].access);
1831 if (cpd->regdesc[cpnum].access&0x3 == 0x3){
1832 len += msgbuild(BUFFERDATA(packet->pk_buffer)+25, "%b%b%b%b%b",
1833 cpd->regdesc[cpnum].accessinst.cprt.read_b0,
1834 cpd->regdesc[cpnum].accessinst.cprt.read_b1,
1835 cpd->regdesc[cpnum].accessinst.cprt.write_b0,
1836 cpd->regdesc[cpnum].accessinst.cprt.write_b1, 0xff);
1837 }
1838 else {
1839 len += msgbuild(BUFFERDATA(packet->pk_buffer)+25, "%b%b%b%b%b%",
1840 cpd->regdesc[cpnum].accessinst.cpdt.rdbits,
1841 cpd->regdesc[cpnum].accessinst.cpdt.nbit,0,0, 0xff);
1842 }
1843 register_debug_message_handler();
1844 packet->pk_length = len;
1845 Adp_ChannelWrite(CI_HADP, packet); /* Transmit message. */
1846 reason = ADP_Info |TtoH;
1847 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1848 &status, &packet);
1849 if (err != RDIError_NoError) {
1850 DevSW_FreePacket(packet);
1851 return err;
1852 }
1853 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
1854 &OSinfo1, &OSinfo2, &subreason, &status);
1855 DevSW_FreePacket(packet);
1856 if (subreason != ADP_Info_DescribeCoPro)
1857 return RDIError_Error;
1858 else
1859 return status;
1860
1861 case RDIInfo_RequestCoProDesc:
1862 #ifdef DEBUG
1863 angel_DebugPrint("DEBUG: RDIInfo_RequestCoProDesc.\n");
1864 #endif
1865 cpnum = *(int *)arg1;
1866 cpd = (struct Dbg_CoProDesc *)arg2;
1867 packet = DevSW_AllocatePacket(Armsd_BufferSize);
1868 len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w", ADP_Info | HtoT, 0,
1869 ADP_HandleUnknown, ADP_HandleUnknown,
1870 ADP_Info_RequestCoProDesc);
1871 len += msgbuild(BUFFERDATA(packet->pk_buffer)+20, "%b", *(int *)arg1);
1872 packet->pk_length = len;
1873 register_debug_message_handler();
1874 Adp_ChannelWrite(CI_HADP, packet); /* Transmit message. */
1875 reason = ADP_Info |TtoH;
1876 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1877 &status, &packet);
1878 if (err != RDIError_NoError) {
1879 DevSW_FreePacket(packet);
1880 return err;
1881 }
1882 count = unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
1883 &debugID, &OSinfo1, &OSinfo2, &subreason, &status);
1884 if (subreason != ADP_Info_RequestCoProDesc) {
1885 DevSW_FreePacket(packet);
1886 return RDIError_Error;
1887 } else if ( status != RDIError_NoError ) {
1888 DevSW_FreePacket(packet);
1889 return status;
1890 } else {
1891 bp = BUFFERDATA(packet->pk_buffer)+count;
1892 for ( i = 0; *bp != 0xFF && i < cpd->entries; ++i ) {
1893 cpd->regdesc[i].rmin = *bp++;
1894 cpd->regdesc[i].rmax = *bp++;
1895 cpd->regdesc[i].nbytes = *bp++;
1896 cpd->regdesc[i].access = *bp++;
1897 }
1898 cpd->entries = i;
1899 if ( *bp != 0xFF )
1900 status = RDIError_BufferFull;
1901 else
1902 SetCPWords( cpnum, cpd );
1903 DevSW_FreePacket(packet);
1904 return status;
1905 }
1906
1907 case RDIInfo_GetLoadSize:
1908 #ifdef DEBUG
1909 angel_DebugPrint("DEBUG: ADP_Info_AngelBufferSize.\n");
1910 #endif
1911 register_debug_message_handler();
1912 msgsend(CI_HADP, "%w%w%w%w%w", ADP_Info | HtoT, 0,
1913 ADP_HandleUnknown, ADP_HandleUnknown,
1914 ADP_Info_AngelBufferSize);
1915 reason = ADP_Info |TtoH;
1916 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
1917 &status, &packet);
1918 if (err != RDIError_NoError) {
1919 DevSW_FreePacket(packet);
1920 return err;
1921 }
1922 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
1923 &debugID, &OSinfo1, &OSinfo2, &subreason, &status);
1924 if (subreason != ADP_Info_AngelBufferSize) {
1925 DevSW_FreePacket(packet);
1926 return RDIError_Error;
1927 }
1928 else {
1929 word defaultsize, longsize;
1930 unpack_message(BUFFERDATA(packet->pk_buffer)+24, "%w%w",
1931 &defaultsize, &longsize);
1932 *arg1 = longsize - ADP_WriteHeaderSize; /* space for ADP header */
1933 #ifdef MONITOR_DOWNLOAD_PACKETS
1934 angel_DebugPrint("DEBUG: ADP_Info_AngelBufferSize: got (%d, %d), returning %d.\n",
1935 defaultsize, longsize, *arg1);
1936 #endif
1937 DevSW_FreePacket(packet);
1938 return status;
1939 }
1940
1941 case RDIVector_Catch:
1942 #ifdef DEBUG
1943 angel_DebugPrint("DEBUG: ADP_Ctrl_VectorCatch %lx.\n", *arg1);
1944 #endif
1945 return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_VectorCatch, *arg1);
1946
1947 case RDISemiHosting_SetState:
1948 #ifdef DEBUG
1949 angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetState %lx.\n", *arg1);
1950 #endif
1951 return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetState, *arg1);
1952
1953 case RDISemiHosting_GetState:
1954 #ifdef DEBUG
1955 angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetState.\n");
1956 #endif
1957 return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetState, arg1);
1958
1959 case RDISemiHosting_SetVector:
1960 #ifdef DEBUG
1961 angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetVector %lx.\n", *arg1);
1962 #endif
1963 return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetVector, *arg1);
1964
1965 case RDISemiHosting_GetVector:
1966 #ifdef DEBUG
1967 angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetVector.\n");
1968 #endif
1969 return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetVector, arg1);
1970
1971 case RDISemiHosting_SetARMSWI:
1972 #ifdef DEBUG
1973 angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetARMSWI.\n");
1974 #endif
1975 return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetARMSWI, *arg1);
1976
1977 case RDISemiHosting_GetARMSWI:
1978 #ifdef DEBUG
1979 angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetARMSWI.\n");
1980 #endif
1981 return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetARMSWI, arg1);
1982
1983 case RDISemiHosting_SetThumbSWI:
1984 #ifdef DEBUG
1985 angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_SetThumbSWI.\n");
1986 #endif
1987 return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_SetThumbSWI, *arg1);
1988
1989 case RDISemiHosting_GetThumbSWI:
1990 #ifdef DEBUG
1991 angel_DebugPrint("DEBUG: ADP_Ctrl_SemiHosting_GetThumbSWI.\n");
1992 #endif
1993 return SendSubMessageGetWordAndCheckReply(ADP_Control, ADP_Ctrl_SemiHosting_GetThumbSWI, arg1);
1994
1995 case RDIInfo_SetTopMem:
1996 #ifdef DEBUG
1997 angel_DebugPrint("DEBUG: ADP_Ctrl_SetTopMem.\n");
1998 #endif
1999 return SendSubMessageWordAndCheckReply(ADP_Control, ADP_Ctrl_SetTopMem, *arg1);
2000
2001 case RDIPointStatus_Watch:
2002 #ifdef DEBUG
2003 angel_DebugPrint("DEBUG: ADP_Ctrl_PointStatus_Watch.\n");
2004 #endif
2005 register_debug_message_handler();
2006 msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Control | HtoT, 0,
2007 ADP_HandleUnknown, ADP_HandleUnknown,
2008 ADP_Ctrl_PointStatus_Watch, *arg1 );
2009 reason = ADP_Control |TtoH;
2010 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2011 &status, &packet);
2012 if (err != RDIError_NoError) {
2013 DevSW_FreePacket(packet);
2014 return err;
2015 }
2016 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", &reason,
2017 &debugID, &OSinfo1, &OSinfo2, &subreason, &status,
2018 arg1, arg2);
2019 if (subreason != ADP_Ctrl_PointStatus_Watch) {
2020 DevSW_FreePacket(packet);
2021 return RDIError_Error;
2022 }
2023 else
2024 return status;
2025
2026 case RDIPointStatus_Break:
2027 #ifdef DEBUG
2028 angel_DebugPrint("DEBUG: ADP_Ctrl_PointStatus_Break.\n");
2029 #endif
2030 register_debug_message_handler();
2031 msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Control | HtoT, 0,
2032 ADP_HandleUnknown, ADP_HandleUnknown,
2033 ADP_Ctrl_PointStatus_Break, *arg1 );
2034 reason = ADP_Control |TtoH;
2035 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2036 &status, &packet);
2037 if (err != RDIError_NoError) {
2038 DevSW_FreePacket(packet);
2039 return err;
2040 }
2041 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w", &reason,
2042 &debugID, &OSinfo1, &OSinfo2, &subreason, &status,
2043 arg1, arg2);
2044 if (subreason != ADP_Ctrl_PointStatus_Break) {
2045 DevSW_FreePacket(packet);
2046 return RDIError_Error;
2047 }
2048 else
2049 return status;
2050
2051 case RDIInfo_DownLoad:
2052 #ifdef DEBUG
2053 angel_DebugPrint("DEBUG: ADP_Ctrl_Download_Supported.\n");
2054 #endif
2055 return SendSubMessageAndCheckReply(ADP_Control, ADP_Ctrl_Download_Supported);
2056
2057 case RDIConfig_Count:
2058 #ifdef DEBUG
2059 angel_DebugPrint("DEBUG: ADP_ICEM_ConfigCount.\n");
2060 #endif
2061 return SendSubMessageGetWordAndCheckReply(ADP_ICEman, ADP_ICEM_ConfigCount, arg1);
2062
2063 case RDIConfig_Nth:
2064 #ifdef DEBUG
2065 angel_DebugPrint("DEBUG: ADP_ICEM_ConfigNth.\n");
2066 #endif
2067 register_debug_message_handler();
2068 msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_ICEman | HtoT, 0,
2069 ADP_HandleUnknown, ADP_HandleUnknown,
2070 ADP_ICEM_ConfigNth, *arg1 );
2071 reason = ADP_ICEman |TtoH;
2072 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2073 &status, &packet);
2074 if (err != RDIError_NoError) {
2075 DevSW_FreePacket(packet);
2076 return err;
2077 } else {
2078 RDI_ConfigDesc *cd = (RDI_ConfigDesc *)arg2;
2079 unsigned char n;
2080 len = unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%b",
2081 &reason, &debugID,
2082 &OSinfo1, &OSinfo2, &subreason, &status,
2083 &cd->version, &n);
2084 if (subreason != ADP_ICEM_ConfigNth) {
2085 DevSW_FreePacket(packet);
2086 return RDIError_Error;
2087 }
2088 else {
2089 memcpy( cd->name, BUFFERDATA(packet->pk_buffer)+len, n+1 );
2090 cd->name[n] = 0;
2091 return status;
2092 }
2093 }
2094
2095 case RDIInfo_Icebreaker:
2096 #ifdef DEBUG
2097 angel_DebugPrint("DEBUG: ADP_ICEB_Exists.\n");
2098 #endif
2099 return SendSubMessageAndCheckReply(ADP_ICEbreakerHADP, ADP_ICEB_Exists);
2100
2101 case RDIIcebreaker_GetLocks:
2102 #ifdef DEBUG
2103 angel_DebugPrint("DEBUG: ADP_ICEB_GetLocks.\n");
2104 #endif
2105 return SendSubMessageGetWordAndCheckReply(ADP_ICEbreakerHADP, ADP_ICEB_GetLocks, arg1);
2106
2107 case RDIIcebreaker_SetLocks:
2108 #ifdef DEBUG
2109 angel_DebugPrint("DEBUG: ADP_ICEB_SetLocks.\n");
2110 #endif
2111 return SendSubMessageWordAndCheckReply(ADP_ICEbreakerHADP, ADP_ICEB_SetLocks, *arg1);
2112
2113 case RDICommsChannel_ToHost:
2114 #ifdef DEBUG
2115 angel_DebugPrint("DEBUG: ADP_ICEB_CC_Connect_ToHost.\n");
2116 #endif
2117 if ( angel_cc_exists() == RDIError_NoError ) {
2118
2119 /*
2120 * The following three lines of code have to be removed in order to get
2121 * the Windows Angel Channel Viewer working with the Thumb comms channel.
2122 * At the moment it allows the ARMSD command line to register a CCIN/CCOUT
2123 * callback which stops the ACV working!
2124 */
2125 #ifdef __unix
2126 ccstate.tohost = (RDICCProc_ToHost *)arg1;
2127 ccstate.tohostarg = arg2;
2128 angel_check_DCC_handler( &ccstate );
2129 #endif
2130 #ifdef _WIN32
2131
2132 #endif
2133
2134 register_debug_message_handler();
2135 msgsend(CI_HADP, "%w%w%w%w%w%b", ADP_ICEbreakerHADP | HtoT, 0,
2136 ADP_HandleUnknown, ADP_HandleUnknown,
2137 ADP_ICEB_CC_Connect_ToHost, (arg1 != NULL) );
2138 return CheckSubMessageReply(ADP_ICEbreakerHADP, ADP_ICEB_CC_Connect_ToHost);
2139 } else {
2140 return RDIError_UnimplementedMessage;
2141 }
2142
2143 case RDICommsChannel_FromHost:
2144 #ifdef DEBUG
2145 angel_DebugPrint("DEBUG: ADP_ICEB_CC_Connect_FromHost.\n");
2146 #endif
2147 if ( angel_cc_exists() == RDIError_NoError ) {
2148
2149 ccstate.fromhost = (RDICCProc_FromHost *)arg1;
2150 ccstate.fromhostarg = arg2;
2151 angel_check_DCC_handler( &ccstate );
2152
2153 register_debug_message_handler();
2154 msgsend(CI_HADP, "%w%w%w%w%w%b", ADP_ICEbreakerHADP | HtoT, 0,
2155 ADP_HandleUnknown, ADP_HandleUnknown,
2156 ADP_ICEB_CC_Connect_FromHost, (arg1 != NULL) );
2157 return CheckSubMessageReply(ADP_ICEbreakerHADP, ADP_ICEB_CC_Connect_FromHost);
2158 } else {
2159 return RDIError_UnimplementedMessage;
2160 }
2161
2162 case RDIProfile_Stop:
2163 return SendSubMessageAndCheckReply(ADP_Profile, ADP_Profile_Stop);
2164
2165 case RDIProfile_ClearCounts:
2166 return SendSubMessageAndCheckReply(ADP_Profile, ADP_Profile_ClearCounts);
2167
2168 case RDIProfile_Start:
2169 #ifdef DEBUG
2170 angel_DebugPrint("DEBUG: ADP_Profile_Start %ld.\n", (long)*arg1);
2171 #endif
2172 return SendSubMessageWordAndCheckReply(ADP_Profile, ADP_Profile_Start, *arg1);
2173
2174 case RDIProfile_WriteMap:
2175 { RDI_ProfileMap *map = (RDI_ProfileMap *)arg1;
2176 int32 maplen = map->len,
2177 offset,
2178 size;
2179 int32 chunk = (Armsd_LongBufSize-CHAN_HEADER_SIZE-ADP_ProfileWriteHeaderSize) / sizeof(ARMword);
2180 /* Maximum number of words sendable in one message */
2181 int oldrev = bytesex_reversing();
2182 int host_little = *(uint8 const *)&hostsex;
2183 #ifdef DEBUG
2184 angel_DebugPrint("DEBUG: ADP_Profile_WriteMap %ld.\n", maplen);
2185 #endif
2186 status = RDIError_NoError;
2187 if (!host_little) {
2188 bytesex_reverse(1);
2189 for (offset = 0; offset < maplen; offset++)
2190 map->map[offset] = bytesex_hostval(map->map[offset]);
2191 }
2192 for (offset = 0; offset < maplen; offset += size) {
2193 unsigned hdrlen;
2194 size = maplen - offset;
2195 packet = (Packet *)DevSW_AllocatePacket(Armsd_LongBufSize);
2196 if (size > chunk) size = chunk;
2197 hdrlen = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w%w",
2198 ADP_Profile | HtoT, 0, ADP_HandleUnknown,
2199 ADP_HandleUnknown, ADP_Profile_WriteMap,
2200 maplen, size, offset);
2201
2202 /* Copy the data into the packet. */
2203 memcpy(BUFFERDATA(packet->pk_buffer)+hdrlen,
2204 &map->map[offset], (size_t)size * sizeof(ARMword));
2205 packet->pk_length = size * sizeof(ARMword) + hdrlen;
2206 register_debug_message_handler();
2207 Adp_ChannelWrite(CI_HADP, packet);
2208 reason = ADP_Profile | TtoH;
2209 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2210 &status, &packet);
2211 if (err == RDIError_NoError) {
2212 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
2213 &debugID, &OSinfo1, &OSinfo2, &subreason, &status);
2214 if (subreason != ADP_Profile_WriteMap) {
2215 err = RDIError_Error;
2216 }
2217 DevSW_FreePacket(packet);
2218 }
2219 if (err != RDIError_NoError) { status = err; break; }
2220 }
2221 if (!host_little) {
2222 for (offset = 0; offset < maplen; offset++)
2223 map->map[offset] = bytesex_hostval(map->map[offset]);
2224 bytesex_reverse(oldrev);
2225 }
2226 return status;
2227 }
2228
2229 case RDIProfile_ReadMap:
2230 { int32 maplen = *(int32 *)arg1,
2231 offset = 0,
2232 size;
2233 int32 chunk = (Armsd_BufferSize-CHAN_HEADER_SIZE-ADP_ProfileReadHeaderSize) / sizeof(ARMword);
2234 #ifdef DEBUG
2235 angel_DebugPrint("DEBUG: ADP_Profile_ReadMap %ld.\n", maplen);
2236 #endif
2237 status = RDIError_NoError;
2238 for (offset = 0; offset < maplen; offset += size) {
2239 size = maplen - offset;
2240 if (size > chunk) size = chunk;
2241 register_debug_message_handler();
2242 msgsend(CI_HADP, "%w%w%w%w%w%w%w", ADP_Profile | HtoT, 0,
2243 ADP_HandleUnknown, ADP_HandleUnknown,
2244 ADP_Profile_ReadMap, offset, size);
2245 reason = ADP_Profile | TtoH;
2246 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2247 &status, &packet);
2248 if (err != RDIError_NoError) return err;
2249 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
2250 &debugID, &OSinfo1, &OSinfo2, &subreason, &status);
2251 memcpy(&arg2[offset], BUFFERDATA(packet->pk_buffer)+ADP_ProfileReadHeaderSize,
2252 size * sizeof(ARMword));
2253 DevSW_FreePacket(packet);
2254 if (status != RDIError_NoError) break;
2255 }
2256 { int oldrev = bytesex_reversing();
2257 int host_little = *(uint8 const *)&hostsex;
2258 if (!host_little) {
2259 bytesex_reverse(1);
2260 for (offset = 0; offset < maplen; offset++)
2261 arg2[offset] = bytesex_hostval(arg2[offset]);
2262 }
2263 bytesex_reverse(oldrev);
2264 }
2265 return status;
2266 }
2267
2268 case RDIInfo_CanTargetExecute:
2269 #ifdef DEBUG
2270 printf("DEBUG: RDIInfo_CanTargetExecute.\n");
2271 #endif
2272 return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_CanTargetExecute);
2273
2274 case RDIInfo_AgentEndianess:
2275 return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_AgentEndianess);
2276
2277 default:
2278 #ifdef DEBUG
2279 angel_DebugPrint("DEBUG: Fell through ADP_Info, default case taken.\n");
2280 angel_DebugPrint("DEBUG: type = 0x%x.\n", type);
2281 #endif
2282 if (type & RDIInfo_CapabilityRequest) {
2283 switch (type & ~RDIInfo_CapabilityRequest) {
2284 case RDISemiHosting_SetARMSWI:
2285 return SendSubMessageAndCheckReply(ADP_Info, ADP_Info_ChangeableSHSWI);
2286 default:
2287 #ifdef DEBUG
2288 angel_DebugPrint(
2289 "DEBUG: ADP_Info - Capability Request(%d) - reporting unimplemented \n",
2290 type & ~RDIInfo_CapabilityRequest);
2291 #endif
2292 break;
2293 }
2294 }
2295 return RDIError_UnimplementedMessage;
2296 }
2297 }
2298
2299
2300 /*----------------------------------------------------------------------*/
2301 /*----angel_RDI_AddConfig------------------------------------------------*/
2302 /*----------------------------------------------------------------------*/
2303
2304 /* Add a configuration: use ADP_ICEM_AddConfig. */
2305 int angel_RDI_AddConfig(unsigned long nbytes) {
2306 Packet *packet = NULL;
2307 int status, reason, subreason, debugID, OSinfo1, OSinfo2, err;
2308
2309 #ifdef DEBUG
2310 angel_DebugPrint("DEBUG: Entered angel_RDI_AddConfig.\n");
2311 #endif
2312 register_debug_message_handler();
2313 msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_ICEman | HtoT,
2314 0, ADP_HandleUnknown, ADP_HandleUnknown,
2315 ADP_ICEM_AddConfig, nbytes);
2316 reason=ADP_ICEman | TtoH;
2317 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2318 &status, &packet);
2319 if (err != RDIError_NoError) {
2320 DevSW_FreePacket(packet);
2321 return -1;
2322 }
2323 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
2324 &OSinfo1, &OSinfo2, &subreason, &status);
2325 DevSW_FreePacket(packet);
2326 if ( subreason != ADP_ICEM_AddConfig )
2327 return RDIError_Error;
2328 else
2329 return status;
2330 }
2331
2332
2333 /*----------------------------------------------------------------------*/
2334 /*----angel_RDI_LoadConfigData-------------------------------------------*/
2335 /*----------------------------------------------------------------------*/
2336
2337 /* Load configuration data: use ADP_Ctrl_Download_Data. */
2338 int angel_RDI_LoadConfigData(unsigned long nbytes, char const *data) {
2339 Packet *packet = NULL;
2340 int len, status, reason, subreason, debugID, OSinfo1, OSinfo2, err;
2341
2342 #ifdef DEBUG
2343 angel_DebugPrint("DEBUG: Entered angel_RDI_LoadConfigData (%d bytes)\n", nbytes);
2344 #endif
2345 #if 0
2346 if (err = angel_RDI_AddConfig(nbytes) != RDIError_NoError)
2347 return err;
2348 #endif
2349 packet = DevSW_AllocatePacket(Armsd_LongBufSize);
2350 len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w",
2351 ADP_Control | HtoT, 0,
2352 ADP_HandleUnknown, ADP_HandleUnknown,
2353 ADP_Ctrl_Download_Data, nbytes);
2354 memcpy(BUFFERDATA(packet->pk_buffer)+len, data, nbytes);
2355 len += nbytes;
2356 packet->pk_length = len;
2357 #ifdef DEBUG
2358 angel_DebugPrint("DEBUG: packet len %d.\n", len);
2359 #endif
2360 register_debug_message_handler();
2361 Adp_ChannelWrite(CI_HADP, packet);
2362 reason=ADP_Control | TtoH;
2363 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2364 &status, &packet);
2365 if (err != RDIError_NoError) {
2366 DevSW_FreePacket(packet);
2367 return -1;
2368 }
2369 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
2370 &OSinfo1, &OSinfo2, &subreason, &status);
2371 DevSW_FreePacket(packet);
2372 if ( subreason != ADP_Ctrl_Download_Data )
2373 return RDIError_Error;
2374 else
2375 return status;
2376 }
2377
2378
2379 /*----------------------------------------------------------------------*/
2380 /*----angel_RDI_SelectConfig---------------------------------------------*/
2381 /*----------------------------------------------------------------------*/
2382
2383 /* Select a configuration: use ADP_ICEM_SelecConfig.*/
2384 int angel_RDI_SelectConfig(RDI_ConfigAspect aspect, char const *name,
2385 RDI_ConfigMatchType matchtype, unsigned versionreq,
2386 unsigned *versionp)
2387 {
2388 Packet *packet = NULL;
2389 int len, status, reason, subreason, debugID, OSinfo1, OSinfo2, err;
2390
2391 #ifdef DEBUG
2392 angel_DebugPrint("DEBUG: Entered angel_RDI_SelectConfig.\n");
2393 #endif
2394 packet = DevSW_AllocatePacket(Armsd_BufferSize);
2395 len = msgbuild(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%b%b%b%w",
2396 ADP_ICEman | HtoT, 0,
2397 ADP_HandleUnknown, ADP_HandleUnknown,
2398 ADP_ICEM_SelectConfig, aspect, strlen(name),
2399 matchtype, versionreq);
2400 /* copy the name into the buffer */
2401 memcpy(BUFFERDATA(packet->pk_buffer)+len, name, strlen(name));
2402 len += strlen(name);
2403 packet->pk_length = len;
2404 register_debug_message_handler();
2405 Adp_ChannelWrite(CI_HADP, packet);
2406 reason=ADP_ICEman | TtoH;
2407 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2408 &status, &packet);
2409 if (err != RDIError_NoError) {
2410 DevSW_FreePacket(packet);
2411 return err;
2412 }
2413 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w%w",
2414 &reason, &debugID, &OSinfo1, &OSinfo2,
2415 &subreason, &status, versionp);
2416 DevSW_FreePacket(packet);
2417 if ( subreason != ADP_ICEM_SelectConfig )
2418 return RDIError_Error;
2419 else
2420 return status;
2421 }
2422
2423
2424 /*----------------------------------------------------------------------*/
2425 /*----angel_RDI_LoadAgent------------------------------------------------*/
2426 /*----------------------------------------------------------------------*/
2427
2428 /* Load a new debug agent: use ADP_Ctrl_Download_Agent. */
2429 int angel_RDI_LoadAgent(ARMword dest, unsigned long size,
2430 getbufferproc *getb, void *getbarg)
2431 {
2432 Packet *packet = NULL;
2433 int status, reason, subreason, debugID, OSinfo1, OSinfo2, err;
2434 time_t t;
2435
2436 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2437 angel_DebugPrint("DEBUG: Entered angel_RDI_LoadAgent.\n");
2438 #endif
2439 register_debug_message_handler();
2440 msgsend(CI_HADP, "%w%w%w%w%w%w%w", ADP_Control | HtoT,
2441 0, ADP_HandleUnknown, ADP_HandleUnknown,
2442 ADP_Ctrl_Download_Agent, dest, size);
2443 reason=ADP_Control | TtoH;
2444 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2445 &status, &packet);
2446 if (err != RDIError_NoError) {
2447 DevSW_FreePacket(packet);
2448 return -1;
2449 }
2450 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason, &debugID,
2451 &OSinfo1, &OSinfo2, &subreason, &status);
2452 DevSW_FreePacket(packet);
2453 if ( subreason != ADP_Ctrl_Download_Agent )
2454 return RDIError_Error;
2455 if ( status != RDIError_NoError )
2456 return status;
2457
2458 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2459 angel_DebugPrint("DEBUG: starting agent data download.\n");
2460 #endif
2461 { unsigned long pos = 0, segsize;
2462 for (; pos < size; pos += segsize) {
2463 char *b = getb(getbarg, &segsize);
2464 if (b == NULL) return RDIError_NoError;
2465 err = angel_RDI_LoadConfigData( segsize, b );
2466 if (err != RDIError_NoError) return err;
2467 }
2468 }
2469 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2470 angel_DebugPrint("DEBUG: finished downloading new agent.\n");
2471 #endif
2472
2473 /* renegotiate back down */
2474 err = angel_negotiate_defaults();
2475 if (err != adp_ok)
2476 return err;
2477
2478 /* Output a message to tell the user what is going on. This is vital
2479 * when switching from ADP EICE to ADP over JTAG, as then the user
2480 * has to reset the target board !
2481 */
2482 { char msg[256];
2483 int len=angel_RDI_errmess(msg, 256, adp_new_agent_starting);
2484 angel_hostif->write(angel_hostif->hostosarg, msg, len);
2485 }
2486
2487 /* get new image started */
2488 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2489 angel_DebugPrint("DEBUG: sending start message for new agent.\n");
2490 #endif
2491
2492 register_debug_message_handler();
2493 msgsend(CI_HADP, "%w%w%w%w%w%w", ADP_Control | HtoT,
2494 0, ADP_HandleUnknown, ADP_HandleUnknown,
2495 ADP_Ctrl_Start_Agent, dest);
2496 reason=ADP_Control | TtoH;
2497 err = wait_for_debug_message(&reason, &debugID, &OSinfo1, &OSinfo2,
2498 &status, &packet);
2499 if (err != RDIError_NoError) {
2500 DevSW_FreePacket(packet);
2501 return -1;
2502 }
2503 unpack_message(BUFFERDATA(packet->pk_buffer), "%w%w%w%w%w%w", &reason,
2504 &debugID, &OSinfo1, &OSinfo2, &subreason, &status);
2505 DevSW_FreePacket(packet);
2506 if ( subreason != ADP_Ctrl_Start_Agent )
2507 return RDIError_Error;
2508 if ( status != RDIError_NoError )
2509 return status;
2510
2511 /* wait for image to start up */
2512 heartbeat_enabled = FALSE;
2513 t=time(NULL);
2514 do {
2515 Adp_AsynchronousProcessing(async_block_on_nothing);
2516 if ((time(NULL)-t) > 2) {
2517 #ifdef DEBUG
2518 angel_DebugPrint("DEBUG: no booted message from new image yet.\n");
2519 #endif
2520 break;
2521 }
2522 } while (booted_not_received);
2523 booted_not_received=1;
2524
2525 /* Give device driver a chance to do any necessary resyncing with new agent.
2526 * Only used by etherdrv.c at the moment.
2527 */
2528 (void)Adp_Ioctl( DC_RESYNC, NULL );
2529
2530 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2531 angel_DebugPrint("DEBUG: reopening to new agent.\n");
2532 #endif
2533 err = angel_RDI_open(0, NULL, NULL, NULL);
2534 switch ( err )
2535 {
2536 case RDIError_NoError:
2537 {
2538 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2539 angel_DebugPrint( "LoadAgent: Open returned RDIError_NoError\n" );
2540 #endif
2541 break;
2542 }
2543
2544 case RDIError_LittleEndian:
2545 {
2546 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2547 angel_DebugPrint( "LoadAgent: Open returned RDIError_LittleEndian (OK)\n" );
2548 #endif
2549 err = RDIError_NoError;
2550 break;
2551 }
2552
2553 case RDIError_BigEndian:
2554 {
2555 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2556 angel_DebugPrint( "LoadAgent: Open returned RDIError_BigEndian (OK)\n" );
2557 #endif
2558 err = RDIError_NoError;
2559 break;
2560 }
2561
2562 default:
2563 {
2564 #if defined(DEBUG) || defined(DEBUG_LOADAGENT)
2565 angel_DebugPrint( "LoadAgent: Open returned %d - unexpected!\n", err );
2566 #endif
2567 break;
2568 }
2569 }
2570 #ifndef NO_HEARTBEAT
2571 heartbeat_enabled = TRUE;
2572 #endif
2573 return err;
2574 }
2575
2576 static int angel_RDI_errmess(char *buf, int blen, int errnum) {
2577 char *s=NULL;
2578 int n;
2579
2580 switch (errnum) {
2581 case adp_malloc_failure:
2582 s=AdpMess_MallocFailed; break;
2583 case adp_illegal_args:
2584 s=AdpMess_IllegalArgs; break;
2585 case adp_device_not_found:
2586 s=AdpMess_DeviceNotFound; break;
2587 case adp_device_open_failed:
2588 s=AdpMess_DeviceOpenFailed; break;
2589 case adp_device_already_open:
2590 s=AdpMess_DeviceAlreadyOpen; break;
2591 case adp_device_not_open:
2592 s=AdpMess_DeviceNotOpen; break;
2593 case adp_bad_channel_id:
2594 s=AdpMess_BadChannelId; break;
2595 case adp_callback_already_registered:
2596 s=AdpMess_CBAlreadyRegd; break;
2597 case adp_write_busy:
2598 s=AdpMess_WriteBusy; break;
2599 case adp_bad_packet:
2600 s=AdpMess_BadPacket; break;
2601 case adp_seq_high:
2602 s=AdpMess_SeqHigh; break;
2603 case adp_seq_low:
2604 s=AdpMess_SeqLow; break;
2605 case adp_timeout_on_open:
2606 s=AdpMess_TimeoutOnOpen; break;
2607 case adp_failed:
2608 s=AdpMess_Failed; break;
2609 case adp_abandon_boot_wait:
2610 s=AdpMess_AbandonBootWait; break;
2611 case adp_late_startup:
2612 s=AdpMess_LateStartup; break;
2613 case adp_new_agent_starting:
2614 s=AdpMess_NewAgentStarting; break;
2615 default: return 0;
2616 }
2617 n=strlen(s);
2618 if (n>blen-1) n=blen-1;
2619 memcpy(buf, s, n);
2620 buf[n++]=0;
2621 return n;
2622 }
2623
2624 extern const struct RDIProcVec angel_rdi;
2625 const struct RDIProcVec angel_rdi = {
2626 "ADP",
2627 angel_RDI_open,
2628 angel_RDI_close,
2629 angel_RDI_read,
2630 angel_RDI_write,
2631 angel_RDI_CPUread,
2632 angel_RDI_CPUwrite,
2633 angel_RDI_CPread,
2634 angel_RDI_CPwrite,
2635 angel_RDI_setbreak,
2636 angel_RDI_clearbreak,
2637 angel_RDI_setwatch,
2638 angel_RDI_clearwatch,
2639 angel_RDI_execute,
2640 angel_RDI_step,
2641 angel_RDI_info,
2642 angel_RDI_pointinq,
2643
2644 angel_RDI_AddConfig,
2645 angel_RDI_LoadConfigData,
2646 angel_RDI_SelectConfig,
2647
2648 0, /*angel_RDI_drivernames,*/
2649 0, /* cpunames */
2650
2651 angel_RDI_errmess,
2652
2653 angel_RDI_LoadAgent
2654 };
2655
2656 /* EOF ardi.c */
2657
2658 /* Not strictly necessary, but allows linking this code into armsd. */
2659
2660 struct foo {
2661 char *name;
2662 int (*action)();
2663 char *syntax;
2664 char **helpmessage;
2665 int doafterend;
2666 int dobeforestart;
2667 int doinmidline;
2668 } hostappl_CmdTable[1] = {{"", NULL}};
2669
2670 void
2671 hostappl_Init()
2672 {
2673 }
2674
2675 int
2676 hostappl_Backstop()
2677 {
2678 return -30;
2679 }