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