gdb/monitor.c

   1 /* Remote debugging interface for boot monitors, for GDB.
   2    Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
   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 file was derived from various remote-* modules. It is a collection
  22    of generic support functions so GDB can talk directly to a ROM based
  23    monitor. This saves use from having to hack an exception based handler
  24    into existance, and makes for quick porting.
  25
  26    This module talks to a debug monitor called 'MONITOR', which
  27    We communicate with MONITOR via either a direct serial line, or a TCP
  28    (or possibly TELNET) stream to a terminal multiplexor,
  29    which in turn talks to the target board.
  30 */
  31
  32 #include "defs.h"
  33 #include "gdbcore.h"
  34 #include "target.h"
  35 #include "wait.h"
  36 #include <varargs.h>
  37 #include <signal.h>
  38 #include <string.h>
  39 #include <sys/types.h>
  40 #include "command.h"
  41 #include "serial.h"
  42 #include "monitor.h"
  43 #include "remote-utils.h"
  44
  45 #ifdef HAVE_TERMIO
  46 #  define TERMINAL struct termios
  47 #else
  48 #  define TERMINAL struct sgttyb
  49 #endif
  50
  51 extern void make_xmodem_packet();
  52 extern void print_xmodem_packet();
  53
  54 struct monitor_ops *current_monitor;
  55 extern struct cmd_list_element *setlist;
  56 extern struct cmd_list_element *unsetlist;
  57 struct cmd_list_element *showlist;
  58 extern char *version;
  59 extern char *host_name;
  60 extern char *target_name;
  61
  62 static int hashmark;                            /* flag set by "set hash" */
  63
  64 #define LOG_FILE "monitor.log"
  65 #if defined (LOG_FILE)
  66 FILE *log_file;
  67 #endif
  68
  69 static int timeout = 24;
  70
  71 /*
  72  * Descriptor for I/O to remote machine.  Initialize it to NULL so that
  73  * monitor_open knows that we don't have a file open when the program starts.
  74  */
  75 static serial_t monitor_desc = NULL;
  76
  77 /* sets the download protocol, choices are srec, generic, boot */
  78 char *loadtype;
  79 static char *loadtype_str;
  80 static char *loadproto_str;
  81 static void set_loadtype_command();
  82 static void set_loadproto_command();
  83 static void monitor_load_srec();
  84 static int monitor_write_srec();
  85
  86 /*
  87  * these definitions are for xmodem protocol
  88  */
  89 #define SOH     0x01
  90 #define ACK     0x06
  91 #define NAK     0x15
  92 #define EOT     0x04
  93 #define CANCEL  0x18
  94 #define GETACK          getacknak(ACK)
  95 #define GETNAK          getacknak(NAK)
  96 #define XMODEM_DATASIZE 128             /* the data   size is ALWAYS 128 */
  97 #define XMODEM_PACKETSIZE       131     /* the packet size is ALWAYS 132 (zero based) */
  98 #define XMODEM          1
  99
 100 /*
 101  * set_loadtype_command -- set the type for downloading. Check to make
 102  *      sure you have a support protocol for this target.
 103  */
 104 static void
 105 set_loadtype_command (ignore, from_tty, c)
 106      char *ignore;
 107      int from_tty;
 108      struct cmd_list_element *c;
 109 {
 110   char *tmp;
 111   char *type;
 112
 113   if (current_monitor == 0x0)
 114     return;
 115
 116     if (STREQ (LOADTYPES, "")) {
 117     error ("No loadtype set");
 118     return;
 119   }
 120
 121   tmp = savestring (LOADTYPES, strlen(LOADTYPES));
 122   type = strtok(tmp, ",");
 123   if (STREQ (type, (*(char **) c->var))) {
 124       loadtype_str = savestring (*(char **) c->var, strlen (*(char **) c->var));
 125       return;
 126     }
 127
 128   while ((type = strtok (NULL, ",")) != (char *)NULL) {
 129     if (STREQ (type, (*(char **) c->var)))
 130       loadtype_str = savestring (*(char **) c->var, strlen (*(char **) c->var));
 131     return;
 132   }
 133   free (tmp);
 134   error ("Loadtype \"%s\" does not exist.", (*(char **) c->var));
 135 }
 136 /*
 137  * set_loadproto_command -- set the protocol for downloading. Check to make
 138  *      sure you have a supported protocol for this target.
 139  */
 140 static void
 141 set_loadproto_command (ignore, from_tty, c)
 142      char *ignore;
 143      int from_tty;
 144      struct cmd_list_element *c;
 145 {
 146   char *tmp;
 147   char *type;
 148
 149   if (current_monitor == 0x0)
 150     return;
 151
 152   if (STREQ (LOADPROTOS, "")) {
 153     error ("No load protocols set");
 154     return;
 155   }
 156
 157   tmp = savestring (LOADPROTOS, strlen(LOADPROTOS));
 158   type = strtok(tmp, ",");
 159   if (STREQ (type, (*(char **) c->var))) {
 160       loadproto_str = savestring (*(char **) c->var, strlen (*(char **) c->var));
 161       return;
 162     }
 163
 164   while ((type = strtok (NULL, ",")) != (char *)NULL) {
 165     if (STREQ (type, (*(char **) c->var)))
 166       loadproto_str = savestring (*(char **) c->var, strlen (*(char **) c->var));
 167     return;
 168   }
 169   free (tmp);
 170   error ("Load protocol \"%s\" does not exist.", (*(char **) c->var));
 171 }
 172
 173 /*
 174  * printf_monitor -- send data to monitor.  Works just like printf.
 175  */
 176 static void
 177 printf_monitor(va_alist)
 178      va_dcl
 179 {
 180   va_list args;
 181   char *pattern;
 182   char buf[200];
 183   int i;
 184
 185   va_start(args);
 186
 187   pattern = va_arg(args, char *);
 188
 189   vsprintf(buf, pattern, args);
 190
 191   debuglogs (1, "printf_monitor(), Sending: \"%s\".", buf);
 192
 193   if (SERIAL_WRITE(monitor_desc, buf, strlen(buf)))
 194     fprintf(stderr, "SERIAL_WRITE failed: %s\n", safe_strerror(errno));
 195 }
 196 /*
 197  * write_monitor -- send raw data to monitor.
 198  */
 199 static void
 200 write_monitor(data, len)
 201      char data[];
 202      int len;
 203 {
 204   if (SERIAL_WRITE(monitor_desc, data, len))
 205     fprintf(stderr, "SERIAL_WRITE failed: %s\n", safe_strerror(errno));
 206
 207   *(data + len+1) = '\0';
 208   debuglogs (1, "write_monitor(), Sending: \"%s\".", data);
 209
 210 }
 211
 212 /*
 213  * debuglogs -- deal with debugging info to multiple sources. This takes
 214  *      two real args, the first one is the level to be compared against
 215  *      the sr_get_debug() value, the second arg is a printf buffer and args
 216  *      to be formatted and printed. A CR is added after each string is printed.
 217  */
 218 static void
 219 debuglogs(va_alist)
 220      va_dcl
 221 {
 222   va_list args;
 223   char *pattern, *p;
 224   char buf[200];
 225   char newbuf[300];
 226   int level, i;
 227
 228   va_start(args);
 229
 230   level = va_arg(args, int);                    /* get the debug level */
 231   if ((level <0) || (level > 100)) {
 232     error ("Bad argument passed to debuglogs(), needs debug level");
 233     return;
 234   }
 235
 236   pattern = va_arg(args, char *);               /* get the printf style pattern */
 237
 238   vsprintf(buf, pattern, args);                 /* format the string */
 239
 240   /* convert some characters so it'll look right in the log */
 241   p = newbuf;
 242   for (i=0 ; buf[i] != '\0'; i++) {
 243     switch (buf[i]) {
 244     case '\n':                                  /* newlines */
 245       *p++ = '\\';
 246       *p++ = 'n';
 247       continue;
 248     case '\r':                                  /* carriage returns */
 249       *p++ = '\\';
 250       *p++ = 'r';
 251       continue;
 252     case '\033':                                /* escape */
 253       *p++ = '\\';
 254       *p++ = 'e';
 255       continue;
 256     case '\t':                                  /* tab */
 257       *p++ = '\\';
 258       *p++ = 't';
 259       continue;
 260     case '\b':                                  /* backspace */
 261       *p++ = '\\';
 262       *p++ = 'b';
 263       continue;
 264     default:                                    /* no change */
 265       *p++ = buf[i];
 266     }
 267
 268     if (buf[i] < 26) {                          /* modify control characters */
 269       *p++ = '^';
 270       *p++ = buf[i] + 'A';
 271       continue;
 272     }
 273   }
 274   *p = '\0';                                    /* terminate the string */
 275
 276   if (sr_get_debug() > level)
 277     puts (newbuf);
 278
 279 #ifdef LOG_FILE                                 /* write to the monitor log */
 280   if (log_file != 0x0) {
 281     fputs (newbuf, log_file);
 282     fputc ('\n', log_file);
 283     fflush (log_file);
 284   }
 285 #endif
 286 }
 287
 288 /* readchar -- read a character from the remote system, doing all the fancy
 289  *      timeout stuff.
 290  */
 291 static int
 292 readchar(timeout)
 293      int timeout;
 294 {
 295   int c;
 296
 297   c = SERIAL_READCHAR(monitor_desc, timeout);
 298
 299   if (sr_get_debug() > 5)
 300     putchar(c & 0x7f);
 301
 302 #ifdef LOG_FILE
 303   if (isascii (c))
 304     putc(c & 0x7f, log_file);
 305 #endif
 306
 307   if (c >= 0)
 308     return c & 0x7f;
 309
 310   if (c == SERIAL_TIMEOUT) {
 311     if (timeout == 0)
 312       return c;         /* Polls shouldn't generate timeout errors */
 313     error("Timeout reading from remote system.");
 314 #ifdef LOG_FILE
 315       fputs ("ERROR: Timeout reading from remote system", log_file);
 316 #endif
 317   }
 318   perror_with_name("remote-monitor");
 319 }
 320
 321 /*
 322  * expect --  scan input from the remote system, until STRING is found.
 323  *      If DISCARD is non-zero, then discard non-matching input, else print
 324  *      it out. Let the user break out immediately.
 325  */
 326 static void
 327 expect (string, discard)
 328      char *string;
 329      int discard;
 330 {
 331   char *p = string;
 332   int c;
 333
 334
 335   debuglogs (1, "Expecting \"%s\".", string);
 336
 337   immediate_quit = 1;
 338   while (1) {
 339     c = readchar(timeout);
 340     if (!isascii (c))
 341       continue;
 342     if (c == *p++) {
 343       if (*p == '\0') {
 344         immediate_quit = 0;
 345         debuglogs (4, "Matched");
 346         return;
 347       }
 348     } else {
 349       if (!discard) {
 350         fwrite(string, 1, (p - 1) - string, stdout);
 351         putchar((char)c);
 352         fflush(stdout);
 353       }
 354       p = string;
 355     }
 356   }
 357 }
 358
 359 /* Keep discarding input until we see the MONITOR prompt.
 360
 361    The convention for dealing with the prompt is that you
 362    o give your command
 363    o *then* wait for the prompt.
 364
 365    Thus the last thing that a procedure does with the serial line
 366    will be an expect_prompt().  Exception:  monitor_resume does not
 367    wait for the prompt, because the terminal is being handed over
 368    to the inferior.  However, the next thing which happens after that
 369    is a monitor_wait which does wait for the prompt.
 370    Note that this includes abnormal exit, e.g. error().  This is
 371    necessary to prevent getting into states from which we can't
 372    recover.  */
 373 static void
 374 expect_prompt(discard)
 375      int discard;
 376 {
 377   expect (PROMPT, discard);
 378 }
 379
 380 /*
 381  * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise
 382  */
 383 static int
 384 junk(ch)
 385      char ch;
 386 {
 387   switch (ch) {
 388   case '\0':
 389   case ' ':
 390   case '-':
 391   case '\t':
 392   case '\r':
 393   case '\n':
 394     if (sr_get_debug() > 5)
 395       debuglogs (5, "Ignoring \'%c\'.", ch);
 396     return 1;
 397   default:
 398     if (sr_get_debug() > 5)
 399       debuglogs (5, "Accepting \'%c\'.", ch);
 400     return 0;
 401   }
 402 }
 403
 404 /*
 405  *  get_hex_digit -- Get a hex digit from the remote system & return its value.
 406  *              If ignore is nonzero, ignore spaces, newline & tabs.
 407  */
 408 static int
 409 get_hex_digit(ignore)
 410      int ignore;
 411 {
 412   static int ch;
 413   while (1) {
 414     ch = readchar(timeout);
 415     if (junk(ch))
 416       continue;
 417     if (sr_get_debug() > 4)
 418       debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch, ch);
 419
 420     if (ch >= '0' && ch <= '9')
 421       return ch - '0';
 422     else if (ch >= 'A' && ch <= 'F')
 423       return ch - 'A' + 10;
 424     else if (ch >= 'a' && ch <= 'f')
 425       return ch - 'a' + 10;
 426     else if (ch == ' ' && ignore)
 427       ;
 428     else {
 429       expect_prompt(1);
 430       error("Invalid hex digit from remote system. (0x%x)", ch);
 431     }
 432   }
 433 }
 434
 435 /* get_hex_byte -- Get a byte from monitor and put it in *BYT.
 436  *      Accept any number leading spaces.
 437  */
 438 static void
 439 get_hex_byte (byt)
 440      char *byt;
 441 {
 442   int val;
 443
 444   val = get_hex_digit (1) << 4;
 445   debuglogs (4, "get_hex_digit() -- Read first nibble 0x%x", val);
 446
 447   val |= get_hex_digit (0);
 448   debuglogs (4, "get_hex_digit() -- Read second nibble 0x%x", val);
 449   *byt = val;
 450
 451   debuglogs (4, "get_hex_digit() -- Read a 0x%x", val);
 452 }
 453
 454 /*
 455  * get_hex_word --  Get N 32-bit words from remote, each preceded by a space,
 456  *      and put them in registers starting at REGNO.
 457  */
 458 static int
 459 get_hex_word ()
 460 {
 461   long val;
 462   int i;
 463
 464   val = 0;
 465   for (i = 0; i < 8; i++)
 466     val = (val << 4) + get_hex_digit (i == 0);
 467
 468   debuglogs (4, "get_hex_word() got a 0x%x.", val);
 469
 470   return val;
 471 }
 472
 473 /* This is called not only when we first attach, but also when the
 474    user types "run" after having attached.  */
 475 void
 476 monitor_create_inferior (execfile, args, env)
 477      char *execfile;
 478      char *args;
 479      char **env;
 480 {
 481   int entry_pt;
 482
 483   if (args && *args)
 484     error("Can't pass arguments to remote MONITOR process");
 485
 486   if (execfile == 0 || exec_bfd == 0)
 487     error("No exec file specified");
 488
 489   entry_pt = (int) bfd_get_start_address (exec_bfd);
 490
 491   debuglogs (1, "create_inferior(exexfile=%s, args=%s, env=%s)", execfile, args, env);
 492
 493 /* The "process" (board) is already stopped awaiting our commands, and
 494    the program is already downloaded.  We just set its PC and go.  */
 495
 496   clear_proceed_status ();
 497
 498   /* Tell wait_for_inferior that we've started a new process.  */
 499   init_wait_for_inferior ();
 500
 501   /* Set up the "saved terminal modes" of the inferior
 502      based on what modes we are starting it with.  */
 503   target_terminal_init ();
 504
 505   /* Install inferior's terminal modes.  */
 506   target_terminal_inferior ();
 507
 508   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 509
 510   /* Let 'er rip... */
 511   proceed ((CORE_ADDR)entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 512 }
 513
 514 /*
 515  * monitor_open -- open a connection to a remote debugger.
 516  *      NAME is the filename used for communication.
 517  */
 518 static int baudrate = 9600;
 519 static char dev_name[100];
 520
 521 void
 522 monitor_open(args, name, from_tty)
 523      char *args;
 524      char *name;
 525      int from_tty;
 526 {
 527
 528   if (args == NULL)
 529     error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
 530 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);
 531
 532 /*  if (is_open) */
 533     monitor_close(0);
 534
 535   strcpy(dev_name, args);
 536   monitor_desc = SERIAL_OPEN(dev_name);
 537
 538   if (monitor_desc == NULL)
 539     perror_with_name(dev_name);
 540
 541   if (baud_rate != -1) {
 542     if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate)) {
 543       SERIAL_CLOSE (monitor_desc);
 544       perror_with_name (name);
 545     }
 546   }
 547
 548   SERIAL_RAW(monitor_desc);
 549
 550 #if defined (LOG_FILE)
 551   log_file = fopen (LOG_FILE, "w");
 552   if (log_file == NULL)
 553     perror_with_name (LOG_FILE);
 554   fprintf_filtered (log_file, "GDB %s (%s", version, host_name);
 555   fprintf_filtered (log_file, " --target %s)\n", target_name);
 556   fprintf_filtered (log_file, "Remote target %s connected to %s\n\n", TARGET_NAME, dev_name);
 557 #endif
 558
 559   /* wake up the monitor and see if it's alive */
 560   printf_monitor(INIT_CMD);
 561   expect_prompt(1);             /* See if we get a prompt */
 562
 563   /* try again to be sure */
 564   printf_monitor(INIT_CMD);
 565   expect_prompt(1);             /* See if we get a prompt */
 566
 567   if (from_tty)
 568     printf("Remote target %s connected to %s\n", TARGET_NAME, dev_name);
 569 }
 570
 571 /*
 572  * monitor_close -- Close out all files and local state before this
 573  *      target loses control.
 574  */
 575
 576 void
 577 monitor_close (quitting)
 578      int quitting;
 579 {
 580   SERIAL_CLOSE(monitor_desc);
 581   monitor_desc = NULL;
 582
 583   debuglogs (1, "monitor_close (quitting=%d)", quitting);
 584
 585 #if defined (LOG_FILE)
 586   if (log_file) {
 587     if (ferror(log_file))
 588       fprintf(stderr, "Error writing log file.\n");
 589     if (fclose(log_file) != 0)
 590       fprintf(stderr, "Error closing log file.\n");
 591   }
 592 #endif
 593 }
 594
 595 /*
 596  * monitor_detach -- terminate the open connection to the remote
 597  *      debugger. Use this when you want to detach and do something
 598  *      else with your gdb.
 599  */
 600 void
 601 monitor_detach (from_tty)
 602      int from_tty;
 603 {
 604
 605   debuglogs (1, "monitor_detach ()");
 606
 607   pop_target();         /* calls monitor_close to do the real work */
 608   if (from_tty)
 609     printf ("Ending remote %s debugging\n", target_shortname);
 610 }
 611
 612 /*
 613  * monitor_attach -- attach GDB to the target.
 614  */
 615 void
 616 monitor_attach (args, from_tty)
 617      char *args;
 618      int from_tty;
 619 {
 620   if (from_tty)
 621     printf ("Starting remote %s debugging\n", target_shortname);
 622
 623   debuglogs (1, "monitor_attach (args=%s)", args);
 624
 625   printf_monitor (GO_CMD);
 626   /* swallow the echo.  */
 627   expect (GO_CMD, 1);
 628 }
 629
 630 /*
 631  * monitor_resume -- Tell the remote machine to resume.
 632  */
 633 void
 634 monitor_resume (pid, step, sig)
 635      int pid, step;
 636      enum target_signal sig;
 637 {
 638   debuglogs (1, "monitor_resume (step=%d, sig=%d)", step, sig);
 639
 640   if (step) {
 641     printf_monitor (STEP_CMD);
 642   } else {
 643     printf_monitor (CONT_CMD);
 644   }
 645 }
 646
 647 /*
 648  * monitor_wait -- Wait until the remote machine stops, then return,
 649  *          storing status in status just as `wait' would.
 650  */
 651 int
 652 monitor_wait (pid, status)
 653      int pid;
 654      struct target_waitstatus *status;
 655 {
 656   int old_timeout = timeout;
 657
 658   debuglogs(1, "monitor_wait (), printing extraneous text.");
 659
 660   status->kind = TARGET_WAITKIND_EXITED;
 661   status->value.integer = 0;
 662
 663   timeout = 0;          /* Don't time out -- user program is running. */
 664
 665   expect_prompt(0);    /* Wait for prompt, outputting extraneous text */
 666   debuglogs (4, "monitor_wait(), got the prompt.");
 667
 668   status->kind = TARGET_WAITKIND_STOPPED;
 669   status->value.sig = TARGET_SIGNAL_TRAP;
 670
 671   timeout = old_timeout;
 672
 673   return 0;
 674 }
 675
 676 /* Return the name of register number regno in the form input and output by
 677    monitor.  Currently, register_names just happens to contain exactly what
 678    monitor wants.  Lets take advantage of that just as long as possible! */
 679
 680 static char *
 681 get_reg_name (regno)
 682      int regno;
 683 {
 684   static char buf[50];
 685   const char *p;
 686   char *b;
 687
 688   b = buf;
 689
 690   if (regno < 0)
 691     return ("");
 692
 693   for (p = REGNAMES(regno); *p; p++)
 694     *b++ = tolower(*p);
 695
 696   *b = '\000';
 697
 698   debuglogs (5, "Got name \"%s\" from regno #%d.", buf, regno);
 699
 700   return buf;
 701 }
 702
 703 /*
 704  * monitor_fetch_registers -- read the remote registers into the
 705  *      block regs.
 706  */
 707 void
 708 monitor_fetch_registers ()
 709 {
 710   int regno;
 711
 712   /* yeah yeah, i know this is horribly inefficient.  but it isn't done
 713      very often...  i'll clean it up later.  */
 714
 715   for (regno = 0; regno <= PC_REGNUM; regno++)
 716     monitor_fetch_register(regno);
 717 }
 718
 719 /*
 720  * monitor_fetch_register -- fetch register REGNO, or all registers if REGNO
 721  *      is -1. Returns errno value.
 722  */
 723 void
 724 monitor_fetch_register (regno)
 725      int regno;
 726 {
 727   int val, j;
 728
 729   debuglogs (1, "monitor_fetch_register (reg=%s)", get_reg_name (regno));
 730
 731   if (regno < 0) {
 732     monitor_fetch_registers ();
 733   } else {
 734     char *name = get_reg_name (regno);
 735     if (STREQ(name, ""))
 736       return;
 737     printf_monitor (ROMCMD(GET_REG), name);     /* send the command */
 738     expect (name, 1);                           /* then strip the leading garbage */
 739     if (*ROMDELIM(GET_REG) != 0) {              /* if there's a delimiter */
 740       expect (ROMDELIM(GET_REG), 1);
 741     }
 742
 743     val =  get_hex_word();                      /* get the value, ignore junk */
 744     supply_register (regno, (char *) &val);
 745
 746     if (*ROMDELIM(GET_REG) != 0) {
 747 /***  expect (ROMRES(GET_REG)); ***/
 748       printf_monitor (CMD_END);
 749     }
 750     expect_prompt (1);
 751   }
 752   return;
 753 }
 754
 755 /* Store the remote registers from the contents of the block REGS.  */
 756
 757 void
 758 monitor_store_registers ()
 759 {
 760   int regno;
 761
 762   debuglogs (1, "monitor_store_registers()");
 763
 764   for (regno = 0; regno <= PC_REGNUM; regno++)
 765     monitor_store_register(regno);
 766
 767   registers_changed ();
 768 }
 769
 770 /*
 771  * monitor_store_register -- store register REGNO, or all if REGNO == 0.
 772  *      return errno value.
 773  */
 774 void
 775 monitor_store_register (regno)
 776      int regno;
 777 {
 778   char *name;
 779   int i;
 780
 781   i = read_register(regno);
 782
 783   debuglogs (1, "monitor_store_register (regno=%d)", regno);
 784
 785   if (regno < 0)
 786     monitor_store_registers ();
 787   else {
 788       debuglogs (3, "Setting register %s to 0x%x", get_reg_name (regno), read_register (regno));
 789
 790     name = get_reg_name (regno);
 791     if (STREQ(name, ""))
 792       return;
 793     printf_monitor (ROMCMD(SET_REG), name, read_register(regno));
 794     expect (name, 1);                           /* strip the leading garbage */
 795     if (*ROMDELIM(SET_REG) != 0) {              /* if there's a delimiter */
 796       expect (ROMDELIM(SET_REG), 1);
 797       get_hex_word(1);
 798       printf_monitor ("%d%s\n", i, CMD_END);
 799     }
 800     expect_prompt (1);
 801   }
 802   return;
 803
 804 #if 0
 805       printf_monitor (SET_REG, get_reg_name (regno),
 806                       read_register (regno));
 807       expect_prompt (1);
 808     }
 809 #endif
 810 }
 811
 812 /* Get ready to modify the registers array.  On machines which store
 813    individual registers, this doesn't need to do anything.  On machines
 814    which store all the registers in one fell swoop, this makes sure
 815    that registers contains all the registers from the program being
 816    debugged.  */
 817
 818 void
 819 monitor_prepare_to_store ()
 820 {
 821   /* Do nothing, since we can store individual regs */
 822 }
 823
 824 void
 825 monitor_files_info ()
 826 {
 827   printf ("\tAttached to %s at %d baud.\n",
 828           dev_name, baudrate);
 829 }
 830
 831 /*
 832  * monitor_write_inferior_memory -- Copy LEN bytes of data from debugger
 833  *      memory at MYADDR to inferior's memory at MEMADDR.  Returns length moved.
 834  */
 835 int
 836 monitor_write_inferior_memory (memaddr, myaddr, len)
 837      CORE_ADDR memaddr;
 838      unsigned char *myaddr;
 839      int len;
 840 {
 841   int i;
 842   char buf[10];
 843
 844   debuglogs (1, "monitor_write_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr, myaddr, len);
 845
 846   for (i = 0; i < len; i++) {
 847     printf_monitor (ROMCMD(SET_MEM), memaddr + i, myaddr[i] );
 848     if (*ROMDELIM(SET_MEM) != 0) {              /* if there's a delimiter */
 849       expect (ROMDELIM(SET_MEM), 1);
 850       expect (CMD_DELIM);
 851       printf_monitor ("%x", myaddr[i]);
 852     }
 853 /***    printf_monitor ("%x", myaddr[i]); ***/
 854     if (sr_get_debug() > 1)
 855       printf ("\nSet 0x%x to 0x%x\n", memaddr + i, myaddr[i]);
 856     if (*ROMDELIM(SET_MEM) != 0) {
 857       expect (CMD_DELIM);
 858       printf_monitor (CMD_END);
 859     }
 860     expect_prompt (1);
 861   }
 862   return len;
 863 }
 864
 865 /*
 866  * monitor_read_inferior_memory -- read LEN bytes from inferior memory
 867  *      at MEMADDR.  Put the result at debugger address MYADDR.  Returns
 868  *      length moved.
 869  */
 870 int
 871 monitor_read_inferior_memory(memaddr, myaddr, len)
 872      CORE_ADDR memaddr;
 873      char *myaddr;
 874      int len;
 875 {
 876   int i, j;
 877   char buf[20];
 878
 879   /* Number of bytes read so far.  */
 880   int count;
 881
 882   /* Starting address of this pass.  */
 883   unsigned long startaddr;
 884
 885   /* Number of bytes to read in this pass.  */
 886   int len_this_pass;
 887
 888   debuglogs (1, "monitor_read_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr, myaddr, len);
 889
 890   /* Note that this code works correctly if startaddr is just less
 891      than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
 892      thing).  That is, something like
 893      monitor_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
 894      works--it never adds len To memaddr and gets 0.  */
 895   /* However, something like
 896      monitor_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
 897      doesn't need to work.  Detect it and give up if there's an attempt
 898      to do that.  */
 899   if (((memaddr - 1) + len) < memaddr) {
 900     errno = EIO;
 901     return 0;
 902   }
 903
 904   startaddr = memaddr;
 905   count = 0;
 906   while (count < len) {
 907     len_this_pass = 16;
 908     if ((startaddr % 16) != 0)
 909       len_this_pass -= startaddr % 16;
 910     if (len_this_pass > (len - count))
 911       len_this_pass = (len - count);
 912
 913     debuglogs (3, "Display %d bytes at %x", len_this_pass, startaddr);
 914
 915     for (i = 0; i < len_this_pass; i++) {
 916       printf_monitor (ROMCMD(GET_MEM), startaddr, startaddr);
 917       sprintf (buf, ROMCMD(GET_MEM), startaddr, startaddr);
 918       if (*ROMDELIM(GET_MEM) != 0) {            /* if there's a delimiter */
 919         expect (ROMDELIM(GET_MEM), 1);
 920       } else {
 921         sprintf (buf, ROMCMD(GET_MEM), startaddr, startaddr);
 922         expect (buf,1);                         /* get the command echo */
 923         get_hex_word(1);                        /* strip away the address */
 924       }
 925       get_hex_byte (&myaddr[count++]);          /* get the value at this address */
 926
 927       if (*ROMDELIM(GET_MEM) != 0) {
 928         printf_monitor (CMD_END);
 929       }
 930       expect_prompt (1);
 931       startaddr += 1;
 932     }
 933   }
 934   return len;
 935 }
 936
 937 /* FIXME-someday!  merge these two.  */
 938 int
 939 monitor_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 940      CORE_ADDR memaddr;
 941      char *myaddr;
 942      int len;
 943      int write;
 944      struct target_ops *target;         /* ignored */
 945 {
 946   if (write)
 947     return monitor_write_inferior_memory (memaddr, myaddr, len);
 948   else
 949     return monitor_read_inferior_memory (memaddr, myaddr, len);
 950 }
 951
 952 void
 953 monitor_kill (args, from_tty)
 954      char *args;
 955      int from_tty;
 956 {
 957   return;               /* ignore attempts to kill target system */
 958 }
 959
 960 /* Clean up when a program exits.
 961    The program actually lives on in the remote processor's RAM, and may be
 962    run again without a download.  Don't leave it full of breakpoint
 963    instructions.  */
 964
 965 void
 966 monitor_mourn_inferior ()
 967 {
 968   remove_breakpoints ();
 969   generic_mourn_inferior ();    /* Do all the proper things now */
 970 }
 971
 972 #define MAX_MONITOR_BREAKPOINTS 16
 973
 974 extern int memory_breakpoint_size;
 975 static CORE_ADDR breakaddr[MAX_MONITOR_BREAKPOINTS] = {0};
 976
 977 /*
 978  * monitor_insert_breakpoint -- add a breakpoint
 979  */
 980 int
 981 monitor_insert_breakpoint (addr, shadow)
 982      CORE_ADDR addr;
 983      char *shadow;
 984 {
 985   int i;
 986
 987   debuglogs (1, "monitor_insert_breakpoint() addr = 0x%x", addr);
 988
 989   for (i = 0; i <= MAX_MONITOR_BREAKPOINTS; i++) {
 990     if (breakaddr[i] == 0) {
 991       breakaddr[i] = addr;
 992       if (sr_get_debug() > 4)
 993         printf ("Breakpoint at %x\n", addr);
 994       monitor_read_inferior_memory(addr, shadow, memory_breakpoint_size);
 995       printf_monitor(SET_BREAK_CMD, addr);
 996       expect_prompt(1);
 997       return 0;
 998     }
 999   }
1000
1001   fprintf(stderr, "Too many breakpoints (> 16) for monitor\n");
1002   return 1;
1003 }
1004
1005 /*
1006  * _remove_breakpoint -- Tell the monitor to remove a breakpoint
1007  */
1008 int
1009 monitor_remove_breakpoint (addr, shadow)
1010      CORE_ADDR addr;
1011      char *shadow;
1012 {
1013   int i;
1014
1015   debuglogs (1, "monitor_remove_breakpoint() addr = 0x%x", addr);
1016
1017   for (i = 0; i < MAX_MONITOR_BREAKPOINTS; i++) {
1018     if (breakaddr[i] == addr) {
1019       breakaddr[i] = 0;
1020       /* some monitors remove breakpoints based on the address */
1021       if (CLR_BREAK_ADDR)
1022         printf_monitor(CLR_BREAK_CMD, addr);
1023       else
1024         printf_monitor(CLR_BREAK_CMD, i);
1025       expect_prompt(1);
1026       return 0;
1027     }
1028   }
1029   fprintf(stderr, "Can't find breakpoint associated with 0x%x\n", addr);
1030   return 1;
1031 }
1032
1033 /* monitor_load -- load a file. This file determines which of the
1034  *      supported formats to use. The current types are:
1035  *      FIXME: not all types supported yet.
1036  *      default - reads any file using bfd and writes it to memory. This
1037  *              is really slow.
1038  *      srec    - reads binary file using bfd and writes it as an
1039  *              ascii srecord.
1040  *      xmodem-bin - reads a binary file using bfd, and  downloads it
1041  *               using xmodem protocol.
1042  *      xmodem-srec - reads a binary file using bfd, and after converting
1043  *               it downloads it as an srecord using xmodem protocol.
1044  *      ascii-srec - reads a ascii srecord file and downloads it
1045  *              without a change.
1046  *      ascii-xmodem - reads a ascii file and downloads using xmodem
1047  *              protocol.
1048  */
1049 void
1050 monitor_load (file, fromtty)
1051     char *file;
1052     int  fromtty;
1053 {
1054   FILE *download;
1055   int i, bytes_read;
1056
1057   debuglogs (1, "Loading %s to monitor", file);
1058
1059   if (STREQ (loadtype_str, "default")) {        /* default, load a binary */
1060     gr_load_image (file, fromtty);              /* by writing it into memory */
1061     return;
1062   }
1063
1064   /* load an srecord by converting */
1065   if ((STREQ (loadtype_str, "srec")) && STREQ (loadproto_str, "xmodem")) {
1066     monitor_load_srec(file, XMODEM);
1067     return;
1068   }
1069
1070   if (STREQ (loadtype_str, "srec")) {           /* load an srecord by converting */
1071     monitor_load_srec(file, 0);                 /* if from a binary */
1072     return;
1073   }
1074
1075   if (STREQ (loadtype_str, "none")) {           /* load an srecord by converting */
1076     error ("Unimplemented");
1077     return;
1078   }
1079
1080   if (STREQ (loadproto_str, "none")) {  /* load an srecord file */
1081     monitor_load_ascii_srec(file, fromtty);             /* if from a binary */
1082     return;
1083   }
1084
1085   if (STREQ (loadproto_str, "xmodem")) {                /* load an srecord using the */
1086     monitor_load_srec(file, XMODEM);
1087     return;
1088   }
1089 }
1090
1091 /*
1092  * monitor_load_ascii_srec -- download an ASCII srecord file.
1093  */
1094 #define DOWNLOAD_LINE_SIZE 100
1095 int
1096 monitor_load_ascii_srec (file, fromtty)
1097     char *file;
1098     int fromtty;
1099 {
1100   FILE *download;
1101   char buf[DOWNLOAD_LINE_SIZE];
1102   int i, bytes_read;
1103
1104   debuglogs (1, "Loading an ASCII srecord file, %s.", file);
1105
1106   download = fopen (file, "r");
1107   if (download == NULL) {
1108     error ("%s Does not exist", file);
1109     return;
1110   }
1111
1112   printf_monitor (LOAD_CMD);
1113   sleep(1);
1114   while (!feof (download)) {
1115     bytes_read = fread (buf, sizeof (char), DOWNLOAD_LINE_SIZE, download);
1116     if (hashmark) {
1117       putchar ('.');
1118       fflush (stdout);
1119     }
1120     if (SERIAL_WRITE(monitor_desc, buf, bytes_read)) {
1121       fprintf(stderr, "SERIAL_WRITE failed: (while downloading) %s\n", safe_strerror(errno));
1122       break;
1123     }
1124     i = 0;
1125     while (i++ <=200) {} ;                      /* Ugly HACK, probably needs flow control */
1126     if (bytes_read < DOWNLOAD_LINE_SIZE) {
1127       if (!feof (download))
1128         error ("Only read %d bytes\n", bytes_read);
1129       break;
1130     }
1131   }
1132
1133   if (hashmark) {
1134     putchar ('\n');
1135   }
1136   if (!feof (download))
1137     error ("Never got EOF while downloading");
1138   expect_prompt(1);
1139   fclose (download);
1140 }
1141
1142 /*
1143  * monitor_command -- put a command string, in args, out to MONITOR.
1144  *      Output from MONITOR is placed on the users terminal until the
1145  *      prompt is seen. FIXME: We read the charcters ourseleves here
1146  *      cause of a nasty echo.
1147  */
1148 void
1149 monitor_command (args, fromtty)
1150      char       *args;
1151      int        fromtty;
1152 {
1153
1154   char *p;
1155   char c, cp;
1156   p = PROMPT;
1157
1158   debuglogs (1, "monitor_command (args=%s)", args);
1159
1160   if (monitor_desc == NULL)
1161     error("monitor target not open.");
1162
1163   if (!args)
1164     error("Missing command.");
1165
1166   printf_monitor ("%s\n", args);
1167
1168   expect_prompt(0);
1169 }
1170
1171 /*
1172  * monitor_load_srec -- download a binary file by converting it to srecords. This
1173  *      will also use xmodem to download the resulting file.
1174  *
1175  *      A download goes like this when using xmodem:
1176  *      Receiver:               Sender
1177  *      NAK ---------->
1178  *              <-------- (packet)      [SOH|1|1|data|SUM]
1179  *      ACK ---------->
1180  *              <-------- (packet)      [SOH|2|2|data|SUM]
1181  *      ACK ---------->
1182  *              <-------- EOT
1183  *      ACK ---------->
1184  *
1185  *      ACK = 0x06
1186  *      NAK = 0x15
1187  *      EOT = 0x04
1188  *
1189  */
1190 static void
1191 monitor_load_srec (args, protocol)
1192      char *args;
1193      int protocol;
1194 {
1195   bfd *abfd;
1196   asection *s;
1197   char buffer[1024];
1198   char srec[1024];
1199   char packet[XMODEM_PACKETSIZE];
1200   int i;
1201   int retries;
1202   int type = 0;                                 /* default to a type 0, header record */
1203   int srec_frame = 57;                          /* FIXME: this must be 57 There is 12 bytes
1204                                                  of header, and 2 bytes of checksum at the end.
1205                                                  The problem is an xmodem packet holds exactly
1206                                                  128 bytes. */
1207
1208   abfd = bfd_openr (args, 0);
1209   if (!abfd) {
1210     printf_filtered ("Unable to open file %s\n", args);
1211     return;
1212   }
1213
1214   if (bfd_check_format (abfd, bfd_object) == 0) {
1215     printf_filtered ("File is not an object file\n");
1216     return;
1217   }
1218
1219   printf_monitor (LOAD_CMD);                    /* tell the monitor to load */
1220   if (protocol == XMODEM) {                     /* get the NAK from the target */
1221     if (GETNAK) {
1222       debuglogs (3, "Got the NAK to start loading");
1223     } else {
1224       printf_monitor ("%c", EOT);
1225       debuglogs (3, "Never got the NAK to start loading");
1226       error ("Never got the NAK to start loading");
1227     }
1228   }
1229
1230   s = abfd->sections;
1231   while (s != (asection *) NULL) {
1232     if (s->flags & SEC_LOAD) {
1233       char *buffer = xmalloc (srec_frame);
1234       printf_filtered ("%s\t: 0x%4x .. 0x%4x  ", s->name, s->vma, s->vma + s->_raw_size);
1235       fflush (stdout);
1236       for (i = 0; i < s->_raw_size; i += srec_frame) {
1237         if (srec_frame > s->_raw_size - i)
1238           srec_frame = s->_raw_size - i;
1239
1240         bfd_get_section_contents (abfd, s, buffer, i, srec_frame);
1241         monitor_make_srec (srec, type, s->vma + i, buffer, srec_frame);
1242         if (protocol == XMODEM) {               /* send a packet using xmodem */
1243           make_xmodem_packet (packet, srec, XMODEM_DATASIZE);
1244           write_monitor (packet, XMODEM_PACKETSIZE+1);
1245           retries = 0;
1246           while (retries++ <= 3) {
1247             if (GETNAK) {                       /* Resend packet */
1248               debuglogs (3, "Got a NAK, resending packet");
1249               sleep(1);
1250               write_monitor (packet, XMODEM_PACKETSIZE+1); /* send it again */
1251               if (GETACK)                       /* ACKnowledged, get next data chunk */
1252                 break;
1253             } else {                            /* assume we got an ACK */
1254               if (hashmark)
1255                 printf_filtered ("#");
1256               debuglogs (3, "Got an ACK, sending next packet");
1257               break;
1258             }
1259           }
1260           if (retries >= 4) {                   /* too many tries, must be hosed */
1261             printf_monitor ("%c", EOT);
1262             error ("Never got a ACK after sending an xmodem packet");
1263           }
1264         } else {                                /* no protocols at all */
1265           printf_monitor ("%s\n", srec);
1266         }
1267         if (hashmark)
1268           printf_filtered ("#");
1269         type = 3;                               /* switch to a 4 byte address record */
1270         fflush (stdout);
1271       }
1272       printf_filtered ("\n");
1273       free (buffer);
1274     } else {
1275       debuglogs (3, "%s doesn't need to be loaded", s->name);
1276     }
1277     s = s->next;
1278   }
1279
1280   /*
1281      write a type 7 terminator record. no data for a type 7,
1282      and there is no data, so len is 0.
1283    */
1284   if (protocol == XMODEM) {             /* send a packet using xmodem */
1285     monitor_make_srec (srec, 7, abfd->start_address, "", 0);
1286     make_xmodem_packet (packet, srec, XMODEM_DATASIZE);
1287     write_monitor (packet, XMODEM_PACKETSIZE+1);
1288   } else {
1289     monitor_make_srec (srec, 7, abfd->start_address, "", 0);
1290     printf_monitor ("%s\n", srec);
1291   }
1292   if (protocol == XMODEM) {
1293     printf_monitor ("%c", EOT);
1294     if (!GETACK)
1295       error ("Never got ACK after sending EOT");
1296   }
1297
1298   if (hashmark)
1299     putchar ('\n');
1300
1301   expect_prompt ();
1302 }
1303
1304 /*
1305  * getacknak -- get an ACK or a NAK from the target.
1306  *              returns 1 (true) or 0 (false) This is
1307  *              for xmodem. ANy string starting with "***"
1308  *              is an error message from the target.
1309  *      Here's a few from the WinBond w89k "Cougar" PA board.
1310  *              *** Too many errors found.
1311  *              *** Bad command
1312  *              *** Command syntax error
1313  */
1314 int
1315 getacknak (byte)
1316      int byte;
1317 {
1318   char character;
1319   int i;
1320
1321   i = 0;
1322   while (i++ < 60) {
1323     character = (char)readchar (0);
1324     if ((character == 0xfffffffe) || (character == 0x7f)) {             /* empty uart */
1325       if (sr_get_debug() > 3)
1326         putchar ('.');
1327       fflush (stdout);
1328       sleep (1);
1329       continue;
1330     }
1331     if (character == CANCEL) {                  /* target aborted load */
1332       expect_prompt (0);
1333       error ("Got a CANCEL from the target.");
1334     }
1335     if (character == '*') {                     /* look for missed error message */
1336       expect_prompt (0);
1337       error ("Got an error message from the target");
1338     }
1339     debuglogs (3, "Got a %s (0x%x or \'%c\'), expecting a %s.\n",
1340                (character == ACK) ? "ACK" : (character == NAK) ? "NAK" : "BOGUS",
1341                character,  character, (byte == ACK) ? "ACK" : "NAK");
1342     if (character == byte)                      /* got what we wanted */
1343       return 1;
1344     if (character == ((byte == ACK) ? NAK : ACK)) {     /* got the opposite */
1345       debuglogs (3, "Got the opposite, wanted 0x%x, got a 0x%x", byte, character);
1346       return 0;
1347     }
1348     sleep (1);
1349   }
1350   return 0;
1351 }
1352
1353 /*
1354  * monitor_make_srec -- make an srecord. This writes each line, one at a
1355  *      time, each with it's own header and trailer line.
1356  *      An srecord looks like this:
1357  *
1358  * byte count-+     address
1359  * start ---+ |        |       data        +- checksum
1360  *          | |        |                   |
1361  *        S01000006F6B692D746573742E73726563E4
1362  *        S315000448600000000000000000FC00005900000000E9
1363  *        S31A0004000023C1400037DE00F023604000377B009020825000348D
1364  *        S30B0004485A0000000000004E
1365  *        S70500040000F6
1366  *
1367  *      S<type><length><address><data><checksum>
1368  *
1369  *      Where
1370  *      - length
1371  *        is the number of bytes following upto the checksum. Note that
1372  *        this is not the number of chars following, since it takes two
1373  *        chars to represent a byte.
1374  *      - type
1375  *        is one of:
1376  *        0) header record
1377  *        1) two byte address data record
1378  *        2) three byte address data record
1379  *        3) four byte address data record
1380  *        7) four byte address termination record
1381  *        8) three byte address termination record
1382  *        9) two byte address termination record
1383  *
1384  *      - address
1385  *        is the start address of the data following, or in the case of
1386  *        a termination record, the start address of the image
1387  *      - data
1388  *        is the data.
1389  *      - checksum
1390  *        is the sum of all the raw byte data in the record, from the length
1391  *        upwards, modulo 256 and subtracted from 255.
1392  */
1393 int
1394 monitor_make_srec (buffer, type, memaddr, myaddr, len)
1395      char *buffer;
1396      int type;
1397      CORE_ADDR memaddr;
1398      unsigned char *myaddr;
1399      int len;
1400 {
1401   int checksum;
1402   int i;
1403   char *buf;
1404
1405   buf = buffer;
1406   debuglogs (4, "monitor_make_srec (buffer=0x%x, type=%d, memaddr=0x%x, len=%d",
1407                                     buffer, type, memaddr, len);
1408   checksum = 0;
1409
1410   /*
1411      create the header for the srec. 4 is the number of bytes in the address,
1412      and 1 is the number of bytes in the count.
1413    */
1414   if (type == 0)                                /* FIXME: type 0 is optional */
1415     type = 3;                                   /* so use data as it works */
1416   sprintf (buf, "S%d%02X%08X", type, len + 4 + 1, memaddr);
1417   buf += 12;
1418
1419   checksum += (len + 4 + 1                      /* calculate the checksum */
1420                + (memaddr & 0xff)
1421                + ((memaddr >>  8) & 0xff)
1422                + ((memaddr >> 16) & 0xff)
1423                + ((memaddr >> 24) & 0xff));
1424
1425   for (i = 0; i < len; i++) {           /* build the srecord */
1426     sprintf (buf, "%02X", myaddr[i]);
1427     checksum += myaddr[i];
1428     buf += 2;
1429   }
1430
1431   sprintf(buf, "%02X", ~checksum & 0xff);       /* add the checksum */
1432   debuglogs (3, "srec is \"%s\"", buffer);
1433
1434   return(0);
1435 }
1436
1437 /*
1438  * make_xmodem_packet -- this takes a 128 bytes of data and makes a packet
1439  *      out of it.
1440  *
1441  *      Each packet looks like this:
1442  *      +-----+-------+-------+------+-----+
1443  *      | SOH | Seq1. | Seq2. | data | SUM |
1444  *      +-----+-------+-------+------+-----+
1445  *      SOH  = 0x01
1446  *      Seq1 = The sequence number.
1447  *      Seq2 = The complement of the sequence number.
1448  *      Data = A 128 bytes of data.
1449  *      SUM  = Add the contents of the 128 bytes and use the low-order
1450  *             8 bits of the result.
1451  */
1452 void
1453 make_xmodem_packet (packet, data, len)
1454      unsigned char packet[];
1455      unsigned char *data;
1456      int len;
1457 {
1458   static int sequence = 1;
1459   int i, sum;
1460   unsigned char *buf;
1461
1462   buf = data;
1463   /* build the packet header */
1464   packet[0] = SOH;
1465   packet[1] = sequence;
1466   packet[2] = 255 - sequence;
1467   sequence++;
1468 #if 0
1469   packet[2] = ~sequence++;                      /* the complement is the sequence checksum */
1470 #endif
1471
1472   sum = 0;                                      /* calculate the data checksum */
1473   for (i = 3; i <= len + 2; i++) {
1474     packet[i] = *buf;
1475     sum += *buf;
1476     buf++;
1477   }
1478
1479   for (i = len+1 ; i <= XMODEM_DATASIZE ; i++) {        /* add padding for the rest of the packet */
1480     packet[i] = '0';
1481   }
1482
1483   packet[XMODEM_PACKETSIZE] = sum & 0xff;       /* add the checksum */
1484
1485   if (sr_get_debug() > 4) {
1486     debuglogs (4, "The xmodem checksum is %d (0x%x)\n", sum & 0xff, sum & 0xff);
1487     print_xmodem_packet (packet);
1488     }
1489 }
1490
1491 /*
1492  * print_xmodem_packet -- print the packet as a debug check
1493  */
1494 void
1495 print_xmodem_packet(packet)
1496      char packet[];
1497 {
1498   int i;
1499   static int lastseq;
1500   int sum;
1501
1502   /* take apart the packet header the packet header */
1503   if (packet[0] == SOH) {
1504      ("SOH");
1505   } else {
1506     error ("xmodem: SOH is wrong");
1507   }
1508
1509   /* check the sequence */
1510   if (packet[1] != 0) {
1511     lastseq = packet[1];
1512     if (packet[2] != ~lastseq)
1513       error ("xmodem: Sequence checksum is wrong");
1514     else
1515       printf_filtered (" %d %d", lastseq, ~lastseq);
1516   }
1517
1518   /* check the data checksum */
1519   sum = 0;
1520   for (i = 3; i <= XMODEM_DATASIZE; i++) {
1521     sum += packet[i];
1522   }
1523
1524   /* ignore the data */
1525 #if 0
1526   printf (" [128 bytes of data] %d\n", sum & 0xff);
1527 #endif
1528   printf_filtered (" [%s] %d\n", packet, sum & 0xff);
1529
1530   if ((packet[XMODEM_PACKETSIZE] & 0xff) != (sum & 0xff)) {
1531     debuglogs (4, "xmodem: data checksum wrong, got a %d", packet[XMODEM_PACKETSIZE] & 0xff);
1532   }
1533   putchar ('\n');
1534 }
1535
1536 /*
1537  * _initialize_remote_monitors -- setup a few addtitional commands that
1538  *              are usually only used by monitors.
1539  */
1540 void
1541 _initialize_remote_monitors ()
1542 {
1543   struct cmd_list_element *c;
1544
1545   /* this sets the type of download protocol */
1546   c = add_set_cmd ("remoteloadprotocol", no_class, var_string, (char *)&loadproto_str,
1547        "Set the type of the remote load protocol.\n", &setlist);
1548   c->function.sfunc =  set_loadproto_command;
1549   add_show_from_set (c, &showlist);
1550   loadproto_str = savestring ("none", 5);
1551
1552   /* this sets the conversion type when loading */
1553   c = add_set_cmd ("remoteloadtype", no_class, var_string, (char *)&loadtype_str,
1554        "Set the type of the remote load protocol.\n", &setlist);
1555   c->function.sfunc =  set_loadtype_command;
1556   add_show_from_set (c, &showlist);
1557   loadtype_str = savestring ("srec", 5);
1558
1559   add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
1560                                   (char *)&hashmark,
1561                                   "Set display of activity while downloading a file.\n\
1562 When enabled, a period \'.\' is displayed.",
1563                                   &setlist),
1564                      &showlist);
1565
1566   /* generic monitor command */
1567   add_com ("monitor", class_obscure, monitor_command,
1568            "Send a command to the debug monitor.");
1569 }