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