- Replace 'if(' with 'if ('.

[fw/openocd] / src / flash / stm32x.c

diff --git a/src/flash/stm32x.c b/src/flash/stm32x.c
index 0f49fae71ddd7a5f72cf1abd37fa70084b56fe19..192ee260e25edd9a5692ecfe14b7d212c15d4e75 100644 (file)
--- a/src/flash/stm32x.c
+++ b/src/flash/stm32x.c
@@ -33,7 +33,7 @@ static int stm32x_register_commands(struct command_context_s *cmd_ctx);
 static int stm32x_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank);
 static int stm32x_erase(struct flash_bank_s *bank, int first, int last);
 static int stm32x_protect(struct flash_bank_s *bank, int set, int first, int last);
-static int stm32x_write(struct flash_bank_s *bank, uint8_t *buffer, u32 offset, u32 count);
+static int stm32x_write(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count);
 static int stm32x_probe(struct flash_bank_s *bank);
 static int stm32x_auto_probe(struct flash_bank_s *bank);
 //static int stm32x_handle_part_id_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
@@ -100,25 +100,25 @@ static int stm32x_flash_bank_command(struct command_context_s *cmd_ctx, char *cm
        return ERROR_OK;
 }
 
-static u32 stm32x_get_flash_status(flash_bank_t *bank)
+static uint32_t stm32x_get_flash_status(flash_bank_t *bank)
 {
        target_t *target = bank->target;
-       u32 status;
+       uint32_t status;
 
        target_read_u32(target, STM32_FLASH_SR, &status);
 
        return status;
 }
 
