Commit | Line | Data |
---|---|---|
c906108c SS |
1 | /* |
2 | ****************************************************************************** | |
3 | ****************************************************************************** | |
4 | * | |
5 | * COPYRIGHT (C) by EMC Corporation, 1997 All rights reserved. | |
6 | * $Id$ | |
7 | * DESCRIPTION: This module has been provided for the purpose of testing GDB. | |
8 | * | |
9 | * NOTES: | |
10 | * | |
11 | ****************************************************************************** | |
12 | *****************************************************************************/ | |
13 | ||
14 | /*============================================================================= | |
15 | * INCLUDE FILES | |
16 | *===========================================================================*/ | |
17 | ||
18 | ||
19 | #ifdef DO_IT_BY_THE_BOOK | |
20 | ||
21 | ||
22 | #include "symtypes_defs.h" | |
23 | #include "printp.h" | |
24 | ||
25 | #include "adbg_expression.h" | |
26 | #include "common_hw_ds.h" | |
27 | #include "common_hw_defs.h" | |
28 | #include "evnttrac.h" | |
29 | #include "sym_scratch_ds.h" | |
30 | #include "symglob_ds.h" | |
31 | #include "sym_protglob_ds.h" | |
32 | ||
33 | #include "ether.h" | |
34 | ||
35 | #include <ctype.h> | |
36 | ||
37 | ||
38 | #else | |
39 | ||
40 | #include "adbg_dtc.h" | |
41 | ||
42 | #define YES 1 | |
43 | #define NO 0 | |
44 | ||
45 | #define TRUE 1 | |
46 | #define FALSE 0 | |
47 | ||
48 | #define ENABLED 1 | |
49 | #define DISABLED 0 | |
50 | ||
51 | #define CONTROL_C 3 /* ASCII 'ETX' */ | |
52 | ||
53 | ||
54 | /* | |
55 | * Faked after ctype.h | |
56 | */ | |
57 | ||
58 | #define isxdigit(X) (((X) >= '0' && (X) <= '9') || \ | |
59 | ((X) >= 'A' && (X) <= 'F') || \ | |
60 | ((X) >= 'a' && (X) <= 'f')) | |
61 | /* | |
62 | * Borrowed from string.h | |
63 | */ | |
64 | ||
65 | extern unsigned int strlen ( const char * ); | |
66 | ||
67 | /* | |
68 | * Extracted from symtypes.h: | |
69 | */ | |
70 | ||
71 | typedef char BOOL; /* 8 Bits */ | |
72 | typedef unsigned char UCHAR; /* 8 Bits */ | |
73 | typedef unsigned short USHORT; /* 16 Bits */ | |
74 | typedef unsigned long ULONG; /* 32 Bits */ | |
75 | ||
76 | /* | |
77 | * for struct t_expr_tag and | |
78 | * decl of build_and_add_expression | |
79 | */ | |
80 | #include "adbg_expression.h" | |
81 | #define NULL 0 | |
82 | ||
83 | /* | |
84 | * Extracted from printp.h: | |
85 | */ | |
86 | ||
87 | extern void printp ( const char * fptr, ... ); | |
88 | extern void sprintp ( const char * fptr, ... ); | |
89 | ||
90 | /* | |
91 | * Extracted from ether.h: | |
92 | */ | |
93 | ||
94 | extern long eth_to_gdb ( UCHAR *buf, long length ); | |
95 | ||
96 | ||
97 | /* | |
98 | * Derived from hwequs.s: | |
99 | */ | |
100 | ||
101 | #define CS_CODE_START 0x100000 | |
102 | #define CS_CODE_SIZE 0x200000 | |
103 | #define LAST_CS_WORD (CS_CODE_START + CS_CODE_SIZE - 2) | |
104 | ||
105 | #define sh_genstat1 (*((volatile ULONG *) 0xFFFFFE54)) | |
106 | ||
107 | #define rs232_mode1 0 /* rs-232 mode 1 reg. */ | |
108 | #define rs232_mode2 rs232_mode1 /* rs-232 mode 2 reg. */ | |
109 | #define rs232_stat 4 /* rs-232 status reg. */ | |
110 | #define rs232_clk rs232_stat /* rs-232 clock select reg. */ | |
111 | #define rs232_cmd 8 /* rs-232 command reg */ | |
112 | #define rs232_transmit 12 /* rs-232 transmit reg. */ | |
113 | #define rs232_receive rs232_transmit /* rs-232 transmit reg. */ | |
114 | #define rs232_aux 16 /* rs-232 aux control reg. */ | |
115 | #define rs232_isr 20 /* rs-232 interrupt status reg. */ | |
116 | #define rs232_imr rs232_isr /* rs-232 interrupt mask reg. */ | |
117 | #define rs232_tc_high 24 /* rs-232 timer/counter high reg. */ | |
118 | #define rs232_tc_low 28 /* rs-232 timer/counter low reg. */ | |
119 | ||
120 | ||
121 | #endif | |
122 | ||
123 | ||
124 | /*============================================================================ | |
125 | * MODULE DEFINES | |
126 | *===========================================================================*/ | |
127 | ||
128 | #define P_RST_LAN_UART_REG ((volatile UCHAR *) 0xFFFFFE45) | |
129 | #define M_RST_LAN_UART 0x80 /* Bit 7 */ | |
130 | ||
131 | #define P_LAN0TR_REG P_RST_LAN_UART_REG | |
132 | #define M_LAN0TR 0x20 /* Bit 5 */ | |
133 | ||
134 | #define M_SH_GENCON_LAN0TR 0x00200000 /* Bit 21 */ | |
135 | ||
136 | #define MAX_RS232_CHARS 512 | |
137 | ||
138 | #define LAN_Q_MOD(X) ((X) % MAX_RS232_CHARS) | |
139 | ||
140 | /*---------------------------------------* | |
141 | * LAN UART Registers * | |
142 | *---------------------------------------*/ | |
143 | ||
144 | #define LAN_UART_BASE ((ULONG) 0xfffffc22) | |
145 | ||
146 | /* Write-Read */ | |
147 | ||
148 | #define P_LAN_MR1 ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_mode1 ))) | |
149 | #define P_LAN_MR2 ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_mode2 ))) | |
150 | ||
151 | /* Write-Only */ | |
152 | ||
153 | #define P_LAN_ACR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_aux ))) | |
154 | #define P_LAN_CR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_cmd ))) | |
155 | #define P_LAN_CSR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_clk ))) | |
156 | #define P_LAN_CTLR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_tc_low ))) | |
157 | #define P_LAN_CTUR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_tc_high ))) | |
158 | #define P_LAN_IMR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_imr ))) | |
159 | ||
160 | /* Read-Only */ | |
161 | ||
162 | #define P_LAN_SR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_stat ))) | |
163 | #define P_LAN_ISR ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_isr ))) | |
164 | #define P_LAN_XMT ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_transmit))) | |
165 | #define P_LAN_RCV ((volatile UCHAR *) (LAN_UART_BASE + ((ULONG) rs232_receive ))) | |
166 | ||
167 | /* | |
168 | * Bit Values for Write-Read and Write-Only Registers | |
169 | */ | |
170 | ||
171 | #define DEFAULT_LAN_MR1 ((UCHAR) 0x13) | |
172 | #define DEFAULT_LAN_MR2 ((UCHAR) 0x07) | |
173 | #define DEFAULT_LAN_CSR ((UCHAR) 0xcc) | |
174 | #define DEFAULT_LAN_ACR ((UCHAR) 0x38) | |
175 | #define DEFAULT_LAN_CTUR ((UCHAR) 0xff) | |
176 | #define DEFAULT_LAN_CTLR ((UCHAR) 0xff) | |
177 | ||
178 | #define LAN_ACR_SELECT_BRG_0 DEFAULT_LAN_ACR | |
179 | #define LAN_ACR_SELECT_BRG_1 (DEFAULT_LAN_ACR | 0x80) | |
180 | ||
181 | #define UART_CR_RESET_MR_PTR ((UCHAR) 0x10) /* Reset MR pointer (points to MR1). */ | |
182 | #define UART_CR_RESET_RVCR ((UCHAR) 0x20) /* Reset receiver (disabled). */ | |
183 | #define UART_CR_RESET_XMTR ((UCHAR) 0x30) /* Reset transmitter (disabled). */ | |
184 | #define UART_CR_RESET_ERROR_STATUS ((UCHAR) 0x40) /* Reset error status. */ | |
185 | #define UART_CR_RESET_BRK_CHG_INT ((UCHAR) 0x50) /* Reset break change interrupt. */ | |
186 | #define UART_CR_START_CNTR_TIMER ((UCHAR) 0x80) /* Start counter/timer. */ | |
187 | #define UART_CR_STOP_CNTR ((UCHAR) 0x90) /* Stop counter. */ | |
188 | ||
189 | #define UART_CR_DISABLE_XMTR ((UCHAR) 0x08) /* Disable transmitter. */ | |
190 | #define UART_CR_ENABLE_XMTR ((UCHAR) 0x04) /* Enable transmitter. */ | |
191 | #define UART_CR_DISABLE_RCVR ((UCHAR) 0x02) /* Disable receiver. */ | |
192 | #define UART_CR_ENABLE_RCVR ((UCHAR) 0x01) /* Enable receiver. */ | |
193 | ||
194 | #define UART_CSR_BR_4800 ((UCHAR) 0x99) /* With either BRG Set selected (via ACR). */ | |
195 | #define UART_CSR_BR_9600 ((UCHAR) 0xbb) /* With either BRG Set selected (via ACR). */ | |
196 | #define UART_CSR_BR_19200 ((UCHAR) 0xcc) /* With BRG Set '1' selected (via ACR). */ | |
197 | #define UART_CSR_BR_38400 ((UCHAR) 0xcc) /* With BRG Set '0' selected (via ACR). */ | |
198 | ||
199 | #define UART_IMR_RxRDY ((UCHAR) 0x04) /* Enable 'RxRDY' interrupt. */ | |
200 | #define UART_IMR_TxEMT ((UCHAR) 0x02) /* Enable 'TxEMT' interrupt. */ | |
201 | #define UART_IMR_TxRDY ((UCHAR) 0x01) /* Enable 'TxRDY' interrupt. */ | |
202 | ||
203 | /* | |
204 | * Bit Masks for Read-Only Registers | |
205 | */ | |
206 | ||
207 | #define M_UART_SR_RCVD_BRK 0x80 /* Bit 7 */ | |
208 | #define M_UART_SR_FE 0x40 /* Bit 6 */ | |
209 | #define M_UART_SR_PE 0x20 /* Bit 5 */ | |
210 | #define M_UART_SR_OE 0x10 /* Bit 4 */ | |
211 | #define M_UART_SR_TxEMT 0x08 /* Bit 3 */ | |
212 | #define M_UART_SR_TxRDY 0x04 /* Bit 2 */ | |
213 | #define M_UART_SR_FFULL 0x02 /* Bit 1 */ | |
214 | #define M_UART_SR_RxRDY 0x01 /* Bit 0 */ | |
215 | ||
216 | #define M_UART_ISR_RxRDY 0x04 /* Bit 2 */ | |
217 | #define M_UART_ISR_TxEMT 0x02 /* Bit 1 */ | |
218 | #define M_UART_ISR_TxRDY 0x01 /* Bit 0 */ | |
219 | ||
220 | /*---------------------------------------* | |
221 | * Support for 'Utility 83'. * | |
222 | *---------------------------------------*/ | |
223 | ||
224 | #define LAN_UTIL_CODE 0x83 | |
225 | ||
226 | #define LAN_INIT ((ULONG) (('I' << 24) | ('N' << 16) | ('I' << 8) | 'T')) | |
227 | #define LAN_BAUD ((ULONG) (('B' << 24) | ('A' << 16) | ('U' << 8) | 'D')) | |
228 | #define LAN_INTR ((ULONG) (('I' << 24) | ('N' << 16) | ('T' << 8) | 'R')) | |
229 | #define LAN_XMT ((ULONG) (('X' << 16) | ('M' << 8) | 'T')) | |
230 | #define LAN_ECHO ((ULONG) (('E' << 24) | ('C' << 16) | ('H' << 8) | 'O')) | |
231 | #define LAN_STAT ((ULONG) (('S' << 24) | ('T' << 16) | ('A' << 8) | 'T')) | |
232 | #define LAN_IN ((ULONG) (('I' << 8) | 'N')) | |
233 | #define LAN_OUT ((ULONG) (('O' << 16) | ('U' << 8) | 'T')) | |
234 | ||
235 | #define LAN_PUTC ((ULONG) (('P' << 24) | ('U' << 16) | ('T' << 8) | 'C')) | |
236 | #define LAN_WPM ((ULONG) (('W' << 16) | ('P' << 8) | 'M')) | |
237 | ||
238 | #define STATUS(X) ( ( ( X ) == 0 ) ? "disabled" : "enabled" ) | |
239 | ||
240 | #define XMT_VIA_BP_ENABLED() ( *P_LAN0TR_REG & M_LAN0TR ? 1 : 0 ) | |
241 | ||
242 | #define TRAP_1_INST 0x4E41 | |
243 | ||
244 | /* | |
245 | * Bit #13 of shared genstat 1 indicates | |
246 | * which processor we are as follows. | |
247 | * | |
248 | * 0 => X (side A) | |
249 | * 1 => Y (side B) | |
250 | */ | |
251 | ||
252 | #define M_PROC_ID 0x00002000 | |
253 | ||
254 | #define IS_SIDE_A() ( ( (sh_genstat1) & M_PROC_ID ) == 0 ) | |
255 | #define IS_SIDE_B() ( (sh_genstat1) & M_PROC_ID ) | |
256 | ||
257 | ||
258 | #ifdef STANDALONE /* Compile this module stand-alone for debugging */ | |
259 | #define LAN_PUT_CHAR(X) printf("%c", X) | |
260 | #else | |
261 | #define LAN_PUT_CHAR(X) while ( lan_put_char( X ) ) | |
262 | #endif | |
263 | ||
264 | ||
265 | ||
266 | ||
267 | #define VIA_RS232 0 | |
268 | #define VIA_ETHERNET 1 | |
269 | ||
270 | #define MAX_IO_BUF_SIZE 400 | |
271 | ||
272 | #define MAX_BYTE_CODES 200 /* maximum length for bytecode string */ | |
273 | ||
274 | ||
275 | static ULONG gdb_host_comm; | |
276 | ||
277 | static ULONG gdb_cat_ack; | |
278 | ||
279 | static char eth_outbuffer[ MAX_IO_BUF_SIZE + 1 ]; | |
280 | ||
281 | ||
282 | #ifdef STANDALONE | |
283 | ||
284 | #define ACK_PKT() LAN_PUT_CHAR( '+' ) | |
285 | #define NACK_PKT() LAN_PUT_CHAR( '-' ) | |
286 | ||
287 | #else | |
288 | ||
289 | #define ACK_PKT() { \ | |
290 | if ( VIA_ETHERNET == gdb_host_comm ) \ | |
291 | { \ | |
292 | gdb_cat_ack = YES; \ | |
293 | } \ | |
294 | else \ | |
295 | { \ | |
296 | LAN_PUT_CHAR( '+' ); \ | |
297 | } \ | |
298 | } | |
299 | ||
300 | ||
301 | ||
302 | #define NACK_PKT() { \ | |
303 | if ( VIA_ETHERNET == gdb_host_comm ) \ | |
304 | { \ | |
305 | eth_outbuffer[ 0 ] = '-'; \ | |
306 | eth_to_gdb( (UCHAR *) eth_outbuffer, 1 ); \ | |
307 | } \ | |
308 | else \ | |
309 | { \ | |
310 | LAN_PUT_CHAR( '-' ); \ | |
311 | } \ | |
312 | } | |
313 | ||
314 | #endif | |
315 | ||
316 | ||
317 | ||
318 | ||
319 | /*============================================================================ | |
320 | * MODULE TYPEDEFS | |
321 | *===========================================================================*/ | |
322 | ||
323 | typedef struct rs232_queue { | |
324 | ||
325 | long head_index; | |
326 | ||
327 | long tail_index; | |
328 | ||
329 | ULONG overflows; | |
330 | ||
331 | long gdb_packet_start; | |
332 | long gdb_packet_end; | |
333 | long gdb_packet_csum1; | |
334 | long gdb_packet_csum2; | |
335 | ||
336 | UCHAR buf[ MAX_RS232_CHARS ]; | |
337 | ||
338 | } T_RS232_QUEUE; | |
339 | ||
340 | ||
341 | ||
342 | ||
343 | /*============================================================================= | |
344 | * EXTERNAL GLOBAL VARIABLES | |
345 | *===========================================================================*/ | |
346 | ||
347 | extern volatile UCHAR sss_trace_flag; | |
348 | ||
349 | ||
350 | /*============================================================================= | |
351 | * STATIC MODULE DECLARATIONS | |
352 | *===========================================================================*/ | |
353 | ||
354 | static T_RS232_QUEUE lan_input_queue, | |
355 | lan_output_queue; | |
356 | ||
357 | static BOOL test_echo; | |
358 | ||
359 | #if 0 | |
360 | /* The stub no longer seems to use this. */ | |
361 | static BOOL write_access_enabled; | |
362 | #endif | |
363 | ||
364 | static int baud_rate_idx; | |
365 | ||
366 | static ULONG tx_by_intr, | |
367 | tx_by_poll; | |
368 | ||
369 | static UCHAR lan_shadow_imr; | |
370 | ||
371 | ||
372 | /*============================================================================= | |
373 | * EXTERNAL FUNCTION PROTOTYPES | |
374 | *===========================================================================*/ | |
375 | ||
376 | extern long write_to_protected_mem( void *address, unsigned short value ); | |
377 | ||
378 | ||
379 | /*============================================================================= | |
380 | * MODULE GLOBAL FUNCTIONS PROTOTYPES | |
381 | *===========================================================================*/ | |
382 | ||
383 | ULONG gdb_c_test( ULONG *parm ); | |
384 | ||
385 | ||
386 | void lan_init( void ); | |
387 | ||
388 | void lan_isr( void ); | |
389 | ||
390 | long lan_get_char( void ); | |
391 | ||
392 | long lan_put_char( UCHAR c ); | |
393 | ||
394 | ULONG lan_util( ULONG *parm ); | |
395 | ||
396 | ||
397 | /*============================================================================= | |
398 | * MODULE LOCAL FUNCTION PROTOTYPES | |
399 | *===========================================================================*/ | |
400 | ||
401 | static void lan_reset( void ); | |
402 | ||
403 | static void lan_configure( void ); | |
404 | ||
405 | static void lan_init_queue( T_RS232_QUEUE *p_queue ); | |
406 | ||
407 | static void lan_add_to_queue( long c, T_RS232_QUEUE *p_queue ); | |
408 | ||
409 | static UCHAR lan_next_queue_char( T_RS232_QUEUE *p_queue ); | |
410 | ||
411 | static void lan_util_menu( void ); | |
412 | ||
413 | static long get_gdb_input( long c, T_RS232_QUEUE *p_input_q ); | |
414 | ||
415 | ||
416 | /*============================================================================= | |
417 | * GDB STUB FUNCTION PROTOTYPES | |
418 | *===========================================================================*/ | |
419 | ||
420 | void gdb_trap_1_handler( void ); | |
421 | void gdb_trace_handler ( void ); | |
422 | ||
423 | void gdb_get_eth_input( unsigned char *buf, long length ); | |
424 | ||
425 | static void getpacket ( void ); | |
426 | static void putpacket ( char * ); | |
427 | static void discard_packet ( void ); | |
428 | ||
429 | #ifdef STANDALONE /* Compile this module stand-alone for debugging */ | |
430 | #include <stdio.h> | |
431 | #define printp printf /* easier than declaring a local varargs stub func. */ | |
432 | #endif /* STANDALONE */ | |
433 | ||
434 | ||
435 | /*============================================================================= | |
436 | * MODULE BODY | |
437 | *===========================================================================*/ | |
438 | ||
439 | /* ------------------- Things that belong in a header file --------------- */ | |
440 | extern char *memset (char *, int, int); | |
441 | ||
442 | /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%* | |
443 | * * | |
444 | * Global Module Functions * | |
445 | * * | |
446 | *%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ | |
447 | ||
448 | ||
449 | static char gdb_char_test; | |
450 | static short gdb_short_test; | |
451 | static long gdb_long_test; | |
452 | static char gdb_arr_test[25]; | |
453 | static struct GDB_STRUCT_TEST | |
454 | { | |
455 | char c; | |
456 | short s; | |
457 | long l; | |
458 | int bfield : 11; /* collect bitfield */ | |
459 | char arr[25]; | |
460 | struct GDB_STRUCT_TEST *next; | |
461 | } gdb_struct1_test, gdb_struct2_test, *gdb_structp_test, **gdb_structpp_test; | |
462 | ||
463 | static union GDB_UNION_TEST | |
464 | { | |
465 | char c; | |
466 | short s; | |
467 | long l; | |
468 | int bfield : 11; /* collect bitfield */ | |
469 | char arr[4]; | |
470 | union GDB_UNION_TEST *next; | |
471 | } gdb_union1_test; | |
472 | ||
473 | void gdb_recursion_test (int, int, int, int, int, int, int); | |
474 | ||
475 | void gdb_recursion_test (int depth, | |
476 | int q1, | |
477 | int q2, | |
478 | int q3, | |
479 | int q4, | |
480 | int q5, | |
481 | int q6) | |
482 | { /* gdb_recursion_test line 0 */ | |
483 | int q = q1; /* gdbtestline 1 */ | |
484 | ||
485 | q1 = q2; /* gdbtestline 2 */ | |
486 | q2 = q3; /* gdbtestline 3 */ | |
487 | q3 = q4; /* gdbtestline 4 */ | |
488 | q4 = q5; /* gdbtestline 5 */ | |
489 | q5 = q6; /* gdbtestline 6 */ | |
490 | q6 = q; /* gdbtestline 7 */ | |
491 | if (depth--) /* gdbtestline 8 */ | |
492 | gdb_recursion_test (depth, q1, q2, q3, q4, q5, q6); /* gdbtestline 9 */ | |
493 | } | |
494 | ||
495 | ||
496 | ULONG gdb_c_test( ULONG *parm ) | |
497 | ||
498 | { | |
499 | char *p = "gdb_c_test"; | |
42c65987 | 500 | char *ridiculously_long_variable_name_with_equally_long_string_assignment; |
c906108c SS |
501 | register long local_reg = 7; |
502 | static unsigned long local_static, local_static_sizeof; | |
503 | long local_long; | |
504 | unsigned long *stack_ptr; | |
505 | unsigned long end_of_stack; | |
506 | ||
42c65987 JB |
507 | ridiculously_long_variable_name_with_equally_long_string_assignment = |
508 | "ridiculously long variable name with equally long string assignment"; | |
c906108c SS |
509 | local_static = 9; |
510 | local_static_sizeof = sizeof (struct GDB_STRUCT_TEST); | |
511 | local_long = local_reg + 1; | |
512 | stack_ptr = (unsigned long *) &local_long; | |
513 | end_of_stack = | |
514 | (unsigned long) &stack_ptr + sizeof(stack_ptr) + sizeof(end_of_stack) - 1; | |
515 | ||
516 | printp ("\n$Id$\n"); | |
517 | ||
518 | printp( "%s: arguments = %X, %X, %X, %X, %X, %X\n", | |
519 | p, parm[ 1 ], parm[ 2 ], parm[ 3 ], parm[ 4 ], parm[ 5 ], parm[ 6 ] ); | |
520 | ||
521 | gdb_char_test = gdb_struct1_test.c = (char) ((long) parm[1] & 0xff); | |
522 | gdb_short_test = gdb_struct1_test.s = (short) ((long) parm[2] & 0xffff); | |
523 | gdb_long_test = gdb_struct1_test.l = (long) ((long) parm[3] & 0xffffffff); | |
524 | gdb_union1_test.l = (long) parm[4]; | |
525 | gdb_arr_test[0] = gdb_struct1_test.arr[0] = (char) ((long) parm[1] & 0xff); | |
526 | gdb_arr_test[1] = gdb_struct1_test.arr[1] = (char) ((long) parm[2] & 0xff); | |
527 | gdb_arr_test[2] = gdb_struct1_test.arr[2] = (char) ((long) parm[3] & 0xff); | |
528 | gdb_arr_test[3] = gdb_struct1_test.arr[3] = (char) ((long) parm[4] & 0xff); | |
529 | gdb_arr_test[4] = gdb_struct1_test.arr[4] = (char) ((long) parm[5] & 0xff); | |
530 | gdb_arr_test[5] = gdb_struct1_test.arr[5] = (char) ((long) parm[6] & 0xff); | |
531 | gdb_struct1_test.bfield = 144; | |
532 | gdb_struct1_test.next = &gdb_struct2_test; | |
533 | gdb_structp_test = &gdb_struct1_test; | |
534 | gdb_structpp_test = &gdb_structp_test; | |
535 | ||
536 | gdb_recursion_test (3, (long) parm[1], (long) parm[2], (long) parm[3], | |
537 | (long) parm[4], (long) parm[5], (long) parm[6]); | |
538 | ||
539 | gdb_char_test = gdb_short_test = gdb_long_test = 0; | |
540 | gdb_structp_test = (void *) 0; | |
541 | gdb_structpp_test = (void *) 0; | |
542 | memset ((char *) &gdb_struct1_test, 0, sizeof (gdb_struct1_test)); | |
543 | memset ((char *) &gdb_struct2_test, 0, sizeof (gdb_struct2_test)); | |
544 | local_static_sizeof = 0; | |
545 | local_static = 0; | |
546 | return ( (ULONG) 0 ); | |
547 | } | |
548 | ||
549 | ||
550 | /*----------------------------------------------------------------------------- | |
551 | * | |
552 | * FUNCTION NAME: lan_init | |
553 | * | |
554 | * | |
555 | * DESCRIPTION: | |
556 | * | |
557 | * | |
558 | * RETURN VALUE: | |
559 | * | |
560 | * | |
561 | * USED GLOBAL VARIABLES: | |
562 | * | |
563 | * | |
564 | * AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: | |
565 | * | |
566 | * | |
567 | * NOTES: | |
568 | * | |
569 | * | |
570 | * | |
571 | *---------------------------------------------------------------------------*/ | |
572 | ||
573 | void lan_init( void ) | |
574 | ||
575 | { | |
576 | ||
577 | if ( IS_SIDE_A( ) ) | |
578 | { | |
579 | ||
580 | lan_reset( ); | |
581 | ||
582 | lan_init_queue( &lan_input_queue ); | |
583 | ||
584 | lan_init_queue( &lan_output_queue ); | |
585 | ||
586 | lan_configure( ); | |
587 | } | |
588 | ||
589 | return; | |
590 | } | |
591 | /* end of 'lan_init' | |
592 | *===========================================================================*/ | |
593 | ||
594 | ||
595 | /*----------------------------------------------------------------------------- | |
596 | * | |
597 | * FUNCTION NAME: lan_isr | |
598 | * | |
599 | * | |
600 | * DESCRIPTION: | |
601 | * | |
602 | * | |
603 | * RETURN VALUE: None. | |
604 | * | |
605 | * | |
606 | * USED GLOBAL VARIABLES: | |
607 | * | |
608 | * | |
609 | * AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: | |
610 | * | |
611 | * | |
612 | * NOTES: | |
613 | * | |
614 | * | |
615 | *---------------------------------------------------------------------------*/ | |
616 | ||
617 | void lan_isr( void ) | |
618 | ||
619 | { | |
620 | UCHAR c; | |
621 | ||
622 | ||
623 | lan_shadow_imr = 0; /* Disable all UART interrupts. */ | |
624 | *P_LAN_IMR = lan_shadow_imr; | |
625 | ||
626 | ||
627 | if ( *P_LAN_ISR & M_UART_ISR_RxRDY ) | |
628 | { | |
629 | ||
630 | gdb_host_comm = VIA_RS232; | |
631 | ||
632 | c = *P_LAN_RCV; | |
633 | ||
634 | if ( test_echo ) | |
635 | { | |
636 | /* ????? */ | |
637 | } | |
638 | ||
639 | if ( c == CONTROL_C ) | |
640 | { | |
641 | /* can't stop the target, but we can tell gdb to stop waiting... */ | |
642 | discard_packet( ); | |
643 | putpacket( "S03" ); /* send back SIGINT to the debugger */ | |
644 | } | |
645 | ||
646 | else | |
647 | { | |
648 | lan_add_to_queue( (long) c, &lan_input_queue ); | |
649 | get_gdb_input( (long) c, &lan_input_queue ); | |
650 | } | |
651 | ||
652 | } | |
653 | ||
654 | if ( XMT_VIA_BP_ENABLED( ) ) | |
655 | { | |
656 | ||
657 | c = 0; | |
658 | ||
659 | while ( (*P_LAN_ISR & M_UART_ISR_TxRDY) && (c = lan_next_queue_char( &lan_output_queue )) ) | |
660 | { | |
661 | *P_LAN_XMT = c; | |
662 | ++tx_by_intr; | |
663 | } | |
664 | ||
665 | if ( c ) | |
666 | { | |
667 | lan_shadow_imr |= UART_IMR_TxRDY; /* (Re-)Enable 'TxRDY' interrupt from UART. */ | |
668 | } | |
669 | ||
670 | } | |
671 | ||
672 | ||
673 | lan_shadow_imr |= UART_IMR_RxRDY; /* Re-Enable 'RxRDY' interrupt from UART. */ | |
674 | *P_LAN_IMR = lan_shadow_imr; | |
675 | ||
676 | ||
677 | ||
678 | return; | |
679 | } | |
680 | /* end of 'lan_isr' | |
681 | *===========================================================================*/ | |
682 | ||
683 | ||
684 | /*----------------------------------------------------------------------------- | |
685 | * | |
686 | * FUNCTION NAME: lan_get_char | |
687 | * | |
688 | * | |
689 | * DESCRIPTION: Fetches a character from the UART. | |
690 | * | |
691 | * | |
692 | * RETURN VALUE: 0 on success, -1 on failure. | |
693 | * | |
694 | * | |
695 | * USED GLOBAL VARIABLES: | |
696 | * | |
697 | * | |
698 | * AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: | |
699 | * | |
700 | * | |
701 | * NOTES: | |
702 | * | |
703 | * | |
704 | *---------------------------------------------------------------------------*/ | |
705 | ||
706 | long lan_get_char( void ) | |
707 | ||
708 | { | |
709 | long status = -2; /* AGD: nothing found in rcv buffer */ | |
710 | ||
711 | if ( *P_LAN_SR & M_UART_SR_RxRDY ) | |
712 | { | |
713 | char c = (char) *P_LAN_RCV; | |
714 | ||
715 | if ( test_echo ) | |
716 | { | |
717 | LAN_PUT_CHAR ( c ); | |
718 | } | |
719 | ||
720 | if ( c == CONTROL_C ) | |
721 | { | |
722 | /* can't stop the target, but we can tell gdb to stop waiting... */ | |
723 | discard_packet( ); | |
724 | putpacket( "S03" ); /* send back SIGINT to the debugger */ | |
725 | status = 0; /* success */ | |
726 | } | |
727 | ||
728 | else | |
729 | { | |
730 | lan_add_to_queue( (long) c, &lan_input_queue ); | |
731 | status = get_gdb_input( (long) c, &lan_input_queue ); | |
732 | } | |
733 | ||
734 | } | |
735 | ||
736 | return( status ); | |
737 | } | |
738 | /* end of 'lan_get_char' | |
739 | *===========================================================================*/ | |
740 | ||
741 | ||
742 | /*----------------------------------------------------------------------------- | |
743 | * | |
744 | * FUNCTION NAME: lan_put_char | |
745 | * | |
746 | * DESCRIPTION: Puts a character out via the UART. | |
747 | * | |
748 | * RETURN VALUE: 0 on success, -1 on failure. | |
749 | * | |
750 | * USED GLOBAL VARIABLES: none. | |
751 | * | |
752 | * AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: | |
753 | * | |
754 | * NOTES: !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | |
755 | * !! !! | |
756 | * !! If 'XMT_VIA_BP_ENABLED()' is FALSE then output is THROWN AWAY. !! | |
757 | * !! This prevents anyone infinite-looping on this function. !! | |
758 | * !! !! | |
759 | * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! | |
760 | * | |
761 | *---------------------------------------------------------------------------*/ | |
762 | ||
763 | long lan_put_char( UCHAR c ) | |
764 | ||
765 | { | |
766 | long status = -1; | |
767 | ||
768 | if ( XMT_VIA_BP_ENABLED( ) ) | |
769 | { | |
770 | ||
771 | if ( *P_LAN_SR & M_UART_SR_TxRDY ) | |
772 | { | |
773 | lan_add_to_queue( (long) c, &lan_output_queue ); | |
774 | ||
775 | c = lan_next_queue_char( &lan_output_queue ); | |
776 | ||
777 | *P_LAN_XMT = c; | |
778 | ++tx_by_poll; | |
779 | status = 0; | |
780 | } | |
781 | #if 0 | |
782 | else | |
783 | { | |
784 | status = 0; | |
785 | lan_shadow_imr |= UART_IMR_TxRDY; /* Enable 'TxRDY' interrupt from UART. */ | |
786 | *P_LAN_IMR = lan_shadow_imr; | |
787 | } | |
788 | #endif | |
789 | } | |
790 | ||
791 | else | |
792 | { | |
793 | status = 0; /* You lose: input character goes to the bit bucket. */ | |
794 | } | |
795 | ||
796 | return( status ); | |
797 | } | |
798 | /* end of 'lan_put_char' | |
799 | *===========================================================================*/ | |
800 | ||
801 | ||
802 | /*----------------------------------------------------------------------------- | |
803 | * | |
804 | * FUNCTION NAME: lan_util | |
805 | * | |
806 | * DESCRIPTION: | |
807 | * | |
808 | * RETURN VALUE: | |
809 | * | |
810 | * USED GLOBAL VARIABLES: | |
811 | * | |
812 | * AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: | |
813 | * | |
814 | * NOTES: | |
815 | * | |
816 | *---------------------------------------------------------------------------*/ | |
817 | ||
818 | ULONG lan_util( ULONG *parm ) | |
819 | ||
820 | { | |
821 | ||
822 | ||
823 | static const struct { | |
824 | ||
825 | ULONG rate_code; | |
826 | UCHAR acr_setting; | |
827 | UCHAR csr_setting; | |
828 | ||
829 | } baud_rate_setting [] = { | |
830 | ||
831 | { 0x38400, LAN_ACR_SELECT_BRG_0, UART_CSR_BR_38400 }, | |
832 | { 0x19200, LAN_ACR_SELECT_BRG_1, UART_CSR_BR_19200 }, | |
833 | { 0x9600, LAN_ACR_SELECT_BRG_0, UART_CSR_BR_9600 }, | |
834 | { 0x4800, LAN_ACR_SELECT_BRG_0, UART_CSR_BR_4800 } | |
835 | }; | |
836 | ||
837 | ||
838 | #define BOGUS_P1 0xE1 | |
839 | #define BOGUS_P2 0xE2 | |
840 | ||
841 | ULONG not_done_code; | |
842 | ||
843 | ||
844 | ULONG opcode; | |
845 | ULONG parm_1; | |
846 | ULONG parm_2; | |
847 | ||
848 | int i; | |
849 | UCHAR c; | |
850 | ||
851 | ||
852 | not_done_code = 0; | |
853 | ||
854 | opcode = parm[ 1 ]; | |
855 | parm_1 = parm[ 2 ]; | |
856 | parm_2 = parm[ 3 ]; | |
857 | ||
858 | ||
859 | switch ( opcode ) | |
860 | { | |
861 | ||
862 | case LAN_INIT: | |
863 | { | |
864 | ||
865 | lan_init( ); | |
866 | printp( "\n\n Interface (Re)Initialized ...\n\n" ); | |
867 | ||
868 | break; | |
869 | } | |
870 | ||
871 | ||
872 | case LAN_BAUD: | |
873 | { | |
874 | ||
875 | for ( i = 0; i < (int)(sizeof(baud_rate_setting) / sizeof(baud_rate_setting[0])); i ++ ) | |
876 | { | |
877 | if ( baud_rate_setting[i].rate_code == parm_1 ) | |
878 | { | |
879 | baud_rate_idx = i; | |
880 | *P_LAN_ACR = baud_rate_setting[i].acr_setting; | |
881 | *P_LAN_CSR = baud_rate_setting[i].csr_setting; | |
882 | printp ( "Baud rate set to %X!\n", baud_rate_setting[i].rate_code ); | |
883 | return( not_done_code ); | |
884 | } | |
885 | } | |
886 | ||
887 | printp( "\n\n *** SYNTAX Error - Invalid baudrate (P2)\n\n" ); | |
888 | not_done_code = BOGUS_P2; | |
889 | ||
890 | break; | |
891 | } | |
892 | ||
893 | ||
894 | case LAN_INTR: | |
895 | { | |
896 | ||
897 | switch ( parm_1 ) | |
898 | { | |
899 | ||
900 | case 0x0D: /* Disable 'RxRDY' Interrupts */ | |
901 | { | |
902 | lan_shadow_imr &= ~UART_IMR_RxRDY; | |
903 | *P_LAN_IMR = lan_shadow_imr; | |
904 | printp( "\n\n Receive Ready Interrupts DISABLED ...\n\n" ); | |
905 | break; | |
906 | } | |
907 | ||
908 | case 0x0E: /* Enable 'RxRDY' Interrupts */ | |
909 | { | |
910 | lan_shadow_imr |= UART_IMR_RxRDY; | |
911 | *P_LAN_IMR = lan_shadow_imr; | |
912 | printp( "\n\n Receive Ready Interrupts ENABLED ...\n\n" ); | |
913 | break; | |
914 | } | |
915 | ||
916 | default: | |
917 | { | |
918 | printp( "\n\n *** SYNTAX Error - Invalid P2 (use D or E)\n\n" ); | |
919 | not_done_code = BOGUS_P2; | |
920 | } | |
921 | } | |
922 | ||
923 | break; | |
924 | } | |
925 | ||
926 | ||
927 | case LAN_XMT: | |
928 | { | |
929 | ||
930 | switch ( parm_1 ) | |
931 | { | |
932 | ||
933 | case 0x0E: /* Enable Transmission-via-Backplane */ | |
934 | { | |
935 | if ( !(*P_LAN0TR_REG & M_LAN0TR) ) | |
936 | { | |
937 | *P_LAN0TR_REG |= M_LAN0TR; /* 0 -> 1 */ | |
938 | } | |
939 | ||
940 | printp( "\n\n Transmit-via-Backplane ENABLED ...\n\n" ); | |
941 | break; | |
942 | } | |
943 | ||
944 | case 0x0D: /* Disable Transmission-via-Backplane */ | |
945 | { | |
946 | if ( *P_LAN0TR_REG & M_LAN0TR ) | |
947 | { | |
948 | *P_LAN0TR_REG &= ~M_LAN0TR; /* 1 -> 0 */ | |
949 | } | |
950 | ||
951 | printp( "\n\n Transmit-via-Backplane DISABLED ...\n\n" ); | |
952 | break; | |
953 | } | |
954 | ||
955 | default: | |
956 | { | |
957 | printp( "\n\n *** SYNTAX Error - Invalid P2 (use D or E)\n\n" ); | |
958 | not_done_code = BOGUS_P2; | |
959 | lan_util_menu( ); | |
960 | } | |
961 | } | |
962 | ||
963 | break; | |
964 | } | |
965 | ||
966 | ||
967 | case LAN_STAT: | |
968 | { | |
969 | ||
970 | printp( "\n -- Status --\n\n" ); | |
971 | ||
972 | printp( " Baud Rate: %X *\n", baud_rate_setting[ baud_rate_idx ].rate_code ); | |
973 | printp( " Xmt-via-BP: %s *\n", STATUS( XMT_VIA_BP_ENABLED( ) ) ); | |
974 | printp( " RxRdy Intr: %s *\n", STATUS( (lan_shadow_imr & M_UART_ISR_RxRDY) ) ); | |
975 | /*** printp( " TxRdy Intr: %s\n", STATUS( (lan_shadow_imr & M_UART_ISR_TxRDY) ) ); ***/ | |
976 | printp( " Echo: %s *\n\n", STATUS( test_echo ) ); | |
977 | ||
978 | printp( " IMR: %02X\n", (ULONG) lan_shadow_imr ); | |
979 | printp( " ISR: %02X\n", (ULONG) *P_LAN_ISR ); | |
980 | printp( " SR: %02X\n\n", (ULONG) *P_LAN_SR ); | |
981 | ||
982 | printp( " Input Overflows: %d\n\n", lan_input_queue.overflows ); | |
983 | ||
984 | printp( " Tx by Intr: %d\n", tx_by_intr ); | |
985 | printp( " Tx by Poll: %d\n\n", tx_by_poll ); | |
986 | ||
987 | printp( " * Can be set or toggled via Utility %2X.\n\n", (ULONG) LAN_UTIL_CODE ); | |
988 | ||
989 | break; | |
990 | } | |
991 | ||
992 | ||
993 | case LAN_IN: | |
994 | { | |
995 | ||
996 | switch ( parm_1 ) | |
997 | { | |
998 | ||
999 | case 0x0C: /* Clear and Reset Queue */ | |
1000 | { | |
1001 | lan_init_queue( &lan_input_queue ); | |
1002 | printp( "\n\n Queue CLEARED/RESET ...\n\n" ); | |
1003 | break; | |
1004 | } | |
1005 | ||
1006 | case 0x0D: /* Display Queue */ | |
1007 | { | |
1008 | printp( "\n -- Input Queue --\n" ); | |
1009 | printp( "\n Head Index: %8X Tail Index: %8X\n\n ", | |
1010 | (ULONG) lan_input_queue.head_index, (ULONG) lan_input_queue.tail_index ); | |
1011 | ||
1012 | for ( i = 0; i < MAX_RS232_CHARS; ++i ) | |
1013 | { | |
1014 | printp( " %02X", (ULONG) lan_input_queue.buf[ i ] ); | |
1015 | ||
1016 | if ( 15 == (i % 16) ) | |
1017 | { | |
1018 | int j; | |
1019 | ||
1020 | printp ( " " ); | |
1021 | for ( j = i - 15; j <= i; j++ ) | |
1022 | { | |
1023 | if ( lan_input_queue.buf[ j ] >= ' ' && | |
1024 | lan_input_queue.buf[ j ] < 127 ) | |
1025 | printp ( "%c", lan_input_queue.buf[ j ] ); | |
1026 | else | |
1027 | printp ( "." ); | |
1028 | } | |
1029 | printp( "\n " ); | |
1030 | } | |
1031 | ||
1032 | else if ( 7 == (i % 8) ) | |
1033 | { | |
1034 | printp( " " ); | |
1035 | } | |
1036 | ||
1037 | } | |
1038 | ||
1039 | printp( "\n" ); | |
1040 | ||
1041 | break; | |
1042 | } | |
1043 | ||
1044 | case 0x0F: /* Fetch next character in Queue */ | |
1045 | { | |
1046 | c = lan_next_queue_char( &lan_input_queue ); | |
1047 | ||
1048 | if ( c ) | |
1049 | { | |
1050 | printp( "\n\n Next Character: " ); | |
1051 | if ( 0x21 <= c && c <= 0x7F ) | |
1052 | { | |
1053 | printp( "%c\n\n", (ULONG) c ); | |
1054 | } | |
1055 | ||
1056 | else if ( 0x20 == ((UCHAR) c) ) | |
1057 | { | |
1058 | printp( "<space>\n\n" ); | |
1059 | } | |
1060 | ||
1061 | else | |
1062 | { | |
1063 | printp( "%02X\n\n", (ULONG) c ); | |
1064 | } | |
1065 | } | |
1066 | ||
1067 | else | |
1068 | { | |
1069 | printp( "\n\n Input Queue EMPTY ...\n\n" ); | |
1070 | } | |
1071 | ||
1072 | break; | |
1073 | } | |
1074 | ||
1075 | default: | |
1076 | { | |
1077 | printp( "\n\n *** SYNTAX Error - Invalid P2 ...\n\n" ); | |
1078 | not_done_code = BOGUS_P2; | |
1079 | break; | |
1080 | } | |
1081 | } | |
1082 | ||
1083 | break; | |
1084 | } | |
1085 | ||
1086 | ||
1087 | case LAN_OUT: | |
1088 | { | |
1089 | ||
1090 | switch ( parm_1 ) | |
1091 | { | |
1092 | ||
1093 | case 0x0C: /* Clear and Reset Queue */ | |
1094 | { | |
1095 | lan_init_queue( &lan_output_queue ); | |
1096 | printp( "\n\n Queue CLEARED/RESET ...\n\n" ); | |
1097 | break; | |
1098 | } | |
1099 | ||
1100 | case 0x0D: /* Display Queue */ | |
1101 | { | |
1102 | printp( "\n -- Output Queue --\n" ); | |
1103 | printp( "\n Head Index: %8X Tail Index: %8X\n\n ", | |
1104 | (ULONG) lan_output_queue.head_index, (ULONG) lan_output_queue.tail_index ); | |
1105 | ||
1106 | for ( i = 0; i < MAX_RS232_CHARS; ++i ) | |
1107 | { | |
1108 | printp( " %02X", (ULONG) lan_output_queue.buf[ i ] ); | |
1109 | ||
1110 | if ( 15 == (i % 16) ) | |
1111 | { | |
1112 | int j; | |
1113 | ||
1114 | printp ( " " ); | |
1115 | for ( j = i - 15; j <= i; j++ ) | |
1116 | { | |
1117 | if ( lan_output_queue.buf[ j ] >= ' ' && | |
1118 | lan_output_queue.buf[ j ] < 127 ) | |
1119 | printp ( "%c", lan_output_queue.buf[ j ] ); | |
1120 | else | |
1121 | printp ( "." ); | |
1122 | } | |
1123 | printp( "\n " ); | |
1124 | } | |
1125 | ||
1126 | else if ( 7 == (i % 8) ) | |
1127 | { | |
1128 | printp( " " ); | |
1129 | } | |
1130 | ||
1131 | } | |
1132 | ||
1133 | printp( "\n" ); | |
1134 | ||
1135 | break; | |
1136 | } | |
1137 | ||
1138 | case 0x0F: /* Fetch next character in Queue */ | |
1139 | { | |
1140 | c = lan_next_queue_char( &lan_output_queue ); | |
1141 | ||
1142 | if ( c ) | |
1143 | { | |
1144 | printp( "\n\n Next Character: " ); | |
1145 | if ( 0x21 <= c && c <= 0x7F ) | |
1146 | { | |
1147 | printp( "%c\n\n", (ULONG) c ); | |
1148 | } | |
1149 | ||
1150 | else if ( 0x20 == c ) | |
1151 | { | |
1152 | printp( "<space>\n\n" ); | |
1153 | } | |
1154 | ||
1155 | else | |
1156 | { | |
1157 | printp( "%02X\n\n", (ULONG) c ); | |
1158 | } | |
1159 | } | |
1160 | ||
1161 | else | |
1162 | { | |
1163 | printp( "\n\n Input Queue EMPTY ...\n\n" ); | |
1164 | } | |
1165 | ||
1166 | break; | |
1167 | } | |
1168 | ||
1169 | default: | |
1170 | { | |
1171 | printp( "\n\n *** SYNTAX Error - Invalid P2 ...\n\n" ); | |
1172 | not_done_code = BOGUS_P2; | |
1173 | break; | |
1174 | } | |
1175 | } | |
1176 | ||
1177 | break; | |
1178 | } | |
1179 | ||
1180 | ||
1181 | case LAN_ECHO: | |
1182 | { | |
1183 | ||
1184 | switch ( parm_1 ) | |
1185 | { | |
1186 | ||
1187 | case 0x0E: | |
1188 | { | |
1189 | test_echo = ENABLED; | |
1190 | printp( "\n\n Test echo ENABLED ...\n\n" ); | |
1191 | break; | |
1192 | } | |
1193 | ||
1194 | case 0x0D: | |
1195 | { | |
1196 | test_echo = DISABLED; | |
1197 | printp( "\n\n Test echo DISABLED ...\n\n" ); | |
1198 | break; | |
1199 | } | |
1200 | ||
1201 | default: | |
1202 | { | |
1203 | printp( "\n\n *** SYNTAX Error - Invalid P2 ...\n\n" ); | |
1204 | not_done_code = BOGUS_P2; | |
1205 | break; | |
1206 | } | |
1207 | } | |
1208 | ||
1209 | break; | |
1210 | } | |
1211 | ||
1212 | ||
1213 | case LAN_PUTC: | |
1214 | { | |
1215 | ||
1216 | if ( 0x20 < parm_1 && parm_1 < 0x7F ) | |
1217 | { | |
1218 | if ( lan_put_char( (UCHAR) parm_1 ) ) | |
1219 | { | |
1220 | printp( "\n\n *** 'lan_put_char' Error ...\n" ); | |
1221 | } | |
1222 | ||
1223 | else | |
1224 | { | |
1225 | printp( "\n\n O.K. ...\n" ); | |
1226 | } | |
1227 | ||
1228 | } | |
1229 | ||
1230 | else | |
1231 | { | |
1232 | printp( "\n\n *** Error - character must be in the 0x21-0x7E range ...\n" ); | |
1233 | not_done_code = BOGUS_P2; | |
1234 | } | |
1235 | ||
1236 | break; | |
1237 | } | |
1238 | ||
1239 | /*** | |
1240 | case LAN_WPM: | |
1241 | { | |
1242 | ||
1243 | if ( write_to_protected_mem( (void *) parm_1, (unsigned short) parm_2 ) ) | |
1244 | { | |
1245 | printp( "\n Write to protected memory FAILED ...\n" ); | |
1246 | } | |
1247 | ||
1248 | break; | |
1249 | } | |
1250 | ***/ | |
1251 | ||
1252 | case 0: /* no argument -- print menu */ | |
1253 | { | |
1254 | lan_util_menu( ); | |
1255 | break; | |
1256 | } | |
1257 | ||
1258 | ||
1259 | default: | |
1260 | { | |
1261 | parm_2 = 0; /* to supress compiler warning with 'LAN_WPM' case disabled */ | |
1262 | ||
1263 | printp( "\n\n *** SYNTAX Error - Invalid P1 ...\n\n" ); | |
1264 | not_done_code = BOGUS_P1; | |
1265 | break; | |
1266 | } | |
1267 | ||
1268 | ||
1269 | } /* End of 'switch ( opcode )'. */ | |
1270 | ||
1271 | ||
1272 | return( not_done_code ); | |
1273 | } | |
1274 | /* end of 'lan_util' | |
1275 | *===========================================================================*/ | |
1276 | ||
1277 | ||
1278 | /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%* | |
1279 | * * | |
1280 | * Local Module Functions * | |
1281 | * * | |
1282 | *%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/ | |
1283 | ||
1284 | /*----------------------------------------------------------------------------- | |
1285 | * | |
1286 | * FUNCTION NAME: lan_reset | |
1287 | * | |
1288 | * DESCRIPTION: Resets the LAN UART by strobing the 'RST_LAN_UART' bit in the | |
1289 | * Shared Control 1 area. | |
1290 | * | |
1291 | * 1 _| ______ | |
1292 | * | | | | |
1293 | * Bit | | | | |
1294 | * | | | | |
1295 | * 0 _|______| |______ | |
1296 | * |---------------------> t | |
1297 | * | |
1298 | * RETURN VALUE: None. | |
1299 | * | |
1300 | * USED GLOBAL VARIABLES: | |
1301 | * | |
1302 | * AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: | |
1303 | * | |
1304 | * NOTES: H/W configuration requires that a byte in the shared | |
1305 | * control 1 area must be read before being written. | |
1306 | * | |
1307 | *---------------------------------------------------------------------------*/ | |
1308 | ||
1309 | static void lan_reset( void ) | |
1310 | ||
1311 | { | |
1312 | ||
1313 | while ( *P_RST_LAN_UART_REG & M_RST_LAN_UART ) | |
1314 | { | |
1315 | *P_RST_LAN_UART_REG &= ~M_RST_LAN_UART; /* 0 */ | |
1316 | } | |
1317 | ||
1318 | while ( !(*P_RST_LAN_UART_REG & M_RST_LAN_UART) ) | |
1319 | { | |
1320 | *P_RST_LAN_UART_REG |= M_RST_LAN_UART; /* 1 */ | |
1321 | } | |
1322 | ||
1323 | while ( *P_RST_LAN_UART_REG & M_RST_LAN_UART ) | |
1324 | { | |
1325 | *P_RST_LAN_UART_REG &= ~M_RST_LAN_UART; /* 0 */ | |
1326 | } | |
1327 | ||
1328 | } | |
1329 | /* end of 'lan_reset' | |
1330 | *===========================================================================*/ | |
1331 | ||
1332 | ||
1333 | /*----------------------------------------------------------------------------- | |
1334 | * | |
1335 | * FUNCTION NAME: lan_configure | |
1336 | * | |
1337 | * | |
1338 | * DESCRIPTION: | |
1339 | * | |
1340 | * | |
1341 | * RETURN VALUE: | |
1342 | * | |
1343 | * | |
1344 | * USED GLOBAL VARIABLES: | |
1345 | * | |
1346 | * | |
1347 | * AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: | |
1348 | * | |
1349 | * | |
1350 | * NOTES: | |
1351 | * | |
1352 | * | |
1353 | * | |
1354 | *---------------------------------------------------------------------------*/ | |
1355 | ||
1356 | static void lan_configure( void ) | |
1357 | ||
1358 | { | |
1359 | ||
1360 | *P_LAN_CR = UART_CR_RESET_MR_PTR; /* Points to MR1. */ | |
1361 | *P_LAN_CR = UART_CR_RESET_RVCR; /* Receiver disabled. */ | |
1362 | *P_LAN_CR = UART_CR_RESET_XMTR; /* Transmitter disabled. */ | |
1363 | *P_LAN_CR = UART_CR_RESET_ERROR_STATUS; | |
1364 | *P_LAN_CR = UART_CR_RESET_BRK_CHG_INT; | |
1365 | ||
1366 | *P_LAN_MR1 = DEFAULT_LAN_MR1; | |
1367 | *P_LAN_MR2 = DEFAULT_LAN_MR2; | |
1368 | ||
1369 | *P_LAN_ACR = DEFAULT_LAN_ACR; | |
1370 | ||
1371 | *P_LAN_CSR = UART_CSR_BR_9600; | |
1372 | baud_rate_idx = 2; | |
1373 | ||
1374 | *P_LAN_CTUR = DEFAULT_LAN_CTUR; | |
1375 | *P_LAN_CTLR = DEFAULT_LAN_CTLR; | |
1376 | ||
1377 | *P_LAN_CR = (UART_CR_START_CNTR_TIMER | UART_CR_ENABLE_XMTR | UART_CR_ENABLE_RCVR); | |
1378 | ||
1379 | lan_shadow_imr = UART_IMR_RxRDY; /* Enable only 'RxRDY' interrupt from UART. */ | |
1380 | *P_LAN_IMR = lan_shadow_imr; | |
1381 | ||
1382 | tx_by_intr = 0; | |
1383 | tx_by_poll = 0; | |
1384 | ||
1385 | return; | |
1386 | } | |
1387 | /* end of 'lan_configure' | |
1388 | *===========================================================================*/ | |
1389 | ||
1390 | ||
1391 | /*----------------------------------------------------------------------------- | |
1392 | * | |
1393 | * FUNCTION NAME: lan_init_queue | |
1394 | * | |
1395 | * DESCRIPTION: | |
1396 | * | |
1397 | * RETURN VALUE: None. | |
1398 | * | |
1399 | * USED GLOBAL VARIABLES: | |
1400 | * | |
1401 | * AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: | |
1402 | * | |
1403 | * NOTES: | |
1404 | * | |
1405 | *---------------------------------------------------------------------------*/ | |
1406 | ||
1407 | static void lan_init_queue( T_RS232_QUEUE *p_queue ) | |
1408 | ||
1409 | { | |
1410 | long i; | |
1411 | ||
1412 | /* | |
1413 | * We set "head" equal to "tail" implying the queue is empty, | |
1414 | * BUT the "head" and "tail" should each point to valid queue | |
1415 | * positions. | |
1416 | */ | |
1417 | ||
1418 | p_queue->head_index = 0; | |
1419 | p_queue->tail_index = 0; | |
1420 | ||
1421 | p_queue->overflows = 0; | |
1422 | ||
1423 | p_queue->gdb_packet_start = -1; | |
1424 | p_queue->gdb_packet_end = -1; | |
1425 | ||
1426 | p_queue->gdb_packet_csum1 = -1; | |
1427 | p_queue->gdb_packet_csum2 = -1; | |
1428 | ||
1429 | for ( i = 0; i < MAX_RS232_CHARS; ++i ) | |
1430 | { | |
1431 | p_queue->buf[ i ] = 0; | |
1432 | } | |
1433 | ||
1434 | return; | |
1435 | } | |
1436 | /* end of 'lan_init_queue' | |
1437 | *===========================================================================*/ | |
1438 | ||
1439 | ||
1440 | /*----------------------------------------------------------------------------- | |
1441 | * | |
1442 | * FUNCTION NAME: lan_add_to_queue | |
1443 | * | |
1444 | * | |
1445 | * DESCRIPTION: Adds the specified character to the tail of the | |
1446 | * specified queue. Observes "oldest thrown on floor" | |
1447 | * rule (i.e. the queue is allowed to "wrap" and the | |
1448 | * input character is unconditionally placed at the | |
1449 | * tail of the queue. | |
1450 | * | |
1451 | * | |
1452 | * RETURN VALUE: None. | |
1453 | * | |
1454 | * | |
1455 | * USED GLOBAL VARIABLES: | |
1456 | * | |
1457 | * | |
1458 | * AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: | |
1459 | * | |
1460 | * | |
1461 | * NOTES: | |
1462 | * | |
1463 | * | |
1464 | *---------------------------------------------------------------------------*/ | |
1465 | ||
1466 | static void lan_add_to_queue( long c, T_RS232_QUEUE *p_queue ) | |
1467 | ||
1468 | { | |
1469 | ||
1470 | if ( p_queue ) /* Sanity check. */ | |
1471 | { | |
1472 | ||
1473 | if ( c & 0x000000FF ) /* We don't allow NULL characters to be added to a queue. */ | |
1474 | { | |
1475 | /* Insert the new character at the tail of the queue. */ | |
1476 | ||
1477 | p_queue->buf[ p_queue->tail_index ] = (UCHAR) (c & 0x000000FF); | |
1478 | ||
1479 | /* Increment the tail index. */ | |
1480 | ||
1481 | if ( MAX_RS232_CHARS <= ++(p_queue->tail_index) ) | |
1482 | { | |
1483 | p_queue->tail_index = 0; | |
1484 | } | |
1485 | ||
1486 | /* Check for wrapping (i.e. overflow). */ | |
1487 | ||
1488 | if ( p_queue->head_index == p_queue->tail_index ) | |
1489 | { | |
1490 | /* If the tail has caught up to the head record the overflow . . . */ | |
1491 | ||
1492 | ++(p_queue->overflows); | |
1493 | ||
1494 | /* . . . then increment the head index. */ | |
1495 | ||
1496 | if ( MAX_RS232_CHARS <= ++(p_queue->head_index) ) | |
1497 | { | |
1498 | p_queue->head_index = 0; | |
1499 | } | |
1500 | ||
1501 | } | |
1502 | ||
1503 | } /* End of 'if ( c & 0x000000FF )'. */ | |
1504 | ||
1505 | } /* End of 'if ( p_queue )'. */ | |
1506 | ||
1507 | ||
1508 | return; | |
1509 | } | |
1510 | /* end of 'lan_add_to_queue' | |
1511 | *===========================================================================*/ | |
1512 | ||
1513 | ||
1514 | /*----------------------------------------------------------------------------- | |
1515 | * | |
1516 | * FUNCTION NAME: lan_next_queue_char | |
1517 | * | |
1518 | * DESCRIPTION: | |
1519 | * | |
1520 | * RETURN VALUE: | |
1521 | * | |
1522 | * USED GLOBAL VARIABLES: | |
1523 | * | |
1524 | * AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: | |
1525 | * | |
1526 | * NOTES: | |
1527 | * | |
1528 | *---------------------------------------------------------------------------*/ | |
1529 | ||
1530 | static UCHAR lan_next_queue_char( T_RS232_QUEUE *p_queue ) | |
1531 | ||
1532 | { | |
1533 | UCHAR c; | |
1534 | ||
1535 | ||
1536 | c = 0; | |
1537 | ||
1538 | if ( p_queue ) | |
1539 | { | |
1540 | ||
1541 | if ( p_queue->head_index != p_queue->tail_index ) | |
1542 | { | |
1543 | /* Return the 'oldest' character in the queue. */ | |
1544 | ||
1545 | c = p_queue->buf[ p_queue->head_index ]; | |
1546 | ||
1547 | /* Increment the head index. */ | |
1548 | ||
1549 | if ( MAX_RS232_CHARS <= ++(p_queue->head_index) ) | |
1550 | { | |
1551 | p_queue->head_index = 0; | |
1552 | } | |
1553 | ||
1554 | } | |
1555 | ||
1556 | } /* End of 'if ( p_queue )'. */ | |
1557 | ||
1558 | ||
1559 | return( c ); | |
1560 | } | |
1561 | ||
1562 | /* end of 'lan_next_queue_char' | |
1563 | *===========================================================================*/ | |
1564 | ||
1565 | ||
1566 | /*----------------------------------------------------------------------------- | |
1567 | * | |
1568 | * FUNCTION NAME: lan_util_menu | |
1569 | * | |
1570 | * DESCRIPTION: Prints out a brief help on the LAN UART control utility. | |
1571 | * | |
1572 | * RETURN VALUE: None. | |
1573 | * | |
1574 | * USED GLOBAL VARIABLES: None. | |
1575 | * | |
1576 | * AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: None. | |
1577 | * | |
1578 | * NOTES: None. | |
1579 | * | |
1580 | *---------------------------------------------------------------------------*/ | |
1581 | ||
1582 | static void lan_util_menu( void ) | |
1583 | ||
1584 | { | |
1585 | ||
1586 | /* | |
1587 | * Multiply calling printp() below is made due to the limitations | |
1588 | * of printp(), incapable of handling long formatting constants: | |
1589 | */ | |
1590 | ||
1591 | printp( "\n -- Options --\n\n" ); | |
1592 | ||
1593 | printp( " %2X,'INIT' ............... Reset & (Re)INITIALIZE Interface.\n", (ULONG) LAN_UTIL_CODE ); | |
1594 | printp( " %2X,'BAUD',<rate> ........ Set BAUD Rate.\n", (ULONG) LAN_UTIL_CODE ); | |
1595 | printp( " %2X,'INTR',<mode> ........ Toggle 'RxRDY' Interrupts.\n", (ULONG) LAN_UTIL_CODE ); | |
1596 | printp( " %2X,'XMT',<mode> ......... Toggle TRANSMIT-via-backplane.\n", (ULONG) LAN_UTIL_CODE ); | |
1597 | printp( " %2X,'STAT' ............... Display STATUS.\n", (ULONG) LAN_UTIL_CODE ); | |
1598 | printp( " %2X,'ECHO',<mode> ........ Enable/Disable Test ECHO.\n", (ULONG) LAN_UTIL_CODE ); | |
1599 | printp( " %2X,'IN',<action> ........ Access INPUT Queue.\n", (ULONG) LAN_UTIL_CODE ); | |
1600 | printp( " %2X,'OUT',<action> ....... Access OUTPUT Queue.\n\n", (ULONG) LAN_UTIL_CODE ); | |
1601 | ||
1602 | printp( " %2X,'PUTC',<char> ........ Output a Character (i.e. <char>).\n\n", (ULONG) LAN_UTIL_CODE ); | |
1603 | ||
1604 | /*** | |
1605 | printp( " %2X,'WPM',address,word ... Write Protected Memory Test.\n\n", (ULONG) LAN_UTIL_CODE ); | |
1606 | ***/ | |
1607 | ||
1608 | printp( " <rate>: 4800 <mode>: E - enable <action>: C - clear/reset\n" ); | |
1609 | printp( " 9600 D - disable D - display\n" ); | |
1610 | printp( " 19200 F - fetch next char\n" ); | |
1611 | printp( " 38400\n" ); | |
1612 | } | |
1613 | /* end of 'lan_util_menu' | |
1614 | *===========================================================================*/ | |
1615 | ||
1616 | ||
1617 | /* Thu Feb 5 17:14:41 EST 1998 CYGNUS...CYGNUS...CYGNUS...CYGNUS...CYGNUS...CYGNUS...CYGNUS...CYGNUS */ | |
1618 | ||
1619 | ||
1620 | static long get_gdb_input( long c, T_RS232_QUEUE * p_input_q ) | |
1621 | ||
1622 | { | |
1623 | ||
1624 | /* Now to detect when we've got a gdb packet... */ | |
1625 | ||
1626 | if ( '$' == c ) { /* char marks beginning of a packet */ | |
1627 | ||
1628 | if ( -1 != p_input_q->gdb_packet_start || | |
1629 | -1 != p_input_q->gdb_packet_end || | |
1630 | -1 != p_input_q->gdb_packet_csum1 || | |
1631 | -1 != p_input_q->gdb_packet_csum2 ) { /* PROTOCOL ERROR */ | |
1632 | ||
1633 | /* NEW: Actually, this probably means that we muffed a packet, | |
1634 | and GDB has already resent it. The thing to do now is to | |
1635 | throw away the one we WERE working on, but immediately start | |
1636 | accepting the new one. Don't NAK, or GDB will have to try | |
1637 | and send it yet a third time! */ | |
1638 | ||
1639 | /*NACK_PKT( );*/ /*<ETHERNET>*/ | |
1640 | discard_packet( ); /* throw away old packet */ | |
1641 | lan_add_to_queue ('$', p_input_q); /* put the new "$" back in */ | |
1642 | return 0; | |
1643 | } else { /* match new "$" */ | |
1644 | p_input_q->gdb_packet_start = p_input_q->tail_index; | |
1645 | p_input_q->gdb_packet_end = | |
1646 | p_input_q->gdb_packet_csum1 = | |
1647 | p_input_q->gdb_packet_csum2 = -1; | |
1648 | } | |
1649 | } else if ( '#' == c ) { /* # marks end of packet (except for checksum) */ | |
1650 | ||
1651 | if ( -1 == p_input_q->gdb_packet_start || | |
1652 | -1 != p_input_q->gdb_packet_end || | |
1653 | -1 != p_input_q->gdb_packet_csum1 || | |
1654 | -1 != p_input_q->gdb_packet_csum2 ) { /* PROTOCOL ERROR */ | |
1655 | ||
1656 | /* Garbled packet. Discard, but do not NAK. */ | |
1657 | ||
1658 | /*NACK_PKT( );*/ /*<ETHERNET>*/ | |
1659 | discard_packet( ); | |
1660 | return -1; | |
1661 | } | |
1662 | p_input_q->gdb_packet_end = p_input_q->tail_index; | |
1663 | p_input_q->gdb_packet_csum1 = p_input_q->gdb_packet_csum2 = -1; | |
1664 | ||
1665 | } else if ( -1 != p_input_q->gdb_packet_start && | |
1666 | -1 != p_input_q->gdb_packet_end) { | |
1667 | ||
1668 | if ( isxdigit( c ) ) { /* char is one of two checksum digits for packet */ | |
1669 | ||
1670 | if ( -1 == p_input_q->gdb_packet_csum1 && | |
1671 | LAN_Q_MOD( p_input_q->gdb_packet_end + 1 ) == | |
1672 | p_input_q->tail_index ) { | |
1673 | ||
1674 | /* first checksum digit */ | |
1675 | ||
1676 | p_input_q->gdb_packet_csum1 = p_input_q->tail_index; | |
1677 | p_input_q->gdb_packet_csum2 = -1; | |
1678 | ||
1679 | } else if ( -1 == p_input_q->gdb_packet_csum2 && | |
1680 | LAN_Q_MOD( p_input_q->gdb_packet_end + 2 ) == | |
1681 | p_input_q->tail_index ) { | |
1682 | ||
1683 | /* second checksum digit: packet is complete! */ | |
1684 | ||
1685 | p_input_q->gdb_packet_csum2 = p_input_q->tail_index; | |
1686 | getpacket(); /* got a packet -- extract it */ | |
1687 | ||
1688 | } else { /* probably can't happen (um... three hex digits?) */ | |
1689 | ||
1690 | /* PROTOCOL ERROR */ | |
1691 | /* Not sure how this can happen, but ... | |
1692 | discard it, but do not NAK it. */ | |
1693 | /*NACK_PKT( );*/ /*<ETHERNET>*/ | |
1694 | discard_packet( ); | |
1695 | return -1; | |
1696 | } | |
1697 | ||
1698 | } else { /* '#' followed by non-hex char */ | |
1699 | ||
1700 | /* PROTOCOL ERROR */ | |
1701 | /* Bad packet -- discard but do not NAK */ | |
1702 | /*NACK_PKT( );*/ /*<ETHERNET>*/ | |
1703 | discard_packet( ); | |
1704 | return -1; | |
1705 | } | |
1706 | } | |
1707 | ||
1708 | return 0; | |
1709 | } | |
1710 | ||
1711 | ||
1712 | ||
1713 | ||
1714 | #ifdef STANDALONE | |
1715 | ||
1716 | /* stand-alone stand-alone stand-alone stand-alone stand-alone stand-alone | |
1717 | stand-alone stand-alone | |
1718 | stand-alone Enable stand-alone build, for ease of debugging stand-alone | |
1719 | stand-alone stand-alone | |
1720 | stand-alone stand-alone stand-alone stand-alone stand-alone stand-alone */ | |
1721 | ||
1722 | long write_to_protected_mem (addr, word) | |
1723 | void *addr; | |
1724 | unsigned short word; | |
1725 | { | |
1726 | return 0; | |
1727 | } | |
1728 | ||
1729 | ||
1730 | char dummy_memory[0x4000]; | |
1731 | ||
1732 | int main ( void ) | |
1733 | { | |
1734 | long c; | |
1735 | ||
1736 | lan_init_queue( &lan_input_queue ); | |
1737 | printf( "Stand-alone EMC 'stub', pid = %d\n", getpid( ) ); | |
1738 | printf( "Start of simulated 'memory': 0x%08x\n", &dummy_memory); | |
1739 | while ( (c = getc( stdin ) ) != EOF ) | |
1740 | { | |
1741 | if ( c == '\\' ) /* escape char */ | |
1742 | break; | |
1743 | ||
1744 | lan_add_to_queue( c, &lan_input_queue ); | |
1745 | get_gdb_input (c, &lan_input_queue); | |
1746 | fflush( stdout ); | |
1747 | } | |
1748 | ||
1749 | printf( "Goodbye!\n" ); | |
1750 | exit( 0 ); | |
1751 | } | |
1752 | ||
1753 | #define SRAM_START ((void *) (&dummy_memory[0] + 0x00000000)) | |
1754 | #define SRAM_END ((void *) (&dummy_memory[0] + 0x00000400)) | |
1755 | ||
1756 | #define RO_AREA_START ((void *) (&dummy_memory[0] + 0x00000100)) | |
1757 | #define RO_AREA_END ((void *) (&dummy_memory[0] + 0x00000300)) | |
1758 | ||
1759 | #define NVD_START ((void *) (&dummy_memory[0] + 0x00003000)) | |
1760 | #define NVD_END ((void *) (&dummy_memory[0] + 0x00003100)) | |
1761 | ||
1762 | #else /* normal stub (not stand-alone) */ | |
1763 | ||
1764 | #define SRAM_START ((void *) 0x00000000) | |
1765 | #define SRAM_END ((void *) 0x00400000) | |
1766 | ||
1767 | #define RO_AREA_START ((void *) 0x00100000) | |
1768 | #define RO_AREA_END ((void *) 0x00300000) | |
1769 | ||
1770 | #define NVD_START ((void *) 0x03000000) | |
1771 | #define NVD_END ((void *) 0x03100000) | |
1772 | ||
1773 | #endif /* STANDALONE */ | |
1774 | ||
1775 | ||
1776 | ||
1777 | ||
1778 | /* gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb | |
1779 | gdb gdb | |
1780 | gdb Here begins the gdb stub section. gdb | |
1781 | gdb The following functions were added by Cygnus, gdb | |
1782 | gdb to make this thing act like a gdb stub. gdb | |
1783 | gdb gdb | |
1784 | gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb gdb */ | |
1785 | ||
1786 | ||
1787 | /* ------------------- global defines and data decl's -------------------- */ | |
1788 | ||
1789 | #define hexchars "0123456789abcdef" | |
1790 | ||
1791 | /* there are 180 bytes of registers on a 68020 w/68881 */ | |
1792 | /* many of the fpa registers are 12 byte (96 bit) registers */ | |
1793 | #define NUMREGBYTES 180 | |
1794 | #define NUMREGS 29 | |
1795 | #define REGISTER_BYTE(regno) regno | |
1796 | ||
1797 | enum regnames { D0, D1, D2, D3, D4, D5, D6, D7, | |
1798 | A0, A1, A2, A3, A4, A5, A6, A7, | |
1799 | PS, PC, | |
1800 | FP0, FP1, | |
1801 | FP2, FP3, | |
1802 | FP4, FP5, | |
1803 | FP6, FP7, | |
1804 | FPCONTROL, FPSTATUS, FPIADDR | |
1805 | }; | |
1806 | ||
1807 | unsigned long registers[NUMREGBYTES/4]; | |
1808 | ||
1809 | static long remote_debug; | |
1810 | ||
1811 | #define BUFMAX MAX_IO_BUF_SIZE | |
1812 | static char inbuffer[BUFMAX], outbuffer[BUFMAX]; | |
1813 | static char spare_buffer[BUFMAX]; | |
1814 | ||
1815 | ||
1816 | struct stub_trace_frame | |
1817 | { | |
1818 | int valid; | |
1819 | unsigned long frame_id; | |
1820 | unsigned long tdp_id; | |
1821 | FRAME_DEF *frame_data; | |
1822 | COLLECTION_FORMAT_DEF *format; | |
1823 | unsigned long traceregs[NUMREGBYTES/4]; | |
1824 | unsigned char *stack_data; | |
1825 | unsigned char *memrange_data; | |
1826 | } curframe; | |
1827 | ||
1828 | /* ------------------- function prototypes -------------------- */ | |
1829 | ||
1830 | void handle_request ( char * ); | |
1831 | ||
1832 | /* ------------------- Implementation -------------------- */ | |
1833 | ||
1834 | static void | |
1835 | discard_packet( void ) | |
1836 | { | |
1837 | lan_input_queue.head_index = lan_input_queue.tail_index; | |
1838 | ||
1839 | lan_input_queue.gdb_packet_start = | |
1840 | lan_input_queue.gdb_packet_end = | |
1841 | lan_input_queue.gdb_packet_csum1 = | |
1842 | lan_input_queue.gdb_packet_csum2 = -1; | |
1843 | } | |
1844 | ||
1845 | /* Utility function: convert an ASCII isxdigit to a hex nybble */ | |
1846 | ||
1847 | static long | |
1848 | hex( char ch ) | |
1849 | { | |
1850 | if ( (ch >= 'A') && (ch <= 'F') ) | |
1851 | return ch - 'A' + 10; | |
1852 | if ( (ch >= 'a') && (ch <= 'f') ) | |
1853 | return ch - 'a' + 10; | |
1854 | if ( (ch >= '0') && (ch <= '9') ) | |
1855 | return ch - '0'; | |
1856 | return -1; | |
1857 | } | |
1858 | ||
1859 | static void | |
1860 | getpacket( void ) | |
1861 | { | |
1862 | unsigned char our_checksum, their_checksum; | |
1863 | char *copy = inbuffer; | |
1864 | unsigned char c; | |
1865 | ||
1866 | our_checksum = 0; | |
1867 | ||
1868 | /* first find the '$' */ | |
1869 | while ((c = lan_next_queue_char ( &lan_input_queue )) != '$') | |
1870 | if (c == 0) /* ??? Protocol error? (paranoia) */ | |
1871 | { | |
1872 | /* PROTOCOL ERROR (missing '$') */ | |
1873 | /*NACK_PKT( );*/ /*<ETHERNET>*/ | |
1874 | return; | |
1875 | } | |
1876 | ||
1877 | /* Now copy the message (up to the '#') */ | |
1878 | for (c = lan_next_queue_char ( &lan_input_queue ); /* skip the '$' */ | |
1879 | c != 0 && c != '#'; /* stop at the '#' */ | |
1880 | c = lan_next_queue_char ( &lan_input_queue )) | |
1881 | { | |
1882 | *copy++ = c; | |
1883 | our_checksum += c; | |
1884 | } | |
1885 | *copy++ = '\0'; /* terminate the copy */ | |
1886 | ||
1887 | if (c == 0) /* ??? Protocol error? (paranoia) */ | |
1888 | { | |
1889 | /* PROTOCOL ERROR (missing '#') */ | |
1890 | /*NACK_PKT( );*/ /*<ETHERNET>*/ | |
1891 | return; | |
1892 | } | |
1893 | their_checksum = hex( lan_next_queue_char ( &lan_input_queue ) ) << 4; | |
1894 | their_checksum += hex( lan_next_queue_char ( &lan_input_queue ) ); | |
1895 | ||
1896 | /* Now reset the queue packet-recognition bits */ | |
1897 | discard_packet( ); | |
1898 | ||
1899 | if ( remote_debug || | |
1900 | our_checksum == their_checksum ) | |
1901 | { | |
1902 | ACK_PKT( ); /* good packet */ | |
1903 | /* Parse and process the packet */ | |
1904 | handle_request( inbuffer ); | |
1905 | } | |
1906 | else | |
1907 | /* PROTOCOL ERROR (bad check sum) */ | |
1908 | NACK_PKT( ); | |
1909 | } | |
1910 | ||
1911 | /* EMC will provide a better implementation | |
1912 | (perhaps just of LAN_PUT_CHAR) that does not block. | |
1913 | For now, this works. */ | |
1914 | ||
1915 | ||
1916 | static void | |
1917 | putpacket( char *str ) | |
1918 | { | |
1919 | unsigned char checksum; | |
1920 | ||
1921 | /* '$'<packet>'#'<checksum> */ | |
1922 | ||
1923 | if ( VIA_ETHERNET == gdb_host_comm ) | |
1924 | { | |
1925 | char *p_out; | |
1926 | long length; | |
1927 | ||
1928 | p_out = eth_outbuffer; | |
1929 | length = 0; | |
1930 | ||
1931 | ||
1932 | if ( YES == gdb_cat_ack ) | |
1933 | { | |
1934 | *p_out++ = '+'; | |
1935 | ++length; | |
1936 | } | |
1937 | ||
1938 | gdb_cat_ack = NO; | |
1939 | ||
1940 | ||
1941 | *p_out++ = '$'; | |
1942 | ++length; | |
1943 | ||
1944 | checksum = 0; | |
1945 | ||
1946 | while ( *str ) | |
1947 | { | |
1948 | *p_out++ = *str; | |
1949 | ++length; | |
1950 | checksum += *str++; | |
1951 | } | |
1952 | ||
1953 | *p_out++ = '#'; | |
1954 | *p_out++ = hexchars[checksum >> 4]; | |
1955 | *p_out = hexchars[checksum % 16]; | |
1956 | length += 3; | |
1957 | ||
1958 | eth_to_gdb( (UCHAR *) eth_outbuffer, length ); | |
1959 | } | |
1960 | ||
1961 | else | |
1962 | { | |
1963 | ||
1964 | /* via RS-232 */ | |
1965 | do { | |
1966 | LAN_PUT_CHAR( '$' ); | |
1967 | checksum = 0; | |
1968 | ||
1969 | while ( *str ) | |
1970 | { | |
1971 | LAN_PUT_CHAR( *str ); | |
1972 | checksum += *str++; | |
1973 | } | |
1974 | ||
1975 | LAN_PUT_CHAR( '#' ); | |
1976 | LAN_PUT_CHAR( hexchars[checksum >> 4] ); | |
1977 | LAN_PUT_CHAR( hexchars[checksum % 16] ); | |
1978 | } while ( 0 /* get_debug_char( ) != '+' */ ); | |
1979 | /* XXX FIXME: not waiting for the ack. */ | |
1980 | ||
1981 | } | |
1982 | ||
1983 | } | |
1984 | ||
1985 | ||
1986 | /*----------------------------------------------------------------------------- | |
1987 | * | |
1988 | * FUNCTION NAME: gdb_get_eth_input | |
1989 | * | |
1990 | * | |
1991 | * DESCRIPTION: | |
1992 | * | |
1993 | * | |
1994 | * RETURN VALUE: None. | |
1995 | * | |
1996 | * | |
1997 | * USED GLOBAL VARIABLES: | |
1998 | * | |
1999 | * | |
2000 | * AFFECTED GLOBAL VARIABLES/SIDE EFFECTS: | |
2001 | * | |
2002 | * | |
2003 | * NOTES: | |
2004 | * | |
2005 | * | |
2006 | *---------------------------------------------------------------------------*/ | |
2007 | ||
2008 | void gdb_get_eth_input( unsigned char *buf, long length ) | |
2009 | ||
2010 | { | |
2011 | ||
2012 | gdb_host_comm = VIA_ETHERNET; | |
2013 | ||
2014 | for ( ; 0 < length; ++buf, --length) | |
2015 | { | |
2016 | ||
2017 | if ( *buf == CONTROL_C ) | |
2018 | { | |
2019 | /* can't stop the target, but we can tell gdb to stop waiting... */ | |
2020 | discard_packet( ); | |
2021 | putpacket( "S03" ); /* send back SIGINT to the debugger */ | |
2022 | } | |
2023 | ||
2024 | else | |
2025 | { | |
2026 | lan_add_to_queue( (long) *buf, &lan_input_queue ); | |
2027 | get_gdb_input( (long) *buf, &lan_input_queue ); | |
2028 | } | |
2029 | ||
2030 | } | |
2031 | ||
2032 | ||
2033 | return; | |
2034 | } | |
2035 | /* end of 'gdb_get_eth_input' | |
2036 | *===========================================================================*/ | |
2037 | ||
2038 | ||
2039 | ||
2040 | ||
2041 | /* STDOUT STDOUT STDOUT STDOUT STDOUT STDOUT STDOUT STDOUT STDOUT STDOUT | |
2042 | Stuff pertaining to simulating stdout by sending chars to gdb to be echoed. | |
2043 | ||
2044 | Dear reader: | |
2045 | This code is based on the premise that if GDB receives a packet | |
2046 | from the stub that begins with the character CAPITAL-OH, GDB will | |
2047 | echo the rest of the packet to GDB's console / stdout. This gives | |
2048 | the stub a way to send a message directly to the user. In practice, | |
2049 | (as currently implemented), GDB will only accept such a packet when | |
2050 | it believes the target to be running (ie. when you say STEP or | |
2051 | CONTINUE); at other times it does not expect it. This will probably | |
2052 | change as a side effect of the "asynchronous" behavior. | |
2053 | ||
2054 | Functions: gdb_putchar(char ch) | |
2055 | gdb_write(char *str, int len) | |
2056 | gdb_puts(char *str) | |
2057 | gdb_error(char *format, char *parm) | |
2058 | */ | |
2059 | ||
2060 | #if 0 /* avoid compiler warning while this is not used */ | |
2061 | ||
2062 | /* Function: gdb_putchar(int) | |
2063 | Make gdb write a char to stdout. | |
2064 | Returns: the char */ | |
2065 | ||
2066 | static int | |
2067 | gdb_putchar( long ch ) | |
2068 | { | |
2069 | char buf[4]; | |
2070 | ||
2071 | buf[0] = 'O'; | |
2072 | buf[1] = hexchars[ch >> 4]; | |
2073 | buf[2] = hexchars[ch & 0x0F]; | |
2074 | buf[3] = 0; | |
2075 | putpacket( buf ); | |
2076 | return ch; | |
2077 | } | |
2078 | #endif | |
2079 | ||
2080 | /* Function: gdb_write(char *, int) | |
2081 | Make gdb write n bytes to stdout (not assumed to be null-terminated). | |
2082 | Returns: number of bytes written */ | |
2083 | ||
2084 | static int | |
2085 | gdb_write( char *data, long len ) | |
2086 | { | |
2087 | char *buf, *cpy; | |
2088 | long i; | |
2089 | ||
2090 | buf = outbuffer; | |
2091 | buf[0] = 'O'; | |
2092 | i = 0; | |
2093 | while ( i < len ) | |
2094 | { | |
2095 | for ( cpy = buf+1; | |
2096 | i < len && cpy < buf + BUFMAX - 3; | |
2097 | i++ ) | |
2098 | { | |
2099 | *cpy++ = hexchars[data[i] >> 4]; | |
2100 | *cpy++ = hexchars[data[i] & 0x0F]; | |
2101 | } | |
2102 | *cpy = 0; | |
2103 | putpacket( buf ); | |
2104 | } | |
2105 | return len; | |
2106 | } | |
2107 | ||
2108 | /* Function: gdb_puts(char *) | |
2109 | Make gdb write a null-terminated string to stdout. | |
2110 | Returns: the length of the string */ | |
2111 | ||
2112 | static int | |
2113 | gdb_puts( char *str ) | |
2114 | { | |
2115 | return gdb_write( str, strlen( str ) ); | |
2116 | } | |
2117 | ||
2118 | /* Function: gdb_error(char *, char *) | |
2119 | Send an error message to gdb's stdout. | |
2120 | First string may have 1 (one) optional "%s" in it, which | |
2121 | will cause the optional second string to be inserted. */ | |
2122 | ||
2123 | #if 0 | |
2124 | static void | |
2125 | gdb_error( char *format, char *parm ) | |
2126 | { | |
2127 | static char buf[400]; | |
2128 | char *cpy; | |
2129 | long len; | |
2130 | ||
2131 | if ( remote_debug ) | |
2132 | { | |
2133 | if ( format && *format ) | |
2134 | len = strlen( format ); | |
2135 | else | |
2136 | return; /* empty input */ | |
2137 | ||
2138 | if ( parm && *parm ) | |
2139 | len += strlen( parm ); | |
2140 | ||
2141 | for ( cpy = buf; *format; ) | |
2142 | { | |
2143 | if ( format[0] == '%' && format[1] == 's' ) /* include 2nd string */ | |
2144 | { | |
2145 | format += 2; /* advance two chars instead of just one */ | |
2146 | while ( parm && *parm ) | |
2147 | *cpy++ = *parm++; | |
2148 | } | |
2149 | else | |
2150 | *cpy++ = *format++; | |
2151 | } | |
2152 | *cpy = '\0'; | |
2153 | gdb_puts( buf ); | |
2154 | } | |
2155 | } | |
2156 | #endif | |
2157 | ||
2158 | static void gdb_note (char *, int); | |
2159 | static int error_ret (int, char *, int); | |
2160 | ||
2161 | static unsigned long | |
2162 | elinum_to_index (unsigned long elinum) | |
2163 | { | |
2164 | if ((elinum & 0xf0) == 0xd0) | |
2165 | return (elinum & 0x0f); | |
2166 | else if ((elinum & 0xf0) == 0xa0) | |
2167 | return (elinum & 0x0f) + 8; | |
2168 | else | |
2169 | return -1; | |
2170 | } | |
2171 | ||
2172 | static long | |
2173 | index_to_elinum (unsigned long index) | |
2174 | { | |
2175 | if (index <= 7) | |
2176 | return index + 0xd0; | |
2177 | else if (index <= 15) | |
2178 | return (index - 8) + 0xa0; | |
2179 | else | |
2180 | return -1; | |
2181 | } | |
2182 | ||
2183 | ||
2184 | /* | |
2185 | READMEM READMEM READMEM READMEM READMEM READMEM READMEM READMEM READMEM | |
2186 | ||
2187 | The following code pertains to reading memory from the target. | |
2188 | Some sort of exception handling should be added to make it safe. | |
2189 | ||
2190 | READMEM READMEM READMEM READMEM READMEM READMEM READMEM READMEM READMEM | |
2191 | ||
2192 | Safe Memory Access: | |
2193 | ||
2194 | All reads and writes into the application's memory will pass thru | |
2195 | get_uchar() or set_uchar(), which check whether accessing their | |
2196 | argument is legal before actual access (thus avoiding a bus error). | |
2197 | ||
2198 | */ | |
2199 | ||
2200 | enum { SUCCESS = 0, FAIL = -1 }; | |
2201 | ||
2202 | #if 0 | |
2203 | static long get_uchar ( const unsigned char * ); | |
2204 | #endif | |
2205 | static long set_uchar ( unsigned char *, unsigned char ); | |
2206 | static long read_access_violation ( const void * ); | |
2207 | static long write_access_violation ( const void * ); | |
2208 | static long read_access_range(const void *, long); | |
2209 | static DTC_RESPONSE find_memory(unsigned char *,long,unsigned char **,long *); | |
2210 | ||
2211 | static int | |
2212 | dtc_error_ret (int ret, char *src, DTC_RESPONSE code) | |
2213 | { | |
2214 | if (src) | |
2215 | sprintp (spare_buffer, | |
2216 | "'%s' returned DTC error '%s'.\n", src, get_err_text (code)); | |
2217 | else | |
2218 | sprintp (spare_buffer, "DTC error '%s'.\n", get_err_text (code)); | |
2219 | ||
2220 | gdb_puts (spare_buffer); | |
2221 | return ret; | |
2222 | } | |
2223 | ||
2224 | ||
2225 | #if 0 | |
2226 | /* I think this function is unnecessary since the introduction of | |
2227 | adbg_find_memory_addr_in_frame. */ | |
2228 | ||
2229 | /* Return the number of expressions in the format associated with a | |
2230 | given trace frame. */ | |
2231 | static int | |
2232 | count_frame_exprs (FRAME_DEF *frame) | |
2233 | { | |
2234 | CFD *format; | |
2235 | T_EXPR *expr; | |
2236 | int num_exprs; | |
2237 | ||
2238 | /* Get the format from the frame. */ | |
2239 | get_frame_format_pointer (frame, &format); | |
2240 | ||
2241 | /* Walk the linked list of expressions, and count the number of | |
2242 | expressions we find there. */ | |
2243 | num_exprs = 0; | |
2244 | for (expr = format->p_cfd_expr; expr; expr = expr->next) | |
2245 | num_exprs++; | |
2246 | ||
2247 | return num_exprs; | |
2248 | } | |
2249 | #endif | |
2250 | ||
2251 | #if 0 | |
2252 | /* Function: get_frame_addr | |
2253 | * | |
2254 | * Description: If the input memory address was collected in the | |
2255 | * current trace frame, then lookup and return the address | |
2256 | * from within the trace buffer from which the collected byte | |
2257 | * may be retrieved. Else return -1. */ | |
2258 | ||
2259 | unsigned char * | |
2260 | get_frame_addr ( const unsigned char *addr ) | |
2261 | { | |
2262 | unsigned char *base, *regs, *stack, *mem; | |
2263 | CFD *dummy; | |
2264 | DTC_RESPONSE ret; | |
2265 | ||
2266 | /* first, see if addr is on the saved piece of stack for curframe */ | |
2267 | if (curframe.format->stack_size > 0 && | |
2268 | (base = (unsigned char *) curframe.traceregs[A7]) <= addr && | |
2269 | addr < base + curframe.format->stack_size) | |
2270 | { | |
2271 | gdb_puts("STUB: get_frame_addr: call get_addr_to_frame_regs_stack_mem\n"); | |
2272 | if ((ret = get_addr_to_frame_regs_stack_mem (curframe.frame_data, | |
2273 | &dummy, | |
2274 | (void *) ®s, | |
2275 | (void *) &stack, | |
2276 | (void *) &mem)) | |
2277 | != OK_TARGET_RESPONSE) | |
2278 | return (void *) dtc_error_ret (-1, | |
2279 | "get_addr_to_frame_regs_stack_mem", | |
2280 | ret); | |
2281 | else | |
2282 | return stack + (addr - base); | |
2283 | } | |
2284 | ||
2285 | /* Next, try to find addr in the current frame's expression- | |
2286 | collected memory blocks. I'm sure this is at least quadradic in | |
2287 | time. */ | |
2288 | { | |
2289 | int num_exprs = count_frame_exprs (curframe.frame_data); | |
2290 | int expr, block; | |
2291 | ||
2292 | /* Try each expression in turn. */ | |
2293 | for (expr = 0; expr < num_exprs; expr++) | |
2294 | { | |
2295 | for (block = 0; ; block++) | |
2296 | { | |
2297 | T_EXPR_DATA *data; | |
2298 | if (adbg_get_expr_data (curframe.frame_data, | |
2299 | 'x', expr, block, | |
2300 | &data) | |
2301 | != OK_TARGET_RESPONSE) | |
2302 | break; | |
2303 | else if ((unsigned char *) data->address <= addr | |
2304 | && addr < ((unsigned char *) data->address + data->size)) | |
2305 | { | |
2306 | /* We have found the right block; is it valid data? | |
2307 | Upper-case stamps mean bad data. */ | |
2308 | if ('A' <= data->stamp && data->stamp <= 'Z') | |
2309 | { | |
2310 | gdb_puts("STUB: get_frame_addr: adbg_get_expr_data INVALID\n"); | |
2311 | return (unsigned char *) -1; | |
2312 | } | |
2313 | else | |
2314 | { | |
2315 | if (remote_debug > 1) | |
2316 | { | |
2317 | sprintp(spare_buffer, | |
2318 | "STUB: get_frame_addr: got it [%x,%x)\n", | |
2319 | data->address, data->address + data->size); | |
2320 | gdb_puts(spare_buffer); | |
2321 | } | |
2322 | ||
2323 | return (((unsigned char *) &data->data) | |
2324 | + (addr - (unsigned char *) data->address)); | |
2325 | } | |
2326 | } | |
2327 | } | |
2328 | } | |
2329 | } | |
2330 | ||
2331 | /* not found, return error */ | |
2332 | return (unsigned char *) -1; | |
2333 | } | |
2334 | ||
2335 | /*============================================================*/ | |
2336 | ||
2337 | static long get_uchar ( const unsigned char * addr ) | |
2338 | { | |
2339 | unsigned char *frame_addr; | |
2340 | ||
2341 | if ( read_access_violation ( addr ) ) | |
2342 | return ( -1 ); /* Access error */ | |
2343 | ||
2344 | if (curframe.valid) /* if debugging a trace frame? */ | |
2345 | { | |
2346 | /* If the requested address was collected in the current frame, | |
2347 | * then fetch and return the data from the trace buffer. | |
2348 | */ | |
2349 | if ((frame_addr = get_frame_addr (addr)) != (unsigned char *) -1) | |
2350 | return ( *frame_addr ); | |
2351 | /* If the requested address is in the Code Section, | |
2352 | * let's be magnanimous and read it anyway (else we shall | |
2353 | * not be able to disassemble, find function prologues, etc.) | |
2354 | */ | |
2355 | else if (CS_CODE_START <= (unsigned long) addr && | |
2356 | (unsigned long) addr < CS_CODE_START + CS_CODE_SIZE) | |
2357 | return (*addr); | |
2358 | else | |
2359 | return ( -1 ); /* "Access error" (the data was not collected) */ | |
2360 | } | |
2361 | else | |
2362 | /* Not debugging a trace frame, read the data from live memory. */ | |
2363 | return ( *addr ); /* Meaningful result >= 0 */ | |
2364 | } | |
2365 | #endif | |
2366 | ||
2367 | /*============================================================*/ | |
2368 | ||
2369 | static long set_uchar ( unsigned char * addr, unsigned char val ) | |
2370 | { | |
2371 | long check_result = write_access_violation ( addr ); | |
2372 | ||
2373 | if ( check_result != 0L ) | |
2374 | return ( check_result ); /* Access error */ | |
2375 | ||
2376 | return ( *addr = val ); /* Successful writing */ | |
2377 | } | |
2378 | ||
2379 | /*============================================================*/ | |
2380 | ||
2381 | /* | |
2382 | * Function read_access_violation() below returns TRUE if dereferencing | |
2383 | * its argument for reading would cause a bus error - and FALSE otherwise: | |
2384 | */ | |
2385 | ||
2386 | static long read_access_violation ( const void * addr ) | |
2387 | { | |
2388 | return ( ( ( addr < SRAM_START ) || ( addr >= SRAM_END ) ) && | |
2389 | ( ( addr < NVD_START ) || ( addr >= NVD_END ) ) ); | |
2390 | } | |
2391 | ||
2392 | /*============================================================*/ | |
2393 | ||
2394 | /* | |
2395 | * Function write_access_violation() below returns zero if dereferencing | |
2396 | * its argument for writing is safe, -1 on a soft error (the argument | |
2397 | * falls into the write-protected area), -2 on a hard error (the argument | |
2398 | * points to a non-existent memory location). In other words, it returns | |
2399 | * FALSE when no bus error is expected - and an error code otherwise: | |
2400 | */ | |
2401 | ||
2402 | static long write_access_violation ( const void * addr ) | |
2403 | { | |
2404 | /* | |
2405 | * The boundaries of the write-protected area have to be received via | |
2406 | * an API provided in the Symmetrix core code. For now, these limits | |
2407 | * are hard-coded: | |
2408 | */ | |
2409 | ||
2410 | if ( ( addr >= RO_AREA_START ) && ( addr < RO_AREA_END ) ) | |
2411 | return ( -1 ); /* soft error */ | |
2412 | ||
2413 | if ( ( ( addr < SRAM_START ) || ( addr >= SRAM_END ) ) && | |
2414 | ( ( addr < NVD_START ) || ( addr >= NVD_END ) ) ) | |
2415 | return ( -2 ); /* hard error */ | |
2416 | ||
2417 | return ( 0 ); | |
2418 | } | |
2419 | ||
2420 | ||
2421 | /* read_access_range is like read_access_violation, | |
2422 | but returns the number of bytes we can read w/o faulting. | |
2423 | that is, it checks an address range and tells us what portion | |
2424 | (if any) of the prefix is safe to read without a bus error */ | |
2425 | static long | |
2426 | read_access_range(const void *addr, long count) | |
2427 | { | |
2428 | if ((addr >= SRAM_START) && (addr < SRAM_END)) | |
2429 | { | |
2430 | if ((char *)addr + count < (char *)SRAM_END) | |
2431 | return (count); | |
2432 | else | |
2433 | return ((char *)SRAM_END - (char *)addr); | |
2434 | } | |
2435 | else if (((char *)addr >= (char *)NVD_START) && | |
2436 | ((char *)addr < (char *)NVD_END)) | |
2437 | { | |
2438 | if ((char *)addr + count < (char *)NVD_END) | |
2439 | return (count); | |
2440 | else | |
2441 | return ((char *)NVD_END - (char *)addr); | |
2442 | } | |
2443 | else | |
2444 | return (0); | |
2445 | } | |
2446 | ||
2447 | /* Convert the memory pointed to by mem into hex, placing result in buf. | |
2448 | Return SUCCESS or FAIL. | |
2449 | If MAY_FAULT is non-zero, then we should return FAIL in response to | |
2450 | a fault; if zero treat a fault like any other fault in the stub. */ | |
2451 | ||
2452 | static long | |
2453 | mem2hex(unsigned char *mem, char *buf, long count, long may_fault) | |
2454 | { | |
2455 | long ndx; | |
2456 | long ndx2; | |
2457 | long ch; | |
2458 | long incr; | |
2459 | unsigned char *location; | |
2460 | DTC_RESPONSE status; | |
2461 | ||
2462 | if (may_fault) | |
2463 | { | |
2464 | for (ndx = 0, incr = 1; (ndx < count) && (incr > 0); ndx += incr) | |
2465 | { | |
2466 | status = find_memory(mem, count - ndx, &location, &incr); | |
2467 | ||
2468 | if (status == OK_TARGET_RESPONSE) | |
2469 | { | |
2470 | if (incr > 0) | |
2471 | { | |
2472 | for (ndx2 = 0; ndx2 < incr; ndx2++) | |
2473 | { | |
2474 | ch = *location++; | |
2475 | *buf++ = hexchars[ch >> 4]; | |
2476 | *buf++ = hexchars[ch & 0xf]; | |
2477 | } | |
2478 | mem += incr; | |
2479 | } | |
2480 | else if (incr <= 0) /* should never happen */ | |
2481 | { | |
2482 | *buf = 0; | |
2483 | return (0); | |
2484 | } | |
2485 | } | |
2486 | else if (status == NOT_FOUND_TARGET_RESPONSE) | |
2487 | { | |
2488 | *buf = 0; | |
2489 | return (ndx); /* return amount copied */ | |
2490 | } | |
2491 | else | |
2492 | { | |
2493 | *buf = 0; | |
2494 | return (0); /* XXX: how do we tell the user the status? */ | |
2495 | } | |
2496 | } | |
2497 | *buf = 0; | |
2498 | return (count); | |
2499 | } | |
2500 | else | |
2501 | { | |
2502 | for (ndx = 0; ndx < count; ndx++) | |
2503 | { | |
2504 | ch = *mem++; | |
2505 | *buf++ = hexchars[ch >> 4]; | |
2506 | *buf++ = hexchars[ch & 0xf]; | |
2507 | } | |
2508 | *buf = 0; | |
2509 | return (count); /* we copied everything */ | |
2510 | } | |
2511 | } | |
2512 | ||
2513 | static DTC_RESPONSE | |
2514 | find_memory(unsigned char *mem, long count, | |
2515 | unsigned char **location, long *incr) | |
2516 | { | |
2517 | DTC_RESPONSE retval; | |
2518 | long length; | |
2519 | ||
2520 | /* figure out how much of the memory range we can read w/o faulting */ | |
2521 | count = read_access_range(mem, count); | |
2522 | if (count == 0) | |
2523 | return (NOT_FOUND_TARGET_RESPONSE); | |
2524 | ||
2525 | if (curframe.valid) | |
2526 | { | |
2527 | unsigned char *mem_block; | |
2528 | unsigned char *mem_addr; | |
2529 | unsigned long mem_size; | |
2530 | unsigned long mem_stamp; | |
2531 | ||
2532 | retval = adbg_find_memory_addr_in_frame(curframe.frame_data, mem, | |
2533 | (unsigned long **)&mem_block, | |
2534 | (unsigned long **)&mem_addr, | |
2535 | &mem_size, &mem_stamp); | |
2536 | ||
2537 | switch (retval) | |
2538 | { | |
2539 | case OK_TARGET_RESPONSE: | |
2540 | #if 0 | |
2541 | printp("FOUND: mem %x block %x addr %x size %d stamp %x\n", | |
2542 | mem, mem_block, mem_addr, mem_size, mem_stamp); | |
2543 | #endif | |
2544 | *location = mem_block + (mem - mem_addr); | |
04c12f60 | 2545 | length = mem_size - (mem - mem_addr); |
c906108c SS |
2546 | |
2547 | if (length < count) | |
2548 | *incr = length; | |
2549 | else | |
2550 | *incr = count; | |
2551 | ||
2552 | break; | |
2553 | ||
2554 | case NOT_FOUND_TARGET_RESPONSE: | |
2555 | case NEAR_FOUND_TARGET_RESPONSE: | |
2556 | #if 0 | |
2557 | printp("NOT FOUND: mem %x, checking code region\n", mem); | |
2558 | #endif | |
2559 | /* check to see if it's in the code region */ | |
2560 | if ((CS_CODE_START <= (long)mem) && | |
2561 | ((long)mem < CS_CODE_START + CS_CODE_SIZE)) | |
2562 | { | |
2563 | /* some or all of the address range is in the code */ | |
2564 | *location = mem; | |
2565 | if ((long)mem + count <= CS_CODE_START + CS_CODE_SIZE) | |
2566 | *incr = count; /* it's totally in the code */ | |
2567 | else | |
2568 | /* how much is in the code? */ | |
2569 | *incr = CS_CODE_START + CS_CODE_SIZE - (long)mem; | |
2570 | #if 0 | |
2571 | printp("FOUND in code region: %x\n", mem); | |
2572 | #endif | |
2573 | retval = OK_TARGET_RESPONSE; | |
2574 | } | |
2575 | else | |
2576 | retval = NOT_FOUND_TARGET_RESPONSE; | |
2577 | ||
2578 | break; | |
2579 | ||
2580 | default: | |
2581 | #if 0 | |
2582 | printp("BAD RETURN: %d\n", retval); | |
2583 | #endif | |
2584 | retval = NOT_FOUND_TARGET_RESPONSE; | |
2585 | break; | |
2586 | } | |
2587 | } | |
2588 | else | |
2589 | { | |
2590 | *location = mem; | |
2591 | *incr = count; | |
2592 | retval = OK_TARGET_RESPONSE; | |
2593 | } | |
2594 | ||
2595 | return (retval); | |
2596 | } | |
2597 | ||
2598 | /* Convert the hex array pointed to by buf into binary to be placed in mem. | |
2599 | Return SUCCESS or FAIL. */ | |
2600 | ||
2601 | static long | |
2602 | hex2mem( char *buf, unsigned char *mem, long count, long may_fault ) | |
2603 | { | |
2604 | long i, ch; | |
2605 | ||
2606 | for ( i=0; i<count; i++ ) | |
2607 | { | |
2608 | ch = hex( *buf++ ) << 4; | |
2609 | ch = ch + hex( *buf++ ); | |
2610 | if ( may_fault ) | |
2611 | { | |
2612 | ch = set_uchar( mem++, ch ); | |
2613 | if ( ch < 0 ) /* negative return indicates error */ | |
2614 | return FAIL; | |
2615 | } | |
2616 | else | |
2617 | *mem++ = ch; | |
2618 | } | |
2619 | return SUCCESS; | |
2620 | } | |
2621 | ||
2622 | /**********************************************/ | |
2623 | /* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */ | |
2624 | /* RETURN NUMBER OF CHARS PROCESSED */ | |
2625 | /**********************************************/ | |
2626 | ||
2627 | static int | |
2628 | hexToInt( char **ptr, unsigned long *intValue ) | |
2629 | { | |
2630 | long numChars = 0; | |
2631 | long hexValue; | |
2632 | ||
2633 | *intValue = 0; | |
2634 | while ( **ptr ) | |
2635 | { | |
2636 | hexValue = hex( **ptr ); | |
2637 | if ( hexValue >=0 ) | |
2638 | { | |
2639 | *intValue = (*intValue << 4) | hexValue; | |
2640 | numChars ++; | |
2641 | } | |
2642 | else | |
2643 | break; | |
2644 | (*ptr)++; | |
2645 | } | |
2646 | return numChars; | |
2647 | } | |
2648 | ||
2649 | static volatile long gdb_handling_trap1; | |
2650 | static volatile long gdb_handling_sstrace; | |
2651 | static volatile long gdb_signo; | |
2652 | ||
2653 | /* | |
2654 | Here is the "callable" stub entry point. | |
2655 | Call this function with a GDB request as an argument, | |
2656 | and it will service the request and return. | |
2657 | ||
2658 | May be further broken up as we go along, with individual requests | |
2659 | broken out as separate functions. | |
2660 | */ | |
2661 | ||
2662 | static char * handle_trace_query (char *); | |
2663 | static char * handle_trace_set (char *); | |
2664 | static int handle_format (char **request, CFD *format); | |
2665 | static unsigned long crc32 (unsigned char *buf, int len, unsigned long crc); | |
2666 | static char * crc_query (char *); | |
2667 | static char * handle_test (char *); | |
2668 | ||
2669 | void | |
2670 | handle_request( char *request ) | |
2671 | { | |
2672 | #if 0 | |
2673 | remote_debug = 2; | |
2674 | #endif | |
2675 | switch( *request++ ) | |
2676 | { | |
2677 | case 'k': /* "kill" */ | |
2678 | curframe.valid = FALSE; | |
2679 | putpacket (""); | |
2680 | break; | |
2681 | case 'D': /* "detach" */ | |
2682 | curframe.valid = FALSE; | |
2683 | putpacket (""); | |
2684 | break; | |
2685 | default: /* Unknown code. Return an empty reply message. */ | |
2686 | putpacket( "" ); /* return empty packet */ | |
2687 | break; | |
2688 | ||
2689 | case 'H': /* Set thread for subsequent operations. | |
2690 | Hct... c = 'c' for thread used in step and continue; | |
2691 | t... can be -1 for all threads. | |
2692 | c = 'g' for thread used in other operations. | |
2693 | If zero, pick a thread, any thread. */ | |
2694 | ||
2695 | putpacket( "OK" ); | |
2696 | break; | |
2697 | ||
2698 | case 'g': /* Read registers. | |
2699 | Each byte of register data is described by | |
2700 | two hex digits. registers are in the | |
2701 | internal order for GDB, and the bytes in a | |
2702 | register are in the same order the machine | |
2703 | uses. */ | |
2704 | { | |
2705 | /* Return the values in (one of) the registers cache(s). | |
2706 | Several situations may pertain: | |
2707 | 1) We're synchronous, in which case the "registers" array | |
2708 | should actually be current. | |
2709 | 2) We're asynchronous, in which case the "registers" array | |
2710 | holds whatever was cached most recently. | |
2711 | 3) We're looking at a trace frame that was collected earlier: | |
2712 | we will return those earlier registers. | |
2713 | */ | |
2714 | ||
2715 | /* all registers default to zero */ | |
2716 | memset (outbuffer, '0', NUMREGBYTES); | |
2717 | outbuffer[NUMREGBYTES] = '\0'; | |
2718 | ||
2719 | if (curframe.valid) /* debugging a trace frame */ | |
2720 | mem2hex( (unsigned char*) curframe.traceregs, | |
2721 | outbuffer, NUMREGBYTES, 0 ); | |
2722 | else | |
2723 | mem2hex( (unsigned char*) registers, outbuffer, NUMREGBYTES, 0 ); | |
2724 | ||
2725 | putpacket( outbuffer ); | |
2726 | } | |
2727 | break; | |
2728 | case 'G': /* Write registers. | |
2729 | Gxxxxxxxx Each byte of register data is described by | |
2730 | two hex digits. */ | |
2731 | if (curframe.valid) /* debugging a trace frame */ | |
2732 | putpacket ("E03"); /* can't write regs into a trace frame! */ | |
2733 | else | |
2734 | { | |
2735 | /* Write the values into the local registers cache... | |
2736 | Note that no actual registers are being changed. */ | |
2737 | ||
2738 | hex2mem( request, | |
2739 | (unsigned char *) registers, NUMREGBYTES, 0 ); | |
2740 | putpacket( "OK" ); | |
2741 | } | |
2742 | break; | |
2743 | case 'P': /* Write (single) register. | |
2744 | Pnn=xxxxxxxx register nn gets value xxxxxxxx; | |
2745 | two hex digits for each byte in the register | |
2746 | (target byte order). */ | |
2747 | ||
2748 | if (curframe.valid) | |
2749 | putpacket ("E03"); /* can't write regs into a trace frame! */ | |
2750 | else | |
2751 | { | |
2752 | unsigned long regno; | |
2753 | ||
2754 | if ( hexToInt( &request, ®no ) && *(request++) == '=' ) | |
2755 | { | |
2756 | if ( regno < NUMREGS ) | |
2757 | { | |
2758 | hexToInt( &request, | |
2759 | (unsigned long *) ®isters[REGISTER_BYTE(regno)]); | |
2760 | ||
2761 | putpacket( "OK" ); | |
2762 | } | |
2763 | else | |
2764 | putpacket( "E01" ); /* bad packet or regno */ | |
2765 | } | |
2766 | } | |
2767 | break; | |
2768 | case 'm': /* Read memory. | |
2769 | mAAAAAAAA,LLLL AAAAAAAA is address, LLLL is length. | |
2770 | Reply can be fewer bytes than requested | |
2771 | if able to read only part of the data. */ | |
2772 | { | |
2773 | unsigned long addr, len; | |
2774 | ||
2775 | if ( hexToInt( &request, &addr ) && | |
2776 | *(request++) == ',' && | |
2777 | hexToInt( &request, &len ) ) | |
2778 | { | |
2779 | /* better not overwrite outbuffer! */ | |
2780 | if ( len > (BUFMAX / 2) - 5 ) | |
2781 | len = (BUFMAX / 2) - 5; | |
2782 | if (mem2hex((unsigned char *) addr, outbuffer, len, 1) == 0) /* XXX: eventually use returned value */ | |
2783 | putpacket( "E03" ); /* read fault (access denied) */ | |
2784 | else | |
2785 | putpacket( outbuffer ); /* read succeeded */ | |
2786 | } | |
2787 | else | |
2788 | putpacket( "E01" ); /* badly formed read request */ | |
2789 | ||
2790 | } | |
2791 | break; | |
2792 | case 'M': /* Write memory. | |
2793 | Maaaaaaaa,llll:xxxx aaaaaaaa is address, llll is length; | |
2794 | xxxx is data to write. */ | |
2795 | ||
2796 | { | |
2797 | unsigned long addr, len; | |
2798 | ||
2799 | if (curframe.valid) /* can't write memory into a trace frame! */ | |
2800 | putpacket ("E03"); /* "access denied" */ | |
2801 | else /*** if ( write_access_enabled ) ***/ | |
2802 | { | |
2803 | if ( hexToInt( &request, &addr ) && | |
2804 | *(request++) == ',' && | |
2805 | hexToInt( &request, &len ) && | |
2806 | *(request++) == ':' ) | |
2807 | { | |
2808 | if (len == 2 && | |
2809 | addr >= CS_CODE_START && | |
2810 | addr <= LAST_CS_WORD) | |
2811 | { | |
2812 | unsigned long val; | |
2813 | ||
2814 | if ( !hexToInt( &request, &val ) || | |
2815 | write_to_protected_mem( (void *)addr, val ) ) | |
2816 | putpacket( "E03" ); /* write fault (access denied) */ | |
2817 | else | |
2818 | putpacket( "OK" ); /* write succeeded */ | |
2819 | } | |
2820 | else | |
2821 | { | |
2822 | if ( hex2mem( request, (unsigned char*) addr, len, 1 ) ) | |
2823 | putpacket( "E03" ); /* write fault (access denied) */ | |
2824 | else | |
2825 | putpacket( "OK" ); /* write succeeded */ | |
2826 | } | |
2827 | } | |
2828 | else | |
2829 | putpacket( "E02" ); /* badly formed write request */ | |
2830 | } | |
2831 | } | |
2832 | break; | |
2833 | case 'c': /* Continue. | |
2834 | cAAAAAAAA AAAAAAAA is address from which to resume. | |
2835 | If omitted, resume at current PC. */ | |
2836 | ||
2837 | { | |
2838 | unsigned long addr; | |
2839 | ||
2840 | if (curframe.valid) | |
2841 | { | |
2842 | /* Don't continue if debugging a trace frame! */ | |
2843 | gdb_puts ("Error: can't continue!\n"); | |
2844 | putpacket ("S03"); | |
2845 | } | |
2846 | else | |
2847 | { | |
2848 | gdb_signo = 3; | |
2849 | if (isxdigit(request[0])) | |
2850 | { | |
2851 | hexToInt(&request, &addr); | |
2852 | registers[REGISTER_BYTE(PC)] = addr; | |
2853 | } | |
2854 | ||
2855 | gdb_handling_trap1 = FALSE; | |
2856 | gdb_handling_sstrace = FALSE; | |
2857 | sss_trace_flag = '\0'; | |
2858 | } | |
2859 | } | |
2860 | break; | |
2861 | case 's': /* Step. | |
2862 | sAAAAAAAA AAAAAAAA is address from which to begin stepping. | |
2863 | If omitted, begin stepping at current PC. */ | |
2864 | { | |
2865 | unsigned long addr; | |
2866 | ||
2867 | if (curframe.valid) | |
2868 | { | |
2869 | /* Don't step if debugging a trace frame! */ | |
2870 | gdb_puts ("Error: can't step!\n"); | |
2871 | putpacket ("S03"); | |
2872 | } | |
2873 | else | |
2874 | { | |
2875 | gdb_signo = 3; | |
2876 | if (isxdigit(request[0])) | |
2877 | { | |
2878 | hexToInt(&request, &addr); | |
2879 | registers[REGISTER_BYTE(PC)] = addr; | |
2880 | } | |
2881 | ||
2882 | gdb_handling_trap1 = FALSE; | |
2883 | gdb_handling_sstrace = FALSE; | |
2884 | sss_trace_flag = 't'; | |
2885 | } | |
2886 | } | |
2887 | break; | |
2888 | case 'C': /* Continue with signal. | |
2889 | Cxx;AAAAAAAA xx is signal number in hex; | |
2890 | AAAAAAAA is adddress from which to resume. | |
2891 | If ;AAAAAAAA omitted, continue from PC. */ | |
2892 | ||
2893 | { | |
2894 | unsigned long addr = 0; | |
2895 | ||
2896 | if (!gdb_handling_trap1 || curframe.valid) | |
2897 | { | |
2898 | /* Don't continue if not currently in synchronous mode, | |
2899 | or if currently debugging a trace frame! */ | |
2900 | gdb_puts( "Error: can't continue!\n" ); | |
2901 | putpacket( "S03" ); /* "sigquit" (better idea?) */ | |
2902 | } | |
2903 | else | |
2904 | { | |
2905 | gdb_signo = 3; | |
2906 | if ( isxdigit( *request ) ) | |
2907 | { | |
2908 | hex2mem( request, (unsigned char *) &gdb_signo, 2, 0 ); | |
2909 | request += 2; | |
2910 | if ( *request == ';' && isxdigit( *++request ) ) | |
2911 | { | |
2912 | hexToInt( &request, &addr ); | |
2913 | registers[REGISTER_BYTE(PC)] = addr; | |
2914 | } | |
2915 | } | |
2916 | gdb_handling_trap1 = FALSE; | |
2917 | gdb_handling_sstrace = FALSE; | |
2918 | sss_trace_flag = '\0'; | |
2919 | } | |
2920 | } | |
2921 | break; | |
2922 | case 'S': /* Step with signal. | |
2923 | Sxx;AAAAAAAA xx is signal number in hex; | |
2924 | AAAAAAAA is adddress from which to begin stepping. | |
2925 | If ;AAAAAAAA omitted, begin stepping from PC. */ | |
2926 | { | |
2927 | unsigned long addr = 0; | |
2928 | ||
2929 | if (!gdb_handling_trap1 || curframe.valid) | |
2930 | { | |
2931 | /* Don't step if not currently in synchronous mode, | |
2932 | or if currently debugging a trace frame! */ | |
2933 | gdb_puts( "Error: can't step!\n" ); | |
2934 | putpacket( "S03" ); /* "sigquit" (better idea?) */ | |
2935 | } | |
2936 | else | |
2937 | { | |
2938 | gdb_signo = 3; | |
2939 | if ( isxdigit( *request ) ) | |
2940 | { | |
2941 | hex2mem( request, (unsigned char *) &gdb_signo, 2, 0 ); | |
2942 | request += 2; | |
2943 | if ( *request == ';' && isxdigit( *++request ) ) | |
2944 | { | |
2945 | hexToInt( &request, &addr ); | |
2946 | registers[REGISTER_BYTE(PC)] = addr; | |
2947 | } | |
2948 | } | |
2949 | gdb_handling_trap1 = FALSE; | |
2950 | gdb_handling_sstrace = FALSE; | |
2951 | sss_trace_flag = 't'; | |
2952 | } | |
2953 | } | |
2954 | break; | |
2955 | case '?': /* Query the latest reason for stopping. | |
2956 | Should be same reply as was last generated | |
2957 | for step or continue. */ | |
2958 | ||
2959 | if ( gdb_signo == 0 ) | |
2960 | gdb_signo = 3; /* default to SIGQUIT */ | |
2961 | outbuffer[ 0 ] = 'S'; | |
2962 | outbuffer[ 1 ] = hexchars[ gdb_signo >> 4 ]; | |
2963 | outbuffer[ 2 ] = hexchars[ gdb_signo & 0xf ]; | |
2964 | outbuffer[ 3 ] = 0; | |
2965 | putpacket( outbuffer ); | |
2966 | break; | |
2967 | ||
2968 | case 'd': /* Toggle debug mode | |
2969 | I'm sure we can think of something interesting. */ | |
2970 | ||
2971 | remote_debug = !remote_debug; | |
2972 | putpacket( "" ); /* return empty packet */ | |
2973 | break; | |
2974 | ||
2975 | case 'q': /* general query */ | |
2976 | switch (*request++) | |
2977 | { | |
2978 | default: | |
2979 | putpacket (""); /* nak a request which we don't handle */ | |
2980 | break; | |
2981 | case 'T': /* trace query */ | |
2982 | putpacket (handle_trace_query (request)); | |
2983 | break; | |
2984 | case 'C': /* crc query (?) */ | |
2985 | if (*request++ == 'R' && | |
2986 | *request++ == 'C' && | |
2987 | *request++ == ':') | |
2988 | putpacket (crc_query (request)); | |
2989 | else | |
2990 | putpacket (""); /* unknown query */ | |
2991 | break; | |
2992 | } | |
2993 | break; | |
2994 | ||
2995 | case 'Q': /* general set */ | |
2996 | switch (*request++) | |
2997 | { | |
2998 | default: | |
2999 | putpacket (""); /* nak a request which we don't handle */ | |
3000 | break; | |
3001 | case 'T': /* trace */ | |
3002 | putpacket (handle_trace_set (request)); | |
3003 | break; | |
3004 | } | |
3005 | break; | |
3006 | ||
3007 | case 'T': | |
3008 | /* call test function: TAAA,BBB,CCC | |
3009 | A, B, and C are arguments to pass to gdb_c_test. Reply is | |
3010 | "E01" (bad arguments) or "OK" (test function called). */ | |
3011 | putpacket (handle_test (request)); | |
3012 | break; | |
3013 | } | |
3014 | } | |
3015 | ||
3016 | static TDP_SETUP_INFO tdp_temp; | |
3017 | static int trace_running; | |
3018 | ||
3019 | /* | |
3020 | * Function msgcmp: | |
3021 | * | |
3022 | * If second argument (str) is matched in first argument, | |
3023 | * then advance first argument past end of str and return "SAME" | |
3024 | * else return "DIFFERENT" without changing first argument. | |
3025 | * | |
3026 | * Return: zero for DIFFERENT, non-zero for SUCCESS | |
3027 | */ | |
3028 | ||
3029 | static int | |
3030 | msgcmp (char **msgp, char *str) | |
3031 | { | |
3032 | char *next; | |
3033 | ||
3034 | if (msgp != 0 && str != 0) /* input validation */ | |
3035 | if ((next = *msgp) != 0) | |
3036 | { | |
3037 | for (; | |
3038 | *next && *str && *next == *str; | |
3039 | next++, str++) | |
3040 | ; | |
3041 | ||
3042 | if (*str == 0) /* matched all of str in msg */ | |
3043 | return (int) (*msgp = next); /* advance msg ptr past str */ | |
3044 | } | |
3045 | return 0; /* failure */ | |
3046 | } | |
3047 | ||
3048 | static char * | |
3049 | handle_trace_query (char *request) | |
3050 | { | |
3051 | if (msgcmp (&request, "Status")) | |
3052 | { | |
3053 | if (adbg_check_if_active ()) | |
3054 | { | |
3055 | gdb_puts ("Target trace is running.\n"); | |
3056 | return "T1"; | |
3057 | } | |
3058 | else | |
3059 | { | |
3060 | gdb_puts ("Target trace not running.\n"); | |
3061 | trace_running = 0; | |
3062 | return "T0"; | |
3063 | } | |
3064 | } | |
3065 | else /* unknown trace query */ | |
3066 | { | |
3067 | return ""; | |
3068 | } | |
3069 | } | |
3070 | ||
3071 | static void | |
3072 | gdb_note (char *fmt, int arg1) | |
3073 | { | |
3074 | if (remote_debug > 1) | |
3075 | { | |
3076 | sprintp (spare_buffer, fmt, arg1); | |
3077 | gdb_puts (spare_buffer); | |
3078 | } | |
3079 | } | |
3080 | ||
3081 | static int | |
3082 | error_ret (int ret, char *fmt, int arg1) | |
3083 | { | |
3084 | if (remote_debug > 0) | |
3085 | { | |
3086 | sprintp (spare_buffer, fmt, arg1); | |
3087 | gdb_puts (spare_buffer); | |
3088 | } | |
3089 | return ret; | |
3090 | } | |
3091 | ||
3092 | static int | |
3093 | handle_format (char **request, COLLECTION_FORMAT_DEF *format) | |
3094 | { | |
3095 | MEMRANGE_DEF m; | |
3096 | DTC_RESPONSE ret; | |
3097 | int elinum; | |
3098 | unsigned long regnum; | |
3099 | long bytecodes[(MAX_BYTE_CODES + sizeof (struct t_expr_tag))/ 4]; | |
3100 | struct t_expr_tag *t_expr = (struct t_expr_tag *)bytecodes; | |
3101 | ||
3102 | if (format->id == 0) | |
3103 | { | |
3104 | if ((ret = get_unused_format_id (&format->id)) != OK_TARGET_RESPONSE) | |
3105 | return dtc_error_ret (-1, "get_unused_format_id", ret); | |
3106 | ||
3107 | if (**request == 'R') | |
3108 | { | |
3109 | (*request)++; | |
3110 | hexToInt (request, &format->regs_mask); | |
3111 | } | |
3112 | gdb_note ("STUB: call define_format (id = %d, ", format->id); | |
3113 | gdb_note ("regs_mask = 0x%X);\n", format->regs_mask); | |
3114 | ||
3115 | if ((ret = define_format (format)) != OK_TARGET_RESPONSE) | |
3116 | { | |
3117 | sprintp (spare_buffer, | |
3118 | "'define_format': DTC error '%s' for format id %d.\n", | |
3119 | get_err_text (ret), | |
3120 | format->id); | |
3121 | gdb_puts (spare_buffer); | |
3122 | return -1; | |
3123 | } | |
3124 | } | |
3125 | ||
3126 | while ((**request == 'M') || (**request == 'X')) | |
3127 | { | |
3128 | switch (**request) | |
3129 | { | |
3130 | case 'M': /* M<regnum>,<offset>,<size> */ | |
3131 | (*request)++; | |
3132 | hexToInt(request, ®num); | |
3133 | ||
3134 | if (regnum == 0 || regnum == (unsigned long) -1) | |
3135 | m.typecode = -1; | |
3136 | else if ((elinum = index_to_elinum (regnum)) > 0) | |
3137 | m.typecode = elinum; | |
3138 | else | |
3139 | return error_ret (-1, | |
3140 | "Memrange register %d is not between 0 and 15\n", | |
3141 | regnum); | |
3142 | ||
3143 | if (*(*request)++ != ',') | |
3144 | return error_ret (-1,"Malformed memrange (comma #%d missing)\n",1); | |
3145 | hexToInt(request, &m.offset); | |
3146 | if (*(*request)++ != ',') | |
3147 | return error_ret (-1,"Malformed memrange (comma #%d missing)\n",2); | |
3148 | hexToInt(request, &m.size); | |
3149 | ||
3150 | gdb_note ("STUB: call add_format_mem_range (typecode = 0x%x, ", | |
3151 | m.typecode); | |
3152 | gdb_note ("offset = 0x%X, ", m.offset); | |
3153 | gdb_note ("size = %d);\n", m.size); | |
3154 | if ((ret = add_format_mem_ranges (format->id, &m)) != | |
3155 | OK_TARGET_RESPONSE) | |
3156 | { | |
3157 | dtc_error_ret (-1, "add_format_mem_ranges", ret); | |
3158 | sprintp (spare_buffer, | |
3159 | "format id %d: memrange (0x%x, 0x%x, 0x%x).\n", | |
3160 | format->id, m.typecode, m.offset, m.size); | |
3161 | gdb_puts (spare_buffer); | |
3162 | return -1; | |
3163 | } | |
3164 | break; | |
3165 | ||
3166 | case 'X': /* X<length>,<bytecodes> */ | |
3167 | { | |
3168 | unsigned long length; | |
3169 | ||
3170 | (*request)++; | |
3171 | hexToInt(request, &length); | |
3172 | ||
3173 | if ((length <= 0) || (length > MAX_BYTE_CODES)) | |
3174 | return error_ret (-1, | |
3175 | "Bytecode expression length (%d) too large\n", | |
3176 | length); | |
3177 | ||
3178 | if (*(*request)++ != ',') | |
3179 | return error_ret (-1, | |
3180 | "Malformed bytecode expr (comma#%d missing)\n", | |
3181 | 1); | |
3182 | t_expr->next = NULL; | |
3183 | /* subtract one to account for expr[0] in header */ | |
3184 | t_expr->size = sizeof(struct t_expr_tag) + length - 1; | |
3185 | t_expr->expr_size = length; | |
3186 | ||
3187 | hex2mem(*request, &t_expr->expr[0], length, 0); | |
3188 | *request += 2 * length; | |
3189 | build_and_add_expression(format->id, t_expr); | |
3190 | } | |
3191 | break; | |
3192 | } | |
3193 | } | |
3194 | return 0; | |
3195 | } | |
3196 | ||
3197 | static char * | |
3198 | handle_trace_set (char *request) | |
3199 | { | |
3200 | long n_frame; | |
3201 | unsigned long frameno, tdp, pc, start, stop; | |
3202 | DTC_RESPONSE ret = -1; | |
3203 | static COLLECTION_FORMAT_DEF tempfmt1; | |
3204 | static char enable; | |
3205 | static char retbuf[20]; | |
3206 | ||
3207 | if (msgcmp (&request, "init")) | |
3208 | { | |
3209 | gdb_note ("STUB: call clear_trace_state();\n", 0); | |
3210 | curframe.valid = 0; /* all old frames become invalid now */ | |
3211 | if ((ret = clear_trace_state ()) == OK_TARGET_RESPONSE) | |
3212 | return "OK"; | |
3213 | else | |
3214 | { | |
3215 | sprintp (retbuf, "E2%x", ret); | |
3216 | return (char *) dtc_error_ret ((int) &retbuf, | |
3217 | "clear_trace_state", | |
3218 | ret); | |
3219 | } | |
3220 | } | |
3221 | else if (msgcmp (&request, "Start")) | |
3222 | { | |
3223 | trace_running = 1; | |
3224 | curframe.valid = 0; /* all old frames become invalid now */ | |
3225 | gdb_note ("STUB: call start_trace_experiment();\n", 0); | |
3226 | adbg_save_trace_in_nvd (); | |
3227 | if ((ret = start_trace_experiment ()) == OK_TARGET_RESPONSE) | |
3228 | return "OK"; | |
3229 | else | |
3230 | { | |
3231 | sprintp (retbuf, "E2%x", ret); | |
3232 | return (char *) dtc_error_ret ((int) &retbuf, | |
3233 | "start_trace_experiment", | |
3234 | ret); | |
3235 | } | |
3236 | } | |
3237 | else if (msgcmp (&request, "Stop")) | |
3238 | { | |
3239 | trace_running = 0; | |
3240 | if (adbg_check_if_active ()) | |
3241 | { | |
3242 | gdb_note ("STUB: call end_trace_experiment();\n", 0); | |
3243 | if ((ret = end_trace_experiment ()) == OK_TARGET_RESPONSE) | |
3244 | return "OK"; | |
3245 | else | |
3246 | { | |
3247 | sprintp (retbuf, "E2%x", ret); | |
3248 | return (char *) dtc_error_ret ((int) &retbuf, | |
3249 | "end_trace_experiment", | |
3250 | ret); | |
3251 | } | |
3252 | } | |
3253 | else return "OK"; | |
3254 | } | |
3255 | /* "TDP:" (The 'T' was consumed in handle_request.) */ | |
3256 | else if (msgcmp (&request, "DP:")) | |
3257 | { | |
3258 | /* TDP:<id>:<addr>:{D,E}:<stepcount>:<pass_limit>{R[M,X]+}<tdp-format> | |
3259 | {S{R[M,X]+}}<tp-format> | |
3260 | ||
3261 | D -- disable tracepoint (illegal from EMC's point of view) | |
3262 | E -- enable tracepoint? | |
3263 | ||
3264 | R -- regs format: R<regs-mask> | |
3265 | M -- memory format: M<regnum>,<offset>,<size> | |
3266 | X -- expr format: X<size>,<bytecodes> | |
3267 | S -- fencepost between trap formats and stepping formats. | |
3268 | */ | |
3269 | ||
3270 | /* state variable, required for splitting TDP packets. */ | |
3271 | static int doing_step_formats; | |
3272 | ||
3273 | /* | |
3274 | * TDP: packets may now be split into multiple packets. | |
3275 | * If a TDP packet is to be continued in another packet, it | |
3276 | * must end in a "-" character. The subsequent continuation | |
3277 | * packet will then begin with a "-" character, between the | |
3278 | * token "TDP:" and the tdp_id field. The ID and address | |
3279 | * will be repeated in each sub-packet. The step_count, | |
3280 | * pass_count, and 'enabled' field must appear in the first | |
3281 | * packet. The boundary between sub-packets may not appear | |
3282 | * between the "S" that denotes the start of stepping "formats", | |
3283 | * and the regs_mask that follows it. The split may also not | |
3284 | * occur in the middle of either a memrange description or a | |
3285 | * bytecode string. -- MVS | |
3286 | */ | |
3287 | ||
3288 | if (*request == '-') /* this is a continuation of a | |
3289 | trace definition in progress */ | |
3290 | { | |
3291 | unsigned long temp_id, temp_addr; | |
3292 | ||
3293 | request++; | |
3294 | if (!(hexToInt (&request, &temp_id) && | |
3295 | *request++ == ':')) | |
3296 | return "E11"; /* badly formed packet, field 1 */ | |
3297 | ||
3298 | if (!(hexToInt (&request, (unsigned long *) &temp_addr) && | |
3299 | *request++ == ':')) | |
3300 | return "E12"; /* badly formed packet, field 2 */ | |
3301 | ||
3302 | if (temp_id != tdp_temp.id) | |
3303 | return "E11"; /* something wrong: field 1 doesn't match */ | |
3304 | if (temp_addr != (unsigned long) tdp_temp.addr) | |
3305 | return "E12"; /* something wrong: field 2 doesn't match */ | |
3306 | } | |
3307 | else /* This is a new TDP definition */ | |
3308 | { | |
3309 | memset ((char *) &tdp_temp, 0, sizeof (tdp_temp)); | |
3310 | memset ((char *) &tempfmt1, 0, sizeof (tempfmt1)); | |
3311 | doing_step_formats = FALSE; | |
3312 | ||
3313 | if (!(hexToInt (&request, &tdp_temp.id) && | |
3314 | *request++ == ':')) | |
3315 | return "E11"; /* badly formed packet, field 1 */ | |
3316 | ||
3317 | if (!(hexToInt (&request, (unsigned long *) &tdp_temp.addr) && | |
3318 | *request++ == ':')) | |
3319 | return "E12"; /* badly formed packet, field 2 */ | |
3320 | ||
3321 | if (!(((enable = *request++) == 'D' || enable == 'E') && | |
3322 | *request++ == ':')) | |
3323 | return "E13"; /* badly formed packet, field 3 */ | |
3324 | #if 0 | |
3325 | if (enable == 'D') | |
3326 | { | |
3327 | gdb_puts ("Disabling of tracepoints not supported by EMC target\n"); | |
3328 | return "E20"; | |
3329 | } | |
3330 | #endif | |
3331 | if (!(hexToInt (&request, &tdp_temp.stepcount) && | |
3332 | *request++ == ':')) | |
3333 | return "E14"; /* badly formed packet, field 4 */ | |
3334 | ||
3335 | if (!hexToInt (&request, &tdp_temp.pass_limit)) | |
3336 | return "E15"; /* badly formed packet, field 5 */ | |
3337 | ||
3338 | } | |
3339 | ||
3340 | /* Typically, the first group of collection descriptors | |
3341 | refers to the trap collection. There is an "S" token | |
3342 | to act as a fencepost between collection descriptors for | |
3343 | the trap, and those for the single-stepping. | |
3344 | ||
3345 | However, when the packet is split up into several packets, | |
3346 | this "S" token may already have been seen in a previous | |
3347 | sub-packet; so we have to remember it in a state variable. */ | |
3348 | ||
3349 | if (*request == 'R' || *request == 'M' || *request == 'X') | |
3350 | { | |
3351 | if (handle_format (&request, &tempfmt1)) | |
3352 | return "E16"; | |
3353 | if (doing_step_formats) | |
3354 | tdp_temp.tp_format_p = tempfmt1.id; | |
3355 | else | |
3356 | tdp_temp.tdp_format_p = tempfmt1.id; | |
3357 | } | |
3358 | ||
3359 | /* When we see the "S" token, we remember it in a state variable | |
3360 | (in case the packet is split up and continued in another message), | |
3361 | and discard all current state from the collection "format". */ | |
3362 | if (*request == 'S') | |
3363 | { | |
3364 | doing_step_formats = TRUE; | |
3365 | /* discard prev format and start a new one */ | |
3366 | memset ((char *) &tempfmt1, 0, sizeof (tempfmt1)); | |
3367 | request++; | |
3368 | ||
3369 | /* Having seen the "S" fencepost, it is now possible that | |
3370 | we will see some more collection descriptors pertaining | |
3371 | to the stepping collection. */ | |
3372 | if (*request == 'R' || *request == 'M' || *request == 'X') | |
3373 | { | |
3374 | if (handle_format (&request, &tempfmt1)) | |
3375 | return "E17"; | |
3376 | /* new format ID is tp_format */ | |
3377 | tdp_temp.tp_format_p = tempfmt1.id; | |
3378 | } | |
3379 | } | |
3380 | ||
3381 | if (*request == '-') /* this TDP definition will be continued. */ | |
3382 | sprintp (retbuf, "OK"); | |
3383 | else if (enable == 'E') /* end of TDP definition: pass to ADBG (if enabled!) */ | |
3384 | { | |
3385 | gdb_note ("STUB: call define_tdp (id %d, ", tdp_temp.id); | |
3386 | gdb_note ("addr 0x%X, ", (int) tdp_temp.addr); | |
3387 | gdb_note ("passc %d, ", tdp_temp.pass_limit); | |
3388 | gdb_note ("stepc %d, ", tdp_temp.stepcount); | |
3389 | gdb_note ("TDP fmt #%d, ", tdp_temp.tdp_format_p); | |
3390 | gdb_note ("TP fmt #%d);\n", tdp_temp.tp_format_p); | |
3391 | ||
3392 | ret = define_tdp (tdp_temp.id, &tdp_temp, 0); | |
3393 | ||
3394 | if (ret == OK_TARGET_RESPONSE) | |
3395 | { | |
3396 | sprintp (retbuf, "OK"); | |
3397 | } | |
3398 | else | |
3399 | { | |
3400 | sprintp (spare_buffer, | |
3401 | "'define_tdp' returned DTC error '%s' for tracepoint %d.\n", | |
3402 | get_err_text (ret), | |
3403 | tdp_temp.id); | |
3404 | gdb_puts (spare_buffer); | |
3405 | sprintp (retbuf, "E2%x", ret); | |
3406 | } | |
3407 | /* Redundant, but let's try to make sure this state gets discarded. */ | |
3408 | { | |
3409 | memset ((char *) &tdp_temp, 0, sizeof (tdp_temp)); | |
3410 | memset ((char *) &tempfmt1, 0, sizeof (tempfmt1)); | |
3411 | } | |
3412 | } | |
3413 | else /* ADBG_DTC does not support disabled tracepoints -- ignore it. */ | |
3414 | gdb_note ("STUB: ignoring disabled tracepoint %d.\n", tdp_temp.id); | |
3415 | ||
3416 | return retbuf; | |
3417 | } | |
3418 | else if (msgcmp (&request, "Frame:")) | |
3419 | { | |
3420 | ret = OK_TARGET_RESPONSE; | |
3421 | ||
3422 | if (msgcmp (&request, "pc:")) | |
3423 | { | |
3424 | if (!hexToInt (&request, &pc)) | |
3425 | return "E10"; /* badly formed packet */ | |
3426 | n_frame = curframe.valid ? curframe.frame_id + 1 : 0; | |
3427 | gdb_note ("STUB: call fetch_trace_frame_pc (id %d, ", n_frame); | |
3428 | gdb_note ("pc 0x%X);\n", pc); | |
3429 | ret = fetch_trace_frame_with_pc (&n_frame, | |
3430 | (void *) pc, | |
3431 | &curframe.format, | |
3432 | &curframe.frame_data); | |
3433 | } | |
3434 | else if (msgcmp (&request, "tdp:")) | |
3435 | { | |
3436 | if (!hexToInt (&request, &tdp)) | |
3437 | return "E10"; /* badly formed packet */ | |
3438 | n_frame = curframe.valid ? curframe.frame_id + 1: 0; | |
3439 | gdb_note ("STUB: call fetch_trace_frame_tdp (id %d, ", n_frame); | |
3440 | gdb_note ("tdp 0x%X);\n", tdp); | |
3441 | ret = fetch_trace_frame_with_tdp (&n_frame, | |
3442 | tdp, | |
3443 | &curframe.format, | |
3444 | &curframe.frame_data); | |
3445 | } | |
3446 | else if (msgcmp (&request, "range:")) | |
3447 | { | |
3448 | if (!(hexToInt (&request, &start) && | |
3449 | *request++ == ':')) | |
3450 | return "E11"; /* badly formed packet, field 1 */ | |
3451 | else if (!hexToInt (&request, &stop)) | |
3452 | return "E12"; /* badly formed packet, field 2 */ | |
3453 | n_frame = curframe.valid ? curframe.frame_id + 1: 0; | |
3454 | gdb_note ("STUB: call fetch_trace_frame_range (id %d, ", n_frame); | |
3455 | gdb_note ("start 0x%X, ", start); | |
3456 | gdb_note ("stop 0x%X);\n", stop); | |
3457 | ret = fetch_trace_frame_with_pc_in_range (&n_frame, | |
3458 | (void *) start, | |
3459 | (void *) stop, | |
3460 | &curframe.format, | |
3461 | &curframe.frame_data); | |
3462 | } | |
3463 | else if (msgcmp (&request, "outside:")) | |
3464 | { | |
3465 | if (!(hexToInt (&request, &start) && | |
3466 | *request++ == ':')) | |
3467 | return "E11"; /* badly formed packet, field 1 */ | |
3468 | else if (!hexToInt (&request, &stop)) | |
3469 | return "E12"; /* badly formed packet, field 2 */ | |
3470 | n_frame = curframe.valid ? curframe.frame_id + 1: 0; | |
3471 | gdb_note ("STUB: call fetch_trace_frame_outside (id %d, ", n_frame); | |
3472 | gdb_note ("start 0x%X, ", start); | |
3473 | gdb_note ("stop 0x%X);\n", stop); | |
3474 | ret = fetch_trace_frame_with_pc_outside (&n_frame, | |
3475 | (void *) start, | |
3476 | (void *) stop, | |
3477 | &curframe.format, | |
3478 | &curframe.frame_data); | |
3479 | } | |
3480 | else /* simple TFind by frame number: */ | |
3481 | { | |
3482 | if (!hexToInt (&request, &frameno)) | |
3483 | return "E10"; /* badly formed packet */ | |
3484 | if (frameno != (unsigned long) -1) | |
3485 | { | |
3486 | gdb_note ("STUB: call fetch_trace_frame (id %d);\n", frameno); | |
3487 | ret = fetch_trace_frame (n_frame = frameno, | |
3488 | &curframe.format, | |
3489 | &curframe.frame_data); | |
3490 | #if 0 | |
3491 | printp("STUB: fetch_trace_frame: return %d\n", ret); | |
3492 | #endif | |
3493 | } | |
3494 | else /* discard any trace frame, debug "the real world" */ | |
3495 | { | |
3496 | if (curframe.valid) | |
3497 | gdb_note ("STUB: discard current trace frame #%d.\n", | |
3498 | curframe.frame_id); | |
3499 | curframe.valid = 0; | |
3500 | return "OK"; | |
3501 | } | |
3502 | } | |
3503 | if (ret == OK_TARGET_RESPONSE) /* fetch_trace_frame succeeded */ | |
3504 | { /* setup for debugging the trace frame */ | |
3505 | curframe.valid = 1; | |
3506 | curframe.frame_id = n_frame; | |
3507 | curframe.tdp_id = curframe.frame_data->id; | |
3508 | ||
3509 | memset ((char *) &curframe.traceregs, 0, | |
3510 | sizeof (curframe.traceregs)); | |
3511 | curframe.traceregs[PC] = (unsigned long) | |
3512 | curframe.frame_data->program_counter; | |
3513 | ||
3514 | if (curframe.format) | |
3515 | { | |
3516 | unsigned long regs_mask = curframe.format->regs_mask; | |
3517 | unsigned long *regs, *stack, *mem; | |
3518 | unsigned long regno, index = 0; | |
3519 | CFD *dummy; | |
3520 | ||
3521 | if ((ret = get_addr_to_frame_regs_stack_mem | |
3522 | (curframe.frame_data, &dummy, ®s, &stack, &mem)) | |
3523 | != OK_TARGET_RESPONSE) | |
3524 | { | |
3525 | curframe.valid = 0; | |
3526 | sprintp (retbuf, "E2%x", ret); | |
3527 | return (char *) | |
3528 | dtc_error_ret ((int) &retbuf, | |
3529 | "get_addr_to_frame_regs_stack_mem", | |
3530 | ret); | |
3531 | } | |
3532 | ||
3533 | if (remote_debug > 1) | |
3534 | { /* echo what we've found to gdb console */ | |
3535 | sprintp (spare_buffer, | |
3536 | "STUB: Found frame %d, TDP %d, format %d (%s):\n", | |
3537 | curframe.frame_id, | |
3538 | curframe.tdp_id & 0x7fffffff, | |
3539 | curframe.format->id, | |
3540 | curframe.tdp_id & 0x80000000 ? | |
3541 | "trap frame" : "stepping frame"); | |
3542 | gdb_puts (spare_buffer); | |
3543 | } | |
3544 | /* copy trace frame regs into stub's data format */ | |
3545 | for (regno = 0, index = 0; | |
3546 | regno < 16; | |
3547 | regno++, regs_mask >>= 1) | |
3548 | if (regs_mask & 1) /* got a collected register */ | |
3549 | { | |
3550 | curframe.traceregs[regno] = regs[index++]; | |
3551 | if (remote_debug > 1) | |
3552 | { | |
3553 | sprintp (spare_buffer, | |
3554 | " Collected 0x%08x for register %d.\n", | |
3555 | curframe.traceregs[regno], regno); | |
3556 | gdb_puts (spare_buffer); | |
3557 | } | |
3558 | } | |
3559 | if (remote_debug > 1) | |
3560 | { | |
3561 | long midx, ridx, len; | |
3562 | MEMRANGE_DEF *mrange; | |
3563 | unsigned char *data, *base; | |
3564 | ||
3565 | if (curframe.format->stack_size > 0) | |
3566 | { | |
3567 | len = curframe.format->stack_size; | |
3568 | sprintp (spare_buffer, | |
3569 | " Collected %d bytes of stack at 0x%x:\n", | |
3570 | len, curframe.traceregs[A7]); | |
3571 | gdb_puts (spare_buffer); | |
3572 | ||
3573 | /* print stack data, but stay under msg len */ | |
3574 | if (len >= (NUMREGBYTES/2 - 2)) | |
3575 | len = (NUMREGBYTES/2 - 3); | |
3576 | mem2hex ((unsigned char *) stack, | |
3577 | spare_buffer, len, 0); | |
3578 | spare_buffer [len * 2] = '\n'; | |
3579 | spare_buffer [len * 2 + 1] = '\0'; /* EOS */ | |
3580 | gdb_puts (spare_buffer); | |
3581 | } | |
3582 | else | |
3583 | gdb_puts ("Stack not collected\n"); | |
3584 | ||
3585 | for (midx = 0; | |
3586 | get_addr_to_a_mem_range (curframe.frame_data, | |
3587 | midx, | |
3588 | &mrange, | |
3589 | (void **) &data) | |
3590 | == OK_TARGET_RESPONSE; | |
3591 | midx++) | |
3592 | { | |
3593 | if ((mrange->typecode == 0) || | |
3594 | (mrange->typecode == (unsigned long) -1)) | |
3595 | { | |
3596 | sprintp (spare_buffer, | |
3597 | " Collected %d bytes at MEM: 0x%x:\n", | |
3598 | mrange->size, mrange->offset); | |
3599 | base = (unsigned char *) mrange->offset; | |
3600 | } | |
3601 | else | |
3602 | { | |
3603 | if ((ridx = elinum_to_index (mrange->typecode)) > 0) | |
3604 | base = (unsigned char *) curframe.traceregs[ridx] | |
3605 | + (long) mrange->offset; | |
3606 | else | |
3607 | { | |
3608 | sprintp (spare_buffer, | |
3609 | "STUB: bad typecode in memrange #%d: (0x%x,0x%x,0x%x).\n", | |
3610 | midx, | |
3611 | mrange->typecode, | |
3612 | mrange->offset, | |
3613 | mrange->size); | |
3614 | gdb_puts (spare_buffer); | |
3615 | continue; | |
3616 | } | |
3617 | sprintp (spare_buffer, | |
3618 | " Collected %d bytes at 0x%x (REG %X + %d):\n", | |
3619 | mrange->size, | |
3620 | base, | |
3621 | mrange->typecode, | |
3622 | mrange->offset); | |
3623 | } | |
3624 | gdb_puts (spare_buffer); | |
3625 | len = mrange->size; | |
3626 | if (len >= (NUMREGBYTES/2 - 2)) | |
3627 | len = (NUMREGBYTES/2 - 3); | |
3628 | mem2hex (data, spare_buffer, len, 0); | |
3629 | spare_buffer [len * 2] = '\n'; | |
3630 | spare_buffer [len * 2 + 1] = '\0'; /* EOS */ | |
3631 | gdb_puts (spare_buffer); | |
3632 | } | |
3633 | } | |
3634 | } | |
3635 | sprintp (retbuf, "F%xT%x", n_frame, curframe.tdp_id & 0x7fffffff); | |
3636 | return retbuf; | |
3637 | } | |
3638 | else if (ret == NOT_FOUND_TARGET_RESPONSE) | |
3639 | { | |
3640 | /* Here's a question: if the fetch_trace_frame call failed | |
3641 | (which probably means a bad "TFIND" command from GDB), | |
3642 | should we remain focused on the previous frame (if any), | |
3643 | or should we revert to "no current frame"? | |
3644 | */ | |
3645 | return "F-1"; | |
3646 | } | |
3647 | else | |
3648 | { | |
3649 | sprintp (retbuf, "E2%x", ret); | |
3650 | return (char *) dtc_error_ret ((int) &retbuf, | |
3651 | "fetch_trace_frame[...]", | |
3652 | ret); | |
3653 | } | |
3654 | } | |
3655 | else /* unknown trace command */ | |
3656 | { | |
3657 | return ""; | |
3658 | } | |
3659 | } | |
3660 | ||
3661 | /* Table used by the crc32 function to calcuate the checksum. */ | |
3662 | static unsigned long crc32_table[256]; | |
3663 | ||
3664 | static int crc_mem_err; | |
3665 | ||
3666 | static unsigned long | |
3667 | crc32 (buf, len, crc) | |
3668 | unsigned char *buf; | |
3669 | int len; | |
3670 | unsigned long crc; | |
3671 | { | |
3672 | crc_mem_err = FALSE; | |
3673 | ||
3674 | if (! crc32_table[1]) | |
3675 | { | |
3676 | /* Initialize the CRC table and the decoding table. */ | |
3677 | int i, j; | |
3678 | unsigned int c; | |
3679 | ||
3680 | for (i = 0; i < 256; i++) | |
3681 | { | |
3682 | for (c = i << 24, j = 8; j > 0; --j) | |
3683 | c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1); | |
3684 | crc32_table[i] = c; | |
3685 | } | |
3686 | } | |
3687 | ||
3688 | while (len--) | |
3689 | { | |
3690 | if (read_access_violation (buf)) | |
3691 | { | |
3692 | crc_mem_err = TRUE; | |
3693 | return -1; | |
3694 | } | |
3695 | crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buf++) & 255]; | |
3696 | } | |
3697 | return crc; | |
3698 | } | |
3699 | ||
3700 | static char * | |
3701 | crc_query (cmd) | |
3702 | char *cmd; | |
3703 | { | |
3704 | unsigned long startmem, len, crc; | |
3705 | static char buf[32]; | |
3706 | ||
3707 | if (hexToInt (&cmd, &startmem) && | |
3708 | *cmd++ == ',' && | |
3709 | hexToInt (&cmd, &len)) | |
3710 | { | |
3711 | crc = crc32 ((unsigned char *) startmem, len, 0xffffffff); | |
3712 | if (!crc_mem_err) | |
3713 | { | |
3714 | sprintp (buf, "C%08x", crc); | |
3715 | return buf; | |
3716 | } | |
3717 | /* else error, fall thru */ | |
3718 | } | |
3719 | sprintp (buf, "E01"); | |
3720 | return buf; | |
3721 | } | |
3722 | ||
3723 | ||
3724 | static char * | |
3725 | handle_test (request) | |
3726 | char *request; | |
3727 | { | |
3728 | ULONG args[7]; | |
3729 | int i; | |
3730 | ||
3731 | /* Parse the arguments, a comma-separated list of hex numbers, into | |
3732 | ARGS. Parse at most six arguments. */ | |
3733 | i = 1; | |
3734 | if (*request != '\0') | |
3735 | while (i < 7) | |
3736 | { | |
3737 | if (! hexToInt (&request, &args[i++])) | |
3738 | return "E01"; | |
3739 | if (*request == '\0') | |
3740 | break; | |
3741 | if (*request++ != ',') | |
3742 | return "E01"; | |
3743 | } | |
3744 | ||
3745 | /* Fill the rest of the args array with zeros. This is what the | |
3746 | INLINES command processor does with omitted arguments. */ | |
3747 | for (; i < 7; i++) | |
3748 | args[i] = 0; | |
3749 | ||
3750 | gdb_c_test (args); | |
3751 | ||
3752 | return "OK"; | |
3753 | } | |
3754 | ||
3755 | ||
3756 | /* GDB_TRAP_1_HANDLER | |
3757 | ||
3758 | By the time this is called, the registers have been saved in "registers", | |
3759 | and the interrupt priority has been set to permit serial UART interrupts. | |
3760 | ||
3761 | However, since no gdb request has yet been received, and there is no | |
3762 | equivalent of getpacket for us to wait on, we can't sit here waiting | |
3763 | for packets and processing them. | |
3764 | ||
3765 | In fact, the ONLY thing for us to do here is sit and wait. | |
3766 | As gdb sends packet requests, they will handle themselves at the | |
3767 | interrupt level. When gdb decides we can continue, it will reset | |
3768 | the global variable "gdb_handling_trap1", and we will return | |
3769 | (whereupon registers will be restored etc.) */ | |
3770 | ||
3771 | void gdb_trap_1_handler( void ) | |
3772 | { | |
3773 | gdb_handling_trap1 = TRUE; | |
3774 | sss_trace_flag = '\0'; /* shut off "trace bit" (indirectly) */ | |
3775 | gdb_signo = 5; | |
3776 | putpacket( "S05" ); | |
3777 | while ( gdb_handling_trap1 ) | |
3778 | ; | |
3779 | return; | |
3780 | } | |
3781 | ||
3782 | void gdb_trace_handler( void ) | |
3783 | { | |
3784 | sss_trace_flag = '\0'; /* shut off "trace bit" (indirectly) */ | |
3785 | gdb_handling_trap1 = TRUE; | |
3786 | gdb_handling_sstrace = TRUE; | |
3787 | gdb_signo = 5; | |
3788 | putpacket( "S05" ); | |
3789 | while ( gdb_handling_trap1 ) | |
3790 | ; | |
3791 | return; | |
3792 | } |