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");