-static u32 stm32x_wait_status_busy(flash_bank_t *bank, int timeout)
+static uint32_t stm32x_wait_status_busy(flash_bank_t *bank, int timeout)
 {
        target_t *target = bank->target;
-       u32 status;
+       uint32_t status;
 
        /* wait for busy to clear */
        while (((status = stm32x_get_flash_status(bank)) & FLASH_BSY) && (timeout-- > 0))
        {
-               LOG_DEBUG("status: 0x%x", status);
+               LOG_DEBUG("status: 0x%" PRIx32 "", status);
                alive_sleep(1);
        }
        /* Clear but report errors */
@@ -131,7 +131,7 @@ static u32 stm32x_wait_status_busy(flash_bank_t *bank, int timeout)
 
 static int stm32x_read_options(struct flash_bank_s *bank)
 {
-       u32 optiondata;
+       uint32_t optiondata;
        stm32x_flash_bank_t *stm32x_info = NULL;
        target_t *target = bank->target;
 
@@ -140,7 +140,7 @@ static int stm32x_read_options(struct flash_bank_s *bank)
        /* read current option bytes */
        target_read_u32(target, STM32_FLASH_OBR, &optiondata);
 
-       stm32x_info->option_bytes.user_options = (u16)0xFFF8|((optiondata >> 2) & 0x07);
+       stm32x_info->option_bytes.user_options = (uint16_t)0xFFF8|((optiondata >> 2) & 0x07);
        stm32x_info->option_bytes.RDP = (optiondata & (1 << OPT_READOUT)) ? 0xFFFF : 0x5AA5;
 
        if (optiondata & (1 << OPT_READOUT))
@@ -149,10 +149,10 @@ static int stm32x_read_options(struct flash_bank_s *bank)
        /* each bit refers to a 4bank protection */
        target_read_u32(target, STM32_FLASH_WRPR, &optiondata);
 
-       stm32x_info->option_bytes.protection[0] = (u16)optiondata;
-       stm32x_info->option_bytes.protection[1] = (u16)(optiondata >> 8);
-       stm32x_info->option_bytes.protection[2] = (u16)(optiondata >> 16);
-       stm32x_info->option_bytes.protection[3] = (u16)(optiondata >> 24);
+       stm32x_info->option_bytes.protection[0] = (uint16_t)optiondata;
+       stm32x_info->option_bytes.protection[1] = (uint16_t)(optiondata >> 8);
+       stm32x_info->option_bytes.protection[2] = (uint16_t)(optiondata >> 16);
+       stm32x_info->option_bytes.protection[3] = (uint16_t)(optiondata >> 24);
 
        return ERROR_OK;
 }
@@ -161,7 +161,7 @@ static int stm32x_erase_options(struct flash_bank_s *bank)
 {
        stm32x_flash_bank_t *stm32x_info = NULL;
        target_t *target = bank->target;
-       u32 status;
+       uint32_t status;
 
        stm32x_info = bank->driver_priv;
 
@@ -182,9 +182,9 @@ static int stm32x_erase_options(struct flash_bank_s *bank)
 
        status = stm32x_wait_status_busy(bank, 10);
 
-       if( status & FLASH_WRPRTERR )
+       if ( status & FLASH_WRPRTERR )
                return ERROR_FLASH_OPERATION_FAILED;
-       if( status & FLASH_PGERR )
+       if ( status & FLASH_PGERR )
                return ERROR_FLASH_OPERATION_FAILED;
 
        /* clear readout protection and complementary option bytes
@@ -198,7 +198,7 @@ static int stm32x_write_options(struct flash_bank_s *bank)
 {
        stm32x_flash_bank_t *stm32x_info = NULL;
        target_t *target = bank->target;
-       u32 status;
+       uint32_t status;
 
        stm32x_info = bank->driver_priv;
 
@@ -218,9 +218,9 @@ static int stm32x_write_options(struct flash_bank_s *bank)
 
        status = stm32x_wait_status_busy(bank, 10);
 
-       if( status & FLASH_WRPRTERR )
+       if ( status & FLASH_WRPRTERR )
                return ERROR_FLASH_OPERATION_FAILED;
-       if( status & FLASH_PGERR )
+       if ( status & FLASH_PGERR )
                return ERROR_FLASH_OPERATION_FAILED;
 
        /* write protection byte 1 */
@@ -228,9 +228,9 @@ static int stm32x_write_options(struct flash_bank_s *bank)
 
        status = stm32x_wait_status_busy(bank, 10);
 
-       if( status & FLASH_WRPRTERR )
+       if ( status & FLASH_WRPRTERR )
                return ERROR_FLASH_OPERATION_FAILED;
-       if( status & FLASH_PGERR )
+       if ( status & FLASH_PGERR )
                return ERROR_FLASH_OPERATION_FAILED;
 
        /* write protection byte 2 */
@@ -238,9 +238,9 @@ static int stm32x_write_options(struct flash_bank_s *bank)
 
        status = stm32x_wait_status_busy(bank, 10);
 
-       if( status & FLASH_WRPRTERR )
+       if ( status & FLASH_WRPRTERR )
                return ERROR_FLASH_OPERATION_FAILED;
-       if( status & FLASH_PGERR )
+       if ( status & FLASH_PGERR )
                return ERROR_FLASH_OPERATION_FAILED;
 
        /* write protection byte 3 */
@@ -248,9 +248,9 @@ static int stm32x_write_options(struct flash_bank_s *bank)
 
        status = stm32x_wait_status_busy(bank, 10);
 
-       if( status & FLASH_WRPRTERR )
+       if ( status & FLASH_WRPRTERR )
                return ERROR_FLASH_OPERATION_FAILED;
-       if( status & FLASH_PGERR )
+       if ( status & FLASH_PGERR )
                return ERROR_FLASH_OPERATION_FAILED;
 
        /* write protection byte 4 */
@@ -258,9 +258,9 @@ static int stm32x_write_options(struct flash_bank_s *bank)
 
        status = stm32x_wait_status_busy(bank, 10);
 
-       if( status & FLASH_WRPRTERR )
+       if ( status & FLASH_WRPRTERR )
                return ERROR_FLASH_OPERATION_FAILED;
-       if( status & FLASH_PGERR )
+       if ( status & FLASH_PGERR )
                return ERROR_FLASH_OPERATION_FAILED;
 
        /* write readout protection bit */
@@ -268,9 +268,9 @@ static int stm32x_write_options(struct flash_bank_s *bank)
 
        status = stm32x_wait_status_busy(bank, 10);
 
-       if( status & FLASH_WRPRTERR )
+       if ( status & FLASH_WRPRTERR )
                return ERROR_FLASH_OPERATION_FAILED;
-       if( status & FLASH_PGERR )
+       if ( status & FLASH_PGERR )
                return ERROR_FLASH_OPERATION_FAILED;
 
        target_write_u32(target, STM32_FLASH_CR, FLASH_LOCK);
@@ -283,7 +283,7 @@ static int stm32x_protect_check(struct flash_bank_s *bank)
        target_t *target = bank->target;
        stm32x_flash_bank_t *stm32x_info = bank->driver_priv;
 
-       u32 protection;
+       uint32_t protection;
        int i, s;
        int num_bits;
        int set;
@@ -338,7 +338,7 @@ static int stm32x_protect_check(struct flash_bank_s *bank)
                {
                        set = 1;
 
-                       if( protection & (1 << i))
+                       if ( protection & (1 << i))
                                set = 0;
 
                        for (s = 0; s < stm32x_info->ppage_size; s++)
@@ -353,7 +353,7 @@ static int stm32x_erase(struct flash_bank_s *bank, int first, int last)
 {
        target_t *target = bank->target;
        int i;
-       u32 status;
+       uint32_t status;
 
        if (bank->target->state != TARGET_HALTED)
        {
@@ -378,9 +378,9 @@ static int stm32x_erase(struct flash_bank_s *bank, int first, int last)
 
                status = stm32x_wait_status_busy(bank, 10);
 
-               if( status & FLASH_WRPRTERR )
+               if ( status & FLASH_WRPRTERR )
                        return ERROR_FLASH_OPERATION_FAILED;
-               if( status & FLASH_PGERR )
+               if ( status & FLASH_PGERR )
                        return ERROR_FLASH_OPERATION_FAILED;
                bank->sectors[i].is_erased = 1;
        }
@@ -394,10 +394,10 @@ static int stm32x_protect(struct flash_bank_s *bank, int set, int first, int las
 {
        stm32x_flash_bank_t *stm32x_info = NULL;
        target_t *target = bank->target;
-       u16 prot_reg[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
+       uint16_t prot_reg[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
        int i, reg, bit;
        int status;
-       u32 protection;
+       uint32_t protection;
 
        stm32x_info = bank->driver_priv;
 
@@ -417,10 +417,10 @@ static int stm32x_protect(struct flash_bank_s *bank, int set, int first, int las
         * high density - each bit refers to a 2bank protection */
        target_read_u32(target, STM32_FLASH_WRPR, &protection);
 
-       prot_reg[0] = (u16)protection;
-       prot_reg[1] = (u16)(protection >> 8);
-       prot_reg[2] = (u16)(protection >> 16);
-       prot_reg[3] = (u16)(protection >> 24);
+       prot_reg[0] = (uint16_t)protection;
+       prot_reg[1] = (uint16_t)(protection >> 8);
+       prot_reg[2] = (uint16_t)(protection >> 16);
+       prot_reg[3] = (uint16_t)(protection >> 24);
 
        if (stm32x_info->ppage_size == 2)
        {
@@ -445,7 +445,7 @@ static int stm32x_protect(struct flash_bank_s *bank, int set, int first, int las
                        reg = (i / stm32x_info->ppage_size) / 8;
                        bit = (i / stm32x_info->ppage_size) - (reg * 8);
 
-                       if( set )
+                       if ( set )
                                prot_reg[reg] &= ~(1 << bit);
                        else
                                prot_reg[reg] |= (1 << bit);
@@ -459,7 +459,7 @@ static int stm32x_protect(struct flash_bank_s *bank, int set, int first, int las
                        reg = (i / stm32x_info->ppage_size) / 8;
                        bit = (i / stm32x_info->ppage_size) - (reg * 8);
 
-                       if( set )
+                       if ( set )
                                prot_reg[reg] &= ~(1 << bit);
                        else
                                prot_reg[reg] |= (1 << bit);
@@ -477,13 +477,13 @@ static int stm32x_protect(struct flash_bank_s *bank, int set, int first, int las
        return stm32x_write_options(bank);
 }
 
-static int stm32x_write_block(struct flash_bank_s *bank, uint8_t *buffer, u32 offset, u32 count)
+static int stm32x_write_block(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
 {
        stm32x_flash_bank_t *stm32x_info = bank->driver_priv;
        target_t *target = bank->target;
-       u32 buffer_size = 16384;
+       uint32_t buffer_size = 16384;
        working_area_t *source;
-       u32 address = bank->base + offset;
+       uint32_t address = bank->base + offset;
        reg_param_t reg_params[4];
        armv7m_algorithm_t armv7m_info;
        int retval = ERROR_OK;
@@ -545,7 +545,7 @@ static int stm32x_write_block(struct flash_bank_s *bank, uint8_t *buffer, u32 of
 
        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;
 
                if ((retval = target_write_buffer(target, source->address, thisrun_count * 2, buffer))!=ERROR_OK)
                        break;
@@ -596,13 +596,13 @@ static int stm32x_write_block(struct flash_bank_s *bank, uint8_t *buffer, u32 of
        return retval;
 }
 
-static int stm32x_write(struct flash_bank_s *bank, uint8_t *buffer, u32 offset, u32 count)
+static int stm32x_write(struct flash_bank_s *bank, 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;
 
@@ -614,7 +614,7 @@ static int stm32x_write(struct flash_bank_s *bank, uint8_t *buffer, u32 offset,
 
        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;
        }
 
@@ -650,20 +650,20 @@ static int stm32x_write(struct flash_bank_s *bank, uint8_t *buffer, u32 offset,
 
        while (words_remaining > 0)
        {
-               u16 value;
-               memcpy(&value, buffer + bytes_written, sizeof(u16));
+               uint16_t value;
+               memcpy(&value, buffer + bytes_written, sizeof(uint16_t));
 
                target_write_u32(target, STM32_FLASH_CR, FLASH_PG);
                target_write_u16(target, address, value);
 
                status = stm32x_wait_status_busy(bank, 5);
 
-               if( status & FLASH_WRPRTERR )
+               if ( status & FLASH_WRPRTERR )
                {
                        LOG_ERROR("flash memory not erased before writing");
                        return ERROR_FLASH_OPERATION_FAILED;
                }
-               if( status & FLASH_PGERR )
+               if ( status & FLASH_PGERR )
                {
                        LOG_ERROR("flash memory write protected");
                        return ERROR_FLASH_OPERATION_FAILED;
@@ -676,7 +676,7 @@ static int stm32x_write(struct flash_bank_s *bank, uint8_t *buffer, u32 offset,
 
        if (bytes_remaining)
        {
-               u16 value = 0xffff;
+               uint16_t value = 0xffff;
                memcpy(&value, buffer + bytes_written, bytes_remaining);
 
                target_write_u32(target, STM32_FLASH_CR, FLASH_PG);
@@ -684,12 +684,12 @@ static int stm32x_write(struct flash_bank_s *bank, uint8_t *buffer, u32 offset,
 
                status = stm32x_wait_status_busy(bank, 5);
 
-               if( status & FLASH_WRPRTERR )
+               if ( status & FLASH_WRPRTERR )
                {
                        LOG_ERROR("flash memory not erased before writing");
                        return ERROR_FLASH_OPERATION_FAILED;
                }
-               if( status & FLASH_PGERR )
+               if ( status & FLASH_PGERR )
                {
                        LOG_ERROR("flash memory write protected");
                        return ERROR_FLASH_OPERATION_FAILED;
@@ -706,8 +706,8 @@ static int stm32x_probe(struct flash_bank_s *bank)
        target_t *target = bank->target;
        stm32x_flash_bank_t *stm32x_info = bank->driver_priv;
        int i;
-       u16 num_pages;
-       u32 device_id;
+       uint16_t num_pages;
+       uint32_t device_id;
        int page_size;
 
        if (bank->target->state != TARGET_HALTED)
@@ -720,7 +720,7 @@ static int stm32x_probe(struct flash_bank_s *bank)
 
        /* read stm32 device id register */
        target_read_u32(target, 0xE0042000, &device_id);
-       LOG_INFO( "device id = 0x%08x", device_id );
+       LOG_INFO( "device id = 0x%08" PRIx32 "", device_id );
 
        /* get flash size from target */
        if (target_read_u16(target, 0x1FFFF7E0, &num_pages) != ERROR_OK)
@@ -836,7 +836,7 @@ static int stm32x_handle_part_id_command(struct command_context_s *cmd_ctx, char
 static int stm32x_info(struct flash_bank_s *bank, char *buf, int buf_size)
 {
        target_t *target = bank->target;
-       u32 device_id;
+       uint32_t device_id;
        int printed;
 
        /* read stm32 device id register */
@@ -1033,7 +1033,7 @@ static int stm32x_handle_unlock_command(struct command_context_s *cmd_ctx, char
 static int stm32x_handle_options_read_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 {
        flash_bank_t *bank;
-       u32 optionbyte;
+       uint32_t optionbyte;
        target_t *target = NULL;
        stm32x_flash_bank_t *stm32x_info = NULL;
 
@@ -1061,7 +1061,7 @@ static int stm32x_handle_options_read_command(struct command_context_s *cmd_ctx,
        }
 
        target_read_u32(target, STM32_FLASH_OBR, &optionbyte);
-       command_print(cmd_ctx, "Option Byte: 0x%x", optionbyte);
+       command_print(cmd_ctx, "Option Byte: 0x%" PRIx32 "", optionbyte);
 
        if (buf_get_u32((uint8_t*)&optionbyte, OPT_ERROR, 1))
                command_print(cmd_ctx, "Option Byte Complement Error");
@@ -1094,7 +1094,7 @@ static int stm32x_handle_options_write_command(struct command_context_s *cmd_ctx
        flash_bank_t *bank;
        target_t *target = NULL;
        stm32x_flash_bank_t *stm32x_info = NULL;
-       u16 optionbyte = 0xF8;
+       uint16_t optionbyte = 0xF8;
 
        if (argc < 4)
        {
@@ -1168,7 +1168,7 @@ static int stm32x_handle_options_write_command(struct command_context_s *cmd_ctx
 static int stm32x_mass_erase(struct flash_bank_s *bank)
 {
        target_t *target = bank->target;
-       u32 status;
+       uint32_t status;
 
        if (target->state != TARGET_HALTED)
        {
@@ -1188,13 +1188,13 @@ static int stm32x_mass_erase(struct flash_bank_s *bank)
 
        target_write_u32(target, STM32_FLASH_CR, FLASH_LOCK);
 
-       if( status & FLASH_WRPRTERR )
+       if ( status & FLASH_WRPRTERR )
        {
                LOG_ERROR("stm32x device protected");
                return ERROR_OK;
        }
 
-       if( status & FLASH_PGERR )
+       if ( status & FLASH_PGERR )
        {
                LOG_ERROR("stm32x device programming failed");
                return ERROR_OK;