Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
- rename log functions to stop conflicts under win32 (wingdi)
[openocd.git] / src / flash / lpc2000.c
diff --git a/src/flash/lpc2000.c b/src/flash/lpc2000.c
index 16e20e2a6777db50bdbe3802bc43010bcbf1501f..3424374d4a51665cdb461a74059b78a374594733 100644 (file)
--- a/src/flash/lpc2000.c
+++ b/src/flash/lpc2000.c
@@ -47,6 +47,8 @@
  * - 213x
  * - 214x
  * - 2101|2|3
+ * - 2364|6|8
+ * - 2378
  */
 
 int lpc2000_register_commands(struct command_context_s *cmd_ctx);
@@ -70,6 +72,7 @@ flash_driver_t lpc2000_flash =
        .protect = lpc2000_protect,
        .write = lpc2000_write,
        .probe = lpc2000_probe,
+       .auto_probe = lpc2000_probe,
        .erase_check = lpc2000_erase_check,
        .protect_check = lpc2000_protect_check,
        .info = lpc2000_info
@@ -88,7 +91,10 @@ int lpc2000_register_commands(struct command_context_s *cmd_ctx)
 int lpc2000_build_sector_list(struct flash_bank_s *bank)
 {
        lpc2000_flash_bank_t *lpc2000_info = bank->driver_priv;
-
+       
+       /* default to a 4096 write buffer */
+       lpc2000_info->cmd51_max_buffer = 4096;
+       
        if (lpc2000_info->variant == 1)
        {
                int i = 0;
@@ -140,7 +146,7 @@ int lpc2000_build_sector_list(struct flash_bank_s *bank)
                }
                else
                {
-                       ERROR("BUG: unknown bank->size encountered");
+                       LOG_ERROR("BUG: unknown bank->size encountered");
                        exit(-1);
                }
        }
@@ -153,7 +159,12 @@ int lpc2000_build_sector_list(struct flash_bank_s *bank)
                /* variant 2 has a uniform layout, only number of sectors differs */
                switch (bank->size)
                {
+                       case 4 * 1024:
+                               lpc2000_info->cmd51_max_buffer = 1024;
+                               num_sectors = 1;
+                               break;
                        case 8 * 1024:
+                               lpc2000_info->cmd51_max_buffer = 1024;
                                num_sectors = 2;
                                break;
                        case 16 * 1024:
@@ -171,18 +182,19 @@ int lpc2000_build_sector_list(struct flash_bank_s *bank)
                        case 256 * 1024:
                                num_sectors = 15;
                                break;
+                       case 512 * 1024:
                        case 500 * 1024:
                                num_sectors = 27;
                                break;
                        default:
-                               ERROR("BUG: unknown bank->size encountered");
+                               LOG_ERROR("BUG: unknown bank->size encountered");
                                exit(-1);
                                break;
                }
                
                bank->num_sectors = num_sectors;
                bank->sectors = malloc(sizeof(flash_sector_t) * num_sectors);
-
+               
                for (i = 0; i < num_sectors; i++)
                {
                        if ((i >= 0) && (i < 8))
@@ -213,7 +225,7 @@ int lpc2000_build_sector_list(struct flash_bank_s *bank)
        }
        else
        {
-               ERROR("BUG: unknown lpc2000_info->variant encountered");
+               LOG_ERROR("BUG: unknown lpc2000_info->variant encountered");
                exit(-1);
        }
        
