Code Review / openocd.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | patch | inline | side by side (parent: 71aba32)
flash/nor: convert enum in uppercase 49/6349/2
authorAntonio Borneo <borneo.antonio@gmail.com>
Sun, 6 Jun 2021 21:59:39 +0000 (23:59 +0200)
committerAntonio Borneo <borneo.antonio@gmail.com>
Tue, 20 Jul 2021 13:54:44 +0000 (14:54 +0100)
Change-Id: I7b31be25a651069b63c6dea6cb5e7994184390b1
Signed-off-by: Antonio Borneo <borneo.antonio@gmail.com>
Reviewed-on: http://openocd.zylin.com/6349
Tested-by: jenkins
Reviewed-by: Xiang W <wxjstz@126.com>
src/flash/nor/fm3.c patch | blob | history
src/flash/nor/fm4.c patch | blob | history
src/flash/nor/lpc2000.c patch | blob | history

diff --git a/src/flash/nor/fm3.c b/src/flash/nor/fm3.c
index 15a08f701adc779b631e0ae3bbf9cf74abadb05d..c5eab5124d279f4ed8662814cce56eec4e3351ef 100644 (file)
--- a/src/flash/nor/fm3.c
+++ b/src/flash/nor/fm3.c
@@ -33,29 +33,29 @@
 #define FLASH_DQ5 0x20         /* Time limit exceeding flag bit (TLOV) position */
 
 enum fm3_variant {
-       mb9bfxx1,       /* Flash Type '1' */
-       mb9bfxx2,
-       mb9bfxx3,
-       mb9bfxx4,
-       mb9bfxx5,
-       mb9bfxx6,
-       mb9bfxx7,
-       mb9bfxx8,
-
-       mb9afxx1,       /* Flash Type '2' */
-       mb9afxx2,
-       mb9afxx3,
-       mb9afxx4,
-       mb9afxx5,
-       mb9afxx6,
-       mb9afxx7,
-       mb9afxx8,
+       MB9BFXX1,       /* Flash Type '1' */
+       MB9BFXX2,
+       MB9BFXX3,
+       MB9BFXX4,
+       MB9BFXX5,
+       MB9BFXX6,
+       MB9BFXX7,
+       MB9BFXX8,
+
+       MB9AFXX1,       /* Flash Type '2' */
+       MB9AFXX2,
+       MB9AFXX3,
+       MB9AFXX4,
+       MB9AFXX5,
+       MB9AFXX6,
+       MB9AFXX7,
+       MB9AFXX8,
 };
 
 enum fm3_flash_type {
-       fm3_no_flash_type = 0,
-       fm3_flash_type1   = 1,
-       fm3_flash_type2   = 2
+       FM3_NO_FLASH_TYPE = 0,
+       FM3_FLASH_TYPE1   = 1,
+       FM3_FLASH_TYPE2   = 2
 };
 
 struct fm3_flash_bank {
@@ -76,53 +76,53 @@ FLASH_BANK_COMMAND_HANDLER(fm3_flash_bank_command)
 
        /* Flash type '1' */
        if (strcmp(CMD_ARGV[5], "mb9bfxx1.cpu") == 0) {
-               fm3_info->variant = mb9bfxx1;
-               fm3_info->flashtype = fm3_flash_type1;
+               fm3_info->variant = MB9BFXX1;
+               fm3_info->flashtype = FM3_FLASH_TYPE1;
        } else if (strcmp(CMD_ARGV[5], "mb9bfxx2.cpu") == 0) {
-               fm3_info->variant = mb9bfxx2;
-               fm3_info->flashtype = fm3_flash_type1;
+               fm3_info->variant = MB9BFXX2;
+               fm3_info->flashtype = FM3_FLASH_TYPE1;
        } else if (strcmp(CMD_ARGV[5], "mb9bfxx3.cpu") == 0) {
-               fm3_info->variant = mb9bfxx3;
-               fm3_info->flashtype = fm3_flash_type1;
+               fm3_info->variant = MB9BFXX3;
+               fm3_info->flashtype = FM3_FLASH_TYPE1;
        } else if (strcmp(CMD_ARGV[5], "mb9bfxx4.cpu") == 0) {
-               fm3_info->variant = mb9bfxx4;
-               fm3_info->flashtype = fm3_flash_type1;
+               fm3_info->variant = MB9BFXX4;
+               fm3_info->flashtype = FM3_FLASH_TYPE1;
        } else if (strcmp(CMD_ARGV[5], "mb9bfxx5.cpu") == 0) {
-               fm3_info->variant = mb9bfxx5;
-               fm3_info->flashtype = fm3_flash_type1;
+               fm3_info->variant = MB9BFXX5;
+               fm3_info->flashtype = FM3_FLASH_TYPE1;
        } else if (strcmp(CMD_ARGV[5], "mb9bfxx6.cpu") == 0) {
-               fm3_info->variant = mb9bfxx6;
-               fm3_info->flashtype = fm3_flash_type1;
+               fm3_info->variant = MB9BFXX6;
+               fm3_info->flashtype = FM3_FLASH_TYPE1;
        } else if (strcmp(CMD_ARGV[5], "mb9bfxx7.cpu") == 0) {
-               fm3_info->variant = mb9bfxx7;
-               fm3_info->flashtype = fm3_flash_type1;
+               fm3_info->variant = MB9BFXX7;
+               fm3_info->flashtype = FM3_FLASH_TYPE1;
        } else if (strcmp(CMD_ARGV[5], "mb9bfxx8.cpu") == 0) {
-               fm3_info->variant = mb9bfxx8;
-               fm3_info->flashtype = fm3_flash_type1;
+               fm3_info->variant = MB9BFXX8;
+               fm3_info->flashtype = FM3_FLASH_TYPE1;
        } else if (strcmp(CMD_ARGV[5], "mb9afxx1.cpu") == 0) {  /* Flash type '2' */
-               fm3_info->variant = mb9afxx1;
-               fm3_info->flashtype = fm3_flash_type2;
+               fm3_info->variant = MB9AFXX1;
+               fm3_info->flashtype = FM3_FLASH_TYPE2;
        } else if (strcmp(CMD_ARGV[5], "mb9afxx2.cpu") == 0) {
-               fm3_info->variant = mb9afxx2;
-               fm3_info->flashtype = fm3_flash_type2;
+               fm3_info->variant = MB9AFXX2;
+               fm3_info->flashtype = FM3_FLASH_TYPE2;
        } else if (strcmp(CMD_ARGV[5], "mb9afxx3.cpu") == 0) {
-               fm3_info->variant = mb9afxx3;
-               fm3_info->flashtype = fm3_flash_type2;
+               fm3_info->variant = MB9AFXX3;
+               fm3_info->flashtype = FM3_FLASH_TYPE2;
        } else if (strcmp(CMD_ARGV[5], "mb9afxx4.cpu") == 0) {
-               fm3_info->variant = mb9afxx4;
-               fm3_info->flashtype = fm3_flash_type2;
+               fm3_info->variant = MB9AFXX4;
+               fm3_info->flashtype = FM3_FLASH_TYPE2;
        } else if (strcmp(CMD_ARGV[5], "mb9afxx5.cpu") == 0) {
-               fm3_info->variant = mb9afxx5;
-               fm3_info->flashtype = fm3_flash_type2;
+               fm3_info->variant = MB9AFXX5;
+               fm3_info->flashtype = FM3_FLASH_TYPE2;
        } else if (strcmp(CMD_ARGV[5], "mb9afxx6.cpu") == 0) {
-               fm3_info->variant = mb9afxx6;
-               fm3_info->flashtype = fm3_flash_type2;
+               fm3_info->variant = MB9AFXX6;
+               fm3_info->flashtype = FM3_FLASH_TYPE2;
        } else if (strcmp(CMD_ARGV[5], "mb9afxx7.cpu") == 0) {
-               fm3_info->variant = mb9afxx7;
-               fm3_info->flashtype = fm3_flash_type2;
+               fm3_info->variant = MB9AFXX7;
+               fm3_info->flashtype = FM3_FLASH_TYPE2;
        } else if (strcmp(CMD_ARGV[5], "mb9afxx8.cpu") == 0) {
-               fm3_info->variant = mb9afxx8;
-               fm3_info->flashtype = fm3_flash_type2;
+               fm3_info->variant = MB9AFXX8;
+               fm3_info->flashtype = FM3_FLASH_TYPE2;
        }
 
        /* unknown Flash type */
@@ -219,10 +219,10 @@ static int fm3_erase(struct flash_bank *bank, unsigned int first,
 
        u32_flash_type = (uint32_t) fm3_info->flashtype;
 
-       if (u32_flash_type == fm3_flash_type1) {
+       if (u32_flash_type == FM3_FLASH_TYPE1) {
                u32_flash_seq_address1 = 0x00001550;
                u32_flash_seq_address2 = 0x00000AA8;
-       } else if (u32_flash_type == fm3_flash_type2) {
+       } else if (u32_flash_type == FM3_FLASH_TYPE2) {
                u32_flash_seq_address1 = 0x00000AA8;
                u32_flash_seq_address2 = 0x00000554;
        } else {
@@ -368,10 +368,10 @@ static int fm3_write_block(struct flash_bank *bank, const uint8_t *buffer,
 
        u32_flash_type = (uint32_t) fm3_info->flashtype;
 
-       if (u32_flash_type == fm3_flash_type1) {
+       if (u32_flash_type == FM3_FLASH_TYPE1) {
                u32_flash_seq_address1 = 0x00001550;
                u32_flash_seq_address2 = 0x00000AA8;
-       } else if (u32_flash_type == fm3_flash_type2) {
+       } else if (u32_flash_type == FM3_FLASH_TYPE2) {
                u32_flash_seq_address1 = 0x00000AA8;
                u32_flash_seq_address2 = 0x00000554;
        } else {
@@ -673,8 +673,8 @@ static int fm3_probe(struct flash_bank *bank)
        bank->sectors[1].is_erased = -1;
        bank->sectors[1].is_protected = -1;
 
-       if ((fm3_info->variant == mb9bfxx1)
-           || (fm3_info->variant == mb9afxx1)) {
+       if ((fm3_info->variant == MB9BFXX1)
+           || (fm3_info->variant == MB9AFXX1)) {
                num_pages = 3;
                bank->size = 64 * 1024; /* bytes */
                bank->num_sectors = num_pages;
@@ -685,18 +685,18 @@ static int fm3_probe(struct flash_bank *bank)
                bank->sectors[2].is_protected = -1;
        }
 
-       if ((fm3_info->variant == mb9bfxx2)
-               || (fm3_info->variant == mb9bfxx4)
-               || (fm3_info->variant == mb9bfxx5)
-               || (fm3_info->variant == mb9bfxx6)
-               || (fm3_info->variant == mb9bfxx7)
-               || (fm3_info->variant == mb9bfxx8)
-               || (fm3_info->variant == mb9afxx2)
-               || (fm3_info->variant == mb9afxx4)
-               || (fm3_info->variant == mb9afxx5)
-               || (fm3_info->variant == mb9afxx6)
-               || (fm3_info->variant == mb9afxx7)
-               || (fm3_info->variant == mb9afxx8)) {
+       if ((fm3_info->variant == MB9BFXX2)
+               || (fm3_info->variant == MB9BFXX4)
+               || (fm3_info->variant == MB9BFXX5)
+               || (fm3_info->variant == MB9BFXX6)
+               || (fm3_info->variant == MB9BFXX7)
+               || (fm3_info->variant == MB9BFXX8)
+               || (fm3_info->variant == MB9AFXX2)
+               || (fm3_info->variant == MB9AFXX4)
+               || (fm3_info->variant == MB9AFXX5)
+               || (fm3_info->variant == MB9AFXX6)
+               || (fm3_info->variant == MB9AFXX7)
+               || (fm3_info->variant == MB9AFXX8)) {
                num_pages = 3;
                bank->size = 128 * 1024; /* bytes */
                bank->num_sectors = num_pages;
@@ -707,16 +707,16 @@ static int fm3_probe(struct flash_bank *bank)
                bank->sectors[2].is_protected = -1;
        }
 
-       if ((fm3_info->variant == mb9bfxx4)
-               || (fm3_info->variant == mb9bfxx5)
-               || (fm3_info->variant == mb9bfxx6)
-               || (fm3_info->variant == mb9bfxx7)
-               || (fm3_info->variant == mb9bfxx8)
-               || (fm3_info->variant == mb9afxx4)
-               || (fm3_info->variant == mb9afxx5)
-               || (fm3_info->variant == mb9afxx6)
-               || (fm3_info->variant == mb9afxx7)
-               || (fm3_info->variant == mb9afxx8)) {
+       if ((fm3_info->variant == MB9BFXX4)
+               || (fm3_info->variant == MB9BFXX5)
+               || (fm3_info->variant == MB9BFXX6)
+               || (fm3_info->variant == MB9BFXX7)
+               || (fm3_info->variant == MB9BFXX8)
+               || (fm3_info->variant == MB9AFXX4)
+               || (fm3_info->variant == MB9AFXX5)
+               || (fm3_info->variant == MB9AFXX6)
+               || (fm3_info->variant == MB9AFXX7)
+               || (fm3_info->variant == MB9AFXX8)) {
                num_pages = 4;
                bank->size = 256 * 1024; /* bytes */
                bank->num_sectors = num_pages;
@@ -727,14 +727,14 @@ static int fm3_probe(struct flash_bank *bank)
                bank->sectors[3].is_protected = -1;
        }
 
-       if ((fm3_info->variant == mb9bfxx5)
-               || (fm3_info->variant == mb9bfxx6)
-               || (fm3_info->variant == mb9bfxx7)
-               || (fm3_info->variant == mb9bfxx8)
-               || (fm3_info->variant == mb9afxx5)
-               || (fm3_info->variant == mb9afxx6)
-               || (fm3_info->variant == mb9afxx7)
-               || (fm3_info->variant == mb9afxx8)) {
+       if ((fm3_info->variant == MB9BFXX5)
+               || (fm3_info->variant == MB9BFXX6)
+               || (fm3_info->variant == MB9BFXX7)
+               || (fm3_info->variant == MB9BFXX8)
+               || (fm3_info->variant == MB9AFXX5)
+               || (fm3_info->variant == MB9AFXX6)
+               || (fm3_info->variant == MB9AFXX7)
+               || (fm3_info->variant == MB9AFXX8)) {
                num_pages = 5;
                bank->size = 384 * 1024; /* bytes */
                bank->num_sectors = num_pages;
@@ -745,12 +745,12 @@ static int fm3_probe(struct flash_bank *bank)
                bank->sectors[4].is_protected = -1;
        }
 
-       if ((fm3_info->variant == mb9bfxx6)
-               || (fm3_info->variant == mb9bfxx7)
-               || (fm3_info->variant == mb9bfxx8)
-               || (fm3_info->variant == mb9afxx6)
-               || (fm3_info->variant == mb9afxx7)
-               || (fm3_info->variant == mb9afxx8)) {
+       if ((fm3_info->variant == MB9BFXX6)
+               || (fm3_info->variant == MB9BFXX7)
+               || (fm3_info->variant == MB9BFXX8)
+               || (fm3_info->variant == MB9AFXX6)
+               || (fm3_info->variant == MB9AFXX7)
+               || (fm3_info->variant == MB9AFXX8)) {
                num_pages = 6;
                bank->size = 512 * 1024; /* bytes */
                bank->num_sectors = num_pages;
@@ -761,10 +761,10 @@ static int fm3_probe(struct flash_bank *bank)
                bank->sectors[5].is_protected = -1;
        }
 
-       if ((fm3_info->variant == mb9bfxx7)
-               || (fm3_info->variant == mb9bfxx8)
-               || (fm3_info->variant == mb9afxx7)
-               || (fm3_info->variant == mb9afxx8)) {
+       if ((fm3_info->variant == MB9BFXX7)
+               || (fm3_info->variant == MB9BFXX8)
+               || (fm3_info->variant == MB9AFXX7)
+               || (fm3_info->variant == MB9AFXX8)) {
                num_pages = 8;
                bank->size = 768 * 1024; /* bytes */
                bank->num_sectors = num_pages;
@@ -780,8 +780,8 @@ static int fm3_probe(struct flash_bank *bank)
                bank->sectors[7].is_protected = -1;
        }
 
-       if ((fm3_info->variant == mb9bfxx8)
-               || (fm3_info->variant == mb9afxx8)) {
+       if ((fm3_info->variant == MB9BFXX8)
+               || (fm3_info->variant == MB9AFXX8)) {
                num_pages = 10;
                bank->size = 1024 * 1024; /* bytes */
                bank->num_sectors = num_pages;
@@ -827,11 +827,11 @@ static int fm3_chip_erase(struct flash_bank *bank)
 
        u32_flash_type = (uint32_t) fm3_info2->flashtype;
 
-       if (u32_flash_type == fm3_flash_type1) {
+       if (u32_flash_type == FM3_FLASH_TYPE1) {
                LOG_INFO("*** Erasing mb9bfxxx type");
                u32_flash_seq_address1 = 0x00001550;
                u32_flash_seq_address2 = 0x00000AA8;
-       } else if (u32_flash_type == fm3_flash_type2) {
+       } else if (u32_flash_type == FM3_FLASH_TYPE2) {
                LOG_INFO("*** Erasing mb9afxxx type");
                u32_flash_seq_address1 = 0x00000AA8;
                u32_flash_seq_address2 = 0x00000554;
diff --git a/src/flash/nor/fm4.c b/src/flash/nor/fm4.c
index 2c51e007f13a7126e5f6f92d0928751419e448f5..592ccb6033992971926c15cf9180c76f8c244067 100644 (file)
--- a/src/flash/nor/fm4.c
+++ b/src/flash/nor/fm4.c
@@ -28,17 +28,17 @@
 #define WDG_LCK (WDG_BASE + 0xC00)
 
 enum fm4_variant {
-       mb9bfx64,
-       mb9bfx65,
-       mb9bfx66,
-       mb9bfx67,
-       mb9bfx68,
+       MB9BFX64,
+       MB9BFX65,
+       MB9BFX66,
+       MB9BFX67,
+       MB9BFX68,
 
-       s6e2cx8,
-       s6e2cx9,
-       s6e2cxa,
+       S6E2CX8,
+       S6E2CX9,
+       S6E2CXA,
 
-       s6e2dx,
+       S6E2DX,
 };
 
 struct fm4_flash_bank {
@@ -350,19 +350,19 @@ static int mb9bf_probe(struct flash_bank *bank)
        uint32_t flash_addr = bank->base;
 
        switch (fm4_bank->variant) {
-       case mb9bfx64:
+       case MB9BFX64:
                bank->num_sectors = 8;
                break;
-       case mb9bfx65:
+       case MB9BFX65:
                bank->num_sectors = 10;
                break;
-       case mb9bfx66:
+       case MB9BFX66:
                bank->num_sectors = 12;
                break;
-       case mb9bfx67:
+       case MB9BFX67:
                bank->num_sectors = 16;
                break;
-       case mb9bfx68:
+       case MB9BFX68:
                bank->num_sectors = 20;
                break;
        default:
@@ -421,13 +421,13 @@ static int s6e2cc_probe(struct flash_bank *bank)
        }
 
        switch (fm4_bank->variant) {
-       case s6e2cx8:
+       case S6E2CX8:
                num_sectors = (fm4_bank->macro_nr == 0) ? 20 : 0;
                break;
-       case s6e2cx9:
+       case S6E2CX9:
                num_sectors = (fm4_bank->macro_nr == 0) ? 20 : 12;
                break;
-       case s6e2cxa:
+       case S6E2CXA:
                num_sectors = 20;
                break;
        default:
@@ -503,19 +503,19 @@ static int fm4_probe(struct flash_bank *bank)
        }
 
        switch (fm4_bank->variant) {
-       case mb9bfx64:
-       case mb9bfx65:
-       case mb9bfx66:
-       case mb9bfx67:
-       case mb9bfx68:
+       case MB9BFX64:
+       case MB9BFX65:
+       case MB9BFX66:
+       case MB9BFX67:
+       case MB9BFX68:
                retval = mb9bf_probe(bank);
                break;
-       case s6e2cx8:
-       case s6e2cx9:
-       case s6e2cxa:
+       case S6E2CX8:
+       case S6E2CX9:
+       case S6E2CXA:
                retval = s6e2cc_probe(bank);
                break;
-       case s6e2dx:
+       case S6E2DX:
                retval = s6e2dh_probe(bank);
                break;
        default:
@@ -550,31 +550,31 @@ static int fm4_get_info_command(struct flash_bank *bank, struct command_invocati
        }
 
        switch (fm4_bank->variant) {
-       case mb9bfx64:
+       case MB9BFX64:
                name = "MB9BFx64";
                break;
-       case mb9bfx65:
+       case MB9BFX65:
                name = "MB9BFx65";
                break;
-       case mb9bfx66:
+       case MB9BFX66:
                name = "MB9BFx66";
                break;
-       case mb9bfx67:
+       case MB9BFX67:
                name = "MB9BFx67";
                break;
-       case mb9bfx68:
+       case MB9BFX68:
                name = "MB9BFx68";
                break;
-       case s6e2cx8:
+       case S6E2CX8:
                name = "S6E2Cx8";
                break;
-       case s6e2cx9:
+       case S6E2CX9:
                name = "S6E2Cx9";
                break;
-       case s6e2cxa:
+       case S6E2CXA:
                name = "S6E2CxA";
                break;
-       case s6e2dx:
+       case S6E2DX:
                name = "S6E2Dx";
                break;
        default:
@@ -583,9 +583,9 @@ static int fm4_get_info_command(struct flash_bank *bank, struct command_invocati
        }
 
        switch (fm4_bank->variant) {
-       case s6e2cx8:
-       case s6e2cx9:
-       case s6e2cxa:
+       case S6E2CX8:
+       case S6E2CX9:
+       case S6E2CXA:
                command_print_sameline(cmd, "%s MainFlash Macro #%i", name, fm4_bank->macro_nr);
                break;
        default:
@@ -617,15 +617,15 @@ static int mb9bf_bank_setup(struct flash_bank *bank, const char *variant)
        struct fm4_flash_bank *fm4_bank = bank->driver_priv;
 
        if (fm4_name_match(variant, "MB9BFx64")) {
-               fm4_bank->variant = mb9bfx64;
+               fm4_bank->variant = MB9BFX64;
        } else if (fm4_name_match(variant, "MB9BFx65")) {
-               fm4_bank->variant = mb9bfx65;
+               fm4_bank->variant = MB9BFX65;
        } else if (fm4_name_match(variant, "MB9BFx66")) {
-               fm4_bank->variant = mb9bfx66;
+               fm4_bank->variant = MB9BFX66;
        } else if (fm4_name_match(variant, "MB9BFx67")) {
-               fm4_bank->variant = mb9bfx67;
+               fm4_bank->variant = MB9BFX67;
        } else if (fm4_name_match(variant, "MB9BFx68")) {
-               fm4_bank->variant = mb9bfx68;
+               fm4_bank->variant = MB9BFX68;
        } else {
                LOG_WARNING("MB9BF variant %s not recognized.", variant);
                return ERROR_FLASH_OPER_UNSUPPORTED;
@@ -639,11 +639,11 @@ static int s6e2cc_bank_setup(struct flash_bank *bank, const char *variant)
        struct fm4_flash_bank *fm4_bank = bank->driver_priv;
 
        if (fm4_name_match(variant, "S6E2Cx8")) {
-               fm4_bank->variant = s6e2cx8;
+               fm4_bank->variant = S6E2CX8;
        } else if (fm4_name_match(variant, "S6E2Cx9")) {
-               fm4_bank->variant = s6e2cx9;
+               fm4_bank->variant = S6E2CX9;
        } else if (fm4_name_match(variant, "S6E2CxA")) {
-               fm4_bank->variant = s6e2cxa;
+               fm4_bank->variant = S6E2CXA;
        } else {
                LOG_WARNING("S6E2CC variant %s not recognized.", variant);
                return ERROR_FLASH_OPER_UNSUPPORTED;
@@ -677,7 +677,7 @@ FLASH_BANK_COMMAND_HANDLER(fm4_flash_bank_command)
        else if (fm4_name_match(variant, "S6E2Cx"))
                ret = s6e2cc_bank_setup(bank, variant);
        else if (fm4_name_match(variant, "S6E2Dx")) {
-               fm4_bank->variant = s6e2dx;
+               fm4_bank->variant = S6E2DX;
                ret = ERROR_OK;
        } else {
                LOG_WARNING("Family %s not recognized.", variant);
diff --git a/src/flash/nor/lpc2000.c b/src/flash/nor/lpc2000.c
index 28dc5c3b363a47713e4fb760f7b621c99da52e83..754957e54f7d7af0ac22bcde99d883ee68ce1e68 100644 (file)
--- a/src/flash/nor/lpc2000.c
+++ b/src/flash/nor/lpc2000.c
@@ -284,15 +284,15 @@
 #define LPC11XX_REG_SECTORS    24
 
 typedef enum {
-       lpc2000_v1,
-       lpc2000_v2,
-       lpc1700,
-       lpc4300,
-       lpc800,
-       lpc1100,
-       lpc1500,
-       lpc54100,
-       lpc_auto,
+       LPC2000_V1,
+       LPC2000_V2,
+       LPC1700,
+       LPC4300,
+       LPC800,
+       LPC1100,
+       LPC1500,
+       LPC54100,
+       LPC_AUTO,
 } lpc2000_variant;
 
 struct lpc2000_flash_bank {
@@ -342,7 +342,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
        /* default to a 4096 write buffer */
        lpc2000_info->cmd51_max_buffer = 4096;
 
-       if (lpc2000_info->variant == lpc2000_v1) {
+       if (lpc2000_info->variant == LPC2000_V1) {
                lpc2000_info->cmd51_dst_boundary = 512;
                lpc2000_info->checksum_vector = 5;
                lpc2000_info->iap_max_stack = 128;
@@ -387,7 +387,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                        LOG_ERROR("BUG: unknown bank->size encountered");
                        exit(-1);
                }
-       } else if (lpc2000_info->variant == lpc2000_v2) {
+       } else if (lpc2000_info->variant == LPC2000_V2) {
                lpc2000_info->cmd51_dst_boundary = 256;
                lpc2000_info->checksum_vector = 5;
                lpc2000_info->iap_max_stack = 128;
@@ -453,7 +453,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                                bank->sectors[i].is_protected = 1;
                        }
                }
-       } else if (lpc2000_info->variant == lpc1700) {
+       } else if (lpc2000_info->variant == LPC1700) {
                lpc2000_info->cmd51_dst_boundary = 256;
                lpc2000_info->checksum_vector = 7;
                lpc2000_info->iap_max_stack = 128;
@@ -502,7 +502,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                        bank->sectors[i].is_erased = -1;
                        bank->sectors[i].is_protected = 1;
                }
-       } else if (lpc2000_info->variant == lpc4300) {
+       } else if (lpc2000_info->variant == LPC4300) {
                lpc2000_info->cmd51_dst_boundary = 512;
                lpc2000_info->checksum_vector = 7;
                lpc2000_info->iap_max_stack = 208;
@@ -533,7 +533,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                        bank->sectors[i].is_protected = 1;
                }
 
-       } else if (lpc2000_info->variant == lpc800) {
+       } else if (lpc2000_info->variant == LPC800) {
                lpc2000_info->cmd51_dst_boundary = 64;
                lpc2000_info->checksum_vector = 7;
                lpc2000_info->iap_max_stack = 208;              /* 148byte for LPC81x,208byte for LPC82x. */
@@ -577,7 +577,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                        bank->sectors[i].is_protected = 1;
                }
 
-       } else if (lpc2000_info->variant == lpc1100) {
+       } else if (lpc2000_info->variant == LPC1100) {
                lpc2000_info->cmd51_dst_boundary = 256;
                lpc2000_info->checksum_vector = 7;
                lpc2000_info->iap_max_stack = 128;
@@ -607,7 +607,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                        bank->sectors[i].is_protected = 1;
                }
 
-       } else if (lpc2000_info->variant == lpc1500) {
+       } else if (lpc2000_info->variant == LPC1500) {
                lpc2000_info->cmd51_dst_boundary = 256;
                lpc2000_info->checksum_vector = 7;
                lpc2000_info->iap_max_stack = 128;
@@ -638,7 +638,7 @@ static int lpc2000_build_sector_list(struct flash_bank *bank)
                        bank->sectors[i].is_protected = 1;
                }
 
-       } else if (lpc2000_info->variant == lpc54100) {
+       } else if (lpc2000_info->variant == LPC54100) {
                lpc2000_info->cmd51_dst_boundary = 256;
                lpc2000_info->checksum_vector = 7;
                lpc2000_info->iap_max_stack = 128;
@@ -697,18 +697,18 @@ static int lpc2000_iap_working_area_init(struct flash_bank *bank, struct working
 
        /* write IAP code to working area */
        switch (lpc2000_info->variant) {
-               case lpc800:
-               case lpc1100:
-               case lpc1500:
-               case lpc1700:
-               case lpc4300:
-               case lpc54100:
-               case lpc_auto:
+               case LPC800:
+               case LPC1100:
+               case LPC1500:
+               case LPC1700:
+               case LPC4300:
+               case LPC54100:
+               case LPC_AUTO:
                        target_buffer_set_u32(target, jump_gate, ARMV4_5_T_BX(12));
                        target_buffer_set_u32(target, jump_gate + 4, ARMV5_T_BKPT(0));
                        break;
-               case lpc2000_v1:
-               case lpc2000_v2:
+               case LPC2000_V1:
+               case LPC2000_V2:
                        target_buffer_set_u32(target, jump_gate, ARMV4_5_BX(12));
                        target_buffer_set_u32(target, jump_gate + 4, ARMV4_5_B(0xfffffe, 0));
                        break;
@@ -740,28 +740,28 @@ static int lpc2000_iap_call(struct flash_bank *bank, struct working_area *iap_wo
        uint32_t iap_entry_point = 0;   /* to make compiler happier */
 
        switch (lpc2000_info->variant) {
-               case lpc800:
-               case lpc1100:
-               case lpc1700:
-               case lpc_auto:
+               case LPC800:
+               case LPC1100:
+               case LPC1700:
+               case LPC_AUTO:
                        armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
                        armv7m_info.core_mode = ARM_MODE_THREAD;
                        iap_entry_point = 0x1fff1ff1;
                        break;
-               case lpc1500:
-               case lpc54100:
+               case LPC1500:
+               case LPC54100:
                        armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
                        armv7m_info.core_mode = ARM_MODE_THREAD;
                        iap_entry_point = 0x03000205;
                        break;
-               case lpc2000_v1:
-               case lpc2000_v2:
+               case LPC2000_V1:
+               case LPC2000_V2:
                        arm_algo.common_magic = ARM_COMMON_MAGIC;
                        arm_algo.core_mode = ARM_MODE_SVC;
                        arm_algo.core_state = ARM_STATE_ARM;
                        iap_entry_point = 0x7ffffff1;
                        break;
-               case lpc4300:
+               case LPC4300:
                        armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
                        armv7m_info.core_mode = ARM_MODE_THREAD;
                        /* read out IAP entry point from ROM driver table at 0x10400100 */
@@ -802,13 +802,13 @@ static int lpc2000_iap_call(struct flash_bank *bank, struct working_area *iap_wo
        buf_set_u32(reg_params[2].value, 0, 32, iap_entry_point);
 
        switch (lpc2000_info->variant) {
-               case lpc800:
-               case lpc1100:
-               case lpc1500:
-               case lpc1700:
-               case lpc4300:
-               case lpc54100:
-               case lpc_auto:
+               case LPC800:
+               case LPC1100:
+               case LPC1500:
+               case LPC1700:
+               case LPC4300:
+               case LPC54100:
+               case LPC_AUTO:
                        /* IAP stack */
                        init_reg_param(&reg_params[3], "sp", 32, PARAM_OUT);
                        buf_set_u32(reg_params[3].value, 0, 32,
@@ -822,8 +822,8 @@ static int lpc2000_iap_call(struct flash_bank *bank, struct working_area *iap_wo
                        target_run_algorithm(target, 2, mem_params, 5, reg_params, iap_working_area->address, 0, 10000,
                                        &armv7m_info);
                        break;
-               case lpc2000_v1:
-               case lpc2000_v2:
+               case LPC2000_V1:
+               case LPC2000_V2:
                        /* IAP stack */
                        init_reg_param(&reg_params[3], "sp_svc", 32, PARAM_OUT);
                        buf_set_u32(reg_params[3].value, 0, 32,
@@ -879,7 +879,7 @@ static int lpc2000_iap_blank_check(struct flash_bank *bank, unsigned int first,
                return retval;
 
        struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
-       if (lpc2000_info->variant == lpc4300)
+       if (lpc2000_info->variant == LPC4300)
                param_table[2] = lpc2000_info->lpc4300_bank;
 
        for (unsigned int i = first; i <= last && retval == ERROR_OK; i++) {
@@ -929,23 +929,23 @@ FLASH_BANK_COMMAND_HANDLER(lpc2000_flash_bank_command)
        bank->driver_priv = lpc2000_info;
 
        if (strcmp(CMD_ARGV[6], "lpc2000_v1") == 0) {
-               lpc2000_info->variant = lpc2000_v1;
+               lpc2000_info->variant = LPC2000_V1;
        } else if (strcmp(CMD_ARGV[6], "lpc2000_v2") == 0) {
-               lpc2000_info->variant = lpc2000_v2;
+               lpc2000_info->variant = LPC2000_V2;
        } else if (strcmp(CMD_ARGV[6], "lpc1700") == 0 || strcmp(CMD_ARGV[6], "lpc4000") == 0) {
-               lpc2000_info->variant = lpc1700;
+               lpc2000_info->variant = LPC1700;
        } else if (strcmp(CMD_ARGV[6], "lpc1800") == 0 || strcmp(CMD_ARGV[6], "lpc4300") == 0) {
-               lpc2000_info->variant = lpc4300;
+               lpc2000_info->variant = LPC4300;
        } else if (strcmp(CMD_ARGV[6], "lpc800") == 0) {
-               lpc2000_info->variant = lpc800;
+               lpc2000_info->variant = LPC800;
        } else if (strcmp(CMD_ARGV[6], "lpc1100") == 0) {
-               lpc2000_info->variant = lpc1100;
+               lpc2000_info->variant = LPC1100;
        } else if (strcmp(CMD_ARGV[6], "lpc1500") == 0) {
-               lpc2000_info->variant = lpc1500;
+               lpc2000_info->variant = LPC1500;
        } else if (strcmp(CMD_ARGV[6], "lpc54100") == 0) {
-               lpc2000_info->variant = lpc54100;
+               lpc2000_info->variant = LPC54100;
        } else if (strcmp(CMD_ARGV[6], "auto") == 0) {
-               lpc2000_info->variant = lpc_auto;
+               lpc2000_info->variant = LPC_AUTO;
        } else {
                LOG_ERROR("unknown LPC2000 variant: %s", CMD_ARGV[6]);
                free(lpc2000_info);
@@ -993,7 +993,7 @@ static int lpc2000_erase(struct flash_bank *bank, unsigned int first,
        param_table[0] = first;
        param_table[1] = last;
 
-       if (lpc2000_info->variant == lpc4300)
+       if (lpc2000_info->variant == LPC4300)
                param_table[2] = lpc2000_info->lpc4300_bank;
        else
                param_table[2] = lpc2000_info->cclk;
@@ -1006,7 +1006,7 @@ static int lpc2000_erase(struct flash_bank *bank, unsigned int first,
        if (retval != ERROR_OK)
                return retval;
 
-       if (lpc2000_info->variant == lpc4300)
+       if (lpc2000_info->variant == LPC4300)
                /* Init IAP Anyway */
                lpc2000_iap_call(bank, iap_working_area, 49, param_table, result_table);
 
@@ -1030,7 +1030,7 @@ static int lpc2000_erase(struct flash_bank *bank, unsigned int first,
        if (retval == ERROR_OK) {
                /* Erase sectors */
                param_table[2] = lpc2000_info->cclk;
-               if (lpc2000_info->variant == lpc4300)
+               if (lpc2000_info->variant == LPC4300)
                        param_table[3] = lpc2000_info->lpc4300_bank;
 
                status_code = lpc2000_iap_call(bank, iap_working_area, 52, param_table, result_table);
@@ -1134,7 +1134,7 @@ static int lpc2000_write(struct flash_bank *bank, const uint8_t *buffer, uint32_
        uint32_t param_table[5] = {0};
        uint32_t result_table[4];
 
-       if (lpc2000_info->variant == lpc4300)
+       if (lpc2000_info->variant == LPC4300)
                /* Init IAP Anyway */
                lpc2000_iap_call(bank, iap_working_area, 49, param_table, result_table);
 
@@ -1149,7 +1149,7 @@ static int lpc2000_write(struct flash_bank *bank, const uint8_t *buffer, uint32_
                param_table[0] = first_sector;
                param_table[1] = last_sector;
 
-               if (lpc2000_info->variant == lpc4300)
+               if (lpc2000_info->variant == LPC4300)
                        param_table[2] = lpc2000_info->lpc4300_bank;
                else
                        param_table[2] = lpc2000_info->cclk;
@@ -1280,7 +1280,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
        switch (part_id) {
                case LPC1110_1:
                case LPC1110_2:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 4 * 1024;
                        break;
 
@@ -1296,7 +1296,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC11E11_101:
                case LPC1311:
                case LPC1311_1:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 8 * 1024;
                        break;
 
@@ -1316,7 +1316,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC11U12_201_1:
                case LPC11U12_201_2:
                case LPC1342:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 16 * 1024;
                        break;
 
@@ -1331,7 +1331,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC11U13_201_1:
                case LPC11U13_201_2:
                case LPC11U23_301:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 24 * 1024;
                        break;
 
@@ -1359,18 +1359,18 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC1343:
                case LPC1343_1:
                case LPC1345:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 32 * 1024;
                        break;
 
                case LPC1751_1:
                case LPC1751_2:
-                       lpc2000_info->variant = lpc1700;
+                       lpc2000_info->variant = LPC1700;
                        bank->size = 32 * 1024;
                        break;
 
                case LPC11U34_311:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 40 * 1024;
                        break;
 
@@ -1378,12 +1378,12 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC11U34_421:
                case LPC1316:
                case LPC1346:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 48 * 1024;
                        break;
 
                case LPC1114_333_1:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 56 * 1024;
                        break;
 
@@ -1394,19 +1394,19 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC11U66:
                case LPC1317:
                case LPC1347:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 64 * 1024;
                        break;
 
                case LPC1752:
                case LPC4072:
-                       lpc2000_info->variant = lpc1700;
+                       lpc2000_info->variant = LPC1700;
                        bank->size = 64 * 1024;
                        break;
 
                case LPC11E36_501:
                case LPC11U36_401:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 96 * 1024;
                        break;
 
@@ -1419,7 +1419,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC11E68:
                case LPC11U67_1:
                case LPC11U67_2:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 128 * 1024;
                        break;
 
@@ -1427,13 +1427,13 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC1764:
                case LPC1774:
                case LPC4074:
-                       lpc2000_info->variant = lpc1700;
+                       lpc2000_info->variant = LPC1700;
                        bank->size = 128 * 1024;
                        break;
 
                case LPC11U68_1:
                case LPC11U68_2:
-                       lpc2000_info->variant = lpc1100;
+                       lpc2000_info->variant = LPC1100;
                        bank->size = 256 * 1024;
                        break;
 
@@ -1445,7 +1445,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC1785:
                case LPC1786:
                case LPC4076:
-                       lpc2000_info->variant = lpc1700;
+                       lpc2000_info->variant = LPC1700;
                        bank->size = 256 * 1024;
                        break;
 
@@ -1460,17 +1460,17 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC1788:
                case LPC4078:
                case LPC4088:
-                       lpc2000_info->variant = lpc1700;
+                       lpc2000_info->variant = LPC1700;
                        bank->size = 512 * 1024;
                        break;
 
                case LPC810_021:
-                       lpc2000_info->variant = lpc800;
+                       lpc2000_info->variant = LPC800;
                        bank->size = 4 * 1024;
                        break;
 
                case LPC811_001:
-                       lpc2000_info->variant = lpc800;
+                       lpc2000_info->variant = LPC800;
                        bank->size = 8 * 1024;
                        break;
 
@@ -1480,13 +1480,13 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC812_101_3:
                case LPC822_101:
                case LPC822_101_1:
-                       lpc2000_info->variant = lpc800;
+                       lpc2000_info->variant = LPC800;
                        bank->size = 16 * 1024;
                        break;
 
                case LPC824_201:
                case LPC824_201_1:
-                       lpc2000_info->variant = lpc800;
+                       lpc2000_info->variant = LPC800;
                        bank->size = 32 * 1024;
                        break;
 
@@ -1494,7 +1494,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case NHS3100:
                case NHS3152:
                case NHS3153:
-                       lpc2000_info->variant = lpc800;
+                       lpc2000_info->variant = LPC800;
                        bank->size = 30 * 1024;
                        break;
 
@@ -1505,7 +1505,7 @@ static int lpc2000_auto_probe_flash(struct flash_bank *bank)
                case LPC845_301_1:
                case LPC845_301_2:
                case LPC845_301_3:
-                       lpc2000_info->variant = lpc800;
+                       lpc2000_info->variant = LPC800;
                        bank->size = 64 * 1024;
                        break;
 
@@ -1524,11 +1524,11 @@ static int lpc2000_probe(struct flash_bank *bank)
        struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
 
        if (!lpc2000_info->probed) {
-               if (lpc2000_info->variant == lpc_auto) {
+               if (lpc2000_info->variant == LPC_AUTO) {
                        status = lpc2000_auto_probe_flash(bank);
                        if (status != ERROR_OK)
                                return status;
-               } else if (lpc2000_info->variant == lpc1100 || lpc2000_info->variant == lpc1700) {
+               } else if (lpc2000_info->variant == LPC1100 || lpc2000_info->variant == LPC1700) {
                        status = get_lpc2000_part_id(bank, &part_id);
                        if (status == LPC2000_CMD_SUCCESS)
                                LOG_INFO("If auto-detection fails for this part, please email "
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)