From 19b351d8c8869305bfef8d4fad018cad1ea220b3 Mon Sep 17 00:00:00 2001 From: Freddie Chopin Date: Fri, 5 Oct 2012 22:16:35 +0200 Subject: [PATCH] Cleanup lpc2000.c Do some cleanup in lpc2000.c - concatenate short lines into single longer lines, move variable declarations to "just before" they are used, etc. Change-Id: Ia7b9f0307dd4857ee8e15c8a6d4d7b5c4392fd80 Signed-off-by: Freddie Chopin Reviewed-on: http://openocd.zylin.com/861 Tested-by: jenkins Reviewed-by: Spencer Oliver --- src/flash/nor/lpc2000.c | 216 ++++++++++++++++------------------------ 1 file changed, 87 insertions(+), 129 deletions(-) diff --git a/src/flash/nor/lpc2000.c b/src/flash/nor/lpc2000.c index 7b247f89e5..43f45c81e3 100644 --- a/src/flash/nor/lpc2000.c +++ b/src/flash/nor/lpc2000.c @@ -35,9 +35,8 @@ * @file * flash programming support for NXP LPC17xx and LPC2xxx devices. * - * @todo Provide a way to update CCLK after declaring the flash bank. - * The value which is correct after chip reset will rarely still work - * right after the clocks switch to use the PLL (e.g. 4MHz --> 100 MHz). + * @todo Provide a way to update CCLK after declaring the flash bank. The value which is correct after chip reset will + * rarely still work right after the clocks switch to use the PLL (e.g. 4MHz --> 100 MHz). */ /* * currently supported devices: @@ -105,7 +104,6 @@ enum lpc2000_status_codes { static int lpc2000_build_sector_list(struct flash_bank *bank) { struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv; - int i; uint32_t offset = 0; /* default to a 4096 write buffer */ @@ -116,7 +114,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank) if (bank->size == 128 * 1024) { bank->num_sectors = 16; bank->sectors = malloc(sizeof(struct flash_sector) * 16); - for (i = 0; i < 16; i++) { + for (int i = 0; i < 16; i++) { bank->sectors[i].offset = offset; bank->sectors[i].size = 8 * 1024; offset += bank->sectors[i].size; @@ -127,21 +125,21 @@ static int lpc2000_build_sector_list(struct flash_bank *bank) bank->num_sectors = 18; bank->sectors = malloc(sizeof(struct flash_sector) * 18); - for (i = 0; i < 8; i++) { + for (int i = 0; i < 8; i++) { bank->sectors[i].offset = offset; bank->sectors[i].size = 8 * 1024; offset += bank->sectors[i].size; bank->sectors[i].is_erased = -1; bank->sectors[i].is_protected = 1; } - for (i = 8; i < 10; i++) { + for (int i = 8; i < 10; i++) { bank->sectors[i].offset = offset; bank->sectors[i].size = 64 * 1024; offset += bank->sectors[i].size; bank->sectors[i].is_erased = -1; bank->sectors[i].is_protected = 1; } - for (i = 10; i < 18; i++) { + for (int i = 10; i < 18; i++) { bank->sectors[i].offset = offset; bank->sectors[i].size = 8 * 1024; offset += bank->sectors[i].size; @@ -193,7 +191,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank) bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors); - for (i = 0; i < bank->num_sectors; i++) { + for (int i = 0; i < bank->num_sectors; i++) { if (i < 8) { bank->sectors[i].offset = offset; bank->sectors[i].size = 4 * 1024; @@ -238,10 +236,9 @@ static int lpc2000_build_sector_list(struct flash_bank *bank) bank->sectors = malloc(sizeof(struct flash_sector) * bank->num_sectors); - for (i = 0; i < bank->num_sectors; i++) { + for (int i = 0; i < bank->num_sectors; i++) { bank->sectors[i].offset = offset; - /* sectors 0-15 are 4kB-sized, 16 and above are 32kB-sized for LPC17xx - *devices */ + /* sectors 0-15 are 4kB-sized, 16 and above are 32kB-sized for LPC17xx devices */ bank->sectors[i].size = (i < 16) ? 4 * 1024 : 32 * 1024; offset += bank->sectors[i].size; bank->sectors[i].is_erased = -1; @@ -262,28 +259,18 @@ static int lpc2000_build_sector_list(struct flash_bank *bank) * 0x20 to 0x33: command result table (1+4 words) * 0x34 to 0xb3: stack (only 128b needed) */ -static int lpc2000_iap_call(struct flash_bank *bank, - int code, - uint32_t param_table[5], - uint32_t result_table[4]) +static int lpc2000_iap_call(struct flash_bank *bank, int code, uint32_t param_table[5], uint32_t result_table[4]) { int retval; struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv; struct target *target = bank->target; - struct mem_param mem_params[2]; - struct reg_param reg_params[5]; - struct arm_algorithm arm_algo; /* for LPC2000 */ - struct armv7m_algorithm armv7m_info; /* for LPC1700 */ - uint32_t status_code; - uint32_t iap_entry_point = 0; /* to make compiler happier */ /* regrab previously allocated working_area, or allocate a new one */ if (!lpc2000_info->iap_working_area) { uint8_t jump_gate[8]; /* make sure we have a working area */ - if (target_alloc_working_area(target, 180, - &lpc2000_info->iap_working_area) != ERROR_OK) { + if (target_alloc_working_area(target, 180, &lpc2000_info->iap_working_area) != ERROR_OK) { LOG_ERROR("no working area specified, can't write LPC2000 internal flash"); return ERROR_FLASH_OPERATION_FAILED; } @@ -304,16 +291,18 @@ static int lpc2000_iap_call(struct flash_bank *bank, exit(-1); } - retval = target_write_memory(target, - lpc2000_info->iap_working_area->address, 4, 2, jump_gate); + retval = target_write_memory(target, lpc2000_info->iap_working_area->address, 4, 2, jump_gate); if (retval != ERROR_OK) { - LOG_ERROR( - "Write memory at address 0x%8.8" PRIx32 " failed (check work_area definition)", - lpc2000_info->iap_working_area->address); + LOG_ERROR("Write memory at address 0x%8.8" PRIx32 " failed (check work_area definition)", + lpc2000_info->iap_working_area->address); return retval; } } + struct arm_algorithm arm_algo; /* for LPC2000 */ + struct armv7m_algorithm armv7m_info; /* for LPC1700 */ + uint32_t iap_entry_point = 0; /* to make compiler happier */ + switch (lpc2000_info->variant) { case lpc1700: armv7m_info.common_magic = ARMV7M_COMMON_MAGIC; @@ -332,9 +321,10 @@ static int lpc2000_iap_call(struct flash_bank *bank, exit(-1); } + struct mem_param mem_params[2]; + /* command parameter table */ - init_mem_param(&mem_params[0], lpc2000_info->iap_working_area->address + 8, 6 * 4, - PARAM_OUT); + init_mem_param(&mem_params[0], lpc2000_info->iap_working_area->address + 8, 6 * 4, PARAM_OUT); target_buffer_set_u32(target, mem_params[0].value, code); target_buffer_set_u32(target, mem_params[0].value + 0x04, param_table[0]); target_buffer_set_u32(target, mem_params[0].value + 0x08, param_table[1]); @@ -342,14 +332,13 @@ static int lpc2000_iap_call(struct flash_bank *bank, target_buffer_set_u32(target, mem_params[0].value + 0x10, param_table[3]); target_buffer_set_u32(target, mem_params[0].value + 0x14, param_table[4]); + struct reg_param reg_params[5]; + init_reg_param(®_params[0], "r0", 32, PARAM_OUT); buf_set_u32(reg_params[0].value, 0, 32, lpc2000_info->iap_working_area->address + 0x08); /* command result table */ - init_mem_param(&mem_params[1], - lpc2000_info->iap_working_area->address + 0x20, - 5 * 4, - PARAM_IN); + init_mem_param(&mem_params[1], lpc2000_info->iap_working_area->address + 0x20, 5 * 4, PARAM_IN); init_reg_param(®_params[1], "r1", 32, PARAM_OUT); buf_set_u32(reg_params[1].value, 0, 32, lpc2000_info->iap_working_area->address + 0x20); @@ -362,51 +351,43 @@ static int lpc2000_iap_call(struct flash_bank *bank, case lpc1700: /* IAP stack */ init_reg_param(®_params[3], "sp", 32, PARAM_OUT); - buf_set_u32(reg_params[3].value, 0, 32, - lpc2000_info->iap_working_area->address + 0xb4); + buf_set_u32(reg_params[3].value, 0, 32, lpc2000_info->iap_working_area->address + 0xb4); /* return address */ init_reg_param(®_params[4], "lr", 32, PARAM_OUT); - buf_set_u32(reg_params[4].value, 0, 32, - (lpc2000_info->iap_working_area->address + 0x04) | 1); + buf_set_u32(reg_params[4].value, 0, 32, (lpc2000_info->iap_working_area->address + 0x04) | 1); /* bit0 of LR = 1 to return in Thumb mode */ - target_run_algorithm(target, 2, mem_params, 5, reg_params, - lpc2000_info->iap_working_area->address, 0, 10000, &armv7m_info); + target_run_algorithm(target, 2, mem_params, 5, reg_params, lpc2000_info->iap_working_area->address, 0, + 10000, &armv7m_info); break; case lpc2000_v1: case lpc2000_v2: /* IAP stack */ init_reg_param(®_params[3], "sp_svc", 32, PARAM_OUT); - buf_set_u32(reg_params[3].value, 0, 32, - lpc2000_info->iap_working_area->address + 0xb4); + buf_set_u32(reg_params[3].value, 0, 32, lpc2000_info->iap_working_area->address + 0xb4); /* return address */ init_reg_param(®_params[4], "lr_svc", 32, PARAM_OUT); - buf_set_u32(reg_params[4].value, 0, 32, - lpc2000_info->iap_working_area->address + 0x04); + buf_set_u32(reg_params[4].value, 0, 32, lpc2000_info->iap_working_area->address + 0x04); - target_run_algorithm(target, 2, mem_params, 5, reg_params, - lpc2000_info->iap_working_area->address, - lpc2000_info->iap_working_area->address + 0x4, - 10000, &arm_algo); + target_run_algorithm(target, 2, mem_params, 5, reg_params, lpc2000_info->iap_working_area->address, + lpc2000_info->iap_working_area->address + 0x4, 10000, &arm_algo); break; default: LOG_ERROR("BUG: unknown lpc2000->variant encountered"); exit(-1); } - status_code = target_buffer_get_u32(target, mem_params[1].value); + int status_code = target_buffer_get_u32(target, mem_params[1].value); result_table[0] = target_buffer_get_u32(target, mem_params[1].value + 0x04); result_table[1] = target_buffer_get_u32(target, mem_params[1].value + 0x08); result_table[2] = target_buffer_get_u32(target, mem_params[1].value + 0x0c); result_table[3] = target_buffer_get_u32(target, mem_params[1].value + 0x10); - LOG_DEBUG("IAP command = %i (0x%8.8" PRIx32 ", 0x%8.8" PRIx32 - ", 0x%8.8" PRIx32 ", 0x%8.8" PRIx32 ", 0x%8.8" - PRIx32 ") completed with result = %8.8" PRIx32, - code, param_table[0], param_table[1], param_table[2], - param_table[3], param_table[4], status_code); + LOG_DEBUG("IAP command = %i (0x%8.8" PRIx32 ", 0x%8.8" PRIx32 ", 0x%8.8" PRIx32 ", 0x%8.8" PRIx32 ", 0x%8.8" PRIx32 + ") completed with result = %8.8" PRIx32, + code, param_table[0], param_table[1], param_table[2], param_table[3], param_table[4], status_code); destroy_mem_param(&mem_params[0]); destroy_mem_param(&mem_params[1]); @@ -422,18 +403,16 @@ static int lpc2000_iap_call(struct flash_bank *bank, static int lpc2000_iap_blank_check(struct flash_bank *bank, int first, int last) { - uint32_t param_table[5] = {0}; - uint32_t result_table[4]; - int status_code; - int i; - if ((first < 0) || (last >= bank->num_sectors)) return ERROR_FLASH_SECTOR_INVALID; - for (i = first; i <= last; i++) { + uint32_t param_table[5] = {0}; + uint32_t result_table[4]; + + for (int i = first; i <= last; i++) { /* check single sector */ param_table[0] = param_table[1] = i; - status_code = lpc2000_iap_call(bank, 53, param_table, result_table); + int status_code = lpc2000_iap_call(bank, 53, param_table, result_table); switch (status_code) { case ERROR_FLASH_OPERATION_FAILED: @@ -464,12 +443,10 @@ static int lpc2000_iap_blank_check(struct flash_bank *bank, int first, int last) */ FLASH_BANK_COMMAND_HANDLER(lpc2000_flash_bank_command) { - struct lpc2000_flash_bank *lpc2000_info; - if (CMD_ARGC < 8) return ERROR_COMMAND_SYNTAX_ERROR; - lpc2000_info = malloc(sizeof(struct lpc2000_flash_bank)); + struct lpc2000_flash_bank *lpc2000_info = malloc(sizeof(struct lpc2000_flash_bank)); bank->driver_priv = lpc2000_info; if (strcmp(CMD_ARGV[6], "lpc2000_v1") == 0) { @@ -511,22 +488,22 @@ FLASH_BANK_COMMAND_HANDLER(lpc2000_flash_bank_command) static int lpc2000_erase(struct flash_bank *bank, int first, int last) { - struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv; - uint32_t param_table[5] = {0}; - uint32_t result_table[4]; - int status_code; - if (bank->target->state != TARGET_HALTED) { LOG_ERROR("Target not halted"); return ERROR_TARGET_NOT_HALTED; } + struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv; + uint32_t param_table[5] = {0}; + param_table[0] = first; param_table[1] = last; param_table[2] = lpc2000_info->cclk; + uint32_t result_table[4]; + /* Prepare sectors */ - status_code = lpc2000_iap_call(bank, 50, param_table, result_table); + int status_code = lpc2000_iap_call(bank, 50, param_table, result_table); switch (status_code) { case ERROR_FLASH_OPERATION_FAILED: return ERROR_FLASH_OPERATION_FAILED; @@ -566,19 +543,7 @@ static int lpc2000_protect(struct flash_bank *bank, int set, int first, int last static int lpc2000_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count) { - struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv; struct target *target = bank->target; - uint32_t dst_min_alignment; - uint32_t bytes_remaining = count; - uint32_t bytes_written = 0; - int first_sector = 0; - int last_sector = 0; - uint32_t param_table[5] = {0}; - uint32_t result_table[4]; - int status_code; - int i; - struct working_area *download_area; - int retval = ERROR_OK; if (bank->target->state != TARGET_HALTED) { LOG_ERROR("Target not halted"); @@ -588,20 +553,22 @@ static int lpc2000_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offs if (offset + count > bank->size) return ERROR_FLASH_DST_OUT_OF_BANK; - dst_min_alignment = lpc2000_info->cmd51_dst_boundary; + struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv; + + uint32_t dst_min_alignment = lpc2000_info->cmd51_dst_boundary; if (offset % dst_min_alignment) { - LOG_WARNING("offset 0x%" PRIx32 " breaks required alignment 0x%" PRIx32, - offset, - dst_min_alignment); + LOG_WARNING("offset 0x%" PRIx32 " breaks required alignment 0x%" PRIx32, offset, dst_min_alignment); return ERROR_FLASH_DST_BREAKS_ALIGNMENT; } - for (i = 0; i < bank->num_sectors; i++) { + int first_sector = 0; + int last_sector = 0; + + for (int i = 0; i < bank->num_sectors; i++) { if (offset >= bank->sectors[i].offset) first_sector = i; - if (offset + DIV_ROUND_UP(count, dst_min_alignment) - * dst_min_alignment > bank->sectors[i].offset) + if (offset + DIV_ROUND_UP(count, dst_min_alignment) * dst_min_alignment > bank->sectors[i].offset) last_sector = i; } @@ -610,35 +577,39 @@ static int lpc2000_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offs /* check if exception vectors should be flashed */ if ((offset == 0) && (count >= 0x20) && lpc2000_info->calc_checksum) { uint32_t checksum = 0; - for (i = 0; i < 8; i++) { - LOG_DEBUG("Vector 0x%2.2x: 0x%8.8" PRIx32, i * 4, - buf_get_u32(buffer + (i * 4), 0, 32)); + for (int i = 0; i < 8; i++) { + LOG_DEBUG("Vector 0x%2.2x: 0x%8.8" PRIx32, i * 4, buf_get_u32(buffer + (i * 4), 0, 32)); if (i != lpc2000_info->checksum_vector) checksum += buf_get_u32(buffer + (i * 4), 0, 32); } checksum = 0 - checksum; LOG_DEBUG("checksum: 0x%8.8" PRIx32, checksum); - uint32_t original_value = buf_get_u32(buffer + - (lpc2000_info->checksum_vector * 4), 0, 32); + uint32_t original_value = buf_get_u32(buffer + (lpc2000_info->checksum_vector * 4), 0, 32); if (original_value != checksum) { - LOG_WARNING("Verification will fail since checksum in image (0x%8.8" PRIx32 ") " - "to be written to flash is different from calculated vector " - "checksum (0x%8.8" PRIx32 ").", original_value, checksum); - LOG_WARNING("To remove this warning modify build tools on developer PC " - "to inject correct LPC vector checksum."); + LOG_WARNING("Verification will fail since checksum in image (0x%8.8" PRIx32 ") to be written to flash is " + "different from calculated vector checksum (0x%8.8" PRIx32 ").", original_value, checksum); + LOG_WARNING("To remove this warning modify build tools on developer PC to inject correct LPC vector " + "checksum."); } buf_set_u32(buffer + (lpc2000_info->checksum_vector * 4), 0, 32, checksum); } + struct working_area *download_area; + /* allocate a working area */ - if (target_alloc_working_area(target, lpc2000_info->cmd51_max_buffer, - &download_area) != ERROR_OK) { + if (target_alloc_working_area(target, lpc2000_info->cmd51_max_buffer, &download_area) != ERROR_OK) { LOG_ERROR("no working area specified, can't write LPC2000 internal flash"); return ERROR_FLASH_OPERATION_FAILED; } + uint32_t bytes_remaining = count; + uint32_t bytes_written = 0; + uint32_t param_table[5] = {0}; + uint32_t result_table[4]; + int retval = ERROR_OK; + while (bytes_remaining > 0) { uint32_t thisrun_bytes; if (bytes_remaining >= lpc2000_info->cmd51_max_buffer) @@ -653,7 +624,7 @@ static int lpc2000_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offs /* Prepare sectors */ param_table[0] = first_sector; param_table[1] = last_sector; - status_code = lpc2000_iap_call(bank, 50, param_table, result_table); + int status_code = lpc2000_iap_call(bank, 50, param_table, result_table); switch (status_code) { case ERROR_FLASH_OPERATION_FAILED: retval = ERROR_FLASH_OPERATION_FAILED; @@ -674,8 +645,7 @@ static int lpc2000_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offs break; if (bytes_remaining >= thisrun_bytes) { - retval = target_write_buffer(bank->target, download_area->address, - thisrun_bytes, buffer + bytes_written); + retval = target_write_buffer(bank->target, download_area->address, thisrun_bytes, buffer + bytes_written); if (retval != ERROR_OK) { retval = ERROR_FLASH_OPERATION_FAILED; break; @@ -683,18 +653,13 @@ static int lpc2000_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offs } else { uint8_t *last_buffer = malloc(thisrun_bytes); memcpy(last_buffer, buffer + bytes_written, bytes_remaining); - memset(last_buffer + bytes_remaining, 0xff, thisrun_bytes - - bytes_remaining); - target_write_buffer(bank->target, - download_area->address, - thisrun_bytes, - last_buffer); + memset(last_buffer + bytes_remaining, 0xff, thisrun_bytes - bytes_remaining); + target_write_buffer(bank->target, download_area->address, thisrun_bytes, last_buffer); free(last_buffer); } - LOG_DEBUG("writing 0x%" PRIx32 " bytes to address 0x%" PRIx32, - thisrun_bytes, - bank->base + offset + bytes_written); + LOG_DEBUG("writing 0x%" PRIx32 " bytes to address 0x%" PRIx32, thisrun_bytes, + bank->base + offset + bytes_written); /* Write data */ param_table[0] = bank->base + offset + bytes_written; @@ -735,9 +700,7 @@ static int lpc2000_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offs static int lpc2000_probe(struct flash_bank *bank) { - /* we can't probe on an lpc2000 - * if this is an lpc2xxx, it has the configured flash - */ + /* we can't probe on an lpc2000 if this is an lpc2xxx, it has the configured flash */ return ERROR_OK; } @@ -761,21 +724,14 @@ static int get_lpc2000_info(struct flash_bank *bank, char *buf, int buf_size) { struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv; - snprintf(buf, - buf_size, - "lpc2000 flash driver variant: %i, clk: %" PRIi32 "kHz", - lpc2000_info->variant, - lpc2000_info->cclk); + snprintf(buf, buf_size, "lpc2000 flash driver variant: %i, clk: %" PRIi32 "kHz", lpc2000_info->variant, + lpc2000_info->cclk); return ERROR_OK; } COMMAND_HANDLER(lpc2000_handle_part_id_command) { - uint32_t param_table[5] = {0}; - uint32_t result_table[4]; - int status_code; - if (CMD_ARGC < 1) return ERROR_COMMAND_SYNTAX_ERROR; @@ -789,11 +745,13 @@ COMMAND_HANDLER(lpc2000_handle_part_id_command) return ERROR_TARGET_NOT_HALTED; } - status_code = lpc2000_iap_call(bank, 54, param_table, result_table); + uint32_t param_table[5] = {0}; + uint32_t result_table[4]; + + int status_code = lpc2000_iap_call(bank, 54, param_table, result_table); if (status_code != 0x0) { if (status_code == ERROR_FLASH_OPERATION_FAILED) { - command_print(CMD_CTX, - "no sufficient working area specified, can't access LPC2000 IAP interface"); + command_print(CMD_CTX, "no sufficient working area specified, can't access LPC2000 IAP interface"); return ERROR_OK; } command_print(CMD_CTX, "lpc2000 IAP returned status code %i", status_code); -- 2.30.2