@@ -230,7 +242,7 @@ int lpc2000_build_sector_list(struct flash_bank_s *bank)
 int lpc2000_iap_call(flash_bank_t *bank, int code, u32 param_table[5], u32 result_table[2])
 {
        lpc2000_flash_bank_t *lpc2000_info = bank->driver_priv;
-       target_t *target = lpc2000_info->target;
+       target_t *target = bank->target;
        mem_param_t mem_params[2];
        reg_param_t reg_params[5];
        armv4_5_algorithm_t armv4_5_info;
@@ -244,7 +256,7 @@ int lpc2000_iap_call(flash_bank_t *bank, int code, u32 param_table[5], u32 resul
                /* make sure we have a working area */
                if (target_alloc_working_area(target, 172, &lpc2000_info->iap_working_area) != ERROR_OK)
                {
-                       ERROR("no working area specified, can't write LPC2000 internal flash");
+                       LOG_ERROR("no working area specified, can't write LPC2000 internal flash");
                        return ERROR_FLASH_OPERATION_FAILED;
                }
                
@@ -339,7 +351,7 @@ int lpc2000_iap_blank_check(struct flash_bank_s *bank, int first, int last)
                                return ERROR_FLASH_BUSY;
                                break;
                        default:
-                               ERROR("BUG: unknown LPC2000 status code");
+                               LOG_ERROR("BUG: unknown LPC2000 status code");
                                exit(-1);
                }
        }
@@ -347,7 +359,7 @@ int lpc2000_iap_blank_check(struct flash_bank_s *bank, int first, int last)
        return ERROR_OK;
 }
 
-/* flash_bank lpc2000 <base> <size> 0 0 <lpc_variant> <target#> <cclk> [calc_checksum]
+/* flash bank lpc2000 <base> <size> 0 0 <target#> <lpc_variant> <cclk> [calc_checksum]
  */
 int lpc2000_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank)
 {
@@ -355,21 +367,21 @@ int lpc2000_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, cha
        
        if (argc < 8)
        {
-               WARNING("incomplete flash_bank lpc2000 configuration");
+               LOG_WARNING("incomplete flash_bank lpc2000 configuration");
                return ERROR_FLASH_BANK_INVALID;
        }
        
        lpc2000_info = malloc(sizeof(lpc2000_flash_bank_t));
        bank->driver_priv = lpc2000_info;
        
-       if (strcmp(args[5], "lpc2000_v1") == 0)
+       if (strcmp(args[6], "lpc2000_v1") == 0)
        {
                lpc2000_info->variant = 1;
                lpc2000_info->cmd51_dst_boundary = 512;
                lpc2000_info->cmd51_can_256b = 0;
                lpc2000_info->cmd51_can_8192b = 1;
        }
-       else if (strcmp(args[5], "lpc2000_v2") == 0)
+       else if (strcmp(args[6], "lpc2000_v2") == 0)
        {
                lpc2000_info->variant = 2;
                lpc2000_info->cmd51_dst_boundary = 256;
@@ -378,23 +390,16 @@ int lpc2000_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, cha
        }
        else
        {
-               ERROR("unknown LPC2000 variant");
+               LOG_ERROR("unknown LPC2000 variant");
                free(lpc2000_info);
                return ERROR_FLASH_BANK_INVALID;
        }
        
-       lpc2000_info->target = get_target_by_num(strtoul(args[6], NULL, 0));
-       if (!lpc2000_info->target)
-       {
-               ERROR("no target '%s' configured", args[6]);
-               exit(-1);
-       }
        lpc2000_info->iap_working_area = NULL;
        lpc2000_info->cclk = strtoul(args[7], NULL, 0);
        lpc2000_info->calc_checksum = 0;
        lpc2000_build_sector_list(bank);
-       
-       
+               
        if (argc >= 9)
        {
                if (strcmp(args[8], "calc_checksum") == 0)
@@ -411,16 +416,11 @@ int lpc2000_erase(struct flash_bank_s *bank, int first, int last)
        u32 result_table[2];
        int status_code;
        
-       if (lpc2000_info->target->state != TARGET_HALTED)
+       if (bank->target->state != TARGET_HALTED)
        {
                return ERROR_TARGET_NOT_HALTED;
        }
-       
-       if ((first < 0) || (last < first) || (last >= bank->num_sectors))
-       {
-               return ERROR_FLASH_SECTOR_INVALID;
-       }
-       
+
        param_table[0] = first;
        param_table[1] = last;
        param_table[2] = lpc2000_info->cclk;
@@ -437,7 +437,7 @@ int lpc2000_erase(struct flash_bank_s *bank, int first, int last)
                        return ERROR_FLASH_SECTOR_INVALID;
                        break;
                default:
-                       WARNING("lpc2000 prepare sectors returned %i", status_code);
+                       LOG_WARNING("lpc2000 prepare sectors returned %i", status_code);
                        return ERROR_FLASH_OPERATION_FAILED;
        }
        
@@ -453,7 +453,7 @@ int lpc2000_erase(struct flash_bank_s *bank, int first, int last)
                        return ERROR_FLASH_SECTOR_INVALID;
                        break;
                default:
-                       WARNING("lpc2000 erase sectors returned %i", status_code);
+                       LOG_WARNING("lpc2000 erase sectors returned %i", status_code);
                        return ERROR_FLASH_OPERATION_FAILED;
        }
        
