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
++;
477 * some ELF linkers produce binaries with *all* the program header
478 * p_paddr fields zero (there can be however one loadable segment
479 * that has valid physical address 0x0).
480 * If we have such a binary with more than
481 * one PT_LOAD header, then use p_vaddr instead of p_paddr
482 * (ARM ELF standard demands p_paddr = 0 anyway, and BFD
483 * library uses this approach to workaround zero-initialized p_paddrs
484 * when obtaining lma - look at elf.c of BDF)
486 for (nload
= 0, i
= 0; i
< elf
->segment_count
; i
++)
487 if (elf
->segments
[i
].p_paddr
!= 0)
489 else if ((field32(elf
, elf
->segments
[i
].p_type
) == PT_LOAD
) && (field32(elf
, elf
->segments
[i
].p_memsz
) != 0))
492 if (i
>= elf
->segment_count
&& nload
> 1)
495 /* alloc and fill sections array with loadable segments */
496 image
->sections
= malloc(image
->num_sections
* sizeof(struct imagesection
));
497 for (i
= 0,j
= 0;i
< elf
->segment_count
;i
++)
499 if ((field32(elf
, elf
->segments
[i
].p_type
) == PT_LOAD
) && (field32(elf
, elf
->segments
[i
].p_filesz
) != 0))
501 image
->sections
[j
].size
= field32(elf
,elf
->segments
[i
].p_filesz
);
503 image
->sections
[j
].base_address
= field32(elf
,elf
->segments
[i
].p_vaddr
);
505 image
->sections
[j
].base_address
= field32(elf
,elf
->segments
[i
].p_paddr
);
506 image
->sections
[j
].private = &elf
->segments
[i
];
507 image
->sections
[j
].flags
= field32(elf
,elf
->segments
[i
].p_flags
);
512 image
->start_address_set
= 1;
513 image
->start_address
= field32(elf
,elf
->header
->e_entry
);
518 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 struct image_elf
*elf
= image
->type_private
;
521 Elf32_Phdr
*segment
= (Elf32_Phdr
*)image
->sections
[section
].private;
522 size_t read_size
,really_read
;
527 LOG_DEBUG("load segment %d at 0x%" PRIx32
" (sz = 0x%" PRIx32
")",section
,offset
,size
);
529 /* read initialized data in current segment if any */
530 if (offset
< field32(elf
,segment
->p_filesz
))
532 /* maximal size present in file for the current segment */
533 read_size
= MIN(size
, field32(elf
,segment
->p_filesz
)-offset
);
534 LOG_DEBUG("read elf: size = 0x%zu at 0x%" PRIx32
"", read_size
,
535 field32(elf
,segment
->p_offset
) + offset
);
536 /* read initialized area of the segment */
537 if ((retval
= fileio_seek(&elf
->fileio
, field32(elf
,segment
->p_offset
) + offset
)) != ERROR_OK
)
539 LOG_ERROR("cannot find ELF segment content, seek failed");
542 if ((retval
= fileio_read(&elf
->fileio
, read_size
, buffer
, &really_read
)) != ERROR_OK
)
544 LOG_ERROR("cannot read ELF segment content, read failed");
550 *size_read
+= read_size
;
551 /* need more data ? */
559 static int image_mot_buffer_complete_inner(struct image
*image
, char *lpszLine
, struct imagesection
*section
)
561 struct image_mot
*mot
= image
->type_private
;
562 struct fileio
*fileio
= &mot
->fileio
;
563 uint32_t full_address
= 0x0;
564 uint32_t cooked_bytes
;
567 /* we can't determine the number of sections that we'll have to create ahead of time,
568 * so we locally hold them until parsing is finished */
572 retval
= fileio_size(fileio
, &filesize
);
573 if (retval
!= ERROR_OK
)
576 mot
->buffer
= malloc(filesize
>> 1);
578 image
->num_sections
= 0;
579 section
[image
->num_sections
].private = &mot
->buffer
[cooked_bytes
];
580 section
[image
->num_sections
].base_address
= 0x0;
581 section
[image
->num_sections
].size
= 0x0;
582 section
[image
->num_sections
].flags
= 0;
584 while (fileio_fgets(fileio
, 1023, lpszLine
) == ERROR_OK
)
588 uint32_t record_type
;
590 uint8_t cal_checksum
= 0;
591 uint32_t bytes_read
= 0;
593 /* get record type and record length */
594 if (sscanf(&lpszLine
[bytes_read
], "S%1" SCNx32
"%2" SCNx32
, &record_type
, &count
) != 2)
596 return ERROR_IMAGE_FORMAT_ERROR
;
600 cal_checksum
+= (uint8_t)count
;
602 /* skip checksum byte */
605 if (record_type
== 0)
607 /* S0 - starting record (optional) */
610 while (count
-- > 0) {
611 sscanf(&lpszLine
[bytes_read
], "%2x", &iValue
);
612 cal_checksum
+= (uint8_t)iValue
;
616 else if (record_type
>= 1 && record_type
<= 3)
621 /* S1 - 16 bit address data record */
622 sscanf(&lpszLine
[bytes_read
], "%4" SCNx32
, &address
);
623 cal_checksum
+= (uint8_t)(address
>> 8);
624 cal_checksum
+= (uint8_t)address
;
630 /* S2 - 24 bit address data record */
631 sscanf(&lpszLine
[bytes_read
], "%6" SCNx32
, &address
);
632 cal_checksum
+= (uint8_t)(address
>> 16);
633 cal_checksum
+= (uint8_t)(address
>> 8);
634 cal_checksum
+= (uint8_t)address
;
640 /* S3 - 32 bit address data record */
641 sscanf(&lpszLine
[bytes_read
], "%8" SCNx32
, &address
);
642 cal_checksum
+= (uint8_t)(address
>> 24);
643 cal_checksum
+= (uint8_t)(address
>> 16);
644 cal_checksum
+= (uint8_t)(address
>> 8);
645 cal_checksum
+= (uint8_t)address
;
652 if (full_address
!= address
)
654 /* we encountered a nonconsecutive location, create a new section,
655 * unless the current section has zero size, in which case this specifies
656 * the current section's base address
658 if (section
[image
->num_sections
].size
!= 0)
660 image
->num_sections
++;
661 section
[image
->num_sections
].size
= 0x0;
662 section
[image
->num_sections
].flags
= 0;
663 section
[image
->num_sections
].private = &mot
->buffer
[cooked_bytes
];
665 section
[image
->num_sections
].base_address
= address
;
666 full_address
= address
;
672 sscanf(&lpszLine
[bytes_read
], "%2x", &value
);
673 mot
->buffer
[cooked_bytes
] = (uint8_t)value
;
674 cal_checksum
+= (uint8_t)mot
->buffer
[cooked_bytes
];
677 section
[image
->num_sections
].size
+= 1;
681 else if (record_type
== 5)
683 /* S5 is the data count record, we ignore it */
688 sscanf(&lpszLine
[bytes_read
], "%2" SCNx32
, &dummy
);
689 cal_checksum
+= (uint8_t)dummy
;
693 else if (record_type
>= 7 && record_type
<= 9)
695 /* S7, S8, S9 - ending records for 32, 24 and 16bit */
696 image
->num_sections
++;
698 /* copy section information */
699 image
->sections
= malloc(sizeof(struct imagesection
) * image
->num_sections
);
700 for (i
= 0; i
< image
->num_sections
; i
++)
702 image
->sections
[i
].private = section
[i
].private;
703 image
->sections
[i
].base_address
= section
[i
].base_address
;
704 image
->sections
[i
].size
= section
[i
].size
;
705 image
->sections
[i
].flags
= section
[i
].flags
;
712 LOG_ERROR("unhandled S19 record type: %i", (int)(record_type
));
713 return ERROR_IMAGE_FORMAT_ERROR
;
716 /* account for checksum, will always be 0xFF */
717 sscanf(&lpszLine
[bytes_read
], "%2" SCNx32
, &checksum
);
718 cal_checksum
+= (uint8_t)checksum
;
721 if (cal_checksum
!= 0xFF)
723 /* checksum failed */
724 LOG_ERROR("incorrect record checksum found in S19 file");
725 return ERROR_IMAGE_CHECKSUM
;
729 LOG_ERROR("premature end of S19 file, no end-of-file record found");
730 return ERROR_IMAGE_FORMAT_ERROR
;
734 * Allocate memory dynamically instead of on the stack. This
735 * is important w/embedded hosts.
737 static int image_mot_buffer_complete(struct image
*image
)
739 char *lpszLine
= malloc(1023);
740 if (lpszLine
== NULL
)
742 LOG_ERROR("Out of memory");
745 struct imagesection
*section
= malloc(sizeof(struct imagesection
) * IMAGE_MAX_SECTIONS
);
749 LOG_ERROR("Out of memory");
754 retval
= image_mot_buffer_complete_inner(image
, lpszLine
, section
);
763 int image_open(struct image
*image
, const char *url
, const char *type_string
)
765 int retval
= ERROR_OK
;
767 if ((retval
= identify_image_type(image
, type_string
, url
)) != ERROR_OK
)
772 if (image
->type
== IMAGE_BINARY
)
774 struct image_binary
*image_binary
;
776 image_binary
= image
->type_private
= malloc(sizeof(struct image_binary
));
778 if ((retval
= fileio_open(&image_binary
->fileio
, url
, FILEIO_READ
, FILEIO_BINARY
)) != ERROR_OK
)
783 retval
= fileio_size(&image_binary
->fileio
, &filesize
);
784 if (retval
!= ERROR_OK
)
786 fileio_close(&image_binary
->fileio
);
790 image
->num_sections
= 1;
791 image
->sections
= malloc(sizeof(struct imagesection
));
792 image
->sections
[0].base_address
= 0x0;
793 image
->sections
[0].size
= filesize
;
794 image
->sections
[0].flags
= 0;
796 else if (image
->type
== IMAGE_IHEX
)
798 struct image_ihex
*image_ihex
;
800 image_ihex
= image
->type_private
= malloc(sizeof(struct image_ihex
));
802 if ((retval
= fileio_open(&image_ihex
->fileio
, url
, FILEIO_READ
, FILEIO_TEXT
)) != ERROR_OK
)
807 if ((retval
= image_ihex_buffer_complete(image
)) != ERROR_OK
)
809 LOG_ERROR("failed buffering IHEX image, check daemon output for additional information");
810 fileio_close(&image_ihex
->fileio
);
814 else if (image
->type
== IMAGE_ELF
)
816 struct image_elf
*image_elf
;
818 image_elf
= image
->type_private
= malloc(sizeof(struct image_elf
));
820 if ((retval
= fileio_open(&image_elf
->fileio
, url
, FILEIO_READ
, FILEIO_BINARY
)) != ERROR_OK
)
825 if ((retval
= image_elf_read_headers(image
)) != ERROR_OK
)
827 fileio_close(&image_elf
->fileio
);
831 else if (image
->type
== IMAGE_MEMORY
)
833 struct target
*target
= get_target(url
);
837 LOG_ERROR("target '%s' not defined", url
);
841 struct image_memory
*image_memory
;
843 image
->num_sections
= 1;
844 image
->sections
= malloc(sizeof(struct imagesection
));
845 image
->sections
[0].base_address
= 0x0;
846 image
->sections
[0].size
= 0xffffffff;
847 image
->sections
[0].flags
= 0;
849 image_memory
= image
->type_private
= malloc(sizeof(struct image_memory
));
851 image_memory
->target
= target
;
852 image_memory
->cache
= NULL
;
853 image_memory
->cache_address
= 0x0;
855 else if (image
->type
== IMAGE_SRECORD
)
857 struct image_mot
*image_mot
;
859 image_mot
= image
->type_private
= malloc(sizeof(struct image_mot
));
861 if ((retval
= fileio_open(&image_mot
->fileio
, url
, FILEIO_READ
, FILEIO_TEXT
)) != ERROR_OK
)
866 if ((retval
= image_mot_buffer_complete(image
)) != ERROR_OK
)
868 LOG_ERROR("failed buffering S19 image, check daemon output for additional information");
869 fileio_close(&image_mot
->fileio
);
873 else if (image
->type
== IMAGE_BUILDER
)
875 image
->num_sections
= 0;
876 image
->sections
= NULL
;
877 image
->type_private
= NULL
;
880 if (image
->base_address_set
)
884 for (section
= 0; section
< image
->num_sections
; section
++)
886 image
->sections
[section
].base_address
+= image
->base_address
;
888 /* we're done relocating. The two statements below are mainly
889 * for documenation purposes: stop anyone from empirically
890 * thinking they should use these values henceforth. */
891 image
->base_address
= 0;
892 image
->base_address_set
= 0;
898 int image_read_section(struct image
*image
, int section
, uint32_t offset
, uint32_t size
, uint8_t *buffer
, size_t *size_read
)
902 /* don't read past the end of a section */
903 if (offset
+ size
> image
->sections
[section
].size
)
905 LOG_DEBUG("read past end of section: 0x%8.8" PRIx32
" + 0x%8.8" PRIx32
" > 0x%8.8" PRIx32
"",
906 offset
, size
, image
->sections
[section
].size
);
907 return ERROR_INVALID_ARGUMENTS
;
910 if (image
->type
== IMAGE_BINARY
)
912 struct image_binary
*image_binary
= image
->type_private
;
914 /* only one section in a plain binary */
916 return ERROR_INVALID_ARGUMENTS
;
919 if ((retval
= fileio_seek(&image_binary
->fileio
, offset
)) != ERROR_OK
)
924 /* return requested bytes */
925 if ((retval
= fileio_read(&image_binary
->fileio
, size
, buffer
, size_read
)) != ERROR_OK
)
930 else if (image
->type
== IMAGE_IHEX
)
932 memcpy(buffer
, (uint8_t*)image
->sections
[section
].private + offset
, size
);
937 else if (image
->type
== IMAGE_ELF
)
939 return image_elf_read_section(image
, section
, offset
, size
, buffer
, size_read
);
941 else if (image
->type
== IMAGE_MEMORY
)
943 struct image_memory
*image_memory
= image
->type_private
;
944 uint32_t address
= image
->sections
[section
].base_address
+ offset
;
948 while ((size
- *size_read
) > 0)
950 uint32_t size_in_cache
;
952 if (!image_memory
->cache
953 || (address
< image_memory
->cache_address
)
954 || (address
>= (image_memory
->cache_address
+ IMAGE_MEMORY_CACHE_SIZE
)))
956 if (!image_memory
->cache
)
957 image_memory
->cache
= malloc(IMAGE_MEMORY_CACHE_SIZE
);
959 if (target_read_buffer(image_memory
->target
, address
& ~(IMAGE_MEMORY_CACHE_SIZE
- 1),
960 IMAGE_MEMORY_CACHE_SIZE
, image_memory
->cache
) != ERROR_OK
)
962 free(image_memory
->cache
);
963 image_memory
->cache
= NULL
;
964 return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE
;
966 image_memory
->cache_address
= address
& ~(IMAGE_MEMORY_CACHE_SIZE
- 1);
969 size_in_cache
= (image_memory
->cache_address
+ IMAGE_MEMORY_CACHE_SIZE
) - address
;
971 memcpy(buffer
+ *size_read
,
972 image_memory
->cache
+ (address
- image_memory
->cache_address
),
973 (size_in_cache
> size
) ? size
: size_in_cache
976 *size_read
+= (size_in_cache
> size
) ? size
: size_in_cache
;
977 address
+= (size_in_cache
> size
) ? size
: size_in_cache
;
980 else if (image
->type
== IMAGE_SRECORD
)
982 memcpy(buffer
, (uint8_t*)image
->sections
[section
].private + offset
, size
);
987 else if (image
->type
== IMAGE_BUILDER
)
989 memcpy(buffer
, (uint8_t*)image
->sections
[section
].private + offset
, size
);
998 int image_add_section(struct image
*image
, uint32_t base
, uint32_t size
, int flags
, uint8_t *data
)
1000 struct imagesection
*section
;
1002 /* only image builder supports adding sections */
1003 if (image
->type
!= IMAGE_BUILDER
)
1004 return ERROR_INVALID_ARGUMENTS
;
1006 /* see if there's a previous section */
1007 if (image
->num_sections
)
1009 section
= &image
->sections
[image
->num_sections
- 1];
1011 /* see if it's enough to extend the last section,
1012 * adding data to previous sections or merging is not supported */
1013 if (((section
->base_address
+ section
->size
) == base
) && (section
->flags
== flags
))
1015 section
->private = realloc(section
->private, section
->size
+ size
);
1016 memcpy((uint8_t*)section
->private + section
->size
, data
, size
);
1017 section
->size
+= size
;
1022 /* allocate new section */
1023 image
->num_sections
++;
1024 image
->sections
= realloc(image
->sections
, sizeof(struct imagesection
) * image
->num_sections
);
1025 section
= &image
->sections
[image
->num_sections
- 1];
1026 section
->base_address
= base
;
1027 section
->size
= size
;
1028 section
->flags
= flags
;
1029 section
->private = malloc(sizeof(uint8_t) * size
);
1030 memcpy((uint8_t*)section
->private, data
, size
);
1035 void image_close(struct image
*image
)
1037 if (image
->type
== IMAGE_BINARY
)
1039 struct image_binary
*image_binary
= image
->type_private
;
1041 fileio_close(&image_binary
->fileio
);
1043 else if (image
->type
== IMAGE_IHEX
)
1045 struct image_ihex
*image_ihex
= image
->type_private
;
1047 fileio_close(&image_ihex
->fileio
);
1049 if (image_ihex
->buffer
)
1051 free(image_ihex
->buffer
);
1052 image_ihex
->buffer
= NULL
;
1055 else if (image
->type
== IMAGE_ELF
)
1057 struct image_elf
*image_elf
= image
->type_private
;
1059 fileio_close(&image_elf
->fileio
);
1061 if (image_elf
->header
)
1063 free(image_elf
->header
);
1064 image_elf
->header
= NULL
;
1067 if (image_elf
->segments
)
1069 free(image_elf
->segments
);
1070 image_elf
->segments
= NULL
;
1073 else if (image
->type
== IMAGE_MEMORY
)
1075 struct image_memory
*image_memory
= image
->type_private
;
1077 if (image_memory
->cache
)
1079 free(image_memory
->cache
);
1080 image_memory
->cache
= NULL
;
1083 else if (image
->type
== IMAGE_SRECORD
)
1085 struct image_mot
*image_mot
= image
->type_private
;
1087 fileio_close(&image_mot
->fileio
);
1089 if (image_mot
->buffer
)
1091 free(image_mot
->buffer
);
1092 image_mot
->buffer
= NULL
;
1095 else if (image
->type
== IMAGE_BUILDER
)
1099 for (i
= 0; i
< image
->num_sections
; i
++)
1101 free(image
->sections
[i
].private);
1102 image
->sections
[i
].private = NULL
;
1106 if (image
->type_private
)
1108 free(image
->type_private
);
1109 image
->type_private
= NULL
;
1112 if (image
->sections
)
1114 free(image
->sections
);
1115 image
->sections
= NULL
;
1119 int image_calculate_checksum(uint8_t* buffer
, uint32_t nbytes
, uint32_t* checksum
)
1121 uint32_t crc
= 0xffffffff;
1122 LOG_DEBUG("Calculating checksum");
1124 static uint32_t crc32_table
[256];
1126 static bool first_init
= false;
1129 /* Initialize the CRC table and the decoding table. */
1132 for (i
= 0; i
< 256; i
++)
1135 for (c
= i
<< 24, j
= 8; j
> 0; --j
)
1136 c
= c
& 0x80000000 ? (c
<< 1) ^ 0x04c11db7 : (c
<< 1);
1154 crc
= (crc
<< 8) ^ crc32_table
[((crc
>> 24) ^ *buffer
++) & 255];
1159 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)