[444] | 1 | /* -*-C-*- |
---|
| 2 | ******************************************************************************* |
---|
| 3 | * |
---|
| 4 | * File: pa_stub.c |
---|
| 5 | * RCS: $Header$ |
---|
| 6 | * Description: main routines for PA RISC monitor stub |
---|
| 7 | * Author: Robert Quist |
---|
| 8 | * Created: Mon Nov 1 10:00:36 1993 |
---|
| 9 | * Modified: Fri Nov 12 15:14:23 1993 (Robert Quist) quist@hpfcrdq |
---|
| 10 | * Language: C |
---|
| 11 | * Package: N/A |
---|
| 12 | * Status: Experimental (Do Not Distribute) |
---|
| 13 | * |
---|
| 14 | ******************************************************************************* |
---|
| 15 | */ |
---|
| 16 | |
---|
| 17 | /**************************************************************************** |
---|
| 18 | |
---|
| 19 | THIS SOFTWARE IS NOT COPYRIGHTED |
---|
| 20 | |
---|
| 21 | HP offers the following for use in the public domain. HP makes no |
---|
| 22 | warranty with regard to the software or it's performance and the |
---|
| 23 | user accepts the software "AS IS" with all faults. |
---|
| 24 | |
---|
| 25 | HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD |
---|
| 26 | TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES |
---|
| 27 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. |
---|
| 28 | |
---|
| 29 | ****************************************************************************/ |
---|
| 30 | |
---|
| 31 | /**************************************************************************** |
---|
| 32 | * |
---|
| 33 | * Description: low level support for gdb debugger. $ |
---|
| 34 | * |
---|
| 35 | * Considerations: only works on target hardware $ |
---|
| 36 | * |
---|
| 37 | * NOTES: See Below $ |
---|
| 38 | * |
---|
| 39 | * To enable debugger support, two things need to happen. |
---|
| 40 | * |
---|
| 41 | * One, a call to set_debug_traps() is necessary in order to allow |
---|
| 42 | * any breakpoints or error conditions to be properly intercepted and |
---|
| 43 | * reported to gdb. |
---|
| 44 | * |
---|
| 45 | * Two, a breakpoint needs to be generated to begin communication. |
---|
| 46 | * This is most easily accomplished by a call to breakpoint(). |
---|
| 47 | * breakpoint() simulates a breakpoint |
---|
| 48 | |
---|
| 49 | |
---|
| 50 | ************* |
---|
| 51 | * |
---|
| 52 | * The following gdb commands are supported: |
---|
| 53 | * |
---|
| 54 | * command function Return value |
---|
| 55 | * |
---|
| 56 | * g return the value of the CPU registers hex data or ENN |
---|
| 57 | * G set the value of the CPU registers OK or ENN |
---|
| 58 | * |
---|
| 59 | * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN |
---|
| 60 | * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN |
---|
| 61 | * |
---|
| 62 | * c Resume at current address SNN ( signal NN) |
---|
| 63 | * cAA..AA Continue at address AA..AA SNN |
---|
| 64 | * |
---|
| 65 | * s Step one instruction SNN |
---|
| 66 | * sAA..AA Step one instruction from AA..AA SNN |
---|
| 67 | * |
---|
| 68 | * k kill |
---|
| 69 | * |
---|
| 70 | * ? What was the last sigval ? SNN (signal NN) |
---|
| 71 | * |
---|
| 72 | * bBB..BB Set baud rate to BB..BB OK or BNN, then sets |
---|
| 73 | * baud rate |
---|
| 74 | * |
---|
| 75 | |
---|
| 76 | ************ |
---|
| 77 | * All commands and responses are sent with a packet which includes a |
---|
| 78 | * checksum. A packet consists of : |
---|
| 79 | * |
---|
| 80 | * $<packet info>#<checksum>. |
---|
| 81 | * |
---|
| 82 | * where |
---|
| 83 | * <packet info> :: <characters representing the command or response> |
---|
| 84 | * <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>> |
---|
| 85 | * |
---|
| 86 | * When a packet is received, it is first acknowledged with either '+' or '-'. |
---|
| 87 | * '+' indicates a successful transfer. '-' indicates a failed transfer. |
---|
| 88 | * |
---|
| 89 | * Example: |
---|
| 90 | * |
---|
| 91 | * Host: Reply: |
---|
| 92 | * $m0,10#2a +$00010203040506070809101112131415#42 |
---|
| 93 | * |
---|
| 94 | ****************************************************************************/ |
---|
| 95 | #include <signal.h> |
---|
| 96 | #include "hppa-defs.h" |
---|
| 97 | |
---|
| 98 | /************************************************************************ |
---|
| 99 | * |
---|
| 100 | * external low-level support |
---|
| 101 | */ |
---|
| 102 | #define OPT_PDC_CACHE 5 |
---|
| 103 | #define OPT_PDC_ADD_VALID 12 |
---|
| 104 | #define PGZ_MEM_PDC 0x0388 /* location of PDC_ENTRY in memory */ |
---|
| 105 | #define CALL_PDC (*(int (*)())((int *)(*((int *)PGZ_MEM_PDC)))) |
---|
| 106 | |
---|
| 107 | extern putDebugChar(); /* write a single character */ |
---|
| 108 | extern getDebugChar(); /* read and return a single char */ |
---|
| 109 | extern FICE(); /* flush i cache entry */ |
---|
| 110 | extern INLINE_BREAK(); /* break for user call */ |
---|
| 111 | |
---|
| 112 | #define RADDR_ALIGN(s,r) (s = ((unsigned int *) ((((int) r ) + 7 ) & 0xFFFFFFF8))) |
---|
| 113 | |
---|
| 114 | /************************************************************************/ |
---|
| 115 | /* BUFMAX defines the maximum number of characters in inbound/outbound buffers*/ |
---|
| 116 | /* at least NUMREGBYTES*2 are needed for register packets */ |
---|
| 117 | |
---|
| 118 | #define BUFMAX 2048 |
---|
| 119 | |
---|
| 120 | #define NUMGPRS 32 |
---|
| 121 | #define NUMSRS 8 |
---|
| 122 | #define NUMCRS 32 |
---|
| 123 | #define NUMSPCLS 3 |
---|
| 124 | #define NUMFPRS 32 |
---|
| 125 | |
---|
| 126 | #define NUMGPRBYTES 4 |
---|
| 127 | #define NUMSRBYTES 4 |
---|
| 128 | #define NUMCRBYTES 4 |
---|
| 129 | #define NUMSPCLBYTES 4 |
---|
| 130 | #define NUMFPRBYTES 8 |
---|
| 131 | |
---|
| 132 | /* Number of bytes of registers. */ |
---|
| 133 | #define NUMREGBYTES \ |
---|
| 134 | ( (NUMGPRS * NUMGPRBYTES) \ |
---|
| 135 | + (NUMSRS * NUMSRBYTES) \ |
---|
| 136 | + (NUMCRS * NUMCRBYTES) \ |
---|
| 137 | + (NUMSPCLS * NUMSPCLBYTES) \ |
---|
| 138 | + (NUMFPRS * NUMFPRBYTES) \ |
---|
| 139 | ) |
---|
| 140 | |
---|
| 141 | |
---|
| 142 | enum regnames {GR0, GR1, GR2, GR3, GR4, GR5, GR6, GR7, |
---|
| 143 | GR8, GR9, GR10, GR11, GR12, GR13, GR14, GR15, |
---|
| 144 | GR16, GR17, GR18, GR19, GR20, GR21, GR22, GR23, |
---|
| 145 | GR24, GR25, GR26, GR27, GR28, GR29, GR30, GR31, |
---|
| 146 | |
---|
| 147 | SR0, SR1, SR2, SR3, SR4, SR5, SR6, SR7, |
---|
| 148 | |
---|
| 149 | CR0, CR1, CR2, CR3, CR4, CR5, CR6, CR7, |
---|
| 150 | CR8, CR9, CR10, CR11, CR12, CR13, CR14, CR15, |
---|
| 151 | CR16, CR17H,CR18H,CR19, CR20, CR21, CR22, CR23, |
---|
| 152 | CR24, CR25, CR26, CR27, CR28, CR29, CR30, CR31, |
---|
| 153 | |
---|
| 154 | CR17T,CR18T,CPUD0 }; |
---|
| 155 | |
---|
| 156 | enum fregnames {FPR0, FPR1, FPR2, FPR3, FPR4, FPR5, FPR6, FPR7, |
---|
| 157 | FPR8, FPR9, FPR10, FPR11, FPR12, FPR13, FPR14, FPR15, |
---|
| 158 | FPR16, FPR17, FPR18, FPR19, FPR20, FPR21, FPR22, FPR23, |
---|
| 159 | FPR24, FPR25, FPR26, FPR27, FPR28, FPR29, FPR30, FPR31 }; |
---|
| 160 | |
---|
| 161 | #define PC CR18H |
---|
| 162 | #define NPC CR18T |
---|
| 163 | #define SP GR30 |
---|
| 164 | |
---|
| 165 | struct registers { |
---|
| 166 | int intregs[NUMGPRS + NUMSRS + NUMCRS + NUMSPCLS]; |
---|
| 167 | int fpregs [NUMFPRS * 2]; |
---|
| 168 | }; |
---|
| 169 | /* Global Variables */ |
---|
| 170 | |
---|
| 171 | static int initialized = 0; /* !0 means we've been initialized */ |
---|
| 172 | static unsigned char hexchars[]="0123456789abcdef"; |
---|
| 173 | static unsigned char remcomInBuffer[BUFMAX]; |
---|
| 174 | static unsigned char remcomOutBuffer[BUFMAX]; |
---|
| 175 | static unsigned int i_cache_params[6]; |
---|
| 176 | |
---|
| 177 | /* This table contains the mapping between PA hardware exception |
---|
| 178 | types, and signals, which are primarily what GDB understands. It also |
---|
| 179 | indicates which hardware traps we need to commandeer when initializing |
---|
| 180 | the stub. |
---|
| 181 | |
---|
| 182 | The only two currently used are Recovery counter (single stepping) |
---|
| 183 | and Break trap ( break points ). |
---|
| 184 | */ |
---|
| 185 | |
---|
| 186 | static struct hard_trap_info |
---|
| 187 | { |
---|
| 188 | unsigned char tt; /* Trap number for PA-RISC */ |
---|
| 189 | unsigned char signo; /* Signal that we map this trap into */ |
---|
| 190 | } hard_trap_info[] = { |
---|
| 191 | /* 1 High priority machine check */ |
---|
| 192 | /* 2 Power failure interrupt*/ |
---|
| 193 | /* 3 Recovery counter -- init */ |
---|
| 194 | /* 4 External interrupt */ |
---|
| 195 | /* 5 Low priority machine check */ |
---|
| 196 | {6, SIGSEGV}, /* Instruction TLB miss/page fault */ |
---|
| 197 | {7, SIGSEGV}, /* Memory protection */ |
---|
| 198 | {8, SIGILL}, /* Illegal instruction */ |
---|
| 199 | {9, SIGTRAP}, /* Break instruction -- init */ |
---|
| 200 | {10,SIGILL}, /* Privileged instruction */ |
---|
| 201 | {11,SIGILL}, /* Privileged register */ |
---|
| 202 | {12,SIGUSR1}, /* Overflow */ |
---|
| 203 | {13,SIGUSR2}, /* Conditional */ |
---|
| 204 | {14,SIGEMT}, /* Assist Exception */ |
---|
| 205 | {15,SIGSEGV}, /* Data TLB miss/page fault */ |
---|
| 206 | {16,SIGSEGV}, /* Non-access Instruction TLB miss */ |
---|
| 207 | {17,SIGSEGV}, /* Non-access Data TLB miss/page fault */ |
---|
| 208 | {18,SIGSEGV}, /* Data memory protection/ unaligned data reference */ |
---|
| 209 | {19,SIGTRAP}, /* Data memory break */ |
---|
| 210 | {20,SIGSEGV}, /* TLB dirty bit */ |
---|
| 211 | {21,SIGSEGV}, /* Page reference */ |
---|
| 212 | {22,SIGEMT}, /* Assist emulation */ |
---|
| 213 | {23,SIGILL}, /* Higher-privilege */ |
---|
| 214 | {24,SIGILL}, /* Lower-privilege */ |
---|
| 215 | {25,SIGTRAP}, /* Taken branch */ |
---|
| 216 | {0, 0} /* Must be last */ |
---|
| 217 | }; |
---|
| 218 | |
---|
| 219 | /* Functions */ |
---|
| 220 | /*========================================================================== */ |
---|
| 221 | |
---|
| 222 | /* Convert ch from a hex digit to an int */ |
---|
| 223 | |
---|
| 224 | static int |
---|
| 225 | hex(ch) |
---|
| 226 | unsigned char ch; |
---|
| 227 | { |
---|
| 228 | if (ch >= 'a' && ch <= 'f') |
---|
| 229 | return ch-'a'+10; |
---|
| 230 | if (ch >= '0' && ch <= '9') |
---|
| 231 | return ch-'0'; |
---|
| 232 | if (ch >= 'A' && ch <= 'F') |
---|
| 233 | return ch-'A'+10; |
---|
| 234 | return -1; |
---|
| 235 | } |
---|
| 236 | |
---|
| 237 | /* scan for the sequence $<data>#<checksum> */ |
---|
| 238 | |
---|
| 239 | static void |
---|
| 240 | getpacket(buffer) |
---|
| 241 | char *buffer; |
---|
| 242 | { |
---|
| 243 | unsigned char checksum; |
---|
| 244 | unsigned char xmitcsum; |
---|
| 245 | int i; |
---|
| 246 | int count; |
---|
| 247 | unsigned char ch; |
---|
| 248 | |
---|
| 249 | do |
---|
| 250 | { |
---|
| 251 | /* wait around for the start character, ignore all other characters */ |
---|
| 252 | strobe(); |
---|
| 253 | while ((ch = getDebugChar()) != '$') ; |
---|
| 254 | |
---|
| 255 | checksum = 0; |
---|
| 256 | xmitcsum = -1; |
---|
| 257 | |
---|
| 258 | count = 0; |
---|
| 259 | |
---|
| 260 | /* now, read until a # or end of buffer is found */ |
---|
| 261 | while (count < BUFMAX) |
---|
| 262 | { |
---|
| 263 | ch = getDebugChar(); |
---|
| 264 | if (ch == '#') |
---|
| 265 | break; |
---|
| 266 | checksum = checksum + ch; |
---|
| 267 | buffer[count] = ch; |
---|
| 268 | count = count + 1; |
---|
| 269 | } |
---|
| 270 | |
---|
| 271 | if (count >= BUFMAX) |
---|
| 272 | continue; |
---|
| 273 | |
---|
| 274 | buffer[count] = 0; |
---|
| 275 | |
---|
| 276 | if (ch == '#') |
---|
| 277 | { |
---|
| 278 | xmitcsum = hex(getDebugChar()) << 4; |
---|
| 279 | xmitcsum |= hex(getDebugChar()); |
---|
| 280 | |
---|
| 281 | #if TESTING |
---|
| 282 | /* Humans shouldn't have to figure out checksums to type to it. */ |
---|
| 283 | putDebugChar ('+'); |
---|
| 284 | return; |
---|
| 285 | #endif |
---|
| 286 | if (checksum != xmitcsum) |
---|
| 287 | putDebugChar('-'); /* failed checksum */ |
---|
| 288 | else |
---|
| 289 | { |
---|
| 290 | putDebugChar('+'); /* successful transfer */ |
---|
| 291 | /* if a sequence char is present, reply the sequence ID */ |
---|
| 292 | if (buffer[2] == ':') |
---|
| 293 | { |
---|
| 294 | putDebugChar(buffer[0]); |
---|
| 295 | putDebugChar(buffer[1]); |
---|
| 296 | /* remove sequence chars from buffer */ |
---|
| 297 | count = strlen(buffer); |
---|
| 298 | for (i=3; i <= count; i++) |
---|
| 299 | buffer[i-3] = buffer[i]; |
---|
| 300 | } |
---|
| 301 | } |
---|
| 302 | } |
---|
| 303 | } |
---|
| 304 | while (checksum != xmitcsum); |
---|
| 305 | } |
---|
| 306 | |
---|
| 307 | /* send the packet in buffer. */ |
---|
| 308 | |
---|
| 309 | static void |
---|
| 310 | putpacket(buffer) |
---|
| 311 | unsigned char *buffer; |
---|
| 312 | { |
---|
| 313 | unsigned char checksum; |
---|
| 314 | int count; |
---|
| 315 | unsigned char ch; |
---|
| 316 | |
---|
| 317 | /* $<packet info>#<checksum>. */ |
---|
| 318 | |
---|
| 319 | do |
---|
| 320 | { |
---|
| 321 | putDebugChar('$'); |
---|
| 322 | checksum = 0; |
---|
| 323 | count = 0; |
---|
| 324 | |
---|
| 325 | while (ch = buffer[count]) |
---|
| 326 | { |
---|
| 327 | if (! putDebugChar(ch)) |
---|
| 328 | return; |
---|
| 329 | checksum += ch; |
---|
| 330 | count += 1; |
---|
| 331 | } |
---|
| 332 | |
---|
| 333 | putDebugChar('#'); |
---|
| 334 | putDebugChar(hexchars[checksum >> 4]); |
---|
| 335 | putDebugChar(hexchars[checksum & 0xf]); |
---|
| 336 | } while (getDebugChar() != '+'); |
---|
| 337 | } |
---|
| 338 | |
---|
| 339 | /* Convert the memory pointed to by mem into hex, placing result in buf. |
---|
| 340 | * Return a pointer to the last char put in buf (null), in case of mem fault, |
---|
| 341 | * return 0. |
---|
| 342 | * If MAY_FAULT is non-zero, then we will handle memory faults by returning |
---|
| 343 | * a 0, else treat a fault like any other fault in the stub. |
---|
| 344 | */ |
---|
| 345 | |
---|
| 346 | static unsigned char * |
---|
| 347 | mem2hex(mem, buf, count, may_fault) |
---|
| 348 | unsigned char *mem; |
---|
| 349 | unsigned char *buf; |
---|
| 350 | int count; |
---|
| 351 | int may_fault; |
---|
| 352 | { |
---|
| 353 | unsigned char ch; |
---|
| 354 | int check_addr, |
---|
| 355 | new_addr; |
---|
| 356 | |
---|
| 357 | check_addr = 0; |
---|
| 358 | |
---|
| 359 | while (count-- > 0) |
---|
| 360 | { |
---|
| 361 | if (may_fault) |
---|
| 362 | { new_addr = ((int) (mem+3)) & 0xFFFFFFF8; |
---|
| 363 | if (new_addr != check_addr) |
---|
| 364 | { check_addr = new_addr; |
---|
| 365 | if (pdc_call(OPT_PDC_ADD_VALID,0,check_addr)) return 0; |
---|
| 366 | } |
---|
| 367 | } |
---|
| 368 | ch = *mem++; |
---|
| 369 | *buf++ = hexchars[ch >> 4]; |
---|
| 370 | *buf++ = hexchars[ch & 0xf]; |
---|
| 371 | } |
---|
| 372 | |
---|
| 373 | *buf = 0; |
---|
| 374 | |
---|
| 375 | return buf; |
---|
| 376 | } |
---|
| 377 | |
---|
| 378 | /* convert the hex array pointed to by buf into binary to be placed in mem |
---|
| 379 | * return a pointer to the character AFTER the last byte written */ |
---|
| 380 | |
---|
| 381 | static unsigned char * |
---|
| 382 | hex2mem(buf, mem, count, may_fault) |
---|
| 383 | unsigned char *buf; |
---|
| 384 | unsigned char *mem; |
---|
| 385 | int count; |
---|
| 386 | int may_fault; |
---|
| 387 | { |
---|
| 388 | int i; |
---|
| 389 | unsigned int ch; |
---|
| 390 | int check_addr, |
---|
| 391 | new_addr; |
---|
| 392 | |
---|
| 393 | check_addr = 0; |
---|
| 394 | |
---|
| 395 | for (i=0; i<count; i++) |
---|
| 396 | { |
---|
| 397 | ch = hex(*buf++) << 4; |
---|
| 398 | ch |= hex(*buf++); |
---|
| 399 | if (may_fault) |
---|
| 400 | { new_addr = ((int)(mem+3)) & 0xFFFFFFF8; |
---|
| 401 | if (new_addr != check_addr) |
---|
| 402 | { check_addr = new_addr; |
---|
| 403 | if (pdc_call(OPT_PDC_ADD_VALID,0,check_addr)) return 0; |
---|
| 404 | } |
---|
| 405 | } |
---|
| 406 | *mem++ = ch; |
---|
| 407 | } |
---|
| 408 | |
---|
| 409 | return mem; |
---|
| 410 | } |
---|
| 411 | |
---|
| 412 | /* Set up exception handlers for traceing and breakpoints */ |
---|
| 413 | |
---|
| 414 | void |
---|
| 415 | set_debug_traps() |
---|
| 416 | { |
---|
| 417 | unsigned int R_addr[33]; |
---|
| 418 | unsigned int *Raddr_ptr; |
---|
| 419 | |
---|
| 420 | setup_vectors(); |
---|
| 421 | |
---|
| 422 | /* get cache params for use by flush_i_cache */ |
---|
| 423 | RADDR_ALIGN(Raddr_ptr,R_addr); |
---|
| 424 | |
---|
| 425 | if (pdc_call(OPT_PDC_CACHE,0,Raddr_ptr,0)) |
---|
| 426 | i_cache_params[0] = -1; |
---|
| 427 | else |
---|
| 428 | i_cache_params[0] = R_addr[0]; |
---|
| 429 | |
---|
| 430 | i_cache_params[1] = Raddr_ptr[1]; |
---|
| 431 | i_cache_params[2] = Raddr_ptr[2]; |
---|
| 432 | i_cache_params[3] = Raddr_ptr[3]; |
---|
| 433 | i_cache_params[4] = Raddr_ptr[4]; |
---|
| 434 | i_cache_params[5] = Raddr_ptr[5]; |
---|
| 435 | |
---|
| 436 | /* In case GDB is started before us, ack any packets (presumably |
---|
| 437 | "$?#xx") sitting there. */ |
---|
| 438 | |
---|
| 439 | putDebugChar ('+'); |
---|
| 440 | |
---|
| 441 | initialized = 1; |
---|
| 442 | } |
---|
| 443 | |
---|
| 444 | |
---|
| 445 | /* Convert the PA-RISC hardware trap number to a unix signal number. */ |
---|
| 446 | |
---|
| 447 | static int |
---|
| 448 | computeSignal(tt) |
---|
| 449 | int tt; |
---|
| 450 | { |
---|
| 451 | struct hard_trap_info *ht; |
---|
| 452 | |
---|
| 453 | for (ht = hard_trap_info; ht->tt && ht->signo; ht++) |
---|
| 454 | if (ht->tt == tt) |
---|
| 455 | return ht->signo; |
---|
| 456 | |
---|
| 457 | return SIGHUP; /* default for things we don't know about */ |
---|
| 458 | } |
---|
| 459 | |
---|
| 460 | /* |
---|
| 461 | * While we find nice hex chars, build an int. |
---|
| 462 | * Return number of chars processed. |
---|
| 463 | */ |
---|
| 464 | |
---|
| 465 | static int |
---|
| 466 | hexToInt(ptr, intValue) |
---|
| 467 | unsigned char **ptr; |
---|
| 468 | int *intValue; |
---|
| 469 | { |
---|
| 470 | int numChars = 0; |
---|
| 471 | int hexValue; |
---|
| 472 | |
---|
| 473 | *intValue = 0; |
---|
| 474 | |
---|
| 475 | while (**ptr) |
---|
| 476 | { |
---|
| 477 | hexValue = hex(**ptr); |
---|
| 478 | if (hexValue < 0) |
---|
| 479 | break; |
---|
| 480 | |
---|
| 481 | *intValue = (*intValue << 4) | hexValue; |
---|
| 482 | numChars ++; |
---|
| 483 | |
---|
| 484 | (*ptr)++; |
---|
| 485 | } |
---|
| 486 | |
---|
| 487 | return (numChars); |
---|
| 488 | } |
---|
| 489 | |
---|
| 490 | void |
---|
| 491 | flush_i_cache() |
---|
| 492 | |
---|
| 493 | { |
---|
| 494 | unsigned int addr,count,loop; |
---|
| 495 | |
---|
| 496 | if (i_cache_params[0] <= 0) return; |
---|
| 497 | |
---|
| 498 | addr = i_cache_params[2]; |
---|
| 499 | for (count = 0; count < i_cache_params[4]; count++) |
---|
| 500 | { for ( loop = 0; loop < i_cache_params[5]; loop++) FICE(addr); |
---|
| 501 | addr = addr + i_cache_params[3]; |
---|
| 502 | } |
---|
| 503 | } |
---|
| 504 | |
---|
| 505 | /* |
---|
| 506 | * This function does all command procesing for interfacing to gdb. |
---|
| 507 | return of 0 will execute DEBUG_GO (continue) |
---|
| 508 | return of 1 will execute DEBUG_SS (single step) |
---|
| 509 | */ |
---|
| 510 | |
---|
| 511 | int |
---|
| 512 | handle_exception (registers,tt) |
---|
| 513 | unsigned long *registers; |
---|
| 514 | int tt; /* Trap type */ |
---|
| 515 | { |
---|
| 516 | int sigval; |
---|
| 517 | int addr; |
---|
| 518 | int length; |
---|
| 519 | unsigned char *ptr; |
---|
| 520 | |
---|
| 521 | /* reply to host that an exception has occurred */ |
---|
| 522 | sigval = computeSignal(tt); |
---|
| 523 | ptr = remcomOutBuffer; |
---|
| 524 | |
---|
| 525 | *ptr++ = 'T'; |
---|
| 526 | *ptr++ = hexchars[sigval >> 4]; |
---|
| 527 | *ptr++ = hexchars[sigval & 0xf]; |
---|
| 528 | |
---|
| 529 | /* could be lots of stuff here like PC and SP registers */ |
---|
| 530 | |
---|
| 531 | *ptr++ = 0; |
---|
| 532 | |
---|
| 533 | putpacket(remcomOutBuffer); |
---|
| 534 | |
---|
| 535 | while (1) |
---|
| 536 | { |
---|
| 537 | remcomOutBuffer[0] = 0; |
---|
| 538 | |
---|
| 539 | getpacket(remcomInBuffer); |
---|
| 540 | switch (remcomInBuffer[0]) |
---|
| 541 | { |
---|
| 542 | case '?': |
---|
| 543 | remcomOutBuffer[0] = 'S'; |
---|
| 544 | remcomOutBuffer[1] = hexchars[sigval >> 4]; |
---|
| 545 | remcomOutBuffer[2] = hexchars[sigval & 0xf]; |
---|
| 546 | remcomOutBuffer[3] = 0; |
---|
| 547 | break; |
---|
| 548 | |
---|
| 549 | case 'd': |
---|
| 550 | /* toggle debug flag */ |
---|
| 551 | led_putnum (16); |
---|
| 552 | break; |
---|
| 553 | |
---|
| 554 | case 'g': /* return the value of the CPU registers */ |
---|
| 555 | { |
---|
| 556 | ptr = remcomOutBuffer; |
---|
| 557 | /* GR0..GR31 SR0..SR7 CR0..CR31 specials */ |
---|
| 558 | ptr = mem2hex((char *)registers, ptr, NUMREGBYTES, 0); |
---|
| 559 | /* need to add floating point registers */ |
---|
| 560 | } |
---|
| 561 | break; |
---|
| 562 | |
---|
| 563 | case 'G': /* set the value of the CPU registers - return OK */ |
---|
| 564 | { |
---|
| 565 | ptr = &remcomInBuffer[1]; |
---|
| 566 | /* GR0..GR31 SR0..SR7 CR0..CR31 specials */ |
---|
| 567 | hex2mem(ptr, (char *)registers, NUMREGBYTES, 0); |
---|
| 568 | strcpy(remcomOutBuffer,"OK 1"); |
---|
| 569 | } |
---|
| 570 | break; |
---|
| 571 | |
---|
| 572 | case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */ |
---|
| 573 | /* Try to read %x,%x. */ |
---|
| 574 | |
---|
| 575 | ptr = &remcomInBuffer[1]; |
---|
| 576 | |
---|
| 577 | if (hexToInt(&ptr, &addr) |
---|
| 578 | && *ptr++ == ',' |
---|
| 579 | && hexToInt(&ptr, &length)) |
---|
| 580 | { |
---|
| 581 | if (mem2hex((char *)addr, remcomOutBuffer, length, 1)) |
---|
| 582 | break; |
---|
| 583 | |
---|
| 584 | strcpy (remcomOutBuffer, "E03"); |
---|
| 585 | } |
---|
| 586 | else |
---|
| 587 | strcpy(remcomOutBuffer,"E01"); |
---|
| 588 | break; |
---|
| 589 | |
---|
| 590 | case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */ |
---|
| 591 | /* Try to read '%x,%x:'. */ |
---|
| 592 | |
---|
| 593 | ptr = &remcomInBuffer[1]; |
---|
| 594 | |
---|
| 595 | if (hexToInt(&ptr, &addr) |
---|
| 596 | && *ptr++ == ',' |
---|
| 597 | && hexToInt(&ptr, &length) |
---|
| 598 | && *ptr++ == ':') |
---|
| 599 | { |
---|
| 600 | if (hex2mem(ptr, (char *)addr, length, 1)) |
---|
| 601 | strcpy(remcomOutBuffer, "OK"); |
---|
| 602 | else |
---|
| 603 | strcpy(remcomOutBuffer, "E03"); |
---|
| 604 | } |
---|
| 605 | else |
---|
| 606 | strcpy(remcomOutBuffer, "E02"); |
---|
| 607 | break; |
---|
| 608 | |
---|
| 609 | case 'c': /* cAA..AA Continue at address AA..AA(optional) */ |
---|
| 610 | /* try to read optional parameter, pc unchanged if no parm */ |
---|
| 611 | |
---|
| 612 | ptr = &remcomInBuffer[1]; |
---|
| 613 | if (hexToInt(&ptr, &addr)) |
---|
| 614 | { |
---|
| 615 | registers[PC] = addr; |
---|
| 616 | registers[NPC] = addr + 4; |
---|
| 617 | } |
---|
| 618 | |
---|
| 619 | /* Need to flush the instruction cache here, as we may have deposited a |
---|
| 620 | breakpoint, and the icache probably has no way of knowing that a data ref to |
---|
| 621 | some location may have changed something that is in the instruction cache. |
---|
| 622 | */ |
---|
| 623 | |
---|
| 624 | flush_i_cache(); |
---|
| 625 | return 0; /* execute GO */ |
---|
| 626 | |
---|
| 627 | /* kill the program */ |
---|
| 628 | case 'k' : /* do nothing */ |
---|
| 629 | break; |
---|
| 630 | |
---|
| 631 | case 's' : /* single step */ |
---|
| 632 | /* try to read optional parameter, pc unchanged if no parm */ |
---|
| 633 | |
---|
| 634 | ptr = &remcomInBuffer[1]; |
---|
| 635 | if (hexToInt(&ptr, &addr)) |
---|
| 636 | { |
---|
| 637 | registers[PC] = addr; |
---|
| 638 | registers[NPC] = addr + 4; |
---|
| 639 | } |
---|
| 640 | /* Need to flush the instruction cache here, as we may have deposited a |
---|
| 641 | breakpoint, and the icache probably has no way of knowing that a data ref to |
---|
| 642 | some location may have changed something that is in the instruction cache. |
---|
| 643 | */ |
---|
| 644 | flush_i_cache(); |
---|
| 645 | return 1; /* execute Single Step */ |
---|
| 646 | break; |
---|
| 647 | |
---|
| 648 | #if TESTING1 |
---|
| 649 | case 't': /* Test feature */ |
---|
| 650 | break; |
---|
| 651 | #endif |
---|
| 652 | case 'r': /* Reset */ |
---|
| 653 | break; |
---|
| 654 | |
---|
| 655 | #if TESTING2 |
---|
| 656 | Disabled until we can unscrew this properly |
---|
| 657 | |
---|
| 658 | case 'b': /* bBB... Set baud rate to BB... */ |
---|
| 659 | { |
---|
| 660 | int baudrate; |
---|
| 661 | extern void set_timer_3(); |
---|
| 662 | |
---|
| 663 | ptr = &remcomInBuffer[1]; |
---|
| 664 | if (!hexToInt(&ptr, &baudrate)) |
---|
| 665 | { |
---|
| 666 | strcpy(remcomOutBuffer,"B01"); |
---|
| 667 | break; |
---|
| 668 | } |
---|
| 669 | |
---|
| 670 | /* Convert baud rate to uart clock divider */ |
---|
| 671 | switch (baudrate) |
---|
| 672 | { |
---|
| 673 | case 38400: |
---|
| 674 | baudrate = 16; |
---|
| 675 | break; |
---|
| 676 | case 19200: |
---|
| 677 | baudrate = 33; |
---|
| 678 | break; |
---|
| 679 | case 9600: |
---|
| 680 | baudrate = 65; |
---|
| 681 | break; |
---|
| 682 | default: |
---|
| 683 | strcpy(remcomOutBuffer,"B02"); |
---|
| 684 | goto x1; |
---|
| 685 | } |
---|
| 686 | |
---|
| 687 | putpacket("OK 2"); /* Ack before changing speed */ |
---|
| 688 | set_timer_3(baudrate); /* Set it */ |
---|
| 689 | } |
---|
| 690 | x1: break; |
---|
| 691 | #endif |
---|
| 692 | } /* switch */ |
---|
| 693 | |
---|
| 694 | /* reply to the request */ |
---|
| 695 | putpacket(remcomOutBuffer); |
---|
| 696 | } |
---|
| 697 | print ("\r\nEscaped handle_exception\r\n"); |
---|
| 698 | } |
---|