#endif
#include "lpc2000.h"
-#include "armv4_5.h"
#include "armv7m.h"
#include "binarybuffer.h"
+#include "algorithm.h"
/* flash programming support for NXP LPC17xx and LPC2xxx devices
* - 176x (tested with LPC1768)
*/
-static int lpc2000_build_sector_list(struct flash_bank_s *bank)
+static int lpc2000_build_sector_list(struct flash_bank *bank)
{
- lpc2000_flash_bank_t *lpc2000_info = bank->driver_priv;
+ struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
int i;
uint32_t offset = 0;
* 0x20 to 0x33: command result table (1+4 words)
* 0x34 to 0xb3: stack (only 128b needed)
*/
-static int lpc2000_iap_call(flash_bank_t *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;
- lpc2000_flash_bank_t *lpc2000_info = bank->driver_priv;
- target_t *target = bank->target;
- mem_param_t mem_params[2];
- reg_param_t reg_params[5];
- armv4_5_algorithm_t armv4_5_info; /* for LPC2000 */
- armv7m_algorithm_t armv7m_info; /* for LPC1700 */
+ 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 armv4_5_algorithm armv4_5_info; /* for LPC2000 */
+ struct armv7m_algorithm armv7m_info; /* for LPC1700 */
uint32_t status_code;
uint32_t iap_entry_point = 0; /* to make compiler happier */
return status_code;
}
-static int lpc2000_iap_blank_check(struct flash_bank_s *bank, int first, int last)
+static int lpc2000_iap_blank_check(struct flash_bank *bank, int first, int last)
{
uint32_t param_table[5];
uint32_t result_table[4];
*/
FLASH_BANK_COMMAND_HANDLER(lpc2000_flash_bank_command)
{
- lpc2000_flash_bank_t *lpc2000_info;
+ struct lpc2000_flash_bank *lpc2000_info;
- if (argc < 8)
+ if (CMD_ARGC < 8)
{
LOG_WARNING("incomplete flash_bank lpc2000 configuration");
return ERROR_FLASH_BANK_INVALID;
}
- lpc2000_info = malloc(sizeof(lpc2000_flash_bank_t));
+ lpc2000_info = malloc(sizeof(struct lpc2000_flash_bank));
bank->driver_priv = lpc2000_info;
- if (strcmp(args[6], "lpc2000_v1") == 0)
+ if (strcmp(CMD_ARGV[6], "lpc2000_v1") == 0)
{
lpc2000_info->variant = lpc2000_v1;
lpc2000_info->cmd51_dst_boundary = 512;
lpc2000_info->cmd51_can_8192b = 1;
lpc2000_info->checksum_vector = 5;
}
- else if (strcmp(args[6], "lpc2000_v2") == 0)
+ else if (strcmp(CMD_ARGV[6], "lpc2000_v2") == 0)
{
lpc2000_info->variant = lpc2000_v2;
lpc2000_info->cmd51_dst_boundary = 256;
lpc2000_info->cmd51_can_8192b = 0;
lpc2000_info->checksum_vector = 5;
}
- else if (strcmp(args[6], "lpc1700") == 0)
+ else if (strcmp(CMD_ARGV[6], "lpc1700") == 0)
{
lpc2000_info->variant = lpc1700;
lpc2000_info->cmd51_dst_boundary = 256;
}
else
{
- LOG_ERROR("unknown LPC2000 variant: %s", args[6]);
+ LOG_ERROR("unknown LPC2000 variant: %s", CMD_ARGV[6]);
free(lpc2000_info);
return ERROR_FLASH_BANK_INVALID;
}
lpc2000_info->iap_working_area = NULL;
- COMMAND_PARSE_NUMBER(u32, args[7], lpc2000_info->cclk);
+ COMMAND_PARSE_NUMBER(u32, CMD_ARGV[7], lpc2000_info->cclk);
lpc2000_info->calc_checksum = 0;
lpc2000_build_sector_list(bank);
- if (argc >= 9)
+ if (CMD_ARGC >= 9)
{
- if (strcmp(args[8], "calc_checksum") == 0)
+ if (strcmp(CMD_ARGV[8], "calc_checksum") == 0)
lpc2000_info->calc_checksum = 1;
}
return ERROR_OK;
}
-static int lpc2000_erase(struct flash_bank_s *bank, int first, int last)
+static int lpc2000_erase(struct flash_bank *bank, int first, int last)
{
- lpc2000_flash_bank_t *lpc2000_info = bank->driver_priv;
+ struct lpc2000_flash_bank *lpc2000_info = bank->driver_priv;
uint32_t param_table[5];
uint32_t result_table[4];
int status_code;
return ERROR_OK;
}
-static int lpc2000_protect(struct flash_bank_s *bank, int set, int first, int last)
+static int lpc2000_protect(struct flash_bank *bank, int set, int first, int last)
{
/* can't protect/unprotect on the lpc2000 */
return ERROR_OK;
}
-static int lpc2000_write(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
+static int lpc2000_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
{
- lpc2000_flash_bank_t *lpc2000_info = bank->driver_priv;
- target_t *target = bank->target;
+ 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;
uint32_t result_table[4];
int status_code;
int i;
- working_area_t *download_area;
+ struct working_area *download_area;
int retval = ERROR_OK;
if (bank->target->state != TARGET_HALTED)
{
if (offset >= bank->sectors[i].offset)
first_sector = i;
- if (offset + CEIL(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;
}
return retval;
}
-static int lpc2000_probe(struct flash_bank_s *bank)
+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
return ERROR_OK;
}
-static int lpc2000_erase_check(struct flash_bank_s *bank)
+static int lpc2000_erase_check(struct flash_bank *bank)
{
if (bank->target->state != TARGET_HALTED)
{
return lpc2000_iap_blank_check(bank, 0, bank->num_sectors - 1);
}
-static int lpc2000_protect_check(struct flash_bank_s *bank)
+static int lpc2000_protect_check(struct flash_bank *bank)
{
/* sectors are always protected */
return ERROR_OK;
}
-static int lpc2000_info(struct flash_bank_s *bank, char *buf, int buf_size)
+static int lpc2000_info(struct flash_bank *bank, char *buf, int buf_size)
{
- lpc2000_flash_bank_t *lpc2000_info = bank->driver_priv;
+ 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);
uint32_t result_table[4];
int status_code;
- if (argc < 1)
+ if (CMD_ARGC < 1)
{
return ERROR_COMMAND_SYNTAX_ERROR;
}
- flash_bank_t *bank;
- int retval = flash_command_get_bank_by_num(cmd_ctx, args[0], &bank);
+ struct flash_bank *bank;
+ int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
if (ERROR_OK != retval)
return retval;
{
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);
+ command_print(CMD_CTX, "lpc2000 IAP returned status code %i", status_code);
}
else
{
- command_print(cmd_ctx, "lpc2000 part id: 0x%8.8" PRIx32 , result_table[0]);
+ command_print(CMD_CTX, "lpc2000 part id: 0x%8.8" PRIx32 , result_table[0]);
}
return ERROR_OK;
}
-static int lpc2000_register_commands(struct command_context_s *cmd_ctx)
+static const struct command_registration lpc2000_exec_command_handlers[] = {
+ {
+ .name = "part_id",
+ .handler = &lpc2000_handle_part_id_command,
+ .mode = COMMAND_EXEC,
+ .help = "print part id of lpc2000 flash bank <num>",
+ },
+ COMMAND_REGISTRATION_DONE
+};
+static const struct command_registration lpc2000_command_handlers[] = {
+ {
+ .name = "lpc2000",
+ .mode = COMMAND_ANY,
+ .help = "lpc2000 flash command group",
+ .chain = lpc2000_exec_command_handlers,
+ },
+ COMMAND_REGISTRATION_DONE
+};
+
+static int lpc2000_register_commands(struct command_context *cmd_ctx)
{
- command_t *lpc2000_cmd = register_command(cmd_ctx, NULL, "lpc2000",
- NULL, COMMAND_ANY, NULL);
-
- register_command(cmd_ctx, lpc2000_cmd, "part_id",
- lpc2000_handle_part_id_command, COMMAND_EXEC,
- "print part id of lpc2000 flash bank <num>");
-
- return ERROR_OK;
+ return register_commands(cmd_ctx, NULL, lpc2000_command_handlers);
}
-flash_driver_t lpc2000_flash = {
+struct flash_driver lpc2000_flash = {
.name = "lpc2000",
.register_commands = &lpc2000_register_commands,
.flash_bank_command = &lpc2000_flash_bank_command,