- added patch by Øyvind Harboe to Intel Hex Start Segment Address Record (Type 3)

[openocd.git] / src / target / image.c

diff --git a/src/target/image.c b/src/target/image.c
index 5ecbb81d10fb0cb8acfdfad6e178a0799acf00a4..a1a2a441eda92b6bc83da619950a3ae3bf1b427e 100644 (file)
--- a/src/target/image.c
+++ b/src/target/image.c
@@ -265,6 +265,19 @@ int image_ihex_buffer_complete(image_t *image)
                                full_address = (full_address & 0xffff) | (upper_address << 4);
                        }
                }
+               else if (record_type == 3) /* Start Segment Address Record */
+               {
+                       u32 dummy;
+                       
+                       /* "Start Segment Address Record" will not be supported */
+                       /* but we must consume it, and do not create an error.  */
+                       while (count-- > 0)
+                       {
+                               sscanf(&lpszLine[bytes_read], "%2x", &dummy);
+                               cal_checksum += (u8)dummy;
+                               bytes_read += 2;
+                       }
+               }
                else if (record_type == 4) /* Extended Linear Address Record */
                {
                        u16 upper_address;
@@ -578,6 +591,18 @@ int image_mot_buffer_complete(image_t *image)
                                full_address++;
                        }
                }
+               else if (record_type == 5)
+               {
+                       /* S5 is the data count record, we ignore it */
+                       u32 dummy;
+                       
+                       while (count-- > 0)
+                       {
+                               sscanf(&lpszLine[bytes_read], "%2x", &dummy);
+                               cal_checksum += (u8)dummy;
+                               bytes_read += 2;
+                       }
+               }
                else if (record_type >= 7 && record_type <= 9)
                {
                        /* S7, S8, S9 - ending records for 32, 24 and 16bit */
@@ -821,6 +846,7 @@ int image_read_section(image_t *image, int section, u32 offset, u32 size, u8 *bu
                                        IMAGE_MEMORY_CACHE_SIZE, image_memory->cache) != ERROR_OK)
                                {
                                        free(image_memory->cache);
+                                       image_memory->cache = NULL;
                                        return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE;
                                }
                                image_memory->cache_address = address & ~(IMAGE_MEMORY_CACHE_SIZE - 1);
@@ -909,7 +935,10 @@ int image_close(image_t *image)
                fileio_close(&image_ihex->fileio);
                
                if (image_ihex->buffer)
+               {
                        free(image_ihex->buffer);
+                       image_ihex->buffer = NULL;
+               }
        }
        else if (image->type == IMAGE_ELF)
        {
@@ -918,17 +947,26 @@ int image_close(image_t *image)
                fileio_close(&image_elf->fileio);
 
                if (image_elf->header)
+               {
                        free(image_elf->header);
+                       image_elf->header = NULL;
+               }
 
                if (image_elf->segments)
+               {
                        free(image_elf->segments);
+                       image_elf->segments = NULL;
+               }
        }
        else if (image->type == IMAGE_MEMORY)
        {
                image_memory_t *image_memory = image->type_private;
                
                if (image_memory->cache)
+               {
                        free(image_memory->cache);
+                       image_memory->cache = NULL;
+               }
        }
        else if (image->type == IMAGE_SRECORD)
        {
@@ -937,7 +975,10 @@ int image_close(image_t *image)
                fileio_close(&image_mot->fileio);
                
                if (image_mot->buffer)
+               {
                        free(image_mot->buffer);
+                       image_mot->buffer = NULL;
+               }
        }
        else if (image->type == IMAGE_BUILDER)
        {
@@ -946,14 +987,21 @@ int image_close(image_t *image)
                for (i = 0; i < image->num_sections; i++)
                {
                        free(image->sections[i].private);
+                       image->sections[i].private = NULL;
                }
        }
 
        if (image->type_private)
+       {
                free(image->type_private);
+               image->type_private = NULL;
+       }
        
        if (image->sections)
+       {
                free(image->sections);
+               image->sections = NULL;
+       }
        
        return ERROR_OK;
 }
@@ -988,3 +1036,4 @@ int image_calculate_checksum(u8* buffer, u32 nbytes, u32* checksum)
        return ERROR_OK;
 }
 
+