gdb/dsrec.c

   1 /* S-record download support for GDB, the GNU debugger.
   2    Copyright 1995, 1996, 1997 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "serial.h"
  23 #include "srec.h"
  24 #include <time.h>
  25
  26 int (*ui_load_progress_hook) PARAMS ((char *, unsigned long));
  27 extern void report_transfer_performance PARAMS ((unsigned long, time_t, time_t));
  28
  29 extern int remote_debug;
  30
  31 static int make_srec PARAMS ((char *srec, CORE_ADDR targ_addr, bfd * abfd,
  32                               asection * sect, int sectoff, int *maxrecsize,
  33                               int flags));
  34
  35 /* Download an executable by converting it to S records.  DESC is a
  36    serial_t to send the data to.  FILE is the name of the file to be
  37    loaded.  LOAD_OFFSET is the offset into memory to load data into.
  38    It is usually specified by the user and is useful with the a.out
  39    file format.  MAXRECSIZE is the length in chars of the largest
  40    S-record the host can accomodate.  This is measured from the
  41    starting `S' to the last char of the checksum.  FLAGS is various
  42    random flags, and HASHMARK is non-zero to cause a `#' to be
  43    printed out for each record loaded.  WAITACK, if non-NULL, is a
  44    function that waits for an acknowledgement after each S-record,
  45    and returns non-zero if the ack is read correctly.  */
  46
  47 void
  48 load_srec (desc, file, load_offset, maxrecsize, flags, hashmark, waitack)
  49      serial_t desc;
  50      const char *file;
  51      bfd_vma load_offset;
  52      int maxrecsize;
  53      int flags;
  54      int hashmark;
  55      int (*waitack) PARAMS ((void));
  56 {
  57   bfd *abfd;
  58   asection *s;
  59   char *srec;
  60   int i;
  61   int reclen;
  62   time_t start_time, end_time;
  63   unsigned long data_count = 0;
  64
  65   srec = (char *) alloca (maxrecsize + 1);
  66
  67   abfd = bfd_openr (file, 0);
  68   if (!abfd)
  69     {
  70       printf_filtered ("Unable to open file %s\n", file);
  71       return;
  72     }
  73
  74   if (bfd_check_format (abfd, bfd_object) == 0)
  75     {
  76       printf_filtered ("File is not an object file\n");
  77       return;
  78     }
  79
  80   start_time = time (NULL);
  81
  82   /* Write a type 0 header record. no data for a type 0, and there
  83      is no data, so len is 0.  */
  84
  85   reclen = maxrecsize;
  86   make_srec (srec, 0, NULL, (asection *) 1, 0, &reclen, flags);
  87   if (remote_debug)
  88     {
  89       srec[reclen] = '\0';
  90       puts_debug ("sent -->", srec, "<--");
  91     }
  92   SERIAL_WRITE (desc, srec, reclen);
  93
  94   for (s = abfd->sections; s; s = s->next)
  95     if (s->flags & SEC_LOAD)
  96       {
  97         int numbytes;
  98         bfd_vma addr = bfd_get_section_vma (abfd, s) + load_offset;
  99         bfd_size_type size = bfd_get_section_size_before_reloc (s);
 100         char *section_name = (char *) bfd_get_section_name (abfd, s);
 101         printf_filtered ("%s\t: 0x%08x .. 0x%08x  ",
 102                          section_name, (int) addr, (int) addr + size);
 103         gdb_flush (gdb_stdout);
 104
 105         data_count += size;
 106
 107         for (i = 0; i < size; i += numbytes)
 108           {
 109             reclen = maxrecsize;
 110             numbytes = make_srec (srec, (CORE_ADDR) (addr + i), abfd, s,
 111                                   i, &reclen, flags);
 112
 113             if (remote_debug)
 114               {
 115                 srec[reclen] = '\0';
 116                 puts_debug ("sent -->", srec, "<--");
 117               }
 118
 119             /* Repeatedly send the S-record until a good
 120                acknowledgement is sent back.  */
 121             do
 122               {
 123                 SERIAL_WRITE (desc, srec, reclen);
 124                 if (ui_load_progress_hook)
 125                   if (ui_load_progress_hook (section_name, (unsigned long) i))
 126                     error ("Canceled the download");
 127               }
 128             while (waitack != NULL && !waitack ());
 129
 130             if (hashmark)
 131               {
 132                 putchar_unfiltered ('#');
 133                 gdb_flush (gdb_stdout);
 134               }
 135           }                     /* Per-packet (or S-record) loop */
 136
 137         if (ui_load_progress_hook)
 138           if (ui_load_progress_hook (section_name, (unsigned long) i))
 139             error ("Canceled the download");
 140         putchar_unfiltered ('\n');
 141       }
 142
 143   if (hashmark)
 144     putchar_unfiltered ('\n');
 145
 146   end_time = time (NULL);
 147
 148   /* Write a terminator record.  */
 149
 150   reclen = maxrecsize;
 151   make_srec (srec, abfd->start_address, NULL, NULL, 0, &reclen, flags);
 152
 153   if (remote_debug)
 154     {
 155       srec[reclen] = '\0';
 156       puts_debug ("sent -->", srec, "<--");
 157     }
 158
 159   SERIAL_WRITE (desc, srec, reclen);
 160
 161   /* Some monitors need these to wake up properly.  (Which ones? -sts)  */
 162   SERIAL_WRITE (desc, "\r\r", 2);
 163   if (remote_debug)
 164     puts_debug ("sent -->", "\r\r", "<---");
 165
 166   SERIAL_FLUSH_INPUT (desc);
 167
 168   report_transfer_performance (data_count, start_time, end_time);
 169 }
 170
 171 /*
 172  * make_srec -- make an srecord. This writes each line, one at a
 173  *      time, each with it's own header and trailer line.
 174  *      An srecord looks like this:
 175  *
 176  * byte count-+     address
 177  * start ---+ |        |       data        +- checksum
 178  *          | |        |                   |
 179  *        S01000006F6B692D746573742E73726563E4
 180  *        S315000448600000000000000000FC00005900000000E9
 181  *        S31A0004000023C1400037DE00F023604000377B009020825000348D
 182  *        S30B0004485A0000000000004E
 183  *        S70500040000F6
 184  *
 185  *      S<type><length><address><data><checksum>
 186  *
 187  *      Where
 188  *      - length
 189  *        is the number of bytes following upto the checksum. Note that
 190  *        this is not the number of chars following, since it takes two
 191  *        chars to represent a byte.
 192  *      - type
 193  *        is one of:
 194  *        0) header record
 195  *        1) two byte address data record
 196  *        2) three byte address data record
 197  *        3) four byte address data record
 198  *        7) four byte address termination record
 199  *        8) three byte address termination record
 200  *        9) two byte address termination record
 201  *
 202  *      - address
 203  *        is the start address of the data following, or in the case of
 204  *        a termination record, the start address of the image
 205  *      - data
 206  *        is the data.
 207  *      - checksum
 208  *        is the sum of all the raw byte data in the record, from the length
 209  *        upwards, modulo 256 and subtracted from 255.
 210  *
 211  * This routine returns the length of the S-record.
 212  *
 213  */
 214
 215 static int
 216 make_srec (srec, targ_addr, abfd, sect, sectoff, maxrecsize, flags)
 217      char *srec;
 218      CORE_ADDR targ_addr;
 219      bfd *abfd;
 220      asection *sect;
 221      int sectoff;
 222      int *maxrecsize;
 223      int flags;
 224 {
 225   unsigned char checksum;
 226   int tmp;
 227   const static char hextab[] = "0123456789ABCDEF";
 228   const static char data_code_table[] = "123";
 229   const static char term_code_table[] = "987";
 230   const static char header_code_table[] = "000";
 231   const static char *formats[] =
 232   {"S%c%02X%04X",
 233    "S%c%02X%06X",
 234    "S%c%02X%08X"};
 235   char const *code_table;
 236   int addr_size;
 237   int payload_size;
 238   char *binbuf;
 239   char *p;
 240
 241   if (sect)
 242     {
 243       tmp = flags;              /* Data or header record */
 244       code_table = abfd ? data_code_table : header_code_table;
 245       binbuf = alloca (*maxrecsize / 2);
 246     }
 247   else
 248     {
 249       tmp = flags >> SREC_TERM_SHIFT;   /* Term record */
 250       code_table = term_code_table;
 251     }
 252
 253   if ((tmp & SREC_2_BYTE_ADDR) && (targ_addr <= 0xffff))
 254     addr_size = 2;
 255   else if ((tmp & SREC_3_BYTE_ADDR) && (targ_addr <= 0xffffff))
 256     addr_size = 3;
 257   else if (tmp & SREC_4_BYTE_ADDR)
 258     addr_size = 4;
 259   else
 260     fatal ("make_srec:  Bad address (0x%x), or bad flags (0x%x).",
 261            targ_addr, flags);
 262
 263   /* Now that we know the address size, we can figure out how much
 264      data this record can hold.  */
 265
 266   if (sect && abfd)
 267     {
 268       payload_size = (*maxrecsize - (1 + 1 + 2 + addr_size * 2 + 2)) / 2;
 269       payload_size = min (payload_size, sect->_raw_size - sectoff);
 270
 271       bfd_get_section_contents (abfd, sect, binbuf, sectoff, payload_size);
 272     }
 273   else
 274     payload_size = 0;           /* Term or header packets have no payload */
 275
 276   /* Output the header.  */
 277
 278   sprintf (srec, formats[addr_size - 2], code_table[addr_size - 2],
 279            addr_size + payload_size + 1, (int) targ_addr);
 280
 281   /* Note that the checksum is calculated on the raw data, not the
 282      hexified data.  It includes the length, address and the data
 283      portions of the packet.  */
 284
 285   checksum = 0;
 286
 287   checksum += (payload_size + addr_size + 1     /* Packet length */
 288                + (targ_addr & 0xff)     /* Address... */
 289                + ((targ_addr >> 8) & 0xff)
 290                + ((targ_addr >> 16) & 0xff)
 291                + ((targ_addr >> 24) & 0xff));
 292
 293   p = srec + 1 + 1 + 2 + addr_size * 2;
 294
 295   /* Build the Srecord.  */
 296   for (tmp = 0; tmp < payload_size; tmp++)
 297     {
 298       unsigned char k;
 299
 300       k = binbuf[tmp];
 301       *p++ = hextab[k >> 4];
 302       *p++ = hextab[k & 0xf];
 303       checksum += k;
 304     }
 305
 306   checksum = ~checksum;
 307
 308   *p++ = hextab[checksum >> 4];
 309   *p++ = hextab[checksum & 0xf];
 310   *p++ = '\r';
 311
 312   *maxrecsize = p - srec;
 313   return payload_size;
 314 }