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