1 /***************************************************************************
2 * Copyright (C) 2007 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * Copyright (C) 2009 by Franck Hereson *
12 * franck.hereson@secad.fr *
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. *
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. *
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 ***************************************************************************/
35 #include <helper/log.h>
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))
43 #define field32(elf,field)\
44 ((elf->endianness == ELFDATA2LSB)? \
45 le_to_h_u32((uint8_t*)&field):be_to_h_u32((uint8_t*)&field))
47 static int autodetect_image_type(struct image
*image
, const char *url
)
54 /* read the first 4 bytes of image */
55 if ((retval
= fileio_open(&fileio
, url
, FILEIO_READ
, FILEIO_BINARY
)) != ERROR_OK
)
59 retval
= fileio_read(&fileio
, 9, buffer
, &read_bytes
);
61 if (retval
== ERROR_OK
)
65 retval
= ERROR_FILEIO_OPERATION_FAILED
;
68 fileio_close(&fileio
);
70 if (retval
!= ERROR_OK
)
73 /* check header against known signatures */
74 if (strncmp((char*)buffer
,ELFMAG
,SELFMAG
) == 0)
76 LOG_DEBUG("ELF image detected.");
77 image
->type
= IMAGE_ELF
;
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'))
89 LOG_DEBUG("IHEX image detected.");
90 image
->type
= IMAGE_IHEX
;
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'))
98 LOG_DEBUG("S19 image detected.");
99 image
->type
= IMAGE_SRECORD
;
103 image
->type
= IMAGE_BINARY
;
109 static int identify_image_type(struct image
*image
, const char *type_string
, const char *url
)
113 if (!strcmp(type_string
, "bin"))
115 image
->type
= IMAGE_BINARY
;
117 else if (!strcmp(type_string
, "ihex"))
119 image
->type
= IMAGE_IHEX
;
121 else if (!strcmp(type_string
, "elf"))
123 image
->type
= IMAGE_ELF
;
125 else if (!strcmp(type_string
, "mem"))
127 image
->type
= IMAGE_MEMORY
;
129 else if (!strcmp(type_string
, "s19"))
131 image
->type
= IMAGE_SRECORD
;
133 else if (!strcmp(type_string
, "build"))
135 image
->type
= IMAGE_BUILDER
;
139 return ERROR_IMAGE_TYPE_UNKNOWN
;
144 return autodetect_image_type(image
, url
);
150 static int image_ihex_buffer_complete_inner(struct image
*image
, char *lpszLine
, struct imagesection
*section
)
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
;
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 */
163 retval
= fileio_size(fileio
, &filesize
);
164 if (retval
!= ERROR_OK
)
167 ihex
->buffer
= malloc(filesize
>> 1);
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;
175 while (fileio_fgets(fileio
, 1023, lpszLine
) == ERROR_OK
)
179 uint32_t record_type
;
181 uint8_t cal_checksum
= 0;
182 size_t bytes_read
= 0;
184 if (sscanf(&lpszLine
[bytes_read
], ":%2" SCNx32
"%4" SCNx32
"%2" SCNx32
, &count
, &address
, &record_type
) != 3)
186 return ERROR_IMAGE_FORMAT_ERROR
;
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
;
195 if (record_type
== 0) /* Data Record */
197 if ((full_address
& 0xffff) != address
)
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
203 if (section
[image
->num_sections
].size
!= 0)
205 image
->num_sections
++;
206 if (image
->num_sections
>= IMAGE_MAX_SECTIONS
)
208 /* too many sections */
209 LOG_ERROR("Too many sections found in IHEX file");
210 return ERROR_IMAGE_FORMAT_ERROR
;
212 section
[image
->num_sections
].size
= 0x0;
213 section
[image
->num_sections
].flags
= 0;
214 section
[image
->num_sections
].private = &ihex
->buffer
[cooked_bytes
];
216 section
[image
->num_sections
].base_address
=
217 (full_address
& 0xffff0000) | address
;
218 full_address
= (full_address
& 0xffff0000) | address
;
224 sscanf(&lpszLine
[bytes_read
], "%2x", &value
);
225 ihex
->buffer
[cooked_bytes
] = (uint8_t)value
;
226 cal_checksum
+= (uint8_t)ihex
->buffer
[cooked_bytes
];
229 section
[image
->num_sections
].size
+= 1;
233 else if (record_type
== 1) /* End of File Record */
235 /* finish the current section */
236 image
->num_sections
++;
238 /* copy section information */
239 image
->sections
= malloc(sizeof(struct imagesection
) * image
->num_sections
);
240 for (i
= 0; i
< image
->num_sections
; i
++)
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
;
250 else if (record_type
== 2) /* Linear Address Record */
252 uint16_t upper_address
;
254 sscanf(&lpszLine
[bytes_read
], "%4hx", &upper_address
);
255 cal_checksum
+= (uint8_t)(upper_address
>> 8);
256 cal_checksum
+= (uint8_t)upper_address
;
259 if ((full_address
>> 4) != upper_address
)
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
265 if (section
[image
->num_sections
].size
!= 0)
267 image
->num_sections
++;
268 if (image
->num_sections
>= IMAGE_MAX_SECTIONS
)
270 /* too many sections */
271 LOG_ERROR("Too many sections found in IHEX file");
272 return ERROR_IMAGE_FORMAT_ERROR
;
274 section
[image
->num_sections
].size
= 0x0;
275 section
[image
->num_sections
].flags
= 0;
276 section
[image
->num_sections
].private = &ihex
->buffer
[cooked_bytes
];
278 section
[image
->num_sections
].base_address
=
279 (full_address
& 0xffff) | (upper_address
<< 4);
280 full_address
= (full_address
& 0xffff) | (upper_address
<< 4);
283 else if (record_type
== 3) /* Start Segment Address Record */
287 /* "Start Segment Address Record" will not be supported */
288 /* but we must consume it, and do not create an error. */
291 sscanf(&lpszLine
[bytes_read
], "%2" SCNx32
, &dummy
);
292 cal_checksum
+= (uint8_t)dummy
;
296 else if (record_type
== 4) /* Extended Linear Address Record */
298 uint16_t upper_address
;
300 sscanf(&lpszLine
[bytes_read
], "%4hx", &upper_address
);
301 cal_checksum
+= (uint8_t)(upper_address
>> 8);
302 cal_checksum
+= (uint8_t)upper_address
;
305 if ((full_address
>> 16) != upper_address
)
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
311 if (section
[image
->num_sections
].size
!= 0)
313 image
->num_sections
++;
314 if (image
->num_sections
>= IMAGE_MAX_SECTIONS
)
316 /* too many sections */
317 LOG_ERROR("Too many sections found in IHEX file");
318 return ERROR_IMAGE_FORMAT_ERROR
;
320 section
[image
->num_sections
].size
= 0x0;
321 section
[image
->num_sections
].flags
= 0;
322 section
[image
->num_sections
].private = &ihex
->buffer
[cooked_bytes
];
324 section
[image
->num_sections
].base_address
=
325 (full_address
& 0xffff) | (upper_address
<< 16);
326 full_address
= (full_address
& 0xffff) | (upper_address
<< 16);
329 else if (record_type
== 5) /* Start Linear Address Record */
331 uint32_t start_address
;
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
;
340 image
->start_address_set
= 1;
341 image
->start_address
= be_to_h_u32((uint8_t*)&start_address
);
345 LOG_ERROR("unhandled IHEX record type: %i", (int)record_type
);
346 return ERROR_IMAGE_FORMAT_ERROR
;
349 sscanf(&lpszLine
[bytes_read
], "%2" SCNx32
, &checksum
);
352 if ((uint8_t)checksum
!= (uint8_t)(~cal_checksum
+ 1))
354 /* checksum failed */
355 LOG_ERROR("incorrect record checksum found in IHEX file");
356 return ERROR_IMAGE_CHECKSUM
;
360 LOG_ERROR("premature end of IHEX file, no end-of-file record found");
361 return ERROR_IMAGE_FORMAT_ERROR
;
365 * Allocate memory dynamically instead of on the stack. This
366 * is important w/embedded hosts.
368 static int image_ihex_buffer_complete(struct image
*image
)
370 char *lpszLine
= malloc(1023);
371 if (lpszLine
== NULL
)
373 LOG_ERROR("Out of memory");
376 struct imagesection
*section
= malloc(sizeof(struct imagesection
) * IMAGE_MAX_SECTIONS
);
380 LOG_ERROR("Out of memory");
385 retval
= image_ihex_buffer_complete_inner(image
, lpszLine
, section
);
393 static int image_elf_read_headers(struct image
*image
)
395 struct image_elf
*elf
= image
->type_private
;
399 uint32_t nload
,load_to_vaddr
=0;
401 elf
->header
= malloc(sizeof(Elf32_Ehdr
));
403 if (elf
->header
== NULL
)
405 LOG_ERROR("insufficient memory to perform operation ");
406 return ERROR_FILEIO_OPERATION_FAILED
;
409 if ((retval
= fileio_read(&elf
->fileio
, sizeof(Elf32_Ehdr
), (uint8_t*)elf
->header
, &read_bytes
)) != ERROR_OK
)
411 LOG_ERROR("cannot read ELF file header, read failed");
412 return ERROR_FILEIO_OPERATION_FAILED
;
414 if (read_bytes
!= sizeof(Elf32_Ehdr
))
416 LOG_ERROR("cannot read ELF file header, only partially read");
417 return ERROR_FILEIO_OPERATION_FAILED
;
420 if (strncmp((char*)elf
->header
->e_ident
,ELFMAG
,SELFMAG
) != 0)
422 LOG_ERROR("invalid ELF file, bad magic number");
423 return ERROR_IMAGE_FORMAT_ERROR
;
425 if (elf
->header
->e_ident
[EI_CLASS
]!=ELFCLASS32
)
427 LOG_ERROR("invalid ELF file, only 32bits files are supported");
428 return ERROR_IMAGE_FORMAT_ERROR
;
431 elf
->endianness
= elf
->header
->e_ident
[EI_DATA
];
432 if ((elf
->endianness
!= ELFDATA2LSB
)
433 &&(elf
->endianness
!= ELFDATA2MSB
))
435 LOG_ERROR("invalid ELF file, unknown endianness setting");
436 return ERROR_IMAGE_FORMAT_ERROR
;
439 elf
->segment_count
= field16(elf
,elf
->header
->e_phnum
);
440 if (elf
->segment_count
== 0)
442 LOG_ERROR("invalid ELF file, no program headers");
443 return ERROR_IMAGE_FORMAT_ERROR
;
446 if ((retval
= fileio_seek(&elf
->fileio
, field32(elf
,elf
->header
->e_phoff
))) != ERROR_OK
)
448 LOG_ERROR("cannot seek to ELF program header table, read failed");
452 elf
->segments
= malloc(elf
->segment_count
*sizeof(Elf32_Phdr
));
453 if (elf
->segments
== NULL
)
455 LOG_ERROR("insufficient memory to perform operation ");
456 return ERROR_FILEIO_OPERATION_FAILED
;
459 if ((retval
= fileio_read(&elf
->fileio
, elf
->segment_count
*sizeof(Elf32_Phdr
), (uint8_t*)elf
->segments
, &read_bytes
)) != ERROR_OK
)
461 LOG_ERROR("cannot read ELF segment headers, read failed");
464 if (read_bytes
!= elf
->segment_count
*sizeof(Elf32_Phdr
))
466 LOG_ERROR("cannot read ELF segment headers, only partially read");
467 return ERROR_FILEIO_OPERATION_FAILED
;
470 /* count useful segments (loadable), ignore BSS section */
471 image
->num_sections
= 0;
472 for (i
= 0;i
< elf
->segment_count
;i
++)
473 if ((field32(elf
, elf
->segments
[i
].p_type
) == PT_LOAD
) && (field32(elf
, elf
->segments
[i
].p_filesz
) != 0))
474 image
->num_sections
++;
476 assert(image
->num_sections
> 0);
479 * some ELF linkers produce binaries with *all* the program header
480 * p_paddr fields zero (there can be however one loadable segment
481 * that has valid physical address 0x0).
482 * If we have such a binary with more than
483 * one PT_LOAD header, then use p_vaddr instead of p_paddr
484 * (ARM ELF standard demands p_paddr = 0 anyway, and BFD
485 * library uses this approach to workaround zero-initialized p_paddrs
486 * when obtaining lma - look at elf.c of BDF)
488 for (nload
= 0, i
= 0; i
< elf
->segment_count
; i
++)
489 if (elf
->segments
[i
].p_paddr
!= 0)
491 else if ((field32(elf
, elf
->segments
[i
].p_type
) == PT_LOAD
) && (field32(elf
, elf
->segments
[i
].p_memsz
) != 0))
494 if (i
>= elf
->segment_count
&& nload
> 1)
497 /* alloc and fill sections array with loadable segments */
498 image
->sections
= malloc(image
->num_sections
* sizeof(struct imagesection
));
499 for (i
= 0,j
= 0;i
< elf
->segment_count
;i
++)
501 if ((field32(elf
, elf
->segments
[i
].p_type
) == PT_LOAD
) && (field32(elf
, elf
->segments
[i
].p_filesz
) != 0))
503 image
->sections
[j
].size
= field32(elf
,elf
->segments
[i
].p_filesz
);
505 image
->sections
[j
].base_address
= field32(elf
,elf
->segments
[i
].p_vaddr
);
507 image
->sections
[j
].base_address
= field32(elf
,elf
->segments
[i
].p_paddr
);
508 image
->sections
[j
].private = &elf
->segments
[i
];
509 image
->sections
[j
].flags
= field32(elf
,elf
->segments
[i
].p_flags
);
514 image
->start_address_set
= 1;
515 image
->start_address
= field32(elf
,elf
->header
->e_entry
);
520 static int image_elf_read_section(struct image
*image
, int section
, uint32_t offset
, uint32_t size
, uint8_t *buffer
, size_t *size_read
)
522 struct image_elf
*elf
= image
->type_private
;
523 Elf32_Phdr
*segment
= (Elf32_Phdr
*)image
->sections
[section
].private;
524 size_t read_size
,really_read
;
529 LOG_DEBUG("load segment %d at 0x%" PRIx32
" (sz = 0x%" PRIx32
")",section
,offset
,size
);
531 /* read initialized data in current segment if any */
532 if (offset
< field32(elf
,segment
->p_filesz
))
534 /* maximal size present in file for the current segment */
535 read_size
= MIN(size
, field32(elf
,segment
->p_filesz
)-offset
);
536 LOG_DEBUG("read elf: size = 0x%zu at 0x%" PRIx32
"", read_size
,
537 field32(elf
,segment
->p_offset
) + offset
);
538 /* read initialized area of the segment */
539 if ((retval
= fileio_seek(&elf
->fileio
, field32(elf
,segment
->p_offset
) + offset
)) != ERROR_OK
)
541 LOG_ERROR("cannot find ELF segment content, seek failed");
544 if ((retval
= fileio_read(&elf
->fileio
, read_size
, buffer
, &really_read
)) != ERROR_OK
)
546 LOG_ERROR("cannot read ELF segment content, read failed");
552 *size_read
+= read_size
;
553 /* need more data ? */
561 static int image_mot_buffer_complete_inner(struct image
*image
, char *lpszLine
, struct imagesection
*section
)
563 struct image_mot
*mot
= image
->type_private
;
564 struct fileio
*fileio
= &mot
->fileio
;
565 uint32_t full_address
= 0x0;
566 uint32_t cooked_bytes
;
569 /* we can't determine the number of sections that we'll have to create ahead of time,
570 * so we locally hold them until parsing is finished */
574 retval
= fileio_size(fileio
, &filesize
);
575 if (retval
!= ERROR_OK
)
578 mot
->buffer
= malloc(filesize
>> 1);
580 image
->num_sections
= 0;
581 section
[image
->num_sections
].private = &mot
->buffer
[cooked_bytes
];
582 section
[image
->num_sections
].base_address
= 0x0;
583 section
[image
->num_sections
].size
= 0x0;
584 section
[image
->num_sections
].flags
= 0;
586 while (fileio_fgets(fileio
, 1023, lpszLine
) == ERROR_OK
)
590 uint32_t record_type
;
592 uint8_t cal_checksum
= 0;
593 uint32_t bytes_read
= 0;
595 /* get record type and record length */
596 if (sscanf(&lpszLine
[bytes_read
], "S%1" SCNx32
"%2" SCNx32
, &record_type
, &count
) != 2)
598 return ERROR_IMAGE_FORMAT_ERROR
;
602 cal_checksum
+= (uint8_t)count
;
604 /* skip checksum byte */
607 if (record_type
== 0)
609 /* S0 - starting record (optional) */
612 while (count
-- > 0) {
613 sscanf(&lpszLine
[bytes_read
], "%2x", &iValue
);
614 cal_checksum
+= (uint8_t)iValue
;
618 else if (record_type
>= 1 && record_type
<= 3)
623 /* S1 - 16 bit address data record */
624 sscanf(&lpszLine
[bytes_read
], "%4" SCNx32
, &address
);
625 cal_checksum
+= (uint8_t)(address
>> 8);
626 cal_checksum
+= (uint8_t)address
;
632 /* S2 - 24 bit address data record */
633 sscanf(&lpszLine
[bytes_read
], "%6" SCNx32
, &address
);
634 cal_checksum
+= (uint8_t)(address
>> 16);
635 cal_checksum
+= (uint8_t)(address
>> 8);
636 cal_checksum
+= (uint8_t)address
;
642 /* S3 - 32 bit address data record */
643 sscanf(&lpszLine
[bytes_read
], "%8" SCNx32
, &address
);
644 cal_checksum
+= (uint8_t)(address
>> 24);
645 cal_checksum
+= (uint8_t)(address
>> 16);
646 cal_checksum
+= (uint8_t)(address
>> 8);
647 cal_checksum
+= (uint8_t)address
;
654 if (full_address
!= address
)
656 /* we encountered a nonconsecutive location, create a new section,
657 * unless the current section has zero size, in which case this specifies
658 * the current section's base address
660 if (section
[image
->num_sections
].size
!= 0)
662 image
->num_sections
++;
663 section
[image
->num_sections
].size
= 0x0;
664 section
[image
->num_sections
].flags
= 0;
665 section
[image
->num_sections
].private = &mot
->buffer
[cooked_bytes
];
667 section
[image
->num_sections
].base_address
= address
;
668 full_address
= address
;
674 sscanf(&lpszLine
[bytes_read
], "%2x", &value
);
675 mot
->buffer
[cooked_bytes
] = (uint8_t)value
;
676 cal_checksum
+= (uint8_t)mot
->buffer
[cooked_bytes
];
679 section
[image
->num_sections
].size
+= 1;
683 else if (record_type
== 5)
685 /* S5 is the data count record, we ignore it */
690 sscanf(&lpszLine
[bytes_read
], "%2" SCNx32
, &dummy
);
691 cal_checksum
+= (uint8_t)dummy
;
695 else if (record_type
>= 7 && record_type
<= 9)
697 /* S7, S8, S9 - ending records for 32, 24 and 16bit */
698 image
->num_sections
++;
700 /* copy section information */
701 image
->sections
= malloc(sizeof(struct imagesection
) * image
->num_sections
);
702 for (i
= 0; i
< image
->num_sections
; i
++)
704 image
->sections
[i
].private = section
[i
].private;
705 image
->sections
[i
].base_address
= section
[i
].base_address
;
706 image
->sections
[i
].size
= section
[i
].size
;
707 image
->sections
[i
].flags
= section
[i
].flags
;
714 LOG_ERROR("unhandled S19 record type: %i", (int)(record_type
));
715 return ERROR_IMAGE_FORMAT_ERROR
;
718 /* account for checksum, will always be 0xFF */
719 sscanf(&lpszLine
[bytes_read
], "%2" SCNx32
, &checksum
);
720 cal_checksum
+= (uint8_t)checksum
;
723 if (cal_checksum
!= 0xFF)
725 /* checksum failed */
726 LOG_ERROR("incorrect record checksum found in S19 file");
727 return ERROR_IMAGE_CHECKSUM
;
731 LOG_ERROR("premature end of S19 file, no end-of-file record found");
732 return ERROR_IMAGE_FORMAT_ERROR
;
736 * Allocate memory dynamically instead of on the stack. This
737 * is important w/embedded hosts.
739 static int image_mot_buffer_complete(struct image
*image
)
741 char *lpszLine
= malloc(1023);
742 if (lpszLine
== NULL
)
744 LOG_ERROR("Out of memory");
747 struct imagesection
*section
= malloc(sizeof(struct imagesection
) * IMAGE_MAX_SECTIONS
);
751 LOG_ERROR("Out of memory");
756 retval
= image_mot_buffer_complete_inner(image
, lpszLine
, section
);
765 int image_open(struct image
*image
, const char *url
, const char *type_string
)
767 int retval
= ERROR_OK
;
769 if ((retval
= identify_image_type(image
, type_string
, url
)) != ERROR_OK
)
774 if (image
->type
== IMAGE_BINARY
)
776 struct image_binary
*image_binary
;
778 image_binary
= image
->type_private
= malloc(sizeof(struct image_binary
));
780 if ((retval
= fileio_open(&image_binary
->fileio
, url
, FILEIO_READ
, FILEIO_BINARY
)) != ERROR_OK
)
785 retval
= fileio_size(&image_binary
->fileio
, &filesize
);
786 if (retval
!= ERROR_OK
)
788 fileio_close(&image_binary
->fileio
);
792 image
->num_sections
= 1;
793 image
->sections
= malloc(sizeof(struct imagesection
));
794 image
->sections
[0].base_address
= 0x0;
795 image
->sections
[0].size
= filesize
;
796 image
->sections
[0].flags
= 0;
798 else if (image
->type
== IMAGE_IHEX
)
800 struct image_ihex
*image_ihex
;
802 image_ihex
= image
->type_private
= malloc(sizeof(struct image_ihex
));
804 if ((retval
= fileio_open(&image_ihex
->fileio
, url
, FILEIO_READ
, FILEIO_TEXT
)) != ERROR_OK
)
809 if ((retval
= image_ihex_buffer_complete(image
)) != ERROR_OK
)
811 LOG_ERROR("failed buffering IHEX image, check daemon output for additional information");
812 fileio_close(&image_ihex
->fileio
);
816 else if (image
->type
== IMAGE_ELF
)
818 struct image_elf
*image_elf
;
820 image_elf
= image
->type_private
= malloc(sizeof(struct image_elf
));
822 if ((retval
= fileio_open(&image_elf
->fileio
, url
, FILEIO_READ
, FILEIO_BINARY
)) != ERROR_OK
)
827 if ((retval
= image_elf_read_headers(image
)) != ERROR_OK
)
829 fileio_close(&image_elf
->fileio
);
833 else if (image
->type
== IMAGE_MEMORY
)
835 struct target
*target
= get_target(url
);
839 LOG_ERROR("target '%s' not defined", url
);
843 struct image_memory
*image_memory
;
845 image
->num_sections
= 1;
846 image
->sections
= malloc(sizeof(struct imagesection
));
847 image
->sections
[0].base_address
= 0x0;
848 image
->sections
[0].size
= 0xffffffff;
849 image
->sections
[0].flags
= 0;
851 image_memory
= image
->type_private
= malloc(sizeof(struct image_memory
));
853 image_memory
->target
= target
;
854 image_memory
->cache
= NULL
;
855 image_memory
->cache_address
= 0x0;
857 else if (image
->type
== IMAGE_SRECORD
)
859 struct image_mot
*image_mot
;
861 image_mot
= image
->type_private
= malloc(sizeof(struct image_mot
));
863 if ((retval
= fileio_open(&image_mot
->fileio
, url
, FILEIO_READ
, FILEIO_TEXT
)) != ERROR_OK
)
868 if ((retval
= image_mot_buffer_complete(image
)) != ERROR_OK
)
870 LOG_ERROR("failed buffering S19 image, check daemon output for additional information");
871 fileio_close(&image_mot
->fileio
);
875 else if (image
->type
== IMAGE_BUILDER
)
877 image
->num_sections
= 0;
878 image
->sections
= NULL
;
879 image
->type_private
= NULL
;
882 if (image
->base_address_set
)
886 for (section
= 0; section
< image
->num_sections
; section
++)
888 image
->sections
[section
].base_address
+= image
->base_address
;
890 /* we're done relocating. The two statements below are mainly
891 * for documenation purposes: stop anyone from empirically
892 * thinking they should use these values henceforth. */
893 image
->base_address
= 0;
894 image
->base_address_set
= 0;
900 int image_read_section(struct image
*image
, int section
, uint32_t offset
, uint32_t size
, uint8_t *buffer
, size_t *size_read
)
904 /* don't read past the end of a section */
905 if (offset
+ size
> image
->sections
[section
].size
)
907 LOG_DEBUG("read past end of section: 0x%8.8" PRIx32
" + 0x%8.8" PRIx32
" > 0x%8.8" PRIx32
"",
908 offset
, size
, image
->sections
[section
].size
);
909 return ERROR_INVALID_ARGUMENTS
;
912 if (image
->type
== IMAGE_BINARY
)
914 struct image_binary
*image_binary
= image
->type_private
;
916 /* only one section in a plain binary */
918 return ERROR_INVALID_ARGUMENTS
;
921 if ((retval
= fileio_seek(&image_binary
->fileio
, offset
)) != ERROR_OK
)
926 /* return requested bytes */
927 if ((retval
= fileio_read(&image_binary
->fileio
, size
, buffer
, size_read
)) != ERROR_OK
)
932 else if (image
->type
== IMAGE_IHEX
)
934 memcpy(buffer
, (uint8_t*)image
->sections
[section
].private + offset
, size
);
939 else if (image
->type
== IMAGE_ELF
)
941 return image_elf_read_section(image
, section
, offset
, size
, buffer
, size_read
);
943 else if (image
->type
== IMAGE_MEMORY
)
945 struct image_memory
*image_memory
= image
->type_private
;
946 uint32_t address
= image
->sections
[section
].base_address
+ offset
;
950 while ((size
- *size_read
) > 0)
952 uint32_t size_in_cache
;
954 if (!image_memory
->cache
955 || (address
< image_memory
->cache_address
)
956 || (address
>= (image_memory
->cache_address
+ IMAGE_MEMORY_CACHE_SIZE
)))
958 if (!image_memory
->cache
)
959 image_memory
->cache
= malloc(IMAGE_MEMORY_CACHE_SIZE
);
961 if (target_read_buffer(image_memory
->target
, address
& ~(IMAGE_MEMORY_CACHE_SIZE
- 1),
962 IMAGE_MEMORY_CACHE_SIZE
, image_memory
->cache
) != ERROR_OK
)
964 free(image_memory
->cache
);
965 image_memory
->cache
= NULL
;
966 return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE
;
968 image_memory
->cache_address
= address
& ~(IMAGE_MEMORY_CACHE_SIZE
- 1);
971 size_in_cache
= (image_memory
->cache_address
+ IMAGE_MEMORY_CACHE_SIZE
) - address
;
973 memcpy(buffer
+ *size_read
,
974 image_memory
->cache
+ (address
- image_memory
->cache_address
),
975 (size_in_cache
> size
) ? size
: size_in_cache
978 *size_read
+= (size_in_cache
> size
) ? size
: size_in_cache
;
979 address
+= (size_in_cache
> size
) ? size
: size_in_cache
;
982 else if (image
->type
== IMAGE_SRECORD
)
984 memcpy(buffer
, (uint8_t*)image
->sections
[section
].private + offset
, size
);
989 else if (image
->type
== IMAGE_BUILDER
)
991 memcpy(buffer
, (uint8_t*)image
->sections
[section
].private + offset
, size
);
1000 int image_add_section(struct image
*image
, uint32_t base
, uint32_t size
, int flags
, uint8_t *data
)
1002 struct imagesection
*section
;
1004 /* only image builder supports adding sections */
1005 if (image
->type
!= IMAGE_BUILDER
)
1006 return ERROR_INVALID_ARGUMENTS
;
1008 /* see if there's a previous section */
1009 if (image
->num_sections
)
1011 section
= &image
->sections
[image
->num_sections
- 1];
1013 /* see if it's enough to extend the last section,
1014 * adding data to previous sections or merging is not supported */
1015 if (((section
->base_address
+ section
->size
) == base
) && (section
->flags
== flags
))
1017 section
->private = realloc(section
->private, section
->size
+ size
);
1018 memcpy((uint8_t*)section
->private + section
->size
, data
, size
);
1019 section
->size
+= size
;
1024 /* allocate new section */
1025 image
->num_sections
++;
1026 image
->sections
= realloc(image
->sections
, sizeof(struct imagesection
) * image
->num_sections
);
1027 section
= &image
->sections
[image
->num_sections
- 1];
1028 section
->base_address
= base
;
1029 section
->size
= size
;
1030 section
->flags
= flags
;
1031 section
->private = malloc(sizeof(uint8_t) * size
);
1032 memcpy((uint8_t*)section
->private, data
, size
);
1037 void image_close(struct image
*image
)
1039 if (image
->type
== IMAGE_BINARY
)
1041 struct image_binary
*image_binary
= image
->type_private
;
1043 fileio_close(&image_binary
->fileio
);
1045 else if (image
->type
== IMAGE_IHEX
)
1047 struct image_ihex
*image_ihex
= image
->type_private
;
1049 fileio_close(&image_ihex
->fileio
);
1051 if (image_ihex
->buffer
)
1053 free(image_ihex
->buffer
);
1054 image_ihex
->buffer
= NULL
;
1057 else if (image
->type
== IMAGE_ELF
)
1059 struct image_elf
*image_elf
= image
->type_private
;
1061 fileio_close(&image_elf
->fileio
);
1063 if (image_elf
->header
)
1065 free(image_elf
->header
);
1066 image_elf
->header
= NULL
;
1069 if (image_elf
->segments
)
1071 free(image_elf
->segments
);
1072 image_elf
->segments
= NULL
;
1075 else if (image
->type
== IMAGE_MEMORY
)
1077 struct image_memory
*image_memory
= image
->type_private
;
1079 if (image_memory
->cache
)
1081 free(image_memory
->cache
);
1082 image_memory
->cache
= NULL
;
1085 else if (image
->type
== IMAGE_SRECORD
)
1087 struct image_mot
*image_mot
= image
->type_private
;
1089 fileio_close(&image_mot
->fileio
);
1091 if (image_mot
->buffer
)
1093 free(image_mot
->buffer
);
1094 image_mot
->buffer
= NULL
;
1097 else if (image
->type
== IMAGE_BUILDER
)
1101 for (i
= 0; i
< image
->num_sections
; i
++)
1103 free(image
->sections
[i
].private);
1104 image
->sections
[i
].private = NULL
;
1108 if (image
->type_private
)
1110 free(image
->type_private
);
1111 image
->type_private
= NULL
;
1114 if (image
->sections
)
1116 free(image
->sections
);
1117 image
->sections
= NULL
;
1121 int image_calculate_checksum(uint8_t* buffer
, uint32_t nbytes
, uint32_t* checksum
)
1123 uint32_t crc
= 0xffffffff;
1124 LOG_DEBUG("Calculating checksum");
1126 static uint32_t crc32_table
[256];
1128 static bool first_init
= false;
1131 /* Initialize the CRC table and the decoding table. */
1134 for (i
= 0; i
< 256; i
++)
1137 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1138 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1156 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buffer
++) & 255];
1161 LOG_DEBUG("Calculating checksum done");
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)