Code Review / openocd.git / blob
? search:


d1db136b7716b43a8cfb84ac16c9a8a161035582
[openocd.git] / src / target / image.c
1 /***************************************************************************
2 * Copyright (C) 2007 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
10 * *
11 * Copyright (C) 2009 by Franck Hereson *
12 * franck.hereson@secad.fr *
13 * *
14 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
18 * *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program; if not, write to the *
26 * Free Software Foundation, Inc., *
27 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
28 ***************************************************************************/
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #include "image.h"
34 #include "target.h"
35 #include <helper/log.h>
36
37
38 /* convert ELF header field to host endianness */
39 #define field16(elf,field)\
40 ((elf->endianness == ELFDATA2LSB)? \
41 le_to_h_u16((uint8_t*)&field):be_to_h_u16((uint8_t*)&field))
42
43 #define field32(elf,field)\
44 ((elf->endianness == ELFDATA2LSB)? \
45 le_to_h_u32((uint8_t*)&field):be_to_h_u32((uint8_t*)&field))
46
47 static int autodetect_image_type(struct image *image, const char *url)
48 {
49 int retval;
50 struct fileio fileio;
51 size_t read_bytes;
52 uint8_t buffer[9];
53
54 /* read the first 4 bytes of image */
55 if ((retval = fileio_open(&fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
56 {
57 return retval;
58 }
59 retval = fileio_read(&fileio, 9, buffer, &read_bytes);
60
61 if (retval == ERROR_OK)
62 {
63 if (read_bytes != 9)
64 {
65 retval = ERROR_FILEIO_OPERATION_FAILED;
66 }
67 }
68 fileio_close(&fileio);
69
70 if (retval != ERROR_OK)
71 return retval;
72
73 /* check header against known signatures */
74 if (strncmp((char*)buffer,ELFMAG,SELFMAG) == 0)
75 {
76 LOG_DEBUG("ELF image detected.");
77 image->type = IMAGE_ELF;
78 }
79 else if ((buffer[0]==':') /* record start byte */
80 &&(isxdigit(buffer[1]))
81 &&(isxdigit(buffer[2]))
82 &&(isxdigit(buffer[3]))
83 &&(isxdigit(buffer[4]))
84 &&(isxdigit(buffer[5]))
85 &&(isxdigit(buffer[6]))
86 &&(buffer[7]=='0') /* record type : 00 -> 05 */
87 &&(buffer[8]>='0') && (buffer[8]<'6'))
88 {
89 LOG_DEBUG("IHEX image detected.");
90 image->type = IMAGE_IHEX;
91 }
92 else if ((buffer[0] == 'S') /* record start byte */
93 &&(isxdigit(buffer[1]))
94 &&(isxdigit(buffer[2]))
95 &&(isxdigit(buffer[3]))
96 &&(buffer[1] >= '0') && (buffer[1] < '9'))
97 {
98 LOG_DEBUG("S19 image detected.");
99 image->type = IMAGE_SRECORD;
100 }
101 else
102 {
103 image->type = IMAGE_BINARY;
104 }
105
106 return ERROR_OK;
107 }
108
109 static int identify_image_type(struct image *image, const char *type_string, const char *url)
110 {
111 if (type_string)
112 {
113 if (!strcmp(type_string, "bin"))
114 {
115 image->type = IMAGE_BINARY;
116 }
117 else if (!strcmp(type_string, "ihex"))
118 {
119 image->type = IMAGE_IHEX;
120 }
121 else if (!strcmp(type_string, "elf"))
122 {
123 image->type = IMAGE_ELF;
124 }
125 else if (!strcmp(type_string, "mem"))
126 {
127 image->type = IMAGE_MEMORY;
128 }
129 else if (!strcmp(type_string, "s19"))
130 {
131 image->type = IMAGE_SRECORD;
132 }
133 else if (!strcmp(type_string, "build"))
134 {
135 image->type = IMAGE_BUILDER;
136 }
137 else
138 {
139 return ERROR_IMAGE_TYPE_UNKNOWN;
140 }
141 }
142 else
143 {
144 return autodetect_image_type(image, url);
145 }
146
147 return ERROR_OK;
148 }
149
150 static int image_ihex_buffer_complete_inner(struct image *image, char *lpszLine, struct imagesection *section)
151 {
152 struct image_ihex *ihex = image->type_private;
153 struct fileio *fileio = &ihex->fileio;
154 uint32_t full_address = 0x0;
155 uint32_t cooked_bytes;
156 int i;
157
158 /* we can't determine the number of sections that we'll have to create ahead of time,
159 * so we locally hold them until parsing is finished */
160
161 int filesize;
162 int retval;
163 retval = fileio_size(fileio, &filesize);
164 if (retval != ERROR_OK)
165 return retval;
166
167 ihex->buffer = malloc(filesize >> 1);
168 cooked_bytes = 0x0;
169 image->num_sections = 0;
170 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
171 section[image->num_sections].base_address = 0x0;
172 section[image->num_sections].size = 0x0;
173 section[image->num_sections].flags = 0;
174
175 while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
176 {
177 uint32_t count;
178 uint32_t address;
179 uint32_t record_type;
180 uint32_t checksum;
181 uint8_t cal_checksum = 0;
182 size_t bytes_read = 0;
183
184 if (sscanf(&lpszLine[bytes_read], ":%2" SCNx32 "%4" SCNx32 "%2" SCNx32 , &count, &address, &record_type) != 3)
185 {
186 return ERROR_IMAGE_FORMAT_ERROR;
187 }
188 bytes_read += 9;
189
190 cal_checksum += (uint8_t)count;
191 cal_checksum += (uint8_t)(address >> 8);
192 cal_checksum += (uint8_t)address;
193 cal_checksum += (uint8_t)record_type;
194
195 if (record_type == 0) /* Data Record */
196 {
197 if ((full_address & 0xffff) != address)
198 {
199 /* we encountered a nonconsecutive location, create a new section,
200 * unless the current section has zero size, in which case this specifies
201 * the current section's base address
202 */
203 if (section[image->num_sections].size != 0)
204 {
205 image->num_sections++;
206 if (image->num_sections >= IMAGE_MAX_SECTIONS)
207 {
208 /* too many sections */
209 LOG_ERROR("Too many sections found in IHEX file");
210 return ERROR_IMAGE_FORMAT_ERROR;
211 }
212 section[image->num_sections].size = 0x0;
213 section[image->num_sections].flags = 0;
214 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
215 }
216 section[image->num_sections].base_address =
217 (full_address & 0xffff0000) | address;
218 full_address = (full_address & 0xffff0000) | address;
219 }
220
221 while (count-- > 0)
222 {
223 unsigned value;
224 sscanf(&lpszLine[bytes_read], "%2x", &value);
225 ihex->buffer[cooked_bytes] = (uint8_t)value;
226 cal_checksum += (uint8_t)ihex->buffer[cooked_bytes];
227 bytes_read += 2;
228 cooked_bytes += 1;
229 section[image->num_sections].size += 1;
230 full_address++;
231 }
232 }
233 else if (record_type == 1) /* End of File Record */
234 {
235 /* finish the current section */
236 image->num_sections++;
237
238 /* copy section information */
239 image->sections = malloc(sizeof(struct imagesection) * image->num_sections);
240 for (i = 0; i < image->num_sections; i++)
241 {
242 image->sections[i].private = section[i].private;
243 image->sections[i].base_address = section[i].base_address;
244 image->sections[i].size = section[i].size;
245 image->sections[i].flags = section[i].flags;
246 }
247
248 return ERROR_OK;
249 }
250 else if (record_type == 2) /* Linear Address Record */
251 {
252 uint16_t upper_address;
253
254 sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
255 cal_checksum += (uint8_t)(upper_address >> 8);
256 cal_checksum += (uint8_t)upper_address;
257 bytes_read += 4;
258
259 if ((full_address >> 4) != upper_address)
260 {
261 /* we encountered a nonconsecutive location, create a new section,
262 * unless the current section has zero size, in which case this specifies
263 * the current section's base address
264 */
265 if (section[image->num_sections].size != 0)
266 {
267 image->num_sections++;
268 if (image->num_sections >= IMAGE_MAX_SECTIONS)
269 {
270 /* too many sections */
271 LOG_ERROR("Too many sections found in IHEX file");
272 return ERROR_IMAGE_FORMAT_ERROR;
273 }
274 section[image->num_sections].size = 0x0;
275 section[image->num_sections].flags = 0;
276 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
277 }
278 section[image->num_sections].base_address =
279 (full_address & 0xffff) | (upper_address << 4);
280 full_address = (full_address & 0xffff) | (upper_address << 4);
281 }
282 }
283 else if (record_type == 3) /* Start Segment Address Record */
284 {
285 uint32_t dummy;
286
287 /* "Start Segment Address Record" will not be supported */
288 /* but we must consume it, and do not create an error. */
289 while (count-- > 0)
290 {
291 sscanf(&lpszLine[bytes_read], "%2" SCNx32 , &dummy);
292 cal_checksum += (uint8_t)dummy;
293 bytes_read += 2;
294 }
295 }
296 else if (record_type == 4) /* Extended Linear Address Record */
297 {
298 uint16_t upper_address;
299
300 sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
301 cal_checksum += (uint8_t)(upper_address >> 8);
302 cal_checksum += (uint8_t)upper_address;
303 bytes_read += 4;
304
305 if ((full_address >> 16) != upper_address)
306 {
307 /* we encountered a nonconsecutive location, create a new section,
308 * unless the current section has zero size, in which case this specifies
309 * the current section's base address
310 */
311 if (section[image->num_sections].size != 0)
312 {
313 image->num_sections++;
314 if (image->num_sections >= IMAGE_MAX_SECTIONS)
315 {
316 /* too many sections */
317 LOG_ERROR("Too many sections found in IHEX file");
318 return ERROR_IMAGE_FORMAT_ERROR;
319 }
320 section[image->num_sections].size = 0x0;
321 section[image->num_sections].flags = 0;
322 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
323 }
324 section[image->num_sections].base_address =
325 (full_address & 0xffff) | (upper_address << 16);
326 full_address = (full_address & 0xffff) | (upper_address << 16);
327 }
328 }
329 else if (record_type == 5) /* Start Linear Address Record */
330 {
331 uint32_t start_address;
332
333 sscanf(&lpszLine[bytes_read], "%8" SCNx32, &start_address);
334 cal_checksum += (uint8_t)(start_address >> 24);
335 cal_checksum += (uint8_t)(start_address >> 16);
336 cal_checksum += (uint8_t)(start_address >> 8);
337 cal_checksum += (uint8_t)start_address;
338 bytes_read += 8;
339
340 image->start_address_set = 1;
341 image->start_address = be_to_h_u32((uint8_t*)&start_address);
342 }
343 else
344 {
345 LOG_ERROR("unhandled IHEX record type: %i", (int)record_type);
346 return ERROR_IMAGE_FORMAT_ERROR;
347 }
348
349 sscanf(&lpszLine[bytes_read], "%2" SCNx32 , &checksum);
350
351 if ((uint8_t)checksum != (uint8_t)(~cal_checksum + 1))
352 {
353 /* checksum failed */
354 LOG_ERROR("incorrect record checksum found in IHEX file");
355 return ERROR_IMAGE_CHECKSUM;
356 }
357 }
358
359 LOG_ERROR("premature end of IHEX file, no end-of-file record found");
360 return ERROR_IMAGE_FORMAT_ERROR;
361 }
362
363 /**
364 * Allocate memory dynamically instead of on the stack. This
365 * is important w/embedded hosts.
366 */
367 static int image_ihex_buffer_complete(struct image *image)
368 {
369 char *lpszLine = malloc(1023);
370 if (lpszLine == NULL)
371 {
372 LOG_ERROR("Out of memory");
373 return ERROR_FAIL;
374 }
375 struct imagesection *section = malloc(sizeof(struct imagesection) * IMAGE_MAX_SECTIONS);
376 if (section == NULL)
377 {
378 free(lpszLine);
379 LOG_ERROR("Out of memory");
380 return ERROR_FAIL;
381 }
382 int retval;
383
384 retval = image_ihex_buffer_complete_inner(image, lpszLine, section);
385
386 free(section);
387 free(lpszLine);
388
389 return retval;
390 }
391
392 static int image_elf_read_headers(struct image *image)
393 {
394 struct image_elf *elf = image->type_private;
395 size_t read_bytes;
396 uint32_t i,j;
397 int retval;
398 uint32_t nload,load_to_vaddr=0;
399
400 elf->header = malloc(sizeof(Elf32_Ehdr));
401
402 if (elf->header == NULL)
403 {
404 LOG_ERROR("insufficient memory to perform operation ");
405 return ERROR_FILEIO_OPERATION_FAILED;
406 }
407
408 if ((retval = fileio_read(&elf->fileio, sizeof(Elf32_Ehdr), (uint8_t*)elf->header, &read_bytes)) != ERROR_OK)
409 {
410 LOG_ERROR("cannot read ELF file header, read failed");
411 return ERROR_FILEIO_OPERATION_FAILED;
412 }
413 if (read_bytes != sizeof(Elf32_Ehdr))
414 {
415 LOG_ERROR("cannot read ELF file header, only partially read");
416 return ERROR_FILEIO_OPERATION_FAILED;
417 }
418
419 if (strncmp((char*)elf->header->e_ident,ELFMAG,SELFMAG) != 0)
420 {
421 LOG_ERROR("invalid ELF file, bad magic number");
422 return ERROR_IMAGE_FORMAT_ERROR;
423 }
424 if (elf->header->e_ident[EI_CLASS]!=ELFCLASS32)
425 {
426 LOG_ERROR("invalid ELF file, only 32bits files are supported");
427 return ERROR_IMAGE_FORMAT_ERROR;
428 }
429
430 elf->endianness = elf->header->e_ident[EI_DATA];
431 if ((elf->endianness != ELFDATA2LSB)
432 &&(elf->endianness != ELFDATA2MSB))
433 {
434 LOG_ERROR("invalid ELF file, unknown endianness setting");
435 return ERROR_IMAGE_FORMAT_ERROR;
436 }
437
438 elf->segment_count = field16(elf,elf->header->e_phnum);
439 if (elf->segment_count == 0)
440 {
441 LOG_ERROR("invalid ELF file, no program headers");
442 return ERROR_IMAGE_FORMAT_ERROR;
443 }
444
445 if ((retval = fileio_seek(&elf->fileio, field32(elf,elf->header->e_phoff))) != ERROR_OK)
446 {
447 LOG_ERROR("cannot seek to ELF program header table, read failed");
448 return retval;
449 }
450
451 elf->segments = malloc(elf->segment_count*sizeof(Elf32_Phdr));
452 if (elf->segments == NULL)
453 {
454 LOG_ERROR("insufficient memory to perform operation ");
455 return ERROR_FILEIO_OPERATION_FAILED;
456 }
457
458 if ((retval = fileio_read(&elf->fileio, elf->segment_count*sizeof(Elf32_Phdr), (uint8_t*)elf->segments, &read_bytes)) != ERROR_OK)
459 {
460 LOG_ERROR("cannot read ELF segment headers, read failed");
461 return retval;
462 }
463 if (read_bytes != elf->segment_count*sizeof(Elf32_Phdr))
464 {
465 LOG_ERROR("cannot read ELF segment headers, only partially read");
466 return ERROR_FILEIO_OPERATION_FAILED;
467 }
468
469 /* count useful segments (loadable), ignore BSS section */
470 image->num_sections = 0;
471 for (i = 0;i < elf->segment_count;i++)
472 if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
473 image->num_sections++;
474
475 assert(image->num_sections > 0);
476
477 /**
478 * some ELF linkers produce binaries with *all* the program header
479 * p_paddr fields zero (there can be however one loadable segment
480 * that has valid physical address 0x0).
481 * If we have such a binary with more than
482 * one PT_LOAD header, then use p_vaddr instead of p_paddr
483 * (ARM ELF standard demands p_paddr = 0 anyway, and BFD
484 * library uses this approach to workaround zero-initialized p_paddrs
485 * when obtaining lma - look at elf.c of BDF)
486 */
487 for (nload = 0, i = 0; i < elf->segment_count; i++)
488 if (elf->segments[i].p_paddr != 0)
489 break;
490 else if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_memsz) != 0))
491 ++nload;
492
493 if (i >= elf->segment_count && nload > 1)
494 load_to_vaddr = 1;
495
496 /* alloc and fill sections array with loadable segments */
497 image->sections = malloc(image->num_sections * sizeof(struct imagesection));
498 for (i = 0,j = 0;i < elf->segment_count;i++)
499 {
500 if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
501 {
502 image->sections[j].size = field32(elf,elf->segments[i].p_filesz);
503 if (load_to_vaddr)
504 image->sections[j].base_address = field32(elf,elf->segments[i].p_vaddr);
505 else
506 image->sections[j].base_address = field32(elf,elf->segments[i].p_paddr);
507 image->sections[j].private = &elf->segments[i];
508 image->sections[j].flags = field32(elf,elf->segments[i].p_flags);
509 j++;
510 }
511 }
512
513 image->start_address_set = 1;
514 image->start_address = field32(elf,elf->header->e_entry);
515
516 return ERROR_OK;
517 }
518
519 static int image_elf_read_section(struct image *image, int section, uint32_t offset, uint32_t size, uint8_t *buffer, size_t *size_read)
520 {
521 struct image_elf *elf = image->type_private;
522 Elf32_Phdr *segment = (Elf32_Phdr *)image->sections[section].private;
523 size_t read_size,really_read;
524 int retval;
525
526 *size_read = 0;
527
528 LOG_DEBUG("load segment %d at 0x%" PRIx32 " (sz = 0x%" PRIx32 ")",section,offset,size);
529
530 /* read initialized data in current segment if any */
531 if (offset < field32(elf,segment->p_filesz))
532 {
533 /* maximal size present in file for the current segment */
534 read_size = MIN(size, field32(elf,segment->p_filesz)-offset);
535 LOG_DEBUG("read elf: size = 0x%zu at 0x%" PRIx32 "", read_size,
536 field32(elf,segment->p_offset) + offset);
537 /* read initialized area of the segment */
538 if ((retval = fileio_seek(&elf->fileio, field32(elf,segment->p_offset) + offset)) != ERROR_OK)
539 {
540 LOG_ERROR("cannot find ELF segment content, seek failed");
541 return retval;
542 }
543 if ((retval = fileio_read(&elf->fileio, read_size, buffer, &really_read)) != ERROR_OK)
544 {
545 LOG_ERROR("cannot read ELF segment content, read failed");
546 return retval;
547 }
548 size -= read_size;
549 *size_read += read_size;
550 /* need more data ? */
551 if (!size)
552 return ERROR_OK;
553 }
554
555 return ERROR_OK;
556 }
557
558 static int image_mot_buffer_complete_inner(struct image *image, char *lpszLine, struct imagesection *section)
559 {
560 struct image_mot *mot = image->type_private;
561 struct fileio *fileio = &mot->fileio;
562 uint32_t full_address = 0x0;
563 uint32_t cooked_bytes;
564 int i;
565
566 /* we can't determine the number of sections that we'll have to create ahead of time,
567 * so we locally hold them until parsing is finished */
568
569 int retval;
570 int filesize;
571 retval = fileio_size(fileio, &filesize);
572 if (retval != ERROR_OK)
573 return retval;
574
575 mot->buffer = malloc(filesize >> 1);
576 cooked_bytes = 0x0;
577 image->num_sections = 0;
578 section[image->num_sections].private = &mot->buffer[cooked_bytes];
579 section[image->num_sections].base_address = 0x0;
580 section[image->num_sections].size = 0x0;
581 section[image->num_sections].flags = 0;
582
583 while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
584 {
585 uint32_t count;
586 uint32_t address;
587 uint32_t record_type;
588 uint32_t checksum;
589 uint8_t cal_checksum = 0;
590 uint32_t bytes_read = 0;
591
592 /* get record type and record length */
593 if (sscanf(&lpszLine[bytes_read], "S%1" SCNx32 "%2" SCNx32 , &record_type, &count) != 2)
594 {
595 return ERROR_IMAGE_FORMAT_ERROR;
596 }
597
598 bytes_read += 4;
599 cal_checksum += (uint8_t)count;
600
601 /* skip checksum byte */
602 count -=1;
603
604 if (record_type == 0)
605 {
606 /* S0 - starting record (optional) */
607 int iValue;
608
609 while (count-- > 0) {
610 sscanf(&lpszLine[bytes_read], "%2x", &iValue);
611 cal_checksum += (uint8_t)iValue;
612 bytes_read += 2;
613 }
614 }
615 else if (record_type >= 1 && record_type <= 3)
616 {
617 switch (record_type)
618 {
619 case 1:
620 /* S1 - 16 bit address data record */
621 sscanf(&lpszLine[bytes_read], "%4" SCNx32, &address);
622 cal_checksum += (uint8_t)(address >> 8);
623 cal_checksum += (uint8_t)address;
624 bytes_read += 4;
625 count -=2;
626 break;
627
628 case 2:
629 /* S2 - 24 bit address data record */
630 sscanf(&lpszLine[bytes_read], "%6" SCNx32 , &address);
631 cal_checksum += (uint8_t)(address >> 16);
632 cal_checksum += (uint8_t)(address >> 8);
633 cal_checksum += (uint8_t)address;
634 bytes_read += 6;
635 count -=3;
636 break;
637
638 case 3:
639 /* S3 - 32 bit address data record */
640 sscanf(&lpszLine[bytes_read], "%8" SCNx32 , &address);
641 cal_checksum += (uint8_t)(address >> 24);
642 cal_checksum += (uint8_t)(address >> 16);
643 cal_checksum += (uint8_t)(address >> 8);
644 cal_checksum += (uint8_t)address;
645 bytes_read += 8;
646 count -=4;
647 break;
648
649 }
650
651 if (full_address != address)
652 {
653 /* we encountered a nonconsecutive location, create a new section,
654 * unless the current section has zero size, in which case this specifies
655 * the current section's base address
656 */
657 if (section[image->num_sections].size != 0)
658 {
659 image->num_sections++;
660 section[image->num_sections].size = 0x0;
661 section[image->num_sections].flags = 0;
662 section[image->num_sections].private = &mot->buffer[cooked_bytes];
663 }
664 section[image->num_sections].base_address = address;
665 full_address = address;
666 }
667
668 while (count-- > 0)
669 {
670 unsigned value;
671 sscanf(&lpszLine[bytes_read], "%2x", &value);
672 mot->buffer[cooked_bytes] = (uint8_t)value;
673 cal_checksum += (uint8_t)mot->buffer[cooked_bytes];
674 bytes_read += 2;
675 cooked_bytes += 1;
676 section[image->num_sections].size += 1;
677 full_address++;
678 }
679 }
680 else if (record_type == 5)
681 {
682 /* S5 is the data count record, we ignore it */
683 uint32_t dummy;
684
685 while (count-- > 0)
686 {
687 sscanf(&lpszLine[bytes_read], "%2" SCNx32 , &dummy);
688 cal_checksum += (uint8_t)dummy;
689 bytes_read += 2;
690 }
691 }
692 else if (record_type >= 7 && record_type <= 9)
693 {
694 /* S7, S8, S9 - ending records for 32, 24 and 16bit */
695 image->num_sections++;
696
697 /* copy section information */
698 image->sections = malloc(sizeof(struct imagesection) * image->num_sections);
699 for (i = 0; i < image->num_sections; i++)
700 {
701 image->sections[i].private = section[i].private;
702 image->sections[i].base_address = section[i].base_address;
703 image->sections[i].size = section[i].size;
704 image->sections[i].flags = section[i].flags;
705 }
706
707 return ERROR_OK;
708 }
709 else
710 {
711 LOG_ERROR("unhandled S19 record type: %i", (int)(record_type));
712 return ERROR_IMAGE_FORMAT_ERROR;
713 }
714
715 /* account for checksum, will always be 0xFF */
716 sscanf(&lpszLine[bytes_read], "%2" SCNx32 , &checksum);
717 cal_checksum += (uint8_t)checksum;
718
719 if (cal_checksum != 0xFF)
720 {
721 /* checksum failed */
722 LOG_ERROR("incorrect record checksum found in S19 file");
723 return ERROR_IMAGE_CHECKSUM;
724 }
725 }
726
727 LOG_ERROR("premature end of S19 file, no end-of-file record found");
728 return ERROR_IMAGE_FORMAT_ERROR;
729 }
730
731 /**
732 * Allocate memory dynamically instead of on the stack. This
733 * is important w/embedded hosts.
734 */
735 static int image_mot_buffer_complete(struct image *image)
736 {
737 char *lpszLine = malloc(1023);
738 if (lpszLine == NULL)
739 {
740 LOG_ERROR("Out of memory");
741 return ERROR_FAIL;
742 }
743 struct imagesection *section = malloc(sizeof(struct imagesection) * IMAGE_MAX_SECTIONS);
744 if (section == NULL)
745 {
746 free(lpszLine);
747 LOG_ERROR("Out of memory");
748 return ERROR_FAIL;
749 }
750 int retval;
751
752 retval = image_mot_buffer_complete_inner(image, lpszLine, section);
753
754 free(section);
755 free(lpszLine);
756
757 return retval;
758 }
759
760
761 int image_open(struct image *image, const char *url, const char *type_string)
762 {
763 int retval = ERROR_OK;
764
765 if ((retval = identify_image_type(image, type_string, url)) != ERROR_OK)
766 {
767 return retval;
768 }
769
770 if (image->type == IMAGE_BINARY)
771 {
772 struct image_binary *image_binary;
773
774 image_binary = image->type_private = malloc(sizeof(struct image_binary));
775
776 if ((retval = fileio_open(&image_binary->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
777 {
778 return retval;
779 }
780 int filesize;
781 retval = fileio_size(&image_binary->fileio, &filesize);
782 if (retval != ERROR_OK)
783 {
784 fileio_close(&image_binary->fileio);
785 return retval;
786 }
787
788 image->num_sections = 1;
789 image->sections = malloc(sizeof(struct imagesection));
790 image->sections[0].base_address = 0x0;
791 image->sections[0].size = filesize;
792 image->sections[0].flags = 0;
793 }
794 else if (image->type == IMAGE_IHEX)
795 {
796 struct image_ihex *image_ihex;
797
798 image_ihex = image->type_private = malloc(sizeof(struct image_ihex));
799
800 if ((retval = fileio_open(&image_ihex->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
801 {
802 return retval;
803 }
804
805 if ((retval = image_ihex_buffer_complete(image)) != ERROR_OK)
806 {
807 LOG_ERROR("failed buffering IHEX image, check daemon output for additional information");
808 fileio_close(&image_ihex->fileio);
809 return retval;
810 }
811 }
812 else if (image->type == IMAGE_ELF)
813 {
814 struct image_elf *image_elf;
815
816 image_elf = image->type_private = malloc(sizeof(struct image_elf));
817
818 if ((retval = fileio_open(&image_elf->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
819 {
820 return retval;
821 }
822
823 if ((retval = image_elf_read_headers(image)) != ERROR_OK)
824 {
825 fileio_close(&image_elf->fileio);
826 return retval;
827 }
828 }
829 else if (image->type == IMAGE_MEMORY)
830 {
831 struct target *target = get_target(url);
832
833 if (target == NULL)
834 {
835 LOG_ERROR("target '%s' not defined", url);
836 return ERROR_FAIL;
837 }
838
839 struct image_memory *image_memory;
840
841 image->num_sections = 1;
842 image->sections = malloc(sizeof(struct imagesection));
843 image->sections[0].base_address = 0x0;
844 image->sections[0].size = 0xffffffff;
845 image->sections[0].flags = 0;
846
847 image_memory = image->type_private = malloc(sizeof(struct image_memory));
848
849 image_memory->target = target;
850 image_memory->cache = NULL;
851 image_memory->cache_address = 0x0;
852 }
853 else if (image->type == IMAGE_SRECORD)
854 {
855 struct image_mot *image_mot;
856
857 image_mot = image->type_private = malloc(sizeof(struct image_mot));
858
859 if ((retval = fileio_open(&image_mot->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
860 {
861 return retval;
862 }
863
864 if ((retval = image_mot_buffer_complete(image)) != ERROR_OK)
865 {
866 LOG_ERROR("failed buffering S19 image, check daemon output for additional information");
867 fileio_close(&image_mot->fileio);
868 return retval;
869 }
870 }
871 else if (image->type == IMAGE_BUILDER)
872 {
873 image->num_sections = 0;
874 image->sections = NULL;
875 image->type_private = NULL;
876 }
877
878 if (image->base_address_set)
879 {
880 /* relocate */
881 int section;
882 for (section = 0; section < image->num_sections; section++)
883 {
884 image->sections[section].base_address += image->base_address;
885 }
886 /* we're done relocating. The two statements below are mainly
887 * for documenation purposes: stop anyone from empirically
888 * thinking they should use these values henceforth. */
889 image->base_address = 0;
890 image->base_address_set = 0;
891 }
892
893 return retval;
894 };
895
896 int image_read_section(struct image *image, int section, uint32_t offset, uint32_t size, uint8_t *buffer, size_t *size_read)
897 {
898 int retval;
899
900 /* don't read past the end of a section */
901 if (offset + size > image->sections[section].size)
902 {
903 LOG_DEBUG("read past end of section: 0x%8.8" PRIx32 " + 0x%8.8" PRIx32 " > 0x%8.8" PRIx32 "",
904 offset, size, image->sections[section].size);
905 return ERROR_INVALID_ARGUMENTS;
906 }
907
908 if (image->type == IMAGE_BINARY)
909 {
910 struct image_binary *image_binary = image->type_private;
911
912 /* only one section in a plain binary */
913 if (section != 0)
914 return ERROR_INVALID_ARGUMENTS;
915
916 /* seek to offset */
917 if ((retval = fileio_seek(&image_binary->fileio, offset)) != ERROR_OK)
918 {
919 return retval;
920 }
921
922 /* return requested bytes */
923 if ((retval = fileio_read(&image_binary->fileio, size, buffer, size_read)) != ERROR_OK)
924 {
925 return retval;
926 }
927 }
928 else if (image->type == IMAGE_IHEX)
929 {
930 memcpy(buffer, (uint8_t*)image->sections[section].private + offset, size);
931 *size_read = size;
932
933 return ERROR_OK;
934 }
935 else if (image->type == IMAGE_ELF)
936 {
937 return image_elf_read_section(image, section, offset, size, buffer, size_read);
938 }
939 else if (image->type == IMAGE_MEMORY)
940 {
941 struct image_memory *image_memory = image->type_private;
942 uint32_t address = image->sections[section].base_address + offset;
943
944 *size_read = 0;
945
946 while ((size - *size_read) > 0)
947 {
948 uint32_t size_in_cache;
949
950 if (!image_memory->cache
951 || (address < image_memory->cache_address)
952 || (address >= (image_memory->cache_address + IMAGE_MEMORY_CACHE_SIZE)))
953 {
954 if (!image_memory->cache)
955 image_memory->cache = malloc(IMAGE_MEMORY_CACHE_SIZE);
956
957 if (target_read_buffer(image_memory->target, address & ~(IMAGE_MEMORY_CACHE_SIZE - 1),
958 IMAGE_MEMORY_CACHE_SIZE, image_memory->cache) != ERROR_OK)
959 {
960 free(image_memory->cache);
961 image_memory->cache = NULL;
962 return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE;
963 }
964 image_memory->cache_address = address & ~(IMAGE_MEMORY_CACHE_SIZE - 1);
965 }
966
967 size_in_cache = (image_memory->cache_address + IMAGE_MEMORY_CACHE_SIZE) - address;
968
969 memcpy(buffer + *size_read,
970 image_memory->cache + (address - image_memory->cache_address),
971 (size_in_cache > size) ? size : size_in_cache
972 );
973
974 *size_read += (size_in_cache > size) ? size : size_in_cache;
975 address += (size_in_cache > size) ? size : size_in_cache;
976 }
977 }
978 else if (image->type == IMAGE_SRECORD)
979 {
980 memcpy(buffer, (uint8_t*)image->sections[section].private + offset, size);
981 *size_read = size;
982
983 return ERROR_OK;
984 }
985 else if (image->type == IMAGE_BUILDER)
986 {
987 memcpy(buffer, (uint8_t*)image->sections[section].private + offset, size);
988 *size_read = size;
989
990 return ERROR_OK;
991 }
992
993 return ERROR_OK;
994 }
995
996 int image_add_section(struct image *image, uint32_t base, uint32_t size, int flags, uint8_t *data)
997 {
998 struct imagesection *section;
999
1000 /* only image builder supports adding sections */
1001 if (image->type != IMAGE_BUILDER)
1002 return ERROR_INVALID_ARGUMENTS;
1003
1004 /* see if there's a previous section */
1005 if (image->num_sections)
1006 {
1007 section = &image->sections[image->num_sections - 1];
1008
1009 /* see if it's enough to extend the last section,
1010 * adding data to previous sections or merging is not supported */
1011 if (((section->base_address + section->size) == base) && (section->flags == flags))
1012 {
1013 section->private = realloc(section->private, section->size + size);
1014 memcpy((uint8_t*)section->private + section->size, data, size);
1015 section->size += size;
1016 return ERROR_OK;
1017 }
1018 }
1019
1020 /* allocate new section */
1021 image->num_sections++;
1022 image->sections = realloc(image->sections, sizeof(struct imagesection) * image->num_sections);
1023 section = &image->sections[image->num_sections - 1];
1024 section->base_address = base;
1025 section->size = size;
1026 section->flags = flags;
1027 section->private = malloc(sizeof(uint8_t) * size);
1028 memcpy((uint8_t*)section->private, data, size);
1029
1030 return ERROR_OK;
1031 }
1032
1033 void image_close(struct image *image)
1034 {
1035 if (image->type == IMAGE_BINARY)
1036 {
1037 struct image_binary *image_binary = image->type_private;
1038
1039 fileio_close(&image_binary->fileio);
1040 }
1041 else if (image->type == IMAGE_IHEX)
1042 {
1043 struct image_ihex *image_ihex = image->type_private;
1044
1045 fileio_close(&image_ihex->fileio);
1046
1047 if (image_ihex->buffer)
1048 {
1049 free(image_ihex->buffer);
1050 image_ihex->buffer = NULL;
1051 }
1052 }
1053 else if (image->type == IMAGE_ELF)
1054 {
1055 struct image_elf *image_elf = image->type_private;
1056
1057 fileio_close(&image_elf->fileio);
1058
1059 if (image_elf->header)
1060 {
1061 free(image_elf->header);
1062 image_elf->header = NULL;
1063 }
1064
1065 if (image_elf->segments)
1066 {
1067 free(image_elf->segments);
1068 image_elf->segments = NULL;
1069 }
1070 }
1071 else if (image->type == IMAGE_MEMORY)
1072 {
1073 struct image_memory *image_memory = image->type_private;
1074
1075 if (image_memory->cache)
1076 {
1077 free(image_memory->cache);
1078 image_memory->cache = NULL;
1079 }
1080 }
1081 else if (image->type == IMAGE_SRECORD)
1082 {
1083 struct image_mot *image_mot = image->type_private;
1084
1085 fileio_close(&image_mot->fileio);
1086
1087 if (image_mot->buffer)
1088 {
1089 free(image_mot->buffer);
1090 image_mot->buffer = NULL;
1091 }
1092 }
1093 else if (image->type == IMAGE_BUILDER)
1094 {
1095 int i;
1096
1097 for (i = 0; i < image->num_sections; i++)
1098 {
1099 free(image->sections[i].private);
1100 image->sections[i].private = NULL;
1101 }
1102 }
1103
1104 if (image->type_private)
1105 {
1106 free(image->type_private);
1107 image->type_private = NULL;
1108 }
1109
1110 if (image->sections)
1111 {
1112 free(image->sections);
1113 image->sections = NULL;
1114 }
1115 }
1116
1117 int image_calculate_checksum(uint8_t* buffer, uint32_t nbytes, uint32_t* checksum)
1118 {
1119 uint32_t crc = 0xffffffff;
1120 LOG_DEBUG("Calculating checksum");
1121
1122 static uint32_t crc32_table[256];
1123
1124 static bool first_init = false;
1125 if (!first_init)
1126 {
1127 /* Initialize the CRC table and the decoding table. */
1128 int i, j;
1129 unsigned int c;
1130 for (i = 0; i < 256; i++)
1131 {
1132 /* as per gdb */
1133 for (c = i << 24, j = 8; j > 0; --j)
1134 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
1135 crc32_table[i] = c;
1136 }
1137
1138 first_init = true;
1139 }
1140
1141 while (nbytes > 0)
1142 {
1143 int run = nbytes;
1144 if (run > 32768)
1145 {
1146 run = 32768;
1147 }
1148 nbytes -= run;
1149 while (run--)
1150 {
1151 /* as per gdb */
1152 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buffer++) & 255];
1153 }
1154 keep_alive();
1155 }
1156
1157 LOG_DEBUG("Calculating checksum done");
1158
1159 *checksum = crc;
1160 return ERROR_OK;
1161 }
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)