OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [testsuite/] [gdb.trace/] [gdb_c_test.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
/*
2
 ******************************************************************************
3
 ******************************************************************************
4
 *
5
 * COPYRIGHT (C) by EMC Corporation, 1997 All rights reserved.
6
 * $Id: gdb_c_test.c,v 1.1.1.1 2001-05-18 11:18:40 markom Exp $
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";
500
   char *rediculously_long_variable_name_with_equally_long_string_assignment;
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
 
507
   rediculously_long_variable_name_with_equally_long_string_assignment =
508
     "rediculously long variable name with equally long string assignment";
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: gdb_c_test.c,v 1.1.1.1 2001-05-18 11:18:40 markom Exp $\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 *) &regs,
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);
2545
          length = mem_size - (mem - mem_addr);;
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, &regno ) && *(request++) == '=' )
2755
            {
2756
              if ( regno < NUMREGS )
2757
                {
2758
                  hexToInt( &request,
2759
                           (unsigned long *) &registers[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, &regnum);
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, &regs, &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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.