@@ -469,7 +469,7 @@ int lpc2000_protect(struct flash_bank_s *bank, int set, int first, int last)
 int lpc2000_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
 {
        lpc2000_flash_bank_t *lpc2000_info = bank->driver_priv;
-       target_t *target = lpc2000_info->target;
+       target_t *target = bank->target;
        u32 dst_min_alignment;
        u32 bytes_remaining = count;
        u32 bytes_written = 0;
@@ -481,15 +481,15 @@ int lpc2000_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
        int i;
        working_area_t *download_area;
                 
-       if (lpc2000_info->target->state != TARGET_HALTED)
+       if (bank->target->state != TARGET_HALTED)
        {
                return ERROR_TARGET_NOT_HALTED;
        }
-       
+
        /* allocate a working area */
-       if (target_alloc_working_area(target, 4096, &download_area) != ERROR_OK)
+       if (target_alloc_working_area(target, lpc2000_info->cmd51_max_buffer, &download_area) != ERROR_OK)
        {
-               ERROR("no working area specified, can't write LPC2000 internal flash");
+               LOG_ERROR("no working area specified, can't write LPC2000 internal flash");
                return ERROR_FLASH_OPERATION_FAILED;
        }
        
@@ -503,7 +503,7 @@ int lpc2000_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
        
        if (offset % dst_min_alignment)
        {
-               WARNING("offset 0x%x breaks required alignment 0x%x", offset, dst_min_alignment);
+               LOG_WARNING("offset 0x%x breaks required alignment 0x%x", offset, dst_min_alignment);
                return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
        }
        
@@ -515,7 +515,7 @@ int lpc2000_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
                        last_sector = i;
        }
        
-       DEBUG("first_sector: %i, last_sector: %i", first_sector, last_sector);
+       LOG_DEBUG("first_sector: %i, last_sector: %i", first_sector, last_sector);
 
        /* check if exception vectors should be flashed */
        if ((offset == 0) && (count >= 0x20) && lpc2000_info->calc_checksum)
@@ -524,20 +524,20 @@ int lpc2000_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
                int i = 0;
                for (i = 0; i < 8; i++)
                {
-                       DEBUG("0x%2.2x: 0x%8.8x", i * 4, buf_get_u32(buffer + (i * 4), 0, 32));
+                       LOG_DEBUG("0x%2.2x: 0x%8.8x", i * 4, buf_get_u32(buffer + (i * 4), 0, 32));
                        if (i != 5)
                                checksum += buf_get_u32(buffer + (i * 4), 0, 32);
                }
                checksum = 0 - checksum;
