Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
The bitbang driver leaves the TCK 0 when in idle
[openocd.git] / src / target / image.c
1 /***************************************************************************
2 * Copyright (C) 2007 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include <stdlib.h>
25 #include <string.h>
26 #ifdef HAVE_ELF_H
27 #include <elf.h>
28 #endif
29
30 #include "image.h"
31
32 #include "types.h"
33 #include "replacements.h"
34 #include "log.h"
35
36 #include "fileio.h"
37 #include "target.h"
38
39 /* convert ELF header field to host endianness */
40 #define field16(elf,field)\
41 ((elf->endianness==ELFDATA2LSB)? \
42 le_to_h_u16((u8*)&field):be_to_h_u16((u8*)&field))
43
44 #define field32(elf,field)\
45 ((elf->endianness==ELFDATA2LSB)? \
46 le_to_h_u32((u8*)&field):be_to_h_u32((u8*)&field))
47
48 static int autodetect_image_type(image_t *image, char *url)
49 {
50 int retval;
51 fileio_t fileio;
52 u32 read_bytes;
53 u8 buffer[9];
54
55 /* read the first 4 bytes of image */
56 if ((retval = fileio_open(&fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
57 {
58 return retval;
59 }
60 if ((retval = fileio_read(&fileio, 9, buffer, &read_bytes)) != ERROR_OK)
61 {
62 return ERROR_FILEIO_OPERATION_FAILED;
63 }
64 if (read_bytes != 9)
65 {
66 return ERROR_FILEIO_OPERATION_FAILED;
67 }
68 fileio_close(&fileio);
69
70 /* check header against known signatures */
71 if (strncmp((char*)buffer,ELFMAG,SELFMAG)==0)
72 {
73 DEBUG("ELF image detected.");
74 image->type = IMAGE_ELF;
75 }
76 else if ((buffer[0]==':') /* record start byte */
77 &&(isxdigit(buffer[1]))
78 &&(isxdigit(buffer[2]))
79 &&(isxdigit(buffer[3]))
80 &&(isxdigit(buffer[4]))
81 &&(isxdigit(buffer[5]))
82 &&(isxdigit(buffer[6]))
83 &&(buffer[7]=='0') /* record type : 00 -> 05 */
84 &&(buffer[8]>='0')&&(buffer[8]<'6'))
85 {
86 DEBUG("IHEX image detected.");
87 image->type = IMAGE_IHEX;
88 }
89 else if ((buffer[0] == 'S') /* record start byte */
90 &&(isxdigit(buffer[1]))
91 &&(isxdigit(buffer[2]))
92 &&(isxdigit(buffer[3]))
93 &&(buffer[1] >= '0') && (buffer[1] < '9'))
94 {
95 DEBUG("S19 image detected.");
96 image->type = IMAGE_SRECORD;
97 }
98 else
99 {
100 image->type = IMAGE_BINARY;
101 }
102
103 return ERROR_OK;
104 }
105
106 int identify_image_type(image_t *image, char *type_string, char *url)
107 {
108 if (type_string)
109 {
110 if (!strcmp(type_string, "bin"))
111 {
112 image->type = IMAGE_BINARY;
113 }
114 else if (!strcmp(type_string, "ihex"))
115 {
116 image->type = IMAGE_IHEX;
117 }
118 else if (!strcmp(type_string, "elf"))
119 {
120 image->type = IMAGE_ELF;
121 }
122 else if (!strcmp(type_string, "mem"))
123 {
124 image->type = IMAGE_MEMORY;
125 }
126 else if (!strcmp(type_string, "s19"))
127 {
128 image->type = IMAGE_SRECORD;
129 }
130 else if (!strcmp(type_string, "build"))
131 {
132 image->type = IMAGE_BUILDER;
133 }
134 else
135 {
136 return ERROR_IMAGE_TYPE_UNKNOWN;
137 }
138 }
139 else
140 {
141 return autodetect_image_type(image, url);
142 }
143
144 return ERROR_OK;
145 }
146
147 int image_ihex_buffer_complete(image_t *image)
148 {
149 image_ihex_t *ihex = image->type_private;
150 fileio_t *fileio = &ihex->fileio;
151 u32 full_address = 0x0;
152 u32 cooked_bytes;
153 int i;
154 char lpszLine[1023];
155
156 /* we can't determine the number of sections that we'll have to create ahead of time,
157 * so we locally hold them until parsing is finished */
158 image_section_t section[IMAGE_MAX_SECTIONS];
159
160 ihex->buffer = malloc(fileio->size >> 1);
161 cooked_bytes = 0x0;
162 image->num_sections = 0;
163 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
164 section[image->num_sections].base_address = 0x0;
165 section[image->num_sections].size = 0x0;
166 section[image->num_sections].flags = 0;
167
168 while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
169 {
170 u32 count;
171 u32 address;
172 u32 record_type;
173 u32 checksum;
174 u8 cal_checksum = 0;
175 u32 bytes_read = 0;
176
177 if (sscanf(&lpszLine[bytes_read], ":%2x%4x%2x", &count, &address, &record_type) != 3)
178 {
179 return ERROR_IMAGE_FORMAT_ERROR;
180 }
181 bytes_read += 9;
182
183 cal_checksum += (u8)count;
184 cal_checksum += (u8)(address >> 8);
185 cal_checksum += (u8)address;
186 cal_checksum += (u8)record_type;
187
188 if (record_type == 0) /* Data Record */
189 {
190 if ((full_address & 0xffff) != address)
191 {
192 /* we encountered a nonconsecutive location, create a new section,
193 * unless the current section has zero size, in which case this specifies
194 * the current section's base address
195 */
196 if (section[image->num_sections].size != 0)
197 {
198 image->num_sections++;
199 section[image->num_sections].size = 0x0;
200 section[image->num_sections].flags = 0;
201 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
202 }
203 section[image->num_sections].base_address =
204 (full_address & 0xffff0000) | address;
205 full_address = (full_address & 0xffff0000) | address;
206 }
207
208 while (count-- > 0)
209 {
210 sscanf(&lpszLine[bytes_read], "%2x", (u32*)&ihex->buffer[cooked_bytes]);
211 cal_checksum += (u8)ihex->buffer[cooked_bytes];
212 bytes_read += 2;
213 cooked_bytes += 1;
214 section[image->num_sections].size += 1;
215 full_address++;
216 }
217 }
218 else if (record_type == 1) /* End of File Record */
219 {
220 /* finish the current section */
221 image->num_sections++;
222
223 /* copy section information */
224 image->sections = malloc(sizeof(image_section_t) * image->num_sections);
225 for (i = 0; i < image->num_sections; i++)
226 {
227 image->sections[i].private = section[i].private;
228 image->sections[i].base_address = section[i].base_address;
229 image->sections[i].size = section[i].size;
230 image->sections[i].flags = section[i].flags;
231 }
232
233 return ERROR_OK;
234 }
235 else if (record_type == 2) /* Linear Address Record */
236 {
237 u16 upper_address;
238
239 sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
240 cal_checksum += (u8)(upper_address >> 8);
241 cal_checksum += (u8)upper_address;
242 bytes_read += 4;
243
244 if ((full_address >> 4) != upper_address)
245 {
246 /* we encountered a nonconsecutive location, create a new section,
247 * unless the current section has zero size, in which case this specifies
248 * the current section's base address
249 */
250 if (section[image->num_sections].size != 0)
251 {
252 image->num_sections++;
253 section[image->num_sections].size = 0x0;
254 section[image->num_sections].flags = 0;
255 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
256 }
257 section[image->num_sections].base_address =
258 (full_address & 0xffff) | (upper_address << 4);
259 full_address = (full_address & 0xffff) | (upper_address << 4);
260 }
261 }
262 else if (record_type == 3) /* Start Segment Address Record */
263 {
264 u32 dummy;
265
266 /* "Start Segment Address Record" will not be supported */
267 /* but we must consume it, and do not create an error. */
268 while (count-- > 0)
269 {
270 sscanf(&lpszLine[bytes_read], "%2x", &dummy);
271 cal_checksum += (u8)dummy;
272 bytes_read += 2;
273 }
274 }
275 else if (record_type == 4) /* Extended Linear Address Record */
276 {
277 u16 upper_address;
278
279 sscanf(&lpszLine[bytes_read], "%4hx", &upper_address);
280 cal_checksum += (u8)(upper_address >> 8);
281 cal_checksum += (u8)upper_address;
282 bytes_read += 4;
283
284 if ((full_address >> 16) != upper_address)
285 {
286 /* we encountered a nonconsecutive location, create a new section,
287 * unless the current section has zero size, in which case this specifies
288 * the current section's base address
289 */
290 if (section[image->num_sections].size != 0)
291 {
292 image->num_sections++;
293 section[image->num_sections].size = 0x0;
294 section[image->num_sections].flags = 0;
295 section[image->num_sections].private = &ihex->buffer[cooked_bytes];
296 }
297 section[image->num_sections].base_address =
298 (full_address & 0xffff) | (upper_address << 16);
299 full_address = (full_address & 0xffff) | (upper_address << 16);
300 }
301 }
302 else if (record_type == 5) /* Start Linear Address Record */
303 {
304 u32 start_address;
305
306 sscanf(&lpszLine[bytes_read], "%8x", &start_address);
307 cal_checksum += (u8)(start_address >> 24);
308 cal_checksum += (u8)(start_address >> 16);
309 cal_checksum += (u8)(start_address >> 8);
310 cal_checksum += (u8)start_address;
311 bytes_read += 8;
312
313 image->start_address_set = 1;
314 image->start_address = be_to_h_u32((u8*)&start_address);
315 }
316 else
317 {
318 ERROR("unhandled IHEX record type: %i", record_type);
319 return ERROR_IMAGE_FORMAT_ERROR;
320 }
321
322 sscanf(&lpszLine[bytes_read], "%2x", &checksum);
323 bytes_read += 2;
324
325 if ((u8)checksum != (u8)(~cal_checksum + 1))
326 {
327 /* checksum failed */
328 ERROR("incorrect record checksum found in IHEX file");
329 return ERROR_IMAGE_CHECKSUM;
330 }
331 }
332
333 ERROR("premature end of IHEX file, no end-of-file record found");
334 return ERROR_IMAGE_FORMAT_ERROR;
335 }
336
337 int image_elf_read_headers(image_t *image)
338 {
339 image_elf_t *elf = image->type_private;
340 u32 read_bytes;
341 u32 i,j;
342 int retval;
343
344 elf->header = malloc(sizeof(Elf32_Ehdr));
345
346 if ((retval = fileio_read(&elf->fileio, sizeof(Elf32_Ehdr), (u8*)elf->header, &read_bytes)) != ERROR_OK)
347 {
348 ERROR("cannot read ELF file header, read failed");
349 return ERROR_FILEIO_OPERATION_FAILED;
350 }
351 if (read_bytes != sizeof(Elf32_Ehdr))
352 {
353 ERROR("cannot read ELF file header, only partially read");
354 return ERROR_FILEIO_OPERATION_FAILED;
355 }
356
357 if (strncmp((char*)elf->header->e_ident,ELFMAG,SELFMAG)!=0)
358 {
359 ERROR("invalid ELF file, bad magic number");
360 return ERROR_IMAGE_FORMAT_ERROR;
361 }
362 if (elf->header->e_ident[EI_CLASS]!=ELFCLASS32)
363 {
364 ERROR("invalid ELF file, only 32bits files are supported");
365 return ERROR_IMAGE_FORMAT_ERROR;
366 }
367
368
369 elf->endianness = elf->header->e_ident[EI_DATA];
370 if ((elf->endianness!=ELFDATA2LSB)
371 &&(elf->endianness!=ELFDATA2MSB))
372 {
373 ERROR("invalid ELF file, unknown endianess setting");
374 return ERROR_IMAGE_FORMAT_ERROR;
375 }
376
377 elf->segment_count = field16(elf,elf->header->e_phnum);
378 if (elf->segment_count==0)
379 {
380 ERROR("invalid ELF file, no program headers");
381 return ERROR_IMAGE_FORMAT_ERROR;
382 }
383
384 if ((retval = fileio_seek(&elf->fileio, field32(elf,elf->header->e_phoff))) != ERROR_OK)
385 {
386 ERROR("cannot seek to ELF program header table, read failed");
387 return retval;
388 }
389
390 elf->segments = malloc(elf->segment_count*sizeof(Elf32_Phdr));
391
392 if ((retval = fileio_read(&elf->fileio, elf->segment_count*sizeof(Elf32_Phdr), (u8*)elf->segments, &read_bytes)) != ERROR_OK)
393 {
394 ERROR("cannot read ELF segment headers, read failed");
395 return retval;
396 }
397 if (read_bytes != elf->segment_count*sizeof(Elf32_Phdr))
398 {
399 ERROR("cannot read ELF segment headers, only partially read");
400 return ERROR_FILEIO_OPERATION_FAILED;
401 }
402
403 /* count useful segments (loadable), ignore BSS section */
404 image->num_sections = 0;
405 for (i=0;i<elf->segment_count;i++)
406 if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
407 image->num_sections++;
408 /* alloc and fill sections array with loadable segments */
409 image->sections = malloc(image->num_sections * sizeof(image_section_t));
410 for (i=0,j=0;i<elf->segment_count;i++)
411 {
412 if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
413 {
414 image->sections[j].size = field32(elf,elf->segments[i].p_filesz);
415 image->sections[j].base_address = field32(elf,elf->segments[i].p_paddr);
416 image->sections[j].private = &elf->segments[i];
417 image->sections[j].flags = field32(elf,elf->segments[i].p_flags);
418 j++;
419 }
420 }
421
422 image->start_address_set = 1;
423 image->start_address = field32(elf,elf->header->e_entry);
424
425 return ERROR_OK;
426 }
427
428 int image_elf_read_section(image_t *image, int section, u32 offset, u32 size, u8 *buffer, u32 *size_read)
429 {
430 image_elf_t *elf = image->type_private;
431 Elf32_Phdr *segment = (Elf32_Phdr *)image->sections[section].private;
432 u32 read_size,really_read;
433 int retval;
434
435 *size_read = 0;
436
437 DEBUG("load segment %d at 0x%x (sz=0x%x)",section,offset,size);
438
439 /* read initialized data in current segment if any */
440 if (offset<field32(elf,segment->p_filesz))
441 {
442 /* maximal size present in file for the current segment */
443 read_size = MIN(size, field32(elf,segment->p_filesz)-offset);
444 DEBUG("read elf: size = 0x%x at 0x%x",read_size,
445 field32(elf,segment->p_offset)+offset);
446 /* read initialized area of the segment */
447 if ((retval = fileio_seek(&elf->fileio, field32(elf,segment->p_offset)+offset)) != ERROR_OK)
448 {
449 ERROR("cannot find ELF segment content, seek failed");
450 return retval;
451 }
452 if ((retval = fileio_read(&elf->fileio, read_size, buffer, &really_read)) != ERROR_OK)
453 {
454 ERROR("cannot read ELF segment content, read failed");
455 return retval;
456 }
457 buffer += read_size;
458 size -= read_size;
459 offset += read_size;
460 *size_read += read_size;
461 /* need more data ? */
462 if (!size)
463 return ERROR_OK;
464 }
465
466 return ERROR_OK;
467 }
468
469 int image_mot_buffer_complete(image_t *image)
470 {
471 image_mot_t *mot = image->type_private;
472 fileio_t *fileio = &mot->fileio;
473 u32 full_address = 0x0;
474 u32 cooked_bytes;
475 int i;
476 char lpszLine[1023];
477
478 /* we can't determine the number of sections that we'll have to create ahead of time,
479 * so we locally hold them until parsing is finished */
480 image_section_t section[IMAGE_MAX_SECTIONS];
481
482 mot->buffer = malloc(fileio->size >> 1);
483 cooked_bytes = 0x0;
484 image->num_sections = 0;
485 section[image->num_sections].private = &mot->buffer[cooked_bytes];
486 section[image->num_sections].base_address = 0x0;
487 section[image->num_sections].size = 0x0;
488 section[image->num_sections].flags = 0;
489
490 while (fileio_fgets(fileio, 1023, lpszLine) == ERROR_OK)
491 {
492 u32 count;
493 u32 address;
494 u32 record_type;
495 u32 checksum;
496 u8 cal_checksum = 0;
497 u32 bytes_read = 0;
498
499 /* get record type and record length */
500 if (sscanf(&lpszLine[bytes_read], "S%1x%2x", &record_type, &count) != 2)
501 {
502 return ERROR_IMAGE_FORMAT_ERROR;
503 }
504
505 bytes_read += 4;
506 cal_checksum += (u8)count;
507
508 /* skip checksum byte */
509 count -=1;
510
511 if (record_type == 0)
512 {
513 /* S0 - starting record (optional) */
514 int iValue;
515
516 while (count-- > 0) {
517 sscanf(&lpszLine[bytes_read], "%2x", &iValue);
518 cal_checksum += (u8)iValue;
519 bytes_read += 2;
520 }
521 }
522 else if (record_type >= 1 && record_type <= 3)
523 {
524 switch( record_type )
525 {
526 case 1:
527 /* S1 - 16 bit address data record */
528 sscanf(&lpszLine[bytes_read], "%4x", &address);
529 cal_checksum += (u8)(address >> 8);
530 cal_checksum += (u8)address;
531 bytes_read += 4;
532 count -=2;
533 break;
534
535 case 2:
536 /* S2 - 24 bit address data record */
537 sscanf(&lpszLine[bytes_read], "%6x", &address);
538 cal_checksum += (u8)(address >> 16);
539 cal_checksum += (u8)(address >> 8);
540 cal_checksum += (u8)address;
541 bytes_read += 6;
542 count -=3;
543 break;
544
545 case 3:
546 /* S3 - 32 bit address data record */
547 sscanf(&lpszLine[bytes_read], "%8x", &address);
548 cal_checksum += (u8)(address >> 24);
549 cal_checksum += (u8)(address >> 16);
550 cal_checksum += (u8)(address >> 8);
551 cal_checksum += (u8)address;
552 bytes_read += 8;
553 count -=4;
554 break;
555
556 }
557
558 if (full_address != address)
559 {
560 /* we encountered a nonconsecutive location, create a new section,
561 * unless the current section has zero size, in which case this specifies
562 * the current section's base address
563 */
564 if (section[image->num_sections].size != 0)
565 {
566 image->num_sections++;
567 section[image->num_sections].size = 0x0;
568 section[image->num_sections].flags = 0;
569 section[image->num_sections].private = &mot->buffer[cooked_bytes];
570 }
571 section[image->num_sections].base_address = address;
572 full_address = address;
573 }
574
575 while (count-- > 0)
576 {
577 sscanf(&lpszLine[bytes_read], "%2x", (u32*)&mot->buffer[cooked_bytes]);
578 cal_checksum += (u8)mot->buffer[cooked_bytes];
579 bytes_read += 2;
580 cooked_bytes += 1;
581 section[image->num_sections].size += 1;
582 full_address++;
583 }
584 }
585 else if (record_type == 5)
586 {
587 /* S5 is the data count record, we ignore it */
588 u32 dummy;
589
590 while (count-- > 0)
591 {
592 sscanf(&lpszLine[bytes_read], "%2x", &dummy);
593 cal_checksum += (u8)dummy;
594 bytes_read += 2;
595 }
596 }
597 else if (record_type >= 7 && record_type <= 9)
598 {
599 /* S7, S8, S9 - ending records for 32, 24 and 16bit */
600 image->num_sections++;
601
602 /* copy section information */
603 image->sections = malloc(sizeof(image_section_t) * image->num_sections);
604 for (i = 0; i < image->num_sections; i++)
605 {
606 image->sections[i].private = section[i].private;
607 image->sections[i].base_address = section[i].base_address;
608 image->sections[i].size = section[i].size;
609 image->sections[i].flags = section[i].flags;
610 }
611
612 return ERROR_OK;
613 }
614 else
615 {
616 ERROR("unhandled S19 record type: %i", record_type);
617 return ERROR_IMAGE_FORMAT_ERROR;
618 }
619
620 /* account for checksum, will always be 0xFF */
621 sscanf(&lpszLine[bytes_read], "%2x", &checksum);
622 cal_checksum += (u8)checksum;
623 bytes_read += 2;
624
625 if( cal_checksum != 0xFF )
626 {
627 /* checksum failed */
628 ERROR("incorrect record checksum found in S19 file");
629 return ERROR_IMAGE_CHECKSUM;
630 }
631 }
632
633 ERROR("premature end of S19 file, no end-of-file record found");
634 return ERROR_IMAGE_FORMAT_ERROR;
635 }
636
637 int image_open(image_t *image, char *url, char *type_string)
638 {
639 int retval = ERROR_OK;
640
641 if ((retval = identify_image_type(image, type_string, url)) != ERROR_OK)
642 {
643 return retval;
644 }
645
646 if (image->type == IMAGE_BINARY)
647 {
648 image_binary_t *image_binary;
649
650 image_binary = image->type_private = malloc(sizeof(image_binary_t));
651
652 if ((retval = fileio_open(&image_binary->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
653 {
654 return retval;
655 }
656
657 image->num_sections = 1;
658 image->sections = malloc(sizeof(image_section_t));
659 image->sections[0].base_address = 0x0;
660 image->sections[0].size = image_binary->fileio.size;
661 image->sections[0].flags = 0;
662 }
663 else if (image->type == IMAGE_IHEX)
664 {
665 image_ihex_t *image_ihex;
666
667 image_ihex = image->type_private = malloc(sizeof(image_ihex_t));
668
669 if ((retval = fileio_open(&image_ihex->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
670 {
671 return retval;
672 }
673
674 if ((retval = image_ihex_buffer_complete(image)) != ERROR_OK)
675 {
676 ERROR("failed buffering IHEX image, check daemon output for additional information");
677 fileio_close(&image_ihex->fileio);
678 return retval;
679 }
680 }
681 else if (image->type == IMAGE_ELF)
682 {
683 image_elf_t *image_elf;
684
685 image_elf = image->type_private = malloc(sizeof(image_elf_t));
686
687 if ((retval = fileio_open(&image_elf->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
688 {
689 return retval;
690 }
691
692 if ((retval = image_elf_read_headers(image)) != ERROR_OK)
693 {
694 fileio_close(&image_elf->fileio);
695 return retval;
696 }
697 }
698 else if (image->type == IMAGE_MEMORY)
699 {
700 image_memory_t *image_memory;
701
702 image->num_sections = 1;
703 image->sections = malloc(sizeof(image_section_t));
704 image->sections[0].base_address = 0x0;
705 image->sections[0].size = 0xffffffff;
706 image->sections[0].flags = 0;
707
708 image_memory = image->type_private = malloc(sizeof(image_memory_t));
709
710 image_memory->target = get_target_by_num(strtoul(url, NULL, 0));;
711 image_memory->cache = NULL;
712 image_memory->cache_address = 0x0;
713 }
714 else if (image->type == IMAGE_SRECORD)
715 {
716 image_mot_t *image_mot;
717
718 image_mot = image->type_private = malloc(sizeof(image_mot_t));
719
720 if ((retval = fileio_open(&image_mot->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
721 {
722 return retval;
723 }
724
725 if ((retval = image_mot_buffer_complete(image)) != ERROR_OK)
726 {
727 ERROR("failed buffering S19 image, check daemon output for additional information");
728 fileio_close(&image_mot->fileio);
729 return retval;
730 }
731 }
732 else if (image->type == IMAGE_BUILDER)
733 {
734 image->num_sections = 0;
735 image->sections = NULL;
736 image->type_private = NULL;
737 }
738
739 if (image->base_address_set)
740 {
741 /* relocate */
742 int section;
743 for (section=0; section < image->num_sections; section++)
744 {
745 image->sections[section].base_address+=image->base_address;
746 }
747 /* we're done relocating. The two statements below are mainly
748 * for documenation purposes: stop anyone from empirically
749 * thinking they should use these values henceforth. */
750 image->base_address=0;
751 image->base_address_set=0;
752 }
753
754 return retval;
755 };
756
757 int image_read_section(image_t *image, int section, u32 offset, u32 size, u8 *buffer, u32 *size_read)
758 {
759 int retval;
760
761 /* don't read past the end of a section */
762 if (offset + size > image->sections[section].size)
763 {
764 DEBUG("read past end of section: 0x%8.8x + 0x%8.8x > 0x%8.8x",
765 offset, size, image->sections[section].size);
766 return ERROR_INVALID_ARGUMENTS;
767 }
768
769 if (image->type == IMAGE_BINARY)
770 {
771 image_binary_t *image_binary = image->type_private;
772
773 /* only one section in a plain binary */
774 if (section != 0)
775 return ERROR_INVALID_ARGUMENTS;
776
777 /* seek to offset */
778 if ((retval = fileio_seek(&image_binary->fileio, offset)) != ERROR_OK)
779 {
780 return retval;
781 }
782
783 /* return requested bytes */
784 if ((retval = fileio_read(&image_binary->fileio, size, buffer, size_read)) != ERROR_OK)
785 {
786 return retval;
787 }
788 }
789 else if (image->type == IMAGE_IHEX)
790 {
791 memcpy(buffer, (u8*)image->sections[section].private + offset, size);
792 *size_read = size;
793
794 return ERROR_OK;
795 }
796 else if (image->type == IMAGE_ELF)
797 {
798 return image_elf_read_section(image, section, offset, size, buffer, size_read);
799 }
800 else if (image->type == IMAGE_MEMORY)
801 {
802 image_memory_t *image_memory = image->type_private;
803 u32 address = image->sections[section].base_address + offset;
804
805 *size_read = 0;
806
807 while ((size - *size_read) > 0)
808 {
809 u32 size_in_cache;
810
811 if (!image_memory->cache
812 || (address < image_memory->cache_address)
813 || (address >= (image_memory->cache_address + IMAGE_MEMORY_CACHE_SIZE)))
814 {
815 if (!image_memory->cache)
816 image_memory->cache = malloc(IMAGE_MEMORY_CACHE_SIZE);
817
818 if (target_read_buffer(image_memory->target, address & ~(IMAGE_MEMORY_CACHE_SIZE - 1),
819 IMAGE_MEMORY_CACHE_SIZE, image_memory->cache) != ERROR_OK)
820 {
821 free(image_memory->cache);
822 image_memory->cache = NULL;
823 return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE;
824 }
825 image_memory->cache_address = address & ~(IMAGE_MEMORY_CACHE_SIZE - 1);
826 }
827
828 size_in_cache = (image_memory->cache_address + IMAGE_MEMORY_CACHE_SIZE) - address;
829
830 memcpy(buffer + *size_read,
831 image_memory->cache + (address - image_memory->cache_address),
832 (size_in_cache > size) ? size : size_in_cache
833 );
834
835 *size_read += (size_in_cache > size) ? size : size_in_cache;
836 address += (size_in_cache > size) ? size : size_in_cache;
837 }
838 }
839 else if (image->type == IMAGE_SRECORD)
840 {
841 memcpy(buffer, (u8*)image->sections[section].private + offset, size);
842 *size_read = size;
843
844 return ERROR_OK;
845 }
846 else if (image->type == IMAGE_BUILDER)
847 {
848 memcpy(buffer, (u8*)image->sections[section].private + offset, size);
849 *size_read = size;
850
851 return ERROR_OK;
852 }
853
854 return ERROR_OK;
855 }
856
857 int image_add_section(image_t *image, u32 base, u32 size, int flags, u8 *data)
858 {
859 image_section_t *section;
860
861 /* only image builder supports adding sections */
862 if (image->type != IMAGE_BUILDER)
863 return ERROR_INVALID_ARGUMENTS;
864
865 /* see if there's a previous section */
866 if (image->num_sections)
867 {
868 section = &image->sections[image->num_sections - 1];
869
870 /* see if it's enough to extend the last section,
871 * adding data to previous sections or merging is not supported */
872 if (((section->base_address + section->size) == base) && (section->flags == flags))
873 {
874 section->private = realloc(section->private, section->size + size);
875 memcpy((u8*)section->private + section->size, data, size);
876 section->size += size;
877 return ERROR_OK;
878 }
879 }
880
881 /* allocate new section */
882 image->num_sections++;
883 image->sections = realloc(image->sections, sizeof(image_section_t) * image->num_sections);
884 section = &image->sections[image->num_sections - 1];
885 section->base_address = base;
886 section->size = size;
887 section->flags = flags;
888 section->private = malloc(sizeof(u8) * size);
889 memcpy((u8*)section->private, data, size);
890
891 return ERROR_OK;
892 }
893
894 int image_close(image_t *image)
895 {
896 if (image->type == IMAGE_BINARY)
897 {
898 image_binary_t *image_binary = image->type_private;
899
900 fileio_close(&image_binary->fileio);
901 }
902 else if (image->type == IMAGE_IHEX)
903 {
904 image_ihex_t *image_ihex = image->type_private;
905
906 fileio_close(&image_ihex->fileio);
907
908 if (image_ihex->buffer)
909 {
910 free(image_ihex->buffer);
911 image_ihex->buffer = NULL;
912 }
913 }
914 else if (image->type == IMAGE_ELF)
915 {
916 image_elf_t *image_elf = image->type_private;
917
918 fileio_close(&image_elf->fileio);
919
920 if (image_elf->header)
921 {
922 free(image_elf->header);
923 image_elf->header = NULL;
924 }
925
926 if (image_elf->segments)
927 {
928 free(image_elf->segments);
929 image_elf->segments = NULL;
930 }
931 }
932 else if (image->type == IMAGE_MEMORY)
933 {
934 image_memory_t *image_memory = image->type_private;
935
936 if (image_memory->cache)
937 {
938 free(image_memory->cache);
939 image_memory->cache = NULL;
940 }
941 }
942 else if (image->type == IMAGE_SRECORD)
943 {
944 image_mot_t *image_mot = image->type_private;
945
946 fileio_close(&image_mot->fileio);
947
948 if (image_mot->buffer)
949 {
950 free(image_mot->buffer);
951 image_mot->buffer = NULL;
952 }
953 }
954 else if (image->type == IMAGE_BUILDER)
955 {
956 int i;
957
958 for (i = 0; i < image->num_sections; i++)
959 {
960 free(image->sections[i].private);
961 image->sections[i].private = NULL;
962 }
963 }
964
965 if (image->type_private)
966 {
967 free(image->type_private);
968 image->type_private = NULL;
969 }
970
971 if (image->sections)
972 {
973 free(image->sections);
974 image->sections = NULL;
975 }
976
977 return ERROR_OK;
978 }
979
980 static u32 crc32_table[256] = {0, 0};
981
982 int image_calculate_checksum(u8* buffer, u32 nbytes, u32* checksum)
983 {
984 u32 crc = 0xffffffff;
985
986 if (!crc32_table[1])
987 {
988 /* Initialize the CRC table and the decoding table. */
989 int i, j;
990 unsigned int c;
991 for (i = 0; i < 256; i++)
992 {
993 /* as per gdb */
994 for (c = i << 24, j = 8; j > 0; --j)
995 c = c & 0x80000000 ? (c << 1) ^ 0x04c11db7 : (c << 1);
996 crc32_table[i] = c;
997 }
998 }
999
1000 while (nbytes--)
1001 {
1002 /* as per gdb */
1003 crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buffer++) & 255];
1004 }
1005
1006 *checksum = crc;
1007 return ERROR_OK;
1008 }
1009
1010
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)