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