gdb/remote-mm.c

   1 /* Remote debugging interface for Am290*0 running MiniMON monitor, for GDB.
   2    Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
   3    Originally written by Daniel Mann at AMD.
   4
   5 This file is part of GDB.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 /* This is like remote.c but ecpects MiniMON to be running on the Am29000
  22    target hardware.
  23  - David Wood ([email protected]) at New York University adapted this
  24         file to gdb 3.95.  I was unable to get this working on sun3os4
  25         with termio, only with sgtty.  Because we are only attempting to
  26         use this module to debug our kernel, which is already loaded when
  27         gdb is started up, I did not code up the file downloading facilities.
  28         As a result this module has only the stubs to download files.
  29         You should get tagged at compile time if you need to make any
  30         changes/additions.  */
  31
  32 #include "defs.h"
  33 #include "inferior.h"
  34 #include "wait.h"
  35 #include "value.h"
  36 #include <ctype.h>
  37 #include <fcntl.h>
  38 #include <signal.h>
  39 #include <errno.h>
  40 #include <string.h>
  41 #include "terminal.h"
  42 #include "minimon.h"
  43 #include "target.h"
  44
  45 /* Offset of member MEMBER in a struct of type TYPE.  */
  46 #define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
  47
  48 /* #define DEBUG 1              /* */
  49 #ifdef DEBUG
  50 # define DENTER(NAME)   (printf("Entering %s\n",NAME), fflush(stdout))
  51 # define DEXIT(NAME)    (printf("Exiting  %s\n",NAME), fflush(stdout))
  52 #else
  53 # define DENTER(NAME)
  54 # define DEXIT(NAME)
  55 #endif
  56
  57 #define DRAIN_INPUT()   (msg_recv_serial((union msg_t*)0))
  58
  59 extern int stop_soon_quietly;           /* for wait_for_inferior */
  60
  61 static void mm_resume();
  62 static void mm_fetch_registers ();
  63 static int fetch_register ();
  64 static void mm_store_registers ();
  65 static int store_register ();
  66 static int regnum_to_srnum();
  67 static void  mm_close ();
  68 static char* msg_str();
  69 static char* error_msg_str();
  70 static int expect_msg();
  71 static void init_target_mm();
  72 static int mm_memory_space();
  73
  74 /*
  75  * Processor types.
  76  */
  77 #define TYPE_UNKNOWN    0
  78 #define TYPE_A29000     1
  79 #define TYPE_A29030     2
  80 #define TYPE_A29050     3
  81 static  char *processor_name[] = { "Unknown", "A29000", "A29030", "A29050" };
  82 static  int processor_type=TYPE_UNKNOWN;
  83 #define FREEZE_MODE     (read_register(CPS_REGNUM) && 0x400)
  84 #define USE_SHADOW_PC   ((processor_type == TYPE_A29050) && FREEZE_MODE)
  85
  86 #define LLOG_FILE "minimon.log"
  87 #if defined (LOG_FILE)
  88 FILE *log_file;
  89 #endif
  90
  91 /*
  92  * Size of message buffers.  I couldn't get memory reads to work when
  93  * the byte_count was larger than 512 (it may be a baud rate problem).
  94  */
  95 #define BUFER_SIZE  512
  96 /*
  97  * Size of data area in message buffer on the TARGET (remote system).
  98  */
  99 #define MAXDATA_T  (target_config.max_msg_size - \
 100                         offsetof(struct write_r_msg_t,data[0]))
 101 /*
 102  * Size of data area in message buffer on the HOST (gdb).
 103  */
 104 #define MAXDATA_H  (BUFER_SIZE - offsetof(struct write_r_msg_t,data[0]))
 105 /*
 106  * Defined as the minimum size of data areas of the two message buffers
 107  */
 108 #define MAXDATA    (MAXDATA_H < MAXDATA_T ? MAXDATA_H : MAXDATA_T)
 109
 110 static char out_buf[BUFER_SIZE];
 111 static char  in_buf[BUFER_SIZE];
 112
 113 int msg_recv_serial();
 114 int msg_send_serial();
 115
 116 #define MAX_RETRIES 5000
 117 extern struct target_ops mm_ops;             /* Forward declaration */
 118 struct config_msg_t  target_config;     /* HIF needs this */
 119 union msg_t  *out_msg_buf = (union msg_t*)out_buf;
 120 union msg_t  *in_msg_buf  = (union msg_t*)in_buf;
 121
 122 static int timeout = 5;
 123
 124 /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
 125    mm_open knows that we don't have a file open when the program
 126    starts.  */
 127 int mm_desc = -1;
 128
 129 /* stream which is fdopen'd from mm_desc.  Only valid when
 130    mm_desc != -1.  */
 131 FILE *mm_stream;
 132
 133 /* Called when SIGALRM signal sent due to alarm() timeout.  */
 134 #ifndef HAVE_TERMIO
 135
 136 #ifndef __STDC__
 137 # ifndef volatile
 138 #  define volatile /**/
 139 # endif
 140 #endif
 141 volatile int n_alarms;
 142
 143 static void
 144 mm_timer ()
 145 {
 146 #if 0
 147   if (kiodebug)
 148     printf ("mm_timer called\n");
 149 #endif
 150   n_alarms++;
 151 }
 152 #endif  /* HAVE_TERMIO */
 153
 154 /* malloc'd name of the program on the remote system.  */
 155 static char *prog_name = NULL;
 156
 157
 158 /* Number of SIGTRAPs we need to simulate.  That is, the next
 159    NEED_ARTIFICIAL_TRAP calls to mm_wait should just return
 160    SIGTRAP without actually waiting for anything.  */
 161
 162 /**************************************************** REMOTE_CREATE_INFERIOR */
 163 /* This is called not only when we first attach, but also when the
 164    user types "run" after having attached.  */
 165 static void
 166 mm_create_inferior (execfile, args, env)
 167      char *execfile;
 168      char *args;
 169      char **env;
 170 {
 171 #define MAX_TOKENS 25
 172 #define BUFFER_SIZE 256
 173    int  token_count;
 174    int  result;
 175    char *token[MAX_TOKENS];
 176    char cmd_line[BUFFER_SIZE];
 177
 178   DENTER("mm_create_inferior()");
 179
 180   if (args && *args)
 181     error ("Can't pass arguments to remote mm process (yet).");
 182
 183   if (execfile == 0 /* || exec_bfd == 0 */ )
 184     error ("No exec file specified");
 185
 186   if (!mm_stream) {
 187         printf("Minimon not open yet.\n");
 188         return;
 189   }
 190
 191   /* On ultra3 (NYU) we assume the kernel is already running so there is
 192      no file to download.
 193      FIXME: Fixed required here -> load your program, possibly with mm_load().
 194      */
 195   printf_filtered ("\n\
 196 Assuming you are at NYU debuging a kernel, i.e., no need to download.\n\n");
 197
 198   /* We will get a task spawn event immediately.  */
 199 #ifdef NOTDEF           /* start_remote() now does a wait without a resume
 200                            so don't use it*/
 201   start_remote ();
 202 #else
 203   init_wait_for_inferior ();
 204   clear_proceed_status ();
 205   stop_soon_quietly = 1;
 206   proceed(-1,-1,0);
 207   normal_stop ();
 208 #endif
 209   DEXIT("mm_create_inferior()");
 210 }
 211 /**************************************************** REMOTE_MOURN_INFERIOR */
 212 static void
 213 mm_mourn()
 214 {
 215   DENTER("mm_mourn()");
 216         pop_target ();                /* Pop back to no-child state */
 217         generic_mourn_inferior ();
 218   DEXIT("mm_mourn()");
 219 }
 220
 221 /********************************************************************** damn_b
 222 */
 223 /* Translate baud rates from integers to damn B_codes.  Unix should
 224    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 225
 226 #ifndef B19200
 227 #define B19200 EXTA
 228 #endif
 229 #ifndef B38400
 230 #define B38400 EXTB
 231 #endif
 232
 233 static struct {int rate, damn_b;} baudtab[] = {
 234         {0, B0},
 235         {50, B50},
 236         {75, B75},
 237         {110, B110},
 238         {134, B134},
 239         {150, B150},
 240         {200, B200},
 241         {300, B300},
 242         {600, B600},
 243         {1200, B1200},
 244         {1800, B1800},
 245         {2400, B2400},
 246         {4800, B4800},
 247         {9600, B9600},
 248         {19200, B19200},
 249         {38400, B38400},
 250         {-1, -1},
 251 };
 252
 253 static int damn_b (rate)
 254      int rate;
 255 {
 256   int i;
 257
 258   for (i = 0; baudtab[i].rate != -1; i++)
 259     if (rate == baudtab[i].rate) return baudtab[i].damn_b;
 260   return B38400;        /* Random */
 261 }
 262
 263
 264 /***************************************************************** REMOTE_OPEN
 265 ** Open a connection to remote minimon.
 266    NAME is the filename used for communication, then a space,
 267    then the baud rate.
 268    'target adapt /dev/ttya 9600 [prognam]' for example.
 269  */
 270
 271 static char *dev_name;
 272 int baudrate = 9600;
 273 static void
 274 mm_open (name, from_tty)
 275      char *name;
 276      int from_tty;
 277 {
 278   TERMINAL sg;
 279   unsigned int prl;
 280   char *p;
 281
 282   DENTER("mm_open()");
 283
 284   /* Find the first whitespace character, it separates dev_name from
 285      prog_name.  */
 286   for (p = name;
 287        p && *p && !isspace (*p); p++)
 288     ;
 289   if (p == 0 || *p == '\0')
 290 erroid:
 291     error ("Usage : <command> <serial-device> <baud-rate> [progname]");
 292   dev_name = (char*)malloc (p - name + 1);
 293   strncpy (dev_name, name, p - name);
 294   dev_name[p - name] = '\0';
 295
 296   /* Skip over the whitespace after dev_name */
 297   for (; isspace (*p); p++)
 298     /*EMPTY*/;
 299
 300   if (1 != sscanf (p, "%d ", &baudrate))
 301     goto erroid;
 302
 303   /* Skip the number and then the spaces */
 304   for (; isdigit (*p); p++)
 305     /*EMPTY*/;
 306   for (; isspace (*p); p++)
 307     /*EMPTY*/;
 308
 309   if (prog_name != NULL)
 310     free (prog_name);
 311   prog_name = savestring (p, strlen (p));
 312
 313
 314   if (mm_desc >= 0)
 315     close (mm_desc);
 316
 317   mm_desc = open (dev_name, O_RDWR);
 318   if (mm_desc < 0)
 319     perror_with_name (dev_name);
 320   ioctl (mm_desc, TIOCGETP, &sg);
 321 #ifdef HAVE_TERMIO
 322   sg.c_cc[VMIN] = 0;            /* read with timeout.  */
 323   sg.c_cc[VTIME] = timeout * 10;
 324   sg.c_lflag &= ~(ICANON | ECHO);
 325   sg.c_cflag = (sg.c_cflag & ~CBAUD) | damn_b (baudrate);
 326 #else
 327   sg.sg_ispeed = damn_b (baudrate);
 328   sg.sg_ospeed = damn_b (baudrate);
 329   sg.sg_flags |= RAW;
 330   sg.sg_flags |= ANYP;
 331   sg.sg_flags &= ~ECHO;
 332 #endif
 333
 334
 335   ioctl (mm_desc, TIOCSETP, &sg);
 336   mm_stream = fdopen (mm_desc, "r+");
 337
 338   push_target (&mm_ops);
 339
 340 #ifndef HAVE_TERMIO
 341 #ifndef NO_SIGINTERRUPT
 342   /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
 343      the read.  */
 344   if (siginterrupt (SIGALRM, 1) != 0)
 345     perror ("mm_open: error in siginterrupt");
 346 #endif
 347
 348   /* Set up read timeout timer.  */
 349   if ((void (*)) signal (SIGALRM, mm_timer) == (void (*)) -1)
 350     perror ("mm_open: error in signal");
 351 #endif
 352
 353 #if defined (LOG_FILE)
 354   log_file = fopen (LOG_FILE, "w");
 355   if (log_file == NULL)
 356     perror_with_name (LOG_FILE);
 357 #endif
 358    /*
 359    ** Initialize target configuration structure (global)
 360    */
 361    DRAIN_INPUT();
 362    out_msg_buf->config_req_msg.code = CONFIG_REQ;
 363    out_msg_buf->config_req_msg.length = 4*0;
 364    msg_send_serial(out_msg_buf); /* send config request message */
 365
 366    expect_msg(CONFIG,in_msg_buf,1);
 367
 368   /* Determine the processor revision level */
 369   /* FIXME: this code is the same as in remote-adapt.c */
 370   prl = (unsigned int)read_register(CFG_REGNUM) >> 24;
 371   if (prl == 0x03) {
 372         processor_type = TYPE_A29000;
 373   } else if ((prl&0xf0) == 0x40) {      /* 29030 = 0x4* */
 374         processor_type = TYPE_A29030;
 375         fprintf_filtered(stderr,"WARNING: debugging of A29030 not tested.\n");
 376   } else if ((prl&0xf0) == 0x20) {      /* 29050 = 0x2* */
 377         processor_type = TYPE_A29050;
 378         fprintf_filtered(stderr,"WARNING: debugging of A29050 not tested.\n");
 379   } else {
 380         processor_type = TYPE_UNKNOWN;
 381         fprintf_filtered(stderr,"WARNING: processor type unknown.\n");
 382   }
 383
 384   /* Print out some stuff, letting the user now what's going on */
 385   printf_filtered("Remote debugging on an %s connect to MiniMon via %s.\n",
 386                 processor_name[processor_type],dev_name);
 387     /* FIXME: can this restriction be removed? */
 388   printf_filtered("Remote debugging using virtual addresses works only\n");
 389   printf_filtered("\twhen virtual addresses map 1:1 to physical addresses.\n")
 390 ;
 391   if (processor_type != TYPE_A29050) {
 392         fprintf_filtered(stderr,
 393         "Freeze-mode debugging not available, and can only be done on an A29050.\n");
 394   }
 395
 396    target_config.code = CONFIG;
 397    target_config.length = 0;
 398    target_config.processor_id = in_msg_buf->config_msg.processor_id;
 399    target_config.version = in_msg_buf->config_msg.version;
 400    target_config.I_mem_start = in_msg_buf->config_msg.I_mem_start;
 401    target_config.I_mem_size = in_msg_buf->config_msg.I_mem_size;
 402    target_config.D_mem_start = in_msg_buf->config_msg.D_mem_start;
 403    target_config.D_mem_size = in_msg_buf->config_msg.D_mem_size;
 404    target_config.ROM_start = in_msg_buf->config_msg.ROM_start;
 405    target_config.ROM_size =  in_msg_buf->config_msg.ROM_size;
 406    target_config.max_msg_size = in_msg_buf->config_msg.max_msg_size;
 407    target_config.max_bkpts = in_msg_buf->config_msg.max_bkpts;
 408    target_config.coprocessor = in_msg_buf->config_msg.coprocessor;
 409    target_config.reserved = in_msg_buf->config_msg.reserved;
 410    if (from_tty) {
 411         printf("Connected to MiniMON :\n");
 412         printf("    Debugcore version            %d.%d\n",
 413                 0x0f & (target_config.version >> 4),
 414                 0x0f & (target_config.version ) );
 415         printf("    Configuration version        %d.%d\n",
 416                 0x0f & (target_config.version >> 12),
 417                 0x0f & (target_config.version >>  8) );
 418         printf("    Message system version       %d.%d\n",
 419                 0x0f & (target_config.version >> 20),
 420                 0x0f & (target_config.version >> 16) );
 421         printf("    Communication driver version %d.%d\n",
 422                 0x0f & (target_config.version >> 28),
 423                 0x0f & (target_config.version >> 24) );
 424    }
 425
 426   /* Leave the target running...
 427    * The above message stopped the target in the dbg core (MiniMon),
 428    * so restart the target out of MiniMon,
 429    */
 430   out_msg_buf->go_msg.code = GO;
 431   out_msg_buf->go_msg.length = 0;
 432   msg_send_serial(out_msg_buf);
 433   /* No message to expect after a GO */
 434
 435   DEXIT("mm_open()");
 436 }
 437
 438 /**************************************************************** REMOTE_CLOSE
 439 ** Close the open connection to the minimon debugger.
 440    Use this when you want to detach and do something else
 441    with your gdb.  */
 442 static void
 443 mm_close (quitting)     /*FIXME: how is quitting used */
 444      int quitting;
 445 {
 446   DENTER("mm_close()");
 447
 448   if (mm_desc < 0)
 449     error ("Can't close remote connection: not debugging remotely.");
 450
 451   /* We should never get here if there isn't something valid in
 452      mm_desc and mm_stream.
 453
 454      Due to a bug in Unix, fclose closes not only the stdio stream,
 455      but also the file descriptor.  So we don't actually close
 456      mm_desc.  */
 457   DRAIN_INPUT();
 458   fclose (mm_stream);
 459   /* close (mm_desc); */
 460
 461   /* Do not try to close mm_desc again, later in the program.  */
 462   mm_stream = NULL;
 463   mm_desc = -1;
 464
 465 #if defined (LOG_FILE)
 466   if (ferror (log_file))
 467     printf ("Error writing log file.\n");
 468   if (fclose (log_file) != 0)
 469     printf ("Error closing log file.\n");
 470 #endif
 471
 472   printf ("Ending remote debugging\n");
 473
 474   DEXIT("mm_close()");
 475
 476 }
 477
 478 /************************************************************* REMOTE_ATACH */
 479 /* Attach to a program that is already loaded and running
 480  * Upon exiting the process's execution is stopped.
 481  */
 482 static void
 483 mm_attach (args, from_tty)
 484      char *args;
 485      int from_tty;
 486 {
 487
 488   DENTER("mm_attach()");
 489
 490   if (!mm_stream)
 491       printf ("MiniMon not opened yet, use the 'target minimon' command.\n");
 492
 493   dont_repeat();
 494
 495   if (from_tty)
 496       printf ("Attaching to remote program %s...\n", prog_name);
 497
 498
 499   /* Make sure the target is currently running, it is supposed to be. */
 500   /* FIXME: is it ok to send MiniMon a BREAK if it is already stopped in
 501    *    the dbg core.  If so, we don't need to send this GO.
 502    */
 503   out_msg_buf->go_msg.code = GO;
 504   out_msg_buf->go_msg.length = 0;
 505   msg_send_serial(out_msg_buf);
 506   sleep(2);     /* At the worst it will stop, receive a message, continue */
 507
 508   /* Send the mm a break. */
 509   out_msg_buf->break_msg.code = BREAK;
 510   out_msg_buf->break_msg.length = 0;
 511   msg_send_serial(out_msg_buf);
 512
 513   mark_breakpoints_out ();
 514   init_wait_for_inferior ();
 515   clear_proceed_status ();
 516   stop_soon_quietly = 1;
 517   wait_for_inferior ();
 518   stop_soon_quietly = 0;
 519   normal_stop ();
 520
 521   DEXIT("mm_attach()");
 522 }
 523 /********************************************************** REMOTE_DETACH */
 524 /* Terminate the open connection to the remote debugger.
 525    Use this when you want to detach and do something else
 526    with your gdb.  Leave remote process running (with no breakpoints set). */
 527 static void
 528 mm_detach (args,from_tty)
 529      char *args;
 530      int from_tty;
 531 {
 532   DENTER("mm_dettach()");
 533   remove_breakpoints();         /* Just in case there were any left in */
 534   out_msg_buf->go_msg.code = GO;
 535   out_msg_buf->go_msg.length = 0;
 536   msg_send_serial(out_msg_buf);
 537   pop_target();                 /* calls mm_close to do the real work */
 538   DEXIT("mm_dettach()");
 539 }
 540
 541
 542 /*************************************************************** REMOTE_RESUME
 543 ** Tell the remote machine to resume.  */
 544
 545 static void
 546 mm_resume (step, sig)
 547      int step, sig;
 548 {
 549   DENTER("mm_resume()");
 550
 551   if (sig)
 552     error ("Can't send signals to a remote MiniMon system.");
 553
 554   if (step) {
 555       out_msg_buf->step_msg.code= STEP;
 556       out_msg_buf->step_msg.length = 1*4;
 557       out_msg_buf->step_msg.count = 1;          /* step 1 instruction */
 558       msg_send_serial(out_msg_buf);
 559   } else {
 560       out_msg_buf->go_msg.code= GO;
 561       out_msg_buf->go_msg.length = 0;
 562       msg_send_serial(out_msg_buf);
 563   }
 564
 565   DEXIT("mm_resume()");
 566 }
 567
 568 /***************************************************************** REMOTE_WAIT
 569 ** Wait until the remote machine stops, then return,
 570    storing status in STATUS just as `wait' would.  */
 571
 572 static int
 573 mm_wait (status)
 574      WAITTYPE *status;
 575 {
 576   int i, result;
 577   int old_timeout = timeout;
 578   int old_immediate_quit = immediate_quit;
 579
 580   DENTER("mm_wait()");
 581   WSETEXIT ((*status), 0);
 582
 583
 584 /* wait for message to arrive. It should be:
 585         - A HIF service request.
 586         - A HIF exit service request.
 587         - A CHANNEL0_ACK.
 588         - A CHANNEL1 request.
 589         - a debugcore HALT message.
 590   HIF services must be responded too, and while-looping continued.
 591   If the target stops executing, mm_wait() should return.
 592 */
 593   timeout = 0;  /* Wait indefinetly for a message */
 594   immediate_quit = 1;   /* Helps ability to QUIT */
 595   while(1)
 596   {
 597     while(msg_recv_serial(in_msg_buf)) {
 598         QUIT;   /* Let user quit if they want */
 599     }
 600     switch (in_msg_buf->halt_msg.code)
 601     {
 602     case HIF_CALL:
 603         i = in_msg_buf->hif_call_rtn_msg.service_number;
 604         result=service_HIF(in_msg_buf);
 605         if(i == 1) /* EXIT */
 606             goto exit;
 607         if(result)
 608             printf("Warning: failure during HIF service %d\n", i);
 609         break;
 610     case CHANNEL0_ACK:
 611         service_HIF(in_msg_buf);
 612         break;
 613     case CHANNEL1:
 614         i=in_msg_buf->channel1_msg.length;
 615         in_msg_buf->channel1_msg.data[i] = '\0';
 616         printf("%s", in_msg_buf->channel1_msg.data);
 617         fflush(stdout);
 618         /* Send CHANNEL1_ACK message */
 619         out_msg_buf->channel1_ack_msg.code = CHANNEL1_ACK;
 620         out_msg_buf->channel1_ack_msg.length = 0;
 621         result = msg_send_serial(out_msg_buf);
 622         break;
 623     case HALT:
 624         goto halted;
 625     default:
 626         goto halted;
 627     }
 628   }
 629 halted:
 630   /* FIXME, these printfs should not be here.  This is a source level
 631      debugger, guys!  */
 632   if (in_msg_buf->halt_msg.trap_number== 0)
 633   { printf("Am290*0 received vector number %d (break point)\n",
 634         in_msg_buf->halt_msg.trap_number);
 635     WSETSTOP ((*status), SIGTRAP);
 636   }
 637   else if (in_msg_buf->halt_msg.trap_number== 1)
 638   { printf("Am290*0 received vector number %d\n",
 639         in_msg_buf->halt_msg.trap_number);
 640     WSETSTOP ((*status), SIGBUS);
 641   }
 642   else if (in_msg_buf->halt_msg.trap_number== 3
 643         || in_msg_buf->halt_msg.trap_number== 4)
 644   { printf("Am290*0 received vector number %d\n",
 645         in_msg_buf->halt_msg.trap_number);
 646     WSETSTOP ((*status), SIGFPE);
 647   }
 648   else if (in_msg_buf->halt_msg.trap_number== 5)
 649   { printf("Am290*0 received vector number %d\n",
 650         in_msg_buf->halt_msg.trap_number);
 651     WSETSTOP ((*status), SIGILL);
 652   }
 653   else if (in_msg_buf->halt_msg.trap_number >= 6
 654         && in_msg_buf->halt_msg.trap_number <= 11)
 655   { printf("Am290*0 received vector number %d\n",
 656         in_msg_buf->halt_msg.trap_number);
 657     WSETSTOP ((*status), SIGSEGV);
 658   }
 659   else if (in_msg_buf->halt_msg.trap_number== 12
 660         || in_msg_buf->halt_msg.trap_number== 13)
 661   { printf("Am290*0 received vector number %d\n",
 662         in_msg_buf->halt_msg.trap_number);
 663     WSETSTOP ((*status), SIGILL);
 664   }
 665   else if (in_msg_buf->halt_msg.trap_number== 14)
 666   { printf("Am290*0 received vector number %d\n",
 667         in_msg_buf->halt_msg.trap_number);
 668     WSETSTOP ((*status), SIGALRM);
 669   }
 670   else if (in_msg_buf->halt_msg.trap_number== 15)
 671     WSETSTOP ((*status), SIGTRAP);
 672   else if (in_msg_buf->halt_msg.trap_number >= 16
 673         && in_msg_buf->halt_msg.trap_number <= 21)
 674   { printf("Am290*0 received vector number %d\n",
 675         in_msg_buf->halt_msg.trap_number);
 676     WSETSTOP ((*status), SIGINT);
 677   }
 678   else if (in_msg_buf->halt_msg.trap_number== 22)
 679   { printf("Am290*0 received vector number %d\n",
 680         in_msg_buf->halt_msg.trap_number);
 681     WSETSTOP ((*status), SIGILL);
 682   } /* BREAK message was sent */
 683   else if (in_msg_buf->halt_msg.trap_number== 75)
 684     WSETSTOP ((*status), SIGTRAP);
 685   else
 686 exit:
 687     WSETEXIT ((*status), 0);
 688
 689   timeout = old_timeout;        /* Restore original timeout value */
 690   immediate_quit = old_immediate_quit;
 691   DEXIT("mm_wait()");
 692   return 0;
 693 }
 694
 695 /******************************************************* REMOTE_FETCH_REGISTERS
 696  * Read a remote register 'regno'.
 697  * If regno==-1 then read all the registers.
 698  */
 699 static void
 700 mm_fetch_registers (regno)
 701 int     regno;
 702 {
 703   INT32 *data_p;
 704
 705   if (regno >= 0)  {
 706         fetch_register(regno);
 707         return;
 708   }
 709
 710   DENTER("mm_fetch_registers()");
 711
 712 /* Gr1/rsp */
 713   out_msg_buf->read_req_msg.byte_count = 4*1;
 714   out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
 715   out_msg_buf->read_req_msg.address = 1;
 716   msg_send_serial(out_msg_buf);
 717   expect_msg(READ_ACK,in_msg_buf,1);
 718   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
 719   supply_register (GR1_REGNUM , data_p);
 720
 721 #if defined(GR64_REGNUM)        /* Read gr64-127 */
 722 /* Global Registers gr64-gr95 */
 723   out_msg_buf->read_req_msg.code= READ_REQ;
 724   out_msg_buf->read_req_msg.length = 4*3;
 725   out_msg_buf->read_req_msg.byte_count = 4*32;
 726   out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
 727   out_msg_buf->read_req_msg.address = 64;
 728   msg_send_serial(out_msg_buf);
 729   expect_msg(READ_ACK,in_msg_buf,1);
 730   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
 731
 732   for (regno=GR64_REGNUM; regno<GR64_REGNUM+32; regno++) {
 733       supply_register (regno, data_p++);
 734   }
 735 #endif  /*  GR64_REGNUM */
 736
 737 /* Global Registers gr96-gr127 */
 738   out_msg_buf->read_req_msg.code= READ_REQ;
 739   out_msg_buf->read_req_msg.length = 4*3;
 740   out_msg_buf->read_req_msg.byte_count = 4 * 32;
 741   out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
 742   out_msg_buf->read_req_msg.address = 96;
 743   msg_send_serial(out_msg_buf);
 744   expect_msg(READ_ACK,in_msg_buf,1);
 745   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
 746
 747   for (regno=GR96_REGNUM; regno<GR96_REGNUM+32; regno++) {
 748       supply_register (regno, data_p++);
 749   }
 750
 751 /* Local Registers */
 752   out_msg_buf->read_req_msg.byte_count = 4 * (128);
 753   out_msg_buf->read_req_msg.memory_space = LOCAL_REG;
 754   out_msg_buf->read_req_msg.address = 0;
 755   msg_send_serial(out_msg_buf);
 756   expect_msg(READ_ACK,in_msg_buf,1);
 757   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
 758
 759   for (regno=LR0_REGNUM; regno<LR0_REGNUM+128; regno++) {
 760       supply_register (regno, data_p++);
 761   }
 762
 763 /* Protected Special Registers */
 764   out_msg_buf->read_req_msg.byte_count = 4*15;
 765   out_msg_buf->read_req_msg.memory_space = SPECIAL_REG;
 766   out_msg_buf->read_req_msg.address = 0;
 767   msg_send_serial( out_msg_buf);
 768   expect_msg(READ_ACK,in_msg_buf,1);
 769   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
 770
 771   for (regno=0; regno<=14; regno++) {
 772       supply_register (SR_REGNUM(regno), data_p++);
 773   }
 774   if (USE_SHADOW_PC) {  /* Let regno_to_srnum() handle the register number */
 775         fetch_register(NPC_REGNUM);
 776         fetch_register(PC_REGNUM);
 777         fetch_register(PC2_REGNUM);
 778   }
 779
 780 /* Unprotected Special Registers */
 781   out_msg_buf->read_req_msg.byte_count = 4*8;
 782   out_msg_buf->read_req_msg.memory_space = SPECIAL_REG;
 783   out_msg_buf->read_req_msg.address = 128;
 784   msg_send_serial( out_msg_buf);
 785   expect_msg(READ_ACK,in_msg_buf,1);
 786   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
 787
 788   for (regno=128; regno<=135; regno++) {
 789       supply_register (SR_REGNUM(regno), data_p++);
 790   }
 791
 792   /* There doesn't seem to be any way to get these.  */
 793   {
 794     int val = -1;
 795     supply_register (FPE_REGNUM, &val);
 796     supply_register (INTE_REGNUM, &val);
 797     supply_register (FPS_REGNUM, &val);
 798     supply_register (EXO_REGNUM, &val);
 799   }
 800
 801   DEXIT("mm_fetch_registerS()");
 802 }
 803
 804
 805 /****************************************************** REMOTE_STORE_REGISTERS
 806  * Store register regno into the target.
 807  * If regno==-1 then store all the registers.
 808  * Result is 0 for success, -1 for failure.
 809  */
 810
 811 static void
 812 mm_store_registers (regno)
 813 int regno;
 814 {
 815   int result;
 816
 817   if (regno >= 0) {
 818     store_register(regno);
 819     return;
 820   }
 821
 822   DENTER("mm_store_registers()");
 823   result = 0;
 824
 825   out_msg_buf->write_r_msg.code= WRITE_REQ;
 826
 827 /* Gr1/rsp */
 828   out_msg_buf->write_r_msg.byte_count = 4*1;
 829   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
 830   out_msg_buf->write_r_msg.memory_space = GLOBAL_REG;
 831   out_msg_buf->write_r_msg.address = 1;
 832   out_msg_buf->write_r_msg.data[0] = read_register (GR1_REGNUM);
 833
 834   msg_send_serial( out_msg_buf);
 835   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
 836         result = -1;
 837   }
 838
 839 #if defined(GR64_REGNUM)
 840 /* Global registers gr64-gr95 */
 841   out_msg_buf->write_r_msg.byte_count = 4* (32);
 842   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
 843   out_msg_buf->write_r_msg.address = 64;
 844
 845   for (regno=GR64_REGNUM ; regno<GR64_REGNUM+32 ; regno++)
 846     {
 847       out_msg_buf->write_r_msg.data[regno-GR64_REGNUM] = read_register (regno);
 848     }
 849   msg_send_serial(out_msg_buf);
 850   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
 851         result = -1;
 852   }
 853 #endif  /* GR64_REGNUM */
 854
 855 /* Global registers gr96-gr127 */
 856   out_msg_buf->write_r_msg.byte_count = 4* (32);
 857   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
 858   out_msg_buf->write_r_msg.address = 96;
 859   for (regno=GR96_REGNUM ; regno<GR96_REGNUM+32 ; regno++)
 860     {
 861       out_msg_buf->write_r_msg.data[regno-GR96_REGNUM] = read_register (regno);
 862     }
 863   msg_send_serial( out_msg_buf);
 864   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
 865         result = -1;
 866   }
 867
 868 /* Local Registers */
 869   out_msg_buf->write_r_msg.memory_space = LOCAL_REG;
 870   out_msg_buf->write_r_msg.byte_count = 4*128;
 871   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
 872   out_msg_buf->write_r_msg.address = 0;
 873
 874   for (regno = LR0_REGNUM ; regno < LR0_REGNUM+128 ; regno++)
 875     {
 876       out_msg_buf->write_r_msg.data[regno-LR0_REGNUM] = read_register (regno);
 877     }
 878   msg_send_serial( out_msg_buf);
 879   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
 880         result = -1;
 881   }
 882
 883 /* Protected Special Registers */
 884   /* VAB through TMR */
 885   out_msg_buf->write_r_msg.memory_space = SPECIAL_REG;
 886   out_msg_buf->write_r_msg.byte_count = 4* 10;
 887   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
 888   out_msg_buf->write_r_msg.address = 0;
 889   for (regno = 0 ; regno<=9 ; regno++)  /* VAB through TMR */
 890     out_msg_buf->write_r_msg.data[regno] = read_register (SR_REGNUM(regno));
 891   msg_send_serial( out_msg_buf);
 892   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
 893         result = -1;
 894   }
 895
 896   /* PC0, PC1, PC2 possibly as shadow registers */
 897   out_msg_buf->write_r_msg.byte_count = 4* 3;
 898   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
 899   for (regno=10 ; regno<=12 ; regno++)  /* LRU and MMU */
 900     out_msg_buf->write_r_msg.data[regno-10] = read_register (SR_REGNUM(regno));
 901   if (USE_SHADOW_PC)
 902     out_msg_buf->write_r_msg.address = 20;      /* SPC0 */
 903   else
 904     out_msg_buf->write_r_msg.address = 10;      /* PC0 */
 905   msg_send_serial( out_msg_buf);
 906   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
 907         result = -1;
 908   }
 909
 910   /* LRU and MMU */
 911   out_msg_buf->write_r_msg.byte_count = 4* 2;
 912   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
 913   out_msg_buf->write_r_msg.address = 13;
 914   for (regno=13 ; regno<=14 ; regno++)  /* LRU and MMU */
 915     out_msg_buf->write_r_msg.data[regno-13] = read_register (SR_REGNUM(regno));
 916   msg_send_serial( out_msg_buf);
 917   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
 918         result = -1;
 919   }
 920
 921 /* Unprotected Special Registers */
 922   out_msg_buf->write_r_msg.byte_count = 4*8;
 923   out_msg_buf->write_r_msg.length = 3*4 + out_msg_buf->write_r_msg.byte_count;
 924   out_msg_buf->write_r_msg.address = 128;
 925   for (regno = 128 ; regno<=135 ; regno++)
 926     out_msg_buf->write_r_msg.data[regno-128] = read_register(SR_REGNUM(regno));
 927   msg_send_serial( out_msg_buf);
 928   if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
 929         result = -1;
 930   }
 931
 932   registers_changed ();
 933   DEXIT("mm_store_registers()");
 934   /* FIXME return result;  it is ignored by caller.  */
 935 }
 936
 937 /*************************************************** REMOTE_PREPARE_TO_STORE */
 938 /* Get ready to modify the registers array.  On machines which store
 939    individual registers, this doesn't need to do anything.  On machines
 940    which store all the registers in one fell swoop, this makes sure
 941    that registers contains all the registers from the program being
 942    debugged.  */
 943
 944 static void
 945 mm_prepare_to_store ()
 946 {
 947   /* Do nothing, since we can store individual regs */
 948 }
 949
 950 /******************************************************* REMOTE_XFER_MEMORY */
 951 static CORE_ADDR
 952 translate_addr(addr)
 953 CORE_ADDR addr;
 954 {
 955 #if defined(KERNEL_DEBUGGING)
 956         /* Check for a virtual address in the kernel */
 957         /* Assume physical address of ublock is in  paddr_u register */
 958         /* FIXME: doesn't work for user virtual addresses */
 959         if (addr >= UVADDR) {
 960                 /* PADDR_U register holds the physical address of the ublock */
 961                 CORE_ADDR i = (CORE_ADDR)read_register(PADDR_U_REGNUM);
 962                 return(i + addr - (CORE_ADDR)UVADDR);
 963         } else {
 964                 return(addr);
 965         }
 966 #else
 967         return(addr);
 968 #endif
 969 }
 970
 971 /******************************************************* REMOTE_FILES_INFO */
 972 static void
 973 mm_files_info ()
 974 {
 975   printf ("\tAttached to %s at %d baud and running program %s.\n",
 976           dev_name, baudrate, prog_name);
 977 }
 978
 979 /************************************************* REMOTE_INSERT_BREAKPOINT */
 980 static int
 981 mm_insert_breakpoint (addr, contents_cache)
 982      CORE_ADDR addr;
 983      char *contents_cache;
 984 {
 985   DENTER("mm_insert_breakpoint()");
 986   out_msg_buf->bkpt_set_msg.code = BKPT_SET;
 987   out_msg_buf->bkpt_set_msg.length = 4*4;
 988   out_msg_buf->bkpt_set_msg.memory_space = I_MEM;
 989   out_msg_buf->bkpt_set_msg.bkpt_addr = (ADDR32) addr;
 990   out_msg_buf->bkpt_set_msg.pass_count = 1;
 991   out_msg_buf->bkpt_set_msg.bkpt_type = -1;     /* use illop for 29000 */
 992   msg_send_serial( out_msg_buf);
 993   if (expect_msg(BKPT_SET_ACK,in_msg_buf,1)) {
 994         DEXIT("mm_insert_breakpoint() success");
 995         return 0;               /* Success */
 996   } else {
 997         DEXIT("mm_insert_breakpoint() failure");
 998         return 1;               /* Failure */
 999   }
1000 }
1001
1002 /************************************************* REMOTE_DELETE_BREAKPOINT */
1003 static int
1004 mm_remove_breakpoint (addr, contents_cache)
1005      CORE_ADDR addr;
1006      char *contents_cache;
1007 {
1008   DENTER("mm_remove_breakpoint()");
1009   out_msg_buf->bkpt_rm_msg.code = BKPT_RM;
1010   out_msg_buf->bkpt_rm_msg.length = 4*3;
1011   out_msg_buf->bkpt_rm_msg.memory_space = I_MEM;
1012   out_msg_buf->bkpt_rm_msg.bkpt_addr = (ADDR32) addr;
1013   msg_send_serial( out_msg_buf);
1014   if (expect_msg(BKPT_RM_ACK,in_msg_buf,1)) {
1015         DEXIT("mm_remove_breakpoint()");
1016         return 0;               /* Success */
1017   } else {
1018         DEXIT("mm_remove_breakpoint()");
1019         return 1;               /* Failure */
1020   }
1021 }
1022
1023
1024 /******************************************************* REMOTE_KILL */
1025 static void
1026 mm_kill(arg,from_tty)
1027 char    *arg;
1028 int     from_tty;
1029 {
1030         char    buf[4];
1031
1032         DENTER("mm_kill()");
1033 #if defined(KERNEL_DEBUGGING)
1034         /* We don't ever kill the kernel */
1035         if (from_tty) {
1036                 printf("Kernel not killed, but left in current state.\n");
1037                 printf("Use detach to leave kernel running.\n");
1038         }
1039 #else
1040         out_msg_buf->break_msg.code = BREAK;
1041         out_msg_buf->bkpt_set_msg.length = 4*0;
1042         expect_msg(HALT,in_msg_buf,from_tty);
1043         if (from_tty) {
1044                 printf("Target has been stopped.");
1045                 printf("Would you like to do a hardware reset (y/n) [n] ");
1046                 fgets(buf,3,stdin);
1047                 if (buf[0] == 'y') {
1048                         out_msg_buf->reset_msg.code = RESET;
1049                         out_msg_buf->bkpt_set_msg.length = 4*0;
1050                         expect_msg(RESET_ACK,in_msg_buf,from_tty);
1051                         printf("Target has been reset.");
1052                 }
1053         }
1054         pop_target();
1055 #endif
1056         DEXIT("mm_kill()");
1057 }
1058
1059
1060
1061 /***************************************************************************/
1062 /*
1063  * Load a program into the target.
1064  */
1065 static void
1066 mm_load(arg_string,from_tty)
1067 char    *arg_string;
1068 int     from_tty;
1069 {
1070   dont_repeat ();
1071
1072 #if defined(KERNEL_DEBUGGING)
1073   printf("The kernel had better be loaded already!  Loading not done.\n");
1074 #else
1075   if (arg_string == 0)
1076     error ("The load command takes a file name");
1077
1078   arg_string = tilde_expand (arg_string);
1079   make_cleanup (free, arg_string);
1080   QUIT;
1081   immediate_quit++;
1082   error("File loading is not yet supported for MiniMon.");
1083   /* FIXME, code to load your file here... */
1084   /* You may need to do an init_target_mm() */
1085   /* init_target_mm(?,?,?,?,?,?,?,?); */
1086   immediate_quit--;
1087   /* symbol_file_add (arg_string, from_tty, text_addr, 0, 0); */
1088 #endif
1089
1090 }
1091
1092 /************************************************ REMOTE_WRITE_INFERIOR_MEMORY
1093 ** Copy LEN bytes of data from debugger memory at MYADDR
1094    to inferior's memory at MEMADDR.  Returns number of bytes written.  */
1095 static int
1096 mm_write_inferior_memory (memaddr, myaddr, len)
1097      CORE_ADDR memaddr;
1098      char *myaddr;
1099      int len;
1100 {
1101   int i,nwritten;
1102
1103   /* DENTER("mm_write_inferior_memory()"); */
1104   out_msg_buf->write_req_msg.code= WRITE_REQ;
1105   out_msg_buf->write_req_msg.memory_space = mm_memory_space(memaddr);
1106
1107   nwritten=0;
1108   while (nwritten < len) {
1109         int num_to_write = len - nwritten;
1110         if (num_to_write > MAXDATA) num_to_write = MAXDATA;
1111         for (i=0 ; i < num_to_write ; i++)
1112                 out_msg_buf->write_req_msg.data[i] = myaddr[i+nwritten];
1113         out_msg_buf->write_req_msg.byte_count = num_to_write;
1114         out_msg_buf->write_req_msg.length = 3*4 + num_to_write;
1115         out_msg_buf->write_req_msg.address = memaddr + nwritten;
1116         msg_send_serial(out_msg_buf);
1117
1118         if (expect_msg(WRITE_ACK,in_msg_buf,1)) {
1119                 nwritten += in_msg_buf->write_ack_msg.byte_count;
1120         } else {
1121                 break;
1122         }
1123   }
1124   /* DEXIT("mm_write_inferior_memory()"); */
1125   return(nwritten);
1126 }
1127
1128 /************************************************* REMOTE_READ_INFERIOR_MEMORY
1129 ** Read LEN bytes from inferior memory at MEMADDR.  Put the result
1130    at debugger address MYADDR.  Returns number of bytes read.  */
1131 static int
1132 mm_read_inferior_memory(memaddr, myaddr, len)
1133      CORE_ADDR memaddr;
1134      char *myaddr;
1135      int len;
1136 {
1137   int i,nread;
1138
1139   /* DENTER("mm_read_inferior_memory()"); */
1140   out_msg_buf->read_req_msg.code= READ_REQ;
1141   out_msg_buf->read_req_msg.memory_space = mm_memory_space(memaddr);
1142
1143   nread=0;
1144   while (nread < len) {
1145         int num_to_read = (len - nread);
1146         if (num_to_read > MAXDATA) num_to_read = MAXDATA;
1147         out_msg_buf->read_req_msg.byte_count = num_to_read;
1148         out_msg_buf->read_req_msg.length = 3*4 + num_to_read;
1149         out_msg_buf->read_req_msg.address = memaddr + nread;
1150         msg_send_serial(out_msg_buf);
1151
1152         if (expect_msg(READ_ACK,in_msg_buf,1)) {
1153                 for (i=0 ; i<in_msg_buf->read_ack_msg.byte_count ; i++)
1154                         myaddr[i+nread] = in_msg_buf->read_ack_msg.data[i];
1155                 nread += in_msg_buf->read_ack_msg.byte_count;
1156         } else {
1157                 break;
1158         }
1159   }
1160   return(nread);
1161 }
1162
1163 /* FIXME!  Merge these two.  */
1164 static int
1165 mm_xfer_inferior_memory (memaddr, myaddr, len, write)
1166      CORE_ADDR memaddr;
1167      char *myaddr;
1168      int len;
1169      int write;
1170 {
1171
1172   memaddr = translate_addr(memaddr);
1173
1174   if (write)
1175     return mm_write_inferior_memory (memaddr, myaddr, len);
1176   else
1177     return mm_read_inferior_memory (memaddr, myaddr, len);
1178 }
1179
1180
1181 /********************************************************** MSG_SEND_SERIAL
1182 ** This function is used to send a message over the
1183 ** serial line.
1184 **
1185 ** If the message is successfully sent, a zero is
1186 ** returned.  If the message was not sendable, a -1
1187 ** is returned.  This function blocks.  That is, it
1188 ** does not return until the message is completely
1189 ** sent, or until an error is encountered.
1190 **
1191 */
1192
1193 int
1194 msg_send_serial(msg_ptr)
1195    union  msg_t  *msg_ptr;
1196 {
1197    INT32  message_size;
1198    int    byte_count;
1199    int    result;
1200    char   c;
1201
1202    /* Send message header */
1203    byte_count = 0;
1204    message_size = msg_ptr->generic_msg.length + (2 * sizeof(INT32));
1205    do {
1206       c = *((char *)msg_ptr+byte_count);
1207       result = write(mm_desc, &c, 1);
1208       if (result == 1) {
1209          byte_count = byte_count + 1;
1210       }
1211    } while ((byte_count < message_size) );
1212
1213    return(0);
1214 }  /* end msg_send_serial() */
1215
1216 /********************************************************** MSG_RECV_SERIAL
1217 ** This function is used to receive a message over a
1218 ** serial line.
1219 **
1220 ** If the message is waiting in the buffer, a zero is
1221 ** returned and the buffer pointed to by msg_ptr is filled
1222 ** in.  If no message was available, a -1 is returned.
1223 ** If timeout==0, wait indefinetly for a character.
1224 **
1225 */
1226
1227 int
1228 msg_recv_serial(msg_ptr)
1229 union  msg_t  *msg_ptr;
1230 {
1231    static INT32  length=0;
1232    static INT32  byte_count=0;
1233    int    result;
1234    char   c;
1235   if(msg_ptr == 0)              /* re-sync request */
1236   {  length=0;
1237      byte_count=0;
1238 #ifdef HAVE_TERMIO
1239      /* The timeout here is the prevailing timeout set with VTIME */
1240      ->"timeout==0 semantics not supported"
1241      read(mm_desc, in_buf, BUFER_SIZE);
1242 #else
1243      alarm (1);
1244      read(mm_desc, in_buf, BUFER_SIZE);
1245      alarm (0);
1246 #endif
1247      return(0);
1248   }
1249    /* Receive message */
1250 #ifdef HAVE_TERMIO
1251 /* Timeout==0, help support the mm_wait() routine */
1252    ->"timeout==0 semantics not supported (and its nice if they are)"
1253    result = read(mm_desc, &c, 1);
1254 #else
1255   alarm(timeout);
1256   result = read(mm_desc, &c, 1);
1257   alarm (0);
1258 #endif
1259   if ( result < 0) {
1260       if (errno == EINTR) {
1261         error ("Timeout reading from remote system.");
1262       } else
1263         perror_with_name ("remote");
1264   } else if (result == 1) {
1265       *((char *)msg_ptr+byte_count) = c;
1266       byte_count = byte_count + 1;
1267   }
1268
1269    /* Message header received.  Save message length. */
1270   if (byte_count == (2 * sizeof(INT32)))
1271       length = msg_ptr->generic_msg.length;
1272
1273   if (byte_count >= (length + (2 * sizeof(INT32)))) {
1274       /* Message received */
1275       byte_count = 0;
1276       return(0);
1277   } else
1278       return (-1);
1279
1280 }  /* end msg_recv_serial() */
1281
1282 /********************************************************************* KBD_RAW
1283 ** This function is used to put the keyboard in "raw"
1284 ** mode for BSD Unix.  The original status is saved
1285 ** so that it may be restored later.
1286 */
1287 TERMINAL kbd_tbuf;
1288
1289 int
1290 kbd_raw() {
1291    int    result;
1292    TERMINAL tbuf;
1293
1294    /* Get keyboard termio (to save to restore original modes) */
1295 #ifdef HAVE_TERMIO
1296    result = ioctl(0, TCGETA, &kbd_tbuf);
1297 #else
1298    result = ioctl(0, TIOCGETP, &kbd_tbuf);
1299 #endif
1300    if (result == -1)
1301       return (errno);
1302
1303    /* Get keyboard TERMINAL (for modification) */
1304 #ifdef HAVE_TERMIO
1305    result = ioctl(0, TCGETA, &tbuf);
1306 #else
1307    result = ioctl(0, TIOCGETP, &tbuf);
1308 #endif
1309    if (result == -1)
1310       return (errno);
1311
1312    /* Set up new parameters */
1313 #ifdef HAVE_TERMIO
1314    tbuf.c_iflag = tbuf.c_iflag &
1315       ~(INLCR | ICRNL | IUCLC | ISTRIP | IXON | BRKINT);
1316    tbuf.c_lflag = tbuf.c_lflag & ~(ICANON | ISIG | ECHO);
1317    tbuf.c_cc[4] = 0;  /* MIN */
1318    tbuf.c_cc[5] = 0;  /* TIME */
1319 #else
1320    /* FIXME: not sure if this is correct (matches HAVE_TERMIO). */
1321    tbuf.sg_flags |= RAW;
1322    tbuf.sg_flags |= ANYP;
1323    tbuf.sg_flags &= ~ECHO;
1324 #endif
1325
1326    /* Set keyboard termio to new mode (RAW) */
1327 #ifdef HAVE_TERMIO
1328    result = ioctl(0, TCSETAF, &tbuf);
1329 #else
1330    result = ioctl(0, TIOCSETP, &tbuf);
1331 #endif
1332    if (result == -1)
1333       return (errno);
1334
1335    return (0);
1336 }  /* end kbd_raw() */
1337
1338
1339
1340 /***************************************************************** KBD_RESTORE
1341 ** This function is used to put the keyboard back in the
1342 ** mode it was in before kbk_raw was called.  Note that
1343 ** kbk_raw() must have been called at least once before
1344 ** kbd_restore() is called.
1345 */
1346
1347 int
1348 kbd_restore() {
1349    int result;
1350
1351    /* Set keyboard termio to original mode */
1352 #ifdef HAVE_TERMIO
1353    result = ioctl(0, TCSETAF, &kbd_tbuf);
1354 #else
1355    result = ioctl(0, TIOCGETP, &kbd_tbuf);
1356 #endif
1357
1358    if (result == -1)
1359       return (errno);
1360
1361    return(0);
1362 }  /* end kbd_cooked() */
1363
1364
1365 /*****************************************************************************/
1366 /* Fetch a single register indicatated by 'regno'.
1367  * Returns 0/-1 on success/failure.
1368  */
1369 static int
1370 fetch_register (regno)
1371      int regno;
1372 {
1373      int  result;
1374   DENTER("mm_fetch_register()");
1375   out_msg_buf->read_req_msg.code= READ_REQ;
1376   out_msg_buf->read_req_msg.length = 4*3;
1377   out_msg_buf->read_req_msg.byte_count = 4;
1378
1379   if (regno == GR1_REGNUM)
1380   { out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
1381     out_msg_buf->read_req_msg.address = 1;
1382   }
1383   else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32)
1384   { out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
1385     out_msg_buf->read_req_msg.address = (regno - GR96_REGNUM) + 96;
1386   }
1387 #if defined(GR64_REGNUM)
1388   else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32 )
1389   { out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
1390     out_msg_buf->read_req_msg.address = (regno - GR64_REGNUM) + 64;
1391   }
1392 #endif  /* GR64_REGNUM */
1393   else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128)
1394   { out_msg_buf->read_req_msg.memory_space = LOCAL_REG;
1395     out_msg_buf->read_req_msg.address = (regno - LR0_REGNUM);
1396   }
1397   else if (regno>=FPE_REGNUM && regno<=EXO_REGNUM)
1398   { int val = -1;
1399     supply_register(160 + (regno - FPE_REGNUM),&val);
1400     return 0;           /* Pretend Success */
1401   }
1402   else
1403   { out_msg_buf->read_req_msg.memory_space = SPECIAL_REG;
1404     out_msg_buf->read_req_msg.address = regnum_to_srnum(regno);
1405   }
1406
1407   msg_send_serial(out_msg_buf);
1408
1409   if (expect_msg(READ_ACK,in_msg_buf,1)) {
1410         supply_register (regno, &(in_msg_buf->read_r_ack_msg.data[0]));
1411         result = 0;
1412   } else {
1413         result = -1;
1414   }
1415   DEXIT("mm_fetch_register()");
1416   return result;
1417 }
1418 /*****************************************************************************/
1419 /* Store a single register indicated by 'regno'.
1420  * Returns 0/-1 on success/failure.
1421  */
1422 static int
1423 store_register (regno)
1424      int regno;
1425 {
1426      int  result;
1427
1428   DENTER("store_register()");
1429   out_msg_buf->write_req_msg.code= WRITE_REQ;
1430   out_msg_buf->write_req_msg.length = 4*4;
1431   out_msg_buf->write_req_msg.byte_count = 4;
1432   out_msg_buf->write_r_msg.data[0] = read_register (regno);
1433
1434   if (regno == GR1_REGNUM)
1435   { out_msg_buf->write_req_msg.memory_space = GLOBAL_REG;
1436     out_msg_buf->write_req_msg.address = 1;
1437     /* Setting GR1 changes the numbers of all the locals, so invalidate the
1438      * register cache.  Do this *after* calling read_register, because we want
1439      * read_register to return the value that write_register has just stuffed
1440      * into the registers array, not the value of the register fetched from
1441      * the inferior.
1442      */
1443     registers_changed ();
1444   }
1445 #if defined(GR64_REGNUM)
1446   else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32 )
1447   { out_msg_buf->write_req_msg.memory_space = GLOBAL_REG;
1448     out_msg_buf->write_req_msg.address = (regno - GR64_REGNUM) + 64;
1449   }
1450 #endif  /* GR64_REGNUM */
1451   else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32)
1452   { out_msg_buf->write_req_msg.memory_space = GLOBAL_REG;
1453     out_msg_buf->write_req_msg.address = (regno - GR96_REGNUM) + 96;
1454   }
1455   else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128)
1456   { out_msg_buf->write_req_msg.memory_space = LOCAL_REG;
1457     out_msg_buf->write_req_msg.address = (regno - LR0_REGNUM);
1458   }
1459   else if (regno>=FPE_REGNUM && regno<=EXO_REGNUM)
1460   {
1461     return 0;           /* Pretend Success */
1462   }
1463   else  /* An unprotected or protected special register */
1464   { out_msg_buf->write_req_msg.memory_space = SPECIAL_REG;
1465     out_msg_buf->write_req_msg.address = regnum_to_srnum(regno);
1466   }
1467
1468   msg_send_serial(out_msg_buf);
1469
1470   if (expect_msg(WRITE_ACK,in_msg_buf,1)) {
1471         result = 0;
1472   } else {
1473         result = -1;
1474   }
1475   DEXIT("store_register()");
1476   return result;
1477 }
1478 /****************************************************************************/
1479 /*
1480  * Convert a gdb special register number to a 29000 special register number.
1481  */
1482 static int
1483 regnum_to_srnum(regno)
1484 int     regno;
1485 {
1486         switch(regno) {
1487                 case VAB_REGNUM: return(0);
1488                 case OPS_REGNUM: return(1);
1489                 case CPS_REGNUM: return(2);
1490                 case CFG_REGNUM: return(3);
1491                 case CHA_REGNUM: return(4);
1492                 case CHD_REGNUM: return(5);
1493                 case CHC_REGNUM: return(6);
1494                 case RBP_REGNUM: return(7);
1495                 case TMC_REGNUM: return(8);
1496                 case TMR_REGNUM: return(9);
1497                 case NPC_REGNUM: return(USE_SHADOW_PC ? (20) : (10));
1498                 case PC_REGNUM:  return(USE_SHADOW_PC ? (21) : (11));
1499                 case PC2_REGNUM: return(USE_SHADOW_PC ? (22) : (12));
1500                 case MMU_REGNUM: return(13);
1501                 case LRU_REGNUM: return(14);
1502                 case IPC_REGNUM: return(128);
1503                 case IPA_REGNUM: return(129);
1504                 case IPB_REGNUM: return(130);
1505                 case Q_REGNUM:   return(131);
1506                 case ALU_REGNUM: return(132);
1507                 case BP_REGNUM:  return(133);
1508                 case FC_REGNUM:  return(134);
1509                 case CR_REGNUM:  return(135);
1510                 case FPE_REGNUM: return(160);
1511                 case INTE_REGNUM: return(161);
1512                 case FPS_REGNUM: return(162);
1513                 case EXO_REGNUM:return(164);
1514                 default:
1515                         return(255);    /* Failure ? */
1516         }
1517 }
1518 /****************************************************************************/
1519 /*
1520  * Initialize the target debugger (minimon only).
1521  */
1522 static void
1523 init_target_mm(tstart,tend,dstart,dend,entry,ms_size,rs_size,arg_start)
1524 ADDR32  tstart,tend,dstart,dend,entry;
1525 INT32   ms_size,rs_size;
1526 ADDR32  arg_start;
1527 {
1528         out_msg_buf->init_msg.code = INIT;
1529         out_msg_buf->init_msg.length= sizeof(struct init_msg_t)-2*sizeof(INT32);
1530         out_msg_buf->init_msg.text_start = tstart;
1531         out_msg_buf->init_msg.text_end = tend;
1532         out_msg_buf->init_msg.data_start = dstart;
1533         out_msg_buf->init_msg.data_end = dend;
1534         out_msg_buf->init_msg.entry_point = entry;
1535         out_msg_buf->init_msg.mem_stack_size = ms_size;
1536         out_msg_buf->init_msg.reg_stack_size = rs_size;
1537         out_msg_buf->init_msg.arg_start = arg_start;
1538         msg_send_serial(out_msg_buf);
1539         expect_msg(INIT_ACK,in_msg_buf,1);
1540 }
1541 /****************************************************************************/
1542 /*
1543  * Return a pointer to a string representing the given message code.
1544  * Not all messages are represented here, only the ones that we expect
1545  * to be called with.
1546  */
1547 static char*
1548 msg_str(code)
1549 INT32   code;
1550 {
1551         static char cbuf[32];
1552
1553         switch (code) {
1554         case BKPT_SET_ACK: sprintf(cbuf,"%s (%d)","BKPT_SET_ACK",code); break;
1555         case BKPT_RM_ACK: sprintf(cbuf,"%s (%d)","BKPT_RM_ACK",code); break;
1556         case INIT_ACK:    sprintf(cbuf,"%s (%d)","INIT_ACK",code); break;
1557         case READ_ACK:    sprintf(cbuf,"%s (%d)","READ_ACK",code); break;
1558         case WRITE_ACK:   sprintf(cbuf,"%s (%d)","WRITE_ACK",code); break;
1559         case ERROR:       sprintf(cbuf,"%s (%d)","ERROR",code); break;
1560         case HALT:      sprintf(cbuf,"%s (%d)","HALT",code); break;
1561         default:        sprintf(cbuf,"UNKNOWN (%d)",code); break;
1562         }
1563         return(cbuf);
1564 }
1565 /****************************************************************************/
1566 /*
1567  * Selected (not all of them) error codes that we might get.
1568  */
1569 static char*
1570 error_msg_str(code)
1571 INT32   code;
1572 {
1573         static char cbuf[50];
1574
1575         switch (code) {
1576         case EMFAIL:    return("EMFAIL: unrecoverable error");
1577         case EMBADADDR: return("EMBADADDR: Illegal address");
1578         case EMBADREG:  return("EMBADREG: Illegal register ");
1579         case EMACCESS:  return("EMACCESS: Could not access memory");
1580         case EMBADMSG:  return("EMBADMSG: Unknown message type");
1581         case EMMSG2BIG: return("EMMSG2BIG: Message to large");
1582         case EMNOSEND:  return("EMNOSEND: Could not send message");
1583         case EMNORECV:  return("EMNORECV: Could not recv message");
1584         case EMRESET:   return("EMRESET: Could not RESET target");
1585         case EMCONFIG:  return("EMCONFIG: Could not get target CONFIG");
1586         case EMSTATUS:  return("EMSTATUS: Could not get target STATUS");
1587         case EMREAD:    return("EMREAD: Could not READ target memory");
1588         case EMWRITE:   return("EMWRITE: Could not WRITE target memory");
1589         case EMBKPTSET: return("EMBKPTSET: Could not set breakpoint");
1590         case EMBKPTRM:  return("EMBKPTRM: Could not remove breakpoint");
1591         case EMBKPTSTAT:return("EMBKPTSTAT: Could not get breakpoint status");
1592         case EMBKPTNONE:return("EMBKPTNONE: All breakpoints in use");
1593         case EMBKPTUSED:return("EMBKPTUSED: Breakpoints already in use");
1594         case EMINIT:    return("EMINIT: Could not init target memory");
1595         case EMGO:      return("EMGO: Could not start execution");
1596         case EMSTEP:    return("EMSTEP: Could not single step");
1597         case EMBREAK:   return("EMBREAK: Could not BREAK");
1598         case EMCOMMERR: return("EMCOMMERR: Communication error");
1599         default:        sprintf(cbuf,"error number %d",code); break;
1600         } /* end switch */
1601
1602         return (cbuf);
1603 }
1604 /****************************************************************************/
1605 /*
1606  *  Receive a message and expect it to be of type msgcode.
1607  *  Returns 0/1 on failure/success.
1608  */
1609 static int
1610 expect_msg(msgcode,msg_buf,from_tty)
1611 INT32   msgcode;                /* Msg code we expect */
1612 union msg_t *msg_buf;           /* Where to put  the message received */
1613 int     from_tty;               /* Print message on error if non-zero */
1614 {
1615   /* DENTER("expect_msg()"); */
1616   int   retries=0;
1617   while(msg_recv_serial(msg_buf) && (retries++<MAX_RETRIES));
1618   if (retries >= MAX_RETRIES) {
1619         printf("Expected msg %s, ",msg_str(msgcode));
1620         printf("no message received!\n");
1621         /* DEXIT("expect_msg() failure"); */
1622         return(0);              /* Failure */
1623   }
1624
1625   if (msg_buf->generic_msg.code != msgcode) {
1626      if (from_tty) {
1627         printf("Expected msg %s, ",msg_str(msgcode));
1628         printf("got msg %s\n",msg_str(msg_buf->generic_msg.code));
1629         if (msg_buf->generic_msg.code == ERROR)
1630                 printf("%s\n",error_msg_str(msg_buf->error_msg.error_code));
1631      }
1632      /* DEXIT("expect_msg() failure"); */
1633      return(0);                 /* Failure */
1634   }
1635   /* DEXIT("expect_msg() success"); */
1636   return(1);                    /* Success */
1637 }
1638 /****************************************************************************/
1639 /*
1640  * Determine the MiniMon memory space qualifier based on the addr.
1641  * FIXME: Can't distinguis I_ROM/D_ROM.
1642  * FIXME: Doesn't know anything about I_CACHE/D_CACHE.
1643  */
1644 static int
1645 mm_memory_space(addr)
1646 CORE_ADDR       *addr;
1647 {
1648         ADDR32 tstart = target_config.I_mem_start;
1649         ADDR32 tend   = tstart + target_config.I_mem_size;
1650         ADDR32 dstart = target_config.D_mem_start;
1651         ADDR32 dend   = tstart + target_config.D_mem_size;
1652         ADDR32 rstart = target_config.ROM_start;
1653         ADDR32 rend   = tstart + target_config.ROM_size;
1654
1655         if (((ADDR32)addr >= tstart) && ((ADDR32)addr < tend)) {
1656                 return I_MEM;
1657         } else if (((ADDR32)addr >= dstart) && ((ADDR32)addr < dend)) {
1658                 return D_MEM;
1659         } else if (((ADDR32)addr >= rstart) && ((ADDR32)addr < rend)) {
1660                 /* FIXME: how do we determine between D_ROM and I_ROM */
1661                 return D_ROM;
1662         } else  /* FIXME: what do me do now? */
1663                 return D_MEM;   /* Hmmm! */
1664 }
1665
1666 /****************************************************************************/
1667 /*
1668  *  Define the target subroutine names
1669  */
1670 struct target_ops mm_ops = {
1671         "minimon", "Remote AMD/Minimon target",
1672         "Remote debug an AMD 290*0 using the MiniMon dbg core on the target",
1673         mm_open, mm_close,
1674         mm_attach, mm_detach, mm_resume, mm_wait,
1675         mm_fetch_registers, mm_store_registers,
1676         mm_prepare_to_store, 0, 0,   /* conv_to, conv_from */
1677         mm_xfer_inferior_memory,
1678         mm_files_info,
1679         mm_insert_breakpoint, mm_remove_breakpoint, /* Breakpoints */
1680         0, 0, 0, 0, 0,          /* Terminal handling */
1681         mm_kill,                /* FIXME, kill */
1682         mm_load,
1683         0,                      /* lookup_symbol */
1684         mm_create_inferior,  /* create_inferior */
1685         mm_mourn,            /* mourn_inferior FIXME */
1686         process_stratum, 0, /* next */
1687         1, 1, 1, 1, 1,  /* all mem, mem, stack, regs, exec */
1688         0,0,            /* sections, sections_end */
1689         OPS_MAGIC,              /* Always the last thing */
1690 };
1691
1692 void
1693 _initialize_remote_mm()
1694 {
1695   add_target (&mm_ops);
1696 }
1697
1698 #ifdef NO_HIF_SUPPORT
1699 service_HIF(msg)
1700 union msg_t     *msg;
1701 {
1702         return(0);      /* Emulate a failure */
1703 }
1704 #endif