-               DEBUG("checksum: 0x%8.8x", checksum);
+               LOG_DEBUG("checksum: 0x%8.8x", checksum);
                buf_set_u32(buffer + 0x14, 0, 32, checksum);
        }
        
        while (bytes_remaining > 0)
        {
                u32 thisrun_bytes;
-               if (bytes_remaining >= 4096)
-                       thisrun_bytes = 4096;
+               if (bytes_remaining >= lpc2000_info->cmd51_max_buffer)
+                       thisrun_bytes = lpc2000_info->cmd51_max_buffer;
                else if (bytes_remaining >= 1024)
                        thisrun_bytes = 1024;
                else if ((bytes_remaining >= 512) || (!lpc2000_info->cmd51_can_256b))
@@ -559,13 +559,13 @@ int lpc2000_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
                                return ERROR_FLASH_SECTOR_INVALID;
                                break;
                        default:
-                               WARNING("lpc2000 prepare sectors returned %i", status_code);
+                               LOG_WARNING("lpc2000 prepare sectors returned %i", status_code);
                                return ERROR_FLASH_OPERATION_FAILED;
                }
                
                if (bytes_remaining >= thisrun_bytes)
                {
-                       if (target_write_buffer(lpc2000_info->target, download_area->address, thisrun_bytes, buffer + bytes_written) != ERROR_OK)
+                       if (target_write_buffer(bank->target, download_area->address, thisrun_bytes, buffer + bytes_written) != ERROR_OK)
                        {
                                target_free_working_area(target, download_area);
                                return ERROR_FLASH_OPERATION_FAILED;
@@ -578,11 +578,11 @@ int lpc2000_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
                        memcpy(last_buffer, buffer + bytes_written, bytes_remaining);
                        for (i = bytes_remaining; i < thisrun_bytes; i++)
                                last_buffer[i] = 0xff;
-                       target_write_buffer(lpc2000_info->target, download_area->address, thisrun_bytes, last_buffer);
+                       target_write_buffer(bank->target, download_area->address, thisrun_bytes, last_buffer);
                        free(last_buffer);
                }
                
-               DEBUG("writing 0x%x bytes to address 0x%x", thisrun_bytes, bank->base + offset + bytes_written);
+               LOG_DEBUG("writing 0x%x bytes to address 0x%x", thisrun_bytes, bank->base + offset + bytes_written);
                
                /* Write data */
                param_table[0] = bank->base + offset + bytes_written;
@@ -600,7 +600,7 @@ int lpc2000_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
                                return ERROR_FLASH_SECTOR_INVALID;
                                break;
                        default:
-                               WARNING("lpc2000 returned %i", status_code);
+                               LOG_WARNING("lpc2000 returned %i", status_code);
                                return ERROR_FLASH_OPERATION_FAILED;
                }
                
@@ -626,9 +626,7 @@ int lpc2000_probe(struct flash_bank_s *bank)
 
 int lpc2000_erase_check(struct flash_bank_s *bank)
 {
-       lpc2000_flash_bank_t *lpc2000_info = bank->driver_priv;
-       
-       if (lpc2000_info->target->state != TARGET_HALTED)
+       if (bank->target->state != TARGET_HALTED)
        {
                return ERROR_TARGET_NOT_HALTED;
        }
@@ -657,12 +655,10 @@ int lpc2000_handle_part_id_command(struct command_context_s *cmd_ctx, char *cmd,
        u32 param_table[5];
        u32 result_table[2];
        int status_code;
-       lpc2000_flash_bank_t *lpc2000_info;
 
        if (argc < 1)
        {
-               command_print(cmd_ctx, "usage: lpc2000 part_id <num>");
-               return ERROR_OK;
+               return ERROR_COMMAND_SYNTAX_ERROR;
        }
        
        bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
@@ -672,8 +668,7 @@ int lpc2000_handle_part_id_command(struct command_context_s *cmd_ctx, char *cmd,
                return ERROR_OK;
        }
 
-       lpc2000_info = bank->driver_priv;
-       if (lpc2000_info->target->state != TARGET_HALTED)
+       if (bank->target->state != TARGET_HALTED)
        {
                return ERROR_TARGET_NOT_HALTED;
        }
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)