projects / fw / openocd / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Remove whitespace that occurs before ')'.
[fw/openocd] / src / flash / str9x.c
diff --git a/src/flash/str9x.c b/src/flash/str9x.c
index c6c366e9ab862c39e1d98079a7a9347f0e0a8fc1..9d7b672dc27ad4f7f2d275a77aba650efe6350aa 100644 (file)
--- a/src/flash/str9x.c
+++ b/src/flash/str9x.c
@@ -31,13 +31,13 @@
 #include "arm966e.h"
 
 
-static u32 bank1start = 0x00080000;
+static uint32_t bank1start = 0x00080000;
 
 static int str9x_register_commands(struct command_context_s *cmd_ctx);
 static int str9x_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank);
 static int str9x_erase(struct flash_bank_s *bank, int first, int last);
 static int str9x_protect(struct flash_bank_s *bank, int set, int first, int last);
-static int str9x_write(struct flash_bank_s *bank, uint8_t *buffer, u32 offset, u32 count);
+static int str9x_write(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count);
 static int str9x_probe(struct flash_bank_s *bank);
 //static int str9x_handle_part_id_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
 static int str9x_protect_check(struct flash_bank_s *bank);
@@ -77,7 +77,7 @@ static int str9x_build_block_list(struct flash_bank_s *bank)
        int i;
        int num_sectors;
        int b0_sectors = 0, b1_sectors = 0;
-       u32 offset = 0;
+       uint32_t offset = 0;
 
        /* set if we have large flash str9 */
        str9x_info->variant = 0;
@@ -121,7 +121,7 @@ static int str9x_build_block_list(struct flash_bank_s *bank)
 
        bank->num_sectors = num_sectors;
        bank->sectors = malloc(sizeof(flash_sector_t) * num_sectors);
-       str9x_info->sector_bits = malloc(sizeof(u32) * num_sectors);
+       str9x_info->sector_bits = malloc(sizeof(uint32_t) * num_sectors);
 
        num_sectors = 0;
 
@@ -132,7 +132,7 @@ static int str9x_build_block_list(struct flash_bank_s *bank)
                offset += bank->sectors[i].size;
                bank->sectors[num_sectors].is_erased = -1;
                bank->sectors[num_sectors].is_protected = 1;
-               str9x_info->sector_bits[num_sectors++] = (1<<i);
+               str9x_info->sector_bits[num_sectors++] = (1 << i);
        }
 
        for (i = 0; i < b1_sectors; i++)
@@ -143,9 +143,9 @@ static int str9x_build_block_list(struct flash_bank_s *bank)
                bank->sectors[num_sectors].is_erased = -1;
                bank->sectors[num_sectors].is_protected = 1;
                if (str9x_info->variant)
-                       str9x_info->sector_bits[num_sectors++] = (1<<i);
+                       str9x_info->sector_bits[num_sectors++] = (1 << i);
                else
-                       str9x_info->sector_bits[num_sectors++] = (1<<(i+8));
+                       str9x_info->sector_bits[num_sectors++] = (1 << (i + 8));
        }
 
        return ERROR_OK;
@@ -181,9 +181,9 @@ static int str9x_protect_check(struct flash_bank_s *bank)
        target_t *target = bank->target;
 
        int i;
-       u32 adr;
-       u32 status = 0;
-       u16 hstatus = 0;
+       uint32_t adr;
+       uint32_t status = 0;
+       uint16_t hstatus = 0;
 
        if (bank->target->state != TARGET_HALTED)
        {
@@ -198,11 +198,11 @@ static int str9x_protect_check(struct flash_bank_s *bank)
                if (str9x_info->bank1)
                {
                        adr = bank1start + 0x18;
-                       if ((retval=target_write_u16(target, adr, 0x90))!=ERROR_OK)
+                       if ((retval = target_write_u16(target, adr, 0x90)) != ERROR_OK)
                        {
                                return retval;
                        }
-                       if ((retval=target_read_u16(target, adr, &hstatus))!=ERROR_OK)
+                       if ((retval = target_read_u16(target, adr, &hstatus)) != ERROR_OK)
                        {
                                return retval;
                        }
@@ -211,11 +211,11 @@ static int str9x_protect_check(struct flash_bank_s *bank)
                else
                {
                        adr = bank1start + 0x14;
-                       if ((retval=target_write_u16(target, adr, 0x90))!=ERROR_OK)
+                       if ((retval = target_write_u16(target, adr, 0x90)) != ERROR_OK)
                        {
                                return retval;
                        }
-                       if ((retval=target_read_u32(target, adr, &status))!=ERROR_OK)
+                       if ((retval = target_read_u32(target, adr, &status)) != ERROR_OK)
                        {
                                return retval;
                        }
@@ -224,11 +224,11 @@ static int str9x_protect_check(struct flash_bank_s *bank)
        else
        {
                adr = bank1start + 0x10;
-               if ((retval=target_write_u16(target, adr, 0x90))!=ERROR_OK)
+               if ((retval = target_write_u16(target, adr, 0x90)) != ERROR_OK)
                {
                        return retval;
                }
-               if ((retval=target_read_u16(target, adr, &hstatus))!=ERROR_OK)
+               if ((retval = target_read_u16(target, adr, &hstatus)) != ERROR_OK)
                {
                        return retval;
                }
@@ -236,7 +236,7 @@ static int str9x_protect_check(struct flash_bank_s *bank)
        }
 
        /* read array command */
-       if ((retval=target_write_u16(target, adr, 0xFF))!=ERROR_OK)
+       if ((retval = target_write_u16(target, adr, 0xFF)) != ERROR_OK)
        {
                return retval;
        }
@@ -256,7 +256,7 @@ static int str9x_erase(struct flash_bank_s *bank, int first, int last)
 {
        target_t *target = bank->target;
        int i;
-       u32 adr;
+       uint32_t adr;
        uint8_t status;
        uint8_t erase_cmd;
 
@@ -284,50 +284,50 @@ static int str9x_erase(struct flash_bank_s *bank, int first, int last)
                adr = bank->base + bank->sectors[i].offset;
 
                /* erase sectors */
-               if ((retval=target_write_u16(target, adr, erase_cmd))!=ERROR_OK)
+               if ((retval = target_write_u16(target, adr, erase_cmd)) != ERROR_OK)
                {
                        return retval;
                }
-               if ((retval=target_write_u16(target, adr, 0xD0))!=ERROR_OK)
+               if ((retval = target_write_u16(target, adr, 0xD0)) != ERROR_OK)
                {
                        return retval;
                }
 
                /* get status */
-               if ((retval=target_write_u16(target, adr, 0x70))!=ERROR_OK)
+               if ((retval = target_write_u16(target, adr, 0x70)) != ERROR_OK)
                {
                        return retval;
                }
 
                int timeout;
-               for (timeout=0; timeout<1000; timeout++) {
-                       if ((retval=target_read_u8(target, adr, &status))!=ERROR_OK)
+               for (timeout = 0; timeout < 1000; timeout++) {
+                       if ((retval = target_read_u8(target, adr, &status)) != ERROR_OK)
                        {
                                return retval;
                        }
-                       if( status & 0x80 )
+                       if (status & 0x80)
                                break;
                        alive_sleep(1);
                }
-               if (timeout==1000)
+               if (timeout == 1000)
                {
                        LOG_ERROR("erase timed out");
                        return ERROR_FAIL;
                }
 
                /* clear status, also clear read array */
-               if ((retval=target_write_u16(target, adr, 0x50))!=ERROR_OK)
+               if ((retval = target_write_u16(target, adr, 0x50)) != ERROR_OK)
                {
                        return retval;
                }
 
                /* read array command */
-               if ((retval=target_write_u16(target, adr, 0xFF))!=ERROR_OK)
+               if ((retval = target_write_u16(target, adr, 0xFF)) != ERROR_OK)
                {
                        return retval;
                }
 
-               if( status & 0x22 )
+               if (status & 0x22)
                {
                        LOG_ERROR("error erasing flash bank, status: 0x%x", status);
                        return ERROR_FLASH_OPERATION_FAILED;
@@ -349,7 +349,7 @@ static int str9x_protect(struct flash_bank_s *bank,
 {
        target_t *target = bank->target;
        int i;
-       u32 adr;
+       uint32_t adr;
        uint8_t status;
 
        if (bank->target->state != TARGET_HALTED)
@@ -365,7 +365,7 @@ static int str9x_protect(struct flash_bank_s *bank,
                adr = bank->base + bank->sectors[i].offset;
 
                target_write_u16(target, adr, 0x60);
-               if( set )
+               if (set)
                        target_write_u16(target, adr, 0x01);
                else
                        target_write_u16(target, adr, 0xD0);
@@ -384,18 +384,18 @@ static int str9x_protect(struct flash_bank_s *bank,
 }
 
 static int str9x_write_block(struct flash_bank_s *bank,
-               uint8_t *buffer, u32 offset, u32 count)
+               uint8_t *buffer, uint32_t offset, uint32_t count)
 {
        str9x_flash_bank_t *str9x_info = bank->driver_priv;
        target_t *target = bank->target;
-       u32 buffer_size = 8192;
+       uint32_t buffer_size = 8192;
        working_area_t *source;
-       u32 address = bank->base + offset;
+       uint32_t address = bank->base + offset;
        reg_param_t reg_params[4];
        armv4_5_algorithm_t armv4_5_info;
        int retval = ERROR_OK;
 
-       u32 str9x_flash_write_code[] = {
+       uint32_t str9x_flash_write_code[] = {
                                        /* write:                               */
                0xe3c14003,     /*      bic     r4, r1, #3              */
                0xe3a03040,     /*      mov     r3, #0x40               */
@@ -455,7 +455,7 @@ static int str9x_write_block(struct flash_bank_s *bank,
 
        while (count > 0)
        {
-               u32 thisrun_count = (count > (buffer_size / 2)) ? (buffer_size / 2) : count;
+               uint32_t thisrun_count = (count > (buffer_size / 2)) ? (buffer_size / 2) : count;
 
                target_write_buffer(target, source->address, thisrun_count * 2, buffer);
 
@@ -493,17 +493,17 @@ static int str9x_write_block(struct flash_bank_s *bank,
 }
 
 static int str9x_write(struct flash_bank_s *bank,
-               uint8_t *buffer, u32 offset, u32 count)
+               uint8_t *buffer, uint32_t offset, uint32_t count)
 {
        target_t *target = bank->target;
-       u32 words_remaining = (count / 2);
-       u32 bytes_remaining = (count & 0x00000001);
-       u32 address = bank->base + offset;
-       u32 bytes_written = 0;
+       uint32_t words_remaining = (count / 2);
+       uint32_t bytes_remaining = (count & 0x00000001);
+       uint32_t address = bank->base + offset;
+       uint32_t bytes_written = 0;
        uint8_t status;
        int retval;
-       u32 check_address = offset;
-       u32 bank_adr;
+       uint32_t check_address = offset;
+       uint32_t bank_adr;
        int i;
 
        if (bank->target->state != TARGET_HALTED)
@@ -514,14 +514,14 @@ static int str9x_write(struct flash_bank_s *bank,
 
        if (offset & 0x1)
        {
-               LOG_WARNING("offset 0x%x breaks required 2-byte alignment", offset);
+               LOG_WARNING("offset 0x%" PRIx32 " breaks required 2-byte alignment", offset);
                return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
        }
 
        for (i = 0; i < bank->num_sectors; i++)
        {
-               u32 sec_start = bank->sectors[i].offset;
-               u32 sec_end = sec_start + bank->sectors[i].size;
+               uint32_t sec_start = bank->sectors[i].offset;
+               uint32_t sec_end = sec_start + bank->sectors[i].size;
 
                /* check if destination falls within the current sector */
                if ((check_address >= sec_start) && (check_address < sec_end))
@@ -575,14 +575,14 @@ static int str9x_write(struct flash_bank_s *bank,
                target_write_u16(target, bank_adr, 0x70);
 
                int timeout;
-               for (timeout=0; timeout<1000; timeout++)
+               for (timeout = 0; timeout < 1000; timeout++)
                {
                        target_read_u8(target, bank_adr, &status);
-                       if( status & 0x80 )
+                       if (status & 0x80)
                                break;
                        alive_sleep(1);
                }
-               if (timeout==1000)
+               if (timeout == 1000)
                {
                        LOG_ERROR("write timed out");
                        return ERROR_FAIL;
@@ -607,7 +607,7 @@ static int str9x_write(struct flash_bank_s *bank,
                uint8_t last_halfword[2] = {0xff, 0xff};
                int i = 0;
 
-               while(bytes_remaining > 0)
+               while (bytes_remaining > 0)
                {
                        last_halfword[i++] = *(buffer + bytes_written);
                        bytes_remaining--;
@@ -624,14 +624,14 @@ static int str9x_write(struct flash_bank_s *bank,
                target_write_u16(target, bank_adr, 0x70);
 
                int timeout;
-               for (timeout=0; timeout<1000; timeout++)
+               for (timeout = 0; timeout < 1000; timeout++)
                {
                        target_read_u8(target, bank_adr, &status);
-                       if( status & 0x80 )
+                       if (status & 0x80)
                                break;
                        alive_sleep(1);
                }
-               if (timeout==1000)
+               if (timeout == 1000)
                {
                        LOG_ERROR("write timed out");
                        return ERROR_FAIL;
@@ -665,7 +665,7 @@ static int str9x_handle_part_id_command(struct command_context_s *cmd_ctx,
 
 static int str9x_info(struct flash_bank_s *bank, char *buf, int buf_size)
 {
-       snprintf(buf, buf_size, "str9x flash driver info" );
+       snprintf(buf, buf_size, "str9x flash driver info");
        return ERROR_OK;
 }
 
openocd with support for Altus Metrum targets