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

Linking to existing account procedure

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

SSH host keys fingerprints

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