X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fflash%2Fstr9xpec.c;h=96e12596a6694bcc58e0bd59c103c5f9d3f01ffc;hb=a93b404161dc42f8dee805c8f95bc4974aded9cb;hp=662cdc5be3739f5c2615dc15a22a51ceaa72973a;hpb=a28eaa85f73759bb189a46308642502c9fa5aa4b;p=openocd.git diff --git a/src/flash/str9xpec.c b/src/flash/str9xpec.c index 662cdc5be3..96e12596a6 100644 --- a/src/flash/str9xpec.c +++ b/src/flash/str9xpec.c @@ -24,113 +24,29 @@ #include "config.h" #endif -#include "replacements.h" - #include "str9xpec.h" -#include "flash.h" -#include "target.h" -#include "log.h" -#include "armv4_5.h" #include "arm7_9_common.h" -#include "jtag.h" -#include "binarybuffer.h" - -#include -#include -#include -#include - -int str9xpec_register_commands(struct command_context_s *cmd_ctx); -int str9xpec_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank); -int str9xpec_erase(struct flash_bank_s *bank, int first, int last); -int str9xpec_protect(struct flash_bank_s *bank, int set, int first, int last); -int str9xpec_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count); -int str9xpec_probe(struct flash_bank_s *bank); -int str9xpec_handle_part_id_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int str9xpec_protect_check(struct flash_bank_s *bank); -int str9xpec_erase_check(struct flash_bank_s *bank); -int str9xpec_info(struct flash_bank_s *bank, char *buf, int buf_size); - -int str9xpec_erase_area(struct flash_bank_s *bank, int first, int last); -int str9xpec_set_address(struct flash_bank_s *bank, u8 sector); -int str9xpec_write_options(struct flash_bank_s *bank); - -int str9xpec_handle_flash_options_cmap_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int str9xpec_handle_flash_options_lvdthd_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int str9xpec_handle_flash_options_lvdsel_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int str9xpec_handle_flash_options_lvdwarn_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int str9xpec_handle_flash_options_read_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int str9xpec_handle_flash_options_write_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int str9xpec_handle_flash_lock_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int str9xpec_handle_flash_unlock_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int str9xpec_handle_flash_enable_turbo_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int str9xpec_handle_flash_disable_turbo_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); - -flash_driver_t str9xpec_flash = -{ - .name = "str9xpec", - .register_commands = str9xpec_register_commands, - .flash_bank_command = str9xpec_flash_bank_command, - .erase = str9xpec_erase, - .protect = str9xpec_protect, - .write = str9xpec_write, - .probe = str9xpec_probe, - .auto_probe = str9xpec_probe, - .erase_check = str9xpec_erase_check, - .protect_check = str9xpec_protect_check, - .info = str9xpec_info -}; -int str9xpec_register_commands(struct command_context_s *cmd_ctx) -{ - command_t *str9xpec_cmd = register_command(cmd_ctx, NULL, "str9xpec", NULL, COMMAND_ANY, "str9xpec flash specific commands"); - - register_command(cmd_ctx, str9xpec_cmd, "enable_turbo", str9xpec_handle_flash_enable_turbo_command, COMMAND_EXEC, - "enable str9xpec turbo mode"); - register_command(cmd_ctx, str9xpec_cmd, "disable_turbo", str9xpec_handle_flash_disable_turbo_command, COMMAND_EXEC, - "disable str9xpec turbo mode"); - register_command(cmd_ctx, str9xpec_cmd, "options_cmap", str9xpec_handle_flash_options_cmap_command, COMMAND_EXEC, - "configure str9xpec boot sector"); - register_command(cmd_ctx, str9xpec_cmd, "options_lvdthd", str9xpec_handle_flash_options_lvdthd_command, COMMAND_EXEC, - "configure str9xpec lvd threshold"); - register_command(cmd_ctx, str9xpec_cmd, "options_lvdsel", str9xpec_handle_flash_options_lvdsel_command, COMMAND_EXEC, - "configure str9xpec lvd selection"); - register_command(cmd_ctx, str9xpec_cmd, "options_lvdwarn", str9xpec_handle_flash_options_lvdwarn_command, COMMAND_EXEC, - "configure str9xpec lvd warning"); - register_command(cmd_ctx, str9xpec_cmd, "options_read", str9xpec_handle_flash_options_read_command, COMMAND_EXEC, - "read str9xpec options"); - register_command(cmd_ctx, str9xpec_cmd, "options_write", str9xpec_handle_flash_options_write_command, COMMAND_EXEC, - "write str9xpec options"); - register_command(cmd_ctx, str9xpec_cmd, "lock", str9xpec_handle_flash_lock_command, COMMAND_EXEC, - "lock str9xpec device"); - register_command(cmd_ctx, str9xpec_cmd, "unlock", str9xpec_handle_flash_unlock_command, COMMAND_EXEC, - "unlock str9xpec device"); - register_command(cmd_ctx, str9xpec_cmd, "part_id", str9xpec_handle_part_id_command, COMMAND_EXEC, - "print part id of str9xpec flash bank "); - return ERROR_OK; -} +static int str9xpec_erase_area(struct flash_bank *bank, int first, int last); +static int str9xpec_set_address(struct flash_bank *bank, uint8_t sector); +static int str9xpec_write_options(struct flash_bank *bank); -int str9xpec_set_instr(jtag_tap_t *tap, u32 new_instr, enum tap_state end_state) +int str9xpec_set_instr(struct jtag_tap *tap, uint32_t new_instr, tap_state_t end_state) { - if( tap == NULL ){ + if (tap == NULL) { return ERROR_TARGET_INVALID; } if (buf_get_u32(tap->cur_instr, 0, tap->ir_length) != new_instr) { - scan_field_t field; + struct scan_field field; field.tap = tap; field.num_bits = tap->ir_length; - field.out_value = calloc(CEIL(field.num_bits, 8), 1); + field.out_value = calloc(DIV_ROUND_UP(field.num_bits, 8), 1); buf_set_u32(field.out_value, 0, field.num_bits, new_instr); - field.out_mask = NULL; field.in_value = NULL; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; jtag_add_ir_scan(1, &field, end_state); @@ -140,25 +56,21 @@ int str9xpec_set_instr(jtag_tap_t *tap, u32 new_instr, enum tap_state end_state) return ERROR_OK; } -u8 str9xpec_isc_status(jtag_tap_t *tap) +static uint8_t str9xpec_isc_status(struct jtag_tap *tap) { - scan_field_t field; - u8 status; + struct scan_field field; + uint8_t status; - if (str9xpec_set_instr(tap, ISC_NOOP, TAP_PI) != ERROR_OK) + if (str9xpec_set_instr(tap, ISC_NOOP, TAP_IRPAUSE) != ERROR_OK) return ISC_STATUS_ERROR; field.tap = tap; field.num_bits = 8; field.out_value = NULL; - field.out_mask = NULL; field.in_value = &status; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, TAP_RTI); + + jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_IDLE)); jtag_execute_queue(); LOG_DEBUG("status: 0x%2.2x", status); @@ -169,11 +81,11 @@ u8 str9xpec_isc_status(jtag_tap_t *tap) return status; } -int str9xpec_isc_enable(struct flash_bank_s *bank) +static int str9xpec_isc_enable(struct flash_bank *bank) { - u8 status; - jtag_tap_t *tap; - str9xpec_flash_controller_t *str9xpec_info = bank->driver_priv; + uint8_t status; + struct jtag_tap *tap; + struct str9xpec_flash_controller *str9xpec_info = bank->driver_priv; tap = str9xpec_info->tap; @@ -181,7 +93,7 @@ int str9xpec_isc_enable(struct flash_bank_s *bank) return ERROR_OK; /* enter isc mode */ - if (str9xpec_set_instr(tap, ISC_ENABLE, TAP_RTI) != ERROR_OK) + if (str9xpec_set_instr(tap, ISC_ENABLE, TAP_IDLE) != ERROR_OK) return ERROR_TARGET_INVALID; /* check ISC status */ @@ -196,18 +108,18 @@ int str9xpec_isc_enable(struct flash_bank_s *bank) return ERROR_OK; } -int str9xpec_isc_disable(struct flash_bank_s *bank) +static int str9xpec_isc_disable(struct flash_bank *bank) { - u8 status; - jtag_tap_t *tap; - str9xpec_flash_controller_t *str9xpec_info = bank->driver_priv; + uint8_t status; + struct jtag_tap *tap; + struct str9xpec_flash_controller *str9xpec_info = bank->driver_priv; tap = str9xpec_info->tap; if (!str9xpec_info->isc_enable) return ERROR_OK; - if (str9xpec_set_instr(tap, ISC_DISABLE, TAP_RTI) != ERROR_OK) + if (str9xpec_set_instr(tap, ISC_DISABLE, TAP_IDLE) != ERROR_OK) return ERROR_TARGET_INVALID; /* delay to handle aborts */ @@ -225,32 +137,28 @@ int str9xpec_isc_disable(struct flash_bank_s *bank) return ERROR_OK; } -int str9xpec_read_config(struct flash_bank_s *bank) +static int str9xpec_read_config(struct flash_bank *bank) { - scan_field_t field; - u8 status; - jtag_tap_t *tap; + struct scan_field field; + uint8_t status; + struct jtag_tap *tap; - str9xpec_flash_controller_t *str9xpec_info = bank->driver_priv; + struct str9xpec_flash_controller *str9xpec_info = bank->driver_priv; tap = str9xpec_info->tap; LOG_DEBUG("ISC_CONFIGURATION"); /* execute ISC_CONFIGURATION command */ - str9xpec_set_instr(tap, ISC_CONFIGURATION, TAP_PI); + str9xpec_set_instr(tap, ISC_CONFIGURATION, TAP_IRPAUSE); field.tap = tap; field.num_bits = 64; field.out_value = NULL; - field.out_mask = NULL; field.in_value = str9xpec_info->options; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, TAP_RTI); + + jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_IDLE)); jtag_execute_queue(); status = str9xpec_isc_status(tap); @@ -258,14 +166,14 @@ int str9xpec_read_config(struct flash_bank_s *bank) return status; } -int str9xpec_build_block_list(struct flash_bank_s *bank) +static int str9xpec_build_block_list(struct flash_bank *bank) { - str9xpec_flash_controller_t *str9xpec_info = bank->driver_priv; + struct str9xpec_flash_controller *str9xpec_info = bank->driver_priv; int i; int num_sectors; int b0_sectors = 0, b1_sectors = 0; - u32 offset = 0; + uint32_t offset = 0; int b1_size = 0x2000; switch (bank->size) @@ -297,8 +205,8 @@ int str9xpec_build_block_list(struct flash_bank_s *bank) num_sectors = b0_sectors + b1_sectors; bank->num_sectors = num_sectors; - bank->sectors = malloc(sizeof(flash_sector_t) * num_sectors); - str9xpec_info->sector_bits = malloc(sizeof(u32) * num_sectors); + bank->sectors = malloc(sizeof(struct flash_sector) * num_sectors); + str9xpec_info->sector_bits = malloc(sizeof(uint32_t) * num_sectors); num_sectors = 0; @@ -327,35 +235,32 @@ int str9xpec_build_block_list(struct flash_bank_s *bank) /* flash bank str9x 0 0 */ -int str9xpec_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct flash_bank_s *bank) +FLASH_BANK_COMMAND_HANDLER(str9xpec_flash_bank_command) { - str9xpec_flash_controller_t *str9xpec_info; - armv4_5_common_t *armv4_5 = NULL; - arm7_9_common_t *arm7_9 = NULL; - arm_jtag_t *jtag_info = NULL; + struct str9xpec_flash_controller *str9xpec_info; + struct arm *armv4_5 = NULL; + struct arm7_9_common *arm7_9 = NULL; + struct arm_jtag *jtag_info = NULL; - if (argc < 6) + if (CMD_ARGC < 6) { LOG_WARNING("incomplete flash_bank str9x configuration"); return ERROR_FLASH_BANK_INVALID; } - str9xpec_info = malloc(sizeof(str9xpec_flash_controller_t)); + str9xpec_info = malloc(sizeof(struct str9xpec_flash_controller)); bank->driver_priv = str9xpec_info; - /* find out jtag position of flash controller - * it is always after the arm966 core */ - + /* REVISIT verify that the jtag position of flash controller is + * right after *THIS* core, which must be a STR9xx core ... + */ armv4_5 = bank->target->arch_info; arm7_9 = armv4_5->arch_info; jtag_info = &arm7_9->jtag_info; - - - str9xpec_info->tap = jtag_TapByAbsPosition( jtag_info->tap->abs_chain_position - 1); + str9xpec_info->tap = bank->target->tap; str9xpec_info->isc_enable = 0; - str9xpec_build_block_list(bank); /* clear option byte register */ @@ -364,27 +269,27 @@ int str9xpec_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, ch return ERROR_OK; } -int str9xpec_blank_check(struct flash_bank_s *bank, int first, int last) +static int str9xpec_blank_check(struct flash_bank *bank, int first, int last) { - scan_field_t field; - u8 status; - jtag_tap_t *tap; + struct scan_field field; + uint8_t status; + struct jtag_tap *tap; int i; - u8 *buffer = NULL; + uint8_t *buffer = NULL; - str9xpec_flash_controller_t *str9xpec_info = bank->driver_priv; + struct str9xpec_flash_controller *str9xpec_info = bank->driver_priv; tap = str9xpec_info->tap; if (!str9xpec_info->isc_enable) { - str9xpec_isc_enable( bank ); + str9xpec_isc_enable(bank); } if (!str9xpec_info->isc_enable) { return ERROR_FLASH_OPERATION_FAILED; } - buffer = calloc(CEIL(64, 8), 1); + buffer = calloc(DIV_ROUND_UP(64, 8), 1); LOG_DEBUG("blank check: first_bank: %i, last_bank: %i", first, last); @@ -393,33 +298,23 @@ int str9xpec_blank_check(struct flash_bank_s *bank, int first, int last) } /* execute ISC_BLANK_CHECK command */ - str9xpec_set_instr(tap, ISC_BLANK_CHECK, TAP_PI); + str9xpec_set_instr(tap, ISC_BLANK_CHECK, TAP_IRPAUSE); field.tap = tap; field.num_bits = 64; field.out_value = buffer; - field.out_mask = NULL; field.in_value = NULL; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, TAP_RTI); + jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_IDLE)); jtag_add_sleep(40000); /* read blank check result */ field.tap = tap; field.num_bits = 64; field.out_value = NULL; - field.out_mask = NULL; field.in_value = buffer; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, TAP_PI); + jtag_add_dr_scan(1, &field, TAP_IRPAUSE); jtag_execute_queue(); status = str9xpec_isc_status(tap); @@ -441,12 +336,12 @@ int str9xpec_blank_check(struct flash_bank_s *bank, int first, int last) return ERROR_OK; } -int str9xpec_protect_check(struct flash_bank_s *bank) +static int str9xpec_protect_check(struct flash_bank *bank) { - u8 status; + uint8_t status; int i; - str9xpec_flash_controller_t *str9xpec_info = bank->driver_priv; + struct str9xpec_flash_controller *str9xpec_info = bank->driver_priv; status = str9xpec_read_config(bank); @@ -463,27 +358,27 @@ int str9xpec_protect_check(struct flash_bank_s *bank) return ERROR_OK; } -int str9xpec_erase_area(struct flash_bank_s *bank, int first, int last) +static int str9xpec_erase_area(struct flash_bank *bank, int first, int last) { - scan_field_t field; - u8 status; - jtag_tap_t *tap; + struct scan_field field; + uint8_t status; + struct jtag_tap *tap; int i; - u8 *buffer = NULL; + uint8_t *buffer = NULL; - str9xpec_flash_controller_t *str9xpec_info = bank->driver_priv; + struct str9xpec_flash_controller *str9xpec_info = bank->driver_priv; tap = str9xpec_info->tap; if (!str9xpec_info->isc_enable) { - str9xpec_isc_enable( bank ); + str9xpec_isc_enable(bank); } if (!str9xpec_info->isc_enable) { return ISC_STATUS_ERROR; } - buffer = calloc(CEIL(64, 8), 1); + buffer = calloc(DIV_ROUND_UP(64, 8), 1); LOG_DEBUG("erase: first_bank: %i, last_bank: %i", first, last); @@ -509,19 +404,14 @@ int str9xpec_erase_area(struct flash_bank_s *bank, int first, int last) LOG_DEBUG("ISC_ERASE"); /* execute ISC_ERASE command */ - str9xpec_set_instr(tap, ISC_ERASE, TAP_PI); + str9xpec_set_instr(tap, ISC_ERASE, TAP_IRPAUSE); field.tap = tap; field.num_bits = 64; field.out_value = buffer; - field.out_mask = NULL; field.in_value = NULL; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, TAP_RTI); + jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_IDLE)); jtag_execute_queue(); jtag_add_sleep(10); @@ -538,7 +428,7 @@ int str9xpec_erase_area(struct flash_bank_s *bank, int first, int last) return status; } -int str9xpec_erase(struct flash_bank_s *bank, int first, int last) +static int str9xpec_erase(struct flash_bank *bank, int first, int last) { int status; @@ -550,18 +440,18 @@ int str9xpec_erase(struct flash_bank_s *bank, int first, int last) return ERROR_OK; } -int str9xpec_lock_device(struct flash_bank_s *bank) +static int str9xpec_lock_device(struct flash_bank *bank) { - scan_field_t field; - u8 status; - jtag_tap_t *tap; - str9xpec_flash_controller_t *str9xpec_info = NULL; + struct scan_field field; + uint8_t status; + struct jtag_tap *tap; + struct str9xpec_flash_controller *str9xpec_info = NULL; str9xpec_info = bank->driver_priv; tap = str9xpec_info->tap; if (!str9xpec_info->isc_enable) { - str9xpec_isc_enable( bank ); + str9xpec_isc_enable(bank); } if (!str9xpec_info->isc_enable) { @@ -572,46 +462,41 @@ int str9xpec_lock_device(struct flash_bank_s *bank) str9xpec_set_address(bank, 0x80); /* execute ISC_PROGRAM command */ - str9xpec_set_instr(tap, ISC_PROGRAM_SECURITY, TAP_RTI); + str9xpec_set_instr(tap, ISC_PROGRAM_SECURITY, TAP_IDLE); - str9xpec_set_instr(tap, ISC_NOOP, TAP_PI); + str9xpec_set_instr(tap, ISC_NOOP, TAP_IRPAUSE); do { field.tap = tap; field.num_bits = 8; field.out_value = NULL; - field.out_mask = NULL; field.in_value = &status; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, -1); + jtag_add_dr_scan(1, &field, jtag_get_end_state()); jtag_execute_queue(); - } while(!(status & ISC_STATUS_BUSY)); + } while (!(status & ISC_STATUS_BUSY)); str9xpec_isc_disable(bank); return status; } -int str9xpec_unlock_device(struct flash_bank_s *bank) +static int str9xpec_unlock_device(struct flash_bank *bank) { - u8 status; + uint8_t status; status = str9xpec_erase_area(bank, 0, 255); return status; } -int str9xpec_protect(struct flash_bank_s *bank, int set, int first, int last) +static int str9xpec_protect(struct flash_bank *bank, int set, int first, int last) { - u8 status; + uint8_t status; int i; - str9xpec_flash_controller_t *str9xpec_info = bank->driver_priv; + struct str9xpec_flash_controller *str9xpec_info = bank->driver_priv; status = str9xpec_read_config(bank); @@ -623,7 +508,7 @@ int str9xpec_protect(struct flash_bank_s *bank, int set, int first, int last) /* last bank: 0xFF signals a full device protect */ if (last == 0xFF) { - if( set ) + if (set) { status = str9xpec_lock_device(bank); } @@ -637,7 +522,7 @@ int str9xpec_protect(struct flash_bank_s *bank, int set, int first, int last) { for (i = first; i <= last; i++) { - if( set ) + if (set) buf_set_u32(str9xpec_info->options, str9xpec_info->sector_bits[i], 1, 1); else buf_set_u32(str9xpec_info->options, str9xpec_info->sector_bits[i], 1, 0); @@ -652,46 +537,41 @@ int str9xpec_protect(struct flash_bank_s *bank, int set, int first, int last) return ERROR_OK; } -int str9xpec_set_address(struct flash_bank_s *bank, u8 sector) +static int str9xpec_set_address(struct flash_bank *bank, uint8_t sector) { - jtag_tap_t *tap; - scan_field_t field; - str9xpec_flash_controller_t *str9xpec_info = bank->driver_priv; + struct jtag_tap *tap; + struct scan_field field; + struct str9xpec_flash_controller *str9xpec_info = bank->driver_priv; tap = str9xpec_info->tap; /* set flash controller address */ - str9xpec_set_instr(tap, ISC_ADDRESS_SHIFT, TAP_PI); + str9xpec_set_instr(tap, ISC_ADDRESS_SHIFT, TAP_IRPAUSE); field.tap = tap; field.num_bits = 8; field.out_value = §or; - field.out_mask = NULL; field.in_value = NULL; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, -1); + jtag_add_dr_scan(1, &field, jtag_get_end_state()); return ERROR_OK; } -int str9xpec_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count) +static int str9xpec_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count) { - str9xpec_flash_controller_t *str9xpec_info = bank->driver_priv; - u32 dwords_remaining = (count / 8); - u32 bytes_remaining = (count & 0x00000007); - u32 bytes_written = 0; - u8 status; - u32 check_address = offset; - jtag_tap_t *tap; - scan_field_t field; - u8 *scanbuf; + struct str9xpec_flash_controller *str9xpec_info = bank->driver_priv; + uint32_t dwords_remaining = (count / 8); + uint32_t bytes_remaining = (count & 0x00000007); + uint32_t bytes_written = 0; + uint8_t status; + uint32_t check_address = offset; + struct jtag_tap *tap; + struct scan_field field; + uint8_t *scanbuf; int i; - u32 first_sector = 0; - u32 last_sector = 0; + int first_sector = 0; + int last_sector = 0; tap = str9xpec_info->tap; @@ -705,14 +585,14 @@ int str9xpec_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count) if (offset & 0x7) { - LOG_WARNING("offset 0x%x breaks required 8-byte alignment", offset); + LOG_WARNING("offset 0x%" PRIx32 " breaks required 8-byte alignment", offset); return ERROR_FLASH_DST_BREAKS_ALIGNMENT; } for (i = 0; i < bank->num_sectors; i++) { - u32 sec_start = bank->sectors[i].offset; - u32 sec_end = sec_start + bank->sectors[i].size; + uint32_t sec_start = bank->sectors[i].offset; + uint32_t sec_end = sec_start + bank->sectors[i].size; /* check if destination falls within the current sector */ if ((check_address >= sec_start) && (check_address < sec_end)) @@ -724,11 +604,11 @@ int str9xpec_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count) check_address = sec_end; } - if ((offset >= sec_start) && (offset < sec_end)){ + if ((offset >= sec_start) && (offset < sec_end)) { first_sector = i; } - if ((offset + count >= sec_start) && (offset + count < sec_end)){ + if ((offset + count >= sec_start) && (offset + count < sec_end)) { last_sector = i; } } @@ -738,7 +618,7 @@ int str9xpec_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count) LOG_DEBUG("first_sector: %i, last_sector: %i", first_sector, last_sector); - scanbuf = calloc(CEIL(64, 8), 1); + scanbuf = calloc(DIV_ROUND_UP(64, 8), 1); LOG_DEBUG("ISC_PROGRAM"); @@ -750,42 +630,32 @@ int str9xpec_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count) while (dwords_remaining > 0) { - str9xpec_set_instr(tap, ISC_PROGRAM, TAP_PI); + str9xpec_set_instr(tap, ISC_PROGRAM, TAP_IRPAUSE); field.tap = tap; field.num_bits = 64; field.out_value = (buffer + bytes_written); - field.out_mask = NULL; field.in_value = NULL; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, TAP_RTI); + jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_IDLE)); /* small delay before polling */ jtag_add_sleep(50); - str9xpec_set_instr(tap, ISC_NOOP, TAP_PI); + str9xpec_set_instr(tap, ISC_NOOP, TAP_IRPAUSE); do { field.tap = tap; field.num_bits = 8; field.out_value = NULL; - field.out_mask = NULL; field.in_value = scanbuf; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, -1); + jtag_add_dr_scan(1, &field, jtag_get_end_state()); jtag_execute_queue(); status = buf_get_u32(scanbuf, 0, 8); - } while(!(status & ISC_STATUS_BUSY)); + } while (!(status & ISC_STATUS_BUSY)); if ((status & ISC_STATUS_ERROR) != STR9XPEC_ISC_SUCCESS) return ERROR_FLASH_OPERATION_FAILED; @@ -800,52 +670,42 @@ int str9xpec_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count) if (bytes_remaining) { - u8 last_dword[8] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; + uint8_t last_dword[8] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; int i = 0; - while(bytes_remaining > 0) + while (bytes_remaining > 0) { last_dword[i++] = *(buffer + bytes_written); bytes_remaining--; bytes_written++; } - str9xpec_set_instr(tap, ISC_PROGRAM, TAP_PI); + str9xpec_set_instr(tap, ISC_PROGRAM, TAP_IRPAUSE); field.tap = tap; field.num_bits = 64; field.out_value = last_dword; - field.out_mask = NULL; field.in_value = NULL; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, TAP_RTI); + jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_IDLE)); /* small delay before polling */ jtag_add_sleep(50); - str9xpec_set_instr(tap, ISC_NOOP, TAP_PI); + str9xpec_set_instr(tap, ISC_NOOP, TAP_IRPAUSE); do { field.tap = tap; field.num_bits = 8; field.out_value = NULL; - field.out_mask = NULL; field.in_value = scanbuf; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, -1); + jtag_add_dr_scan(1, &field, jtag_get_end_state()); jtag_execute_queue(); status = buf_get_u32(scanbuf, 0, 8); - } while(!(status & ISC_STATUS_BUSY)); + } while (!(status & ISC_STATUS_BUSY)); if ((status & ISC_STATUS_ERROR) != STR9XPEC_ISC_SUCCESS) return ERROR_FLASH_OPERATION_FAILED; @@ -861,90 +721,77 @@ int str9xpec_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count) return ERROR_OK; } -int str9xpec_probe(struct flash_bank_s *bank) +static int str9xpec_probe(struct flash_bank *bank) { return ERROR_OK; } -int str9xpec_handle_part_id_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(str9xpec_handle_part_id_command) { - flash_bank_t *bank; - scan_field_t field; - u8 *buffer = NULL; - jtag_tap_t *tap; - u32 idcode; - str9xpec_flash_controller_t *str9xpec_info = NULL; - - if (argc < 1) - { + struct scan_field field; + uint8_t *buffer = NULL; + struct jtag_tap *tap; + uint32_t idcode; + struct str9xpec_flash_controller *str9xpec_info = NULL; + + if (CMD_ARGC < 1) return ERROR_COMMAND_SYNTAX_ERROR; - } - bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0)); - if (!bank) - { - command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]); - return ERROR_OK; - } + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; str9xpec_info = bank->driver_priv; tap = str9xpec_info->tap; - buffer = calloc(CEIL(32, 8), 1); + buffer = calloc(DIV_ROUND_UP(32, 8), 1); - str9xpec_set_instr(tap, ISC_IDCODE, TAP_PI); + str9xpec_set_instr(tap, ISC_IDCODE, TAP_IRPAUSE); field.tap = tap; field.num_bits = 32; field.out_value = NULL; - field.out_mask = NULL; field.in_value = buffer; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, TAP_RTI); + jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_IDLE)); jtag_execute_queue(); idcode = buf_get_u32(buffer, 0, 32); - command_print(cmd_ctx, "str9xpec part id: 0x%8.8x", idcode); + command_print(CMD_CTX, "str9xpec part id: 0x%8.8" PRIx32 "", idcode); free(buffer); return ERROR_OK; } -int str9xpec_erase_check(struct flash_bank_s *bank) +static int str9xpec_erase_check(struct flash_bank *bank) { return str9xpec_blank_check(bank, 0, bank->num_sectors - 1); } -int str9xpec_info(struct flash_bank_s *bank, char *buf, int buf_size) +static int str9xpec_info(struct flash_bank *bank, char *buf, int buf_size) { - snprintf(buf, buf_size, "str9xpec flash driver info" ); + snprintf(buf, buf_size, "str9xpec flash driver info"); return ERROR_OK; } -int str9xpec_handle_flash_options_read_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(str9xpec_handle_flash_options_read_command) { - flash_bank_t *bank; - u8 status; - str9xpec_flash_controller_t *str9xpec_info = NULL; + uint8_t status; + struct str9xpec_flash_controller *str9xpec_info = NULL; - if (argc < 1) + if (CMD_ARGC < 1) { - command_print(cmd_ctx, "str9xpec options_read "); + command_print(CMD_CTX, "str9xpec options_read "); return ERROR_OK; } - bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0)); - if (!bank) - { - command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]); - return ERROR_OK; - } + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; str9xpec_info = bank->driver_priv; @@ -955,55 +802,55 @@ int str9xpec_handle_flash_options_read_command(struct command_context_s *cmd_ctx /* boot bank */ if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_CSMAPBIT, 1)) - command_print(cmd_ctx, "CS Map: bank1"); + command_print(CMD_CTX, "CS Map: bank1"); else - command_print(cmd_ctx, "CS Map: bank0"); + command_print(CMD_CTX, "CS Map: bank0"); /* OTP lock */ if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_OTPBIT, 1)) - command_print(cmd_ctx, "OTP Lock: OTP Locked"); + command_print(CMD_CTX, "OTP Lock: OTP Locked"); else - command_print(cmd_ctx, "OTP Lock: OTP Unlocked"); + command_print(CMD_CTX, "OTP Lock: OTP Unlocked"); /* LVD Threshold */ if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_LVDTHRESBIT, 1)) - command_print(cmd_ctx, "LVD Threshold: 2.7v"); + command_print(CMD_CTX, "LVD Threshold: 2.7v"); else - command_print(cmd_ctx, "LVD Threshold: 2.4v"); + command_print(CMD_CTX, "LVD Threshold: 2.4v"); /* LVD reset warning */ if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_LVDWARNBIT, 1)) - command_print(cmd_ctx, "LVD Reset Warning: VDD or VDDQ Inputs"); + command_print(CMD_CTX, "LVD Reset Warning: VDD or VDDQ Inputs"); else - command_print(cmd_ctx, "LVD Reset Warning: VDD Input Only"); + command_print(CMD_CTX, "LVD Reset Warning: VDD Input Only"); /* LVD reset select */ if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_LVDSELBIT, 1)) - command_print(cmd_ctx, "LVD Reset Selection: VDD or VDDQ Inputs"); + command_print(CMD_CTX, "LVD Reset Selection: VDD or VDDQ Inputs"); else - command_print(cmd_ctx, "LVD Reset Selection: VDD Input Only"); + command_print(CMD_CTX, "LVD Reset Selection: VDD Input Only"); return ERROR_OK; } -int str9xpec_write_options(struct flash_bank_s *bank) +static int str9xpec_write_options(struct flash_bank *bank) { - scan_field_t field; - u8 status; - jtag_tap_t *tap; - str9xpec_flash_controller_t *str9xpec_info = NULL; + struct scan_field field; + uint8_t status; + struct jtag_tap *tap; + struct str9xpec_flash_controller *str9xpec_info = NULL; str9xpec_info = bank->driver_priv; tap = str9xpec_info->tap; /* erase config options first */ - status = str9xpec_erase_area( bank, 0xFE, 0xFE ); + status = str9xpec_erase_area(bank, 0xFE, 0xFE); if ((status & ISC_STATUS_ERROR) != STR9XPEC_ISC_SUCCESS) return status; if (!str9xpec_info->isc_enable) { - str9xpec_isc_enable( bank ); + str9xpec_isc_enable(bank); } if (!str9xpec_info->isc_enable) { @@ -1017,63 +864,50 @@ int str9xpec_write_options(struct flash_bank_s *bank) str9xpec_set_address(bank, 0x50); /* execute ISC_PROGRAM command */ - str9xpec_set_instr(tap, ISC_PROGRAM, TAP_PI); + str9xpec_set_instr(tap, ISC_PROGRAM, TAP_IRPAUSE); field.tap = tap; field.num_bits = 64; field.out_value = str9xpec_info->options; - field.out_mask = NULL; field.in_value = NULL; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, TAP_RTI); + jtag_add_dr_scan(1, &field, jtag_set_end_state(TAP_IDLE)); /* small delay before polling */ jtag_add_sleep(50); - str9xpec_set_instr(tap, ISC_NOOP, TAP_PI); + str9xpec_set_instr(tap, ISC_NOOP, TAP_IRPAUSE); do { field.tap = tap; field.num_bits = 8; field.out_value = NULL; - field.out_mask = NULL; field.in_value = &status; - field.in_check_value = NULL; - field.in_check_mask = NULL; - field.in_handler = NULL; - field.in_handler_priv = NULL; - jtag_add_dr_scan(1, &field, -1); + jtag_add_dr_scan(1, &field, jtag_get_end_state()); jtag_execute_queue(); - } while(!(status & ISC_STATUS_BUSY)); + } while (!(status & ISC_STATUS_BUSY)); str9xpec_isc_disable(bank); return status; } -int str9xpec_handle_flash_options_write_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(str9xpec_handle_flash_options_write_command) { - flash_bank_t *bank; - u8 status; + uint8_t status; - if (argc < 1) + if (CMD_ARGC < 1) { - command_print(cmd_ctx, "str9xpec options_write "); + command_print(CMD_CTX, "str9xpec options_write "); return ERROR_OK; } - bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0)); - if (!bank) - { - command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]); - return ERROR_OK; - } + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; status = str9xpec_write_options(bank); @@ -1083,27 +917,24 @@ int str9xpec_handle_flash_options_write_command(struct command_context_s *cmd_ct return ERROR_OK; } -int str9xpec_handle_flash_options_cmap_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(str9xpec_handle_flash_options_cmap_command) { - flash_bank_t *bank; - str9xpec_flash_controller_t *str9xpec_info = NULL; + struct str9xpec_flash_controller *str9xpec_info = NULL; - if (argc < 2) + if (CMD_ARGC < 2) { - command_print(cmd_ctx, "str9xpec options_cmap "); + command_print(CMD_CTX, "str9xpec options_cmap "); return ERROR_OK; } - bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0)); - if (!bank) - { - command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]); - return ERROR_OK; - } + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; str9xpec_info = bank->driver_priv; - if (strcmp(args[1], "bank1") == 0) + if (strcmp(CMD_ARGV[1], "bank1") == 0) { buf_set_u32(str9xpec_info->options, STR9XPEC_OPT_CSMAPBIT, 1, 1); } @@ -1115,27 +946,24 @@ int str9xpec_handle_flash_options_cmap_command(struct command_context_s *cmd_ctx return ERROR_OK; } -int str9xpec_handle_flash_options_lvdthd_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(str9xpec_handle_flash_options_lvdthd_command) { - flash_bank_t *bank; - str9xpec_flash_controller_t *str9xpec_info = NULL; + struct str9xpec_flash_controller *str9xpec_info = NULL; - if (argc < 2) + if (CMD_ARGC < 2) { - command_print(cmd_ctx, "str9xpec options_lvdthd <2.4v|2.7v>"); + command_print(CMD_CTX, "str9xpec options_lvdthd <2.4v | 2.7v>"); return ERROR_OK; } - bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0)); - if (!bank) - { - command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]); - return ERROR_OK; - } + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; str9xpec_info = bank->driver_priv; - if (strcmp(args[1], "2.7v") == 0) + if (strcmp(CMD_ARGV[1], "2.7v") == 0) { buf_set_u32(str9xpec_info->options, STR9XPEC_OPT_LVDTHRESBIT, 1, 1); } @@ -1147,27 +975,24 @@ int str9xpec_handle_flash_options_lvdthd_command(struct command_context_s *cmd_c return ERROR_OK; } -int str9xpec_handle_flash_options_lvdsel_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(str9xpec_handle_flash_options_lvdsel_command) { - flash_bank_t *bank; - str9xpec_flash_controller_t *str9xpec_info = NULL; + struct str9xpec_flash_controller *str9xpec_info = NULL; - if (argc < 2) + if (CMD_ARGC < 2) { - command_print(cmd_ctx, "str9xpec options_lvdsel "); + command_print(CMD_CTX, "str9xpec options_lvdsel "); return ERROR_OK; } - bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0)); - if (!bank) - { - command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]); - return ERROR_OK; - } + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; str9xpec_info = bank->driver_priv; - if (strcmp(args[1], "vdd_vddq") == 0) + if (strcmp(CMD_ARGV[1], "vdd_vddq") == 0) { buf_set_u32(str9xpec_info->options, STR9XPEC_OPT_LVDSELBIT, 1, 1); } @@ -1179,27 +1004,24 @@ int str9xpec_handle_flash_options_lvdsel_command(struct command_context_s *cmd_c return ERROR_OK; } -int str9xpec_handle_flash_options_lvdwarn_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(str9xpec_handle_flash_options_lvdwarn_command) { - flash_bank_t *bank; - str9xpec_flash_controller_t *str9xpec_info = NULL; + struct str9xpec_flash_controller *str9xpec_info = NULL; - if (argc < 2) + if (CMD_ARGC < 2) { - command_print(cmd_ctx, "str9xpec options_lvdwarn "); + command_print(CMD_CTX, "str9xpec options_lvdwarn "); return ERROR_OK; } - bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0)); - if (!bank) - { - command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]); - return ERROR_OK; - } + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; str9xpec_info = bank->driver_priv; - if (strcmp(args[1], "vdd_vddq") == 0) + if (strcmp(CMD_ARGV[1], "vdd_vddq") == 0) { buf_set_u32(str9xpec_info->options, STR9XPEC_OPT_LVDWARNBIT, 1, 1); } @@ -1211,23 +1033,20 @@ int str9xpec_handle_flash_options_lvdwarn_command(struct command_context_s *cmd_ return ERROR_OK; } -int str9xpec_handle_flash_lock_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(str9xpec_handle_flash_lock_command) { - u8 status; - flash_bank_t *bank; + uint8_t status; - if (argc < 1) + if (CMD_ARGC < 1) { - command_print(cmd_ctx, "str9xpec lock "); + command_print(CMD_CTX, "str9xpec lock "); return ERROR_OK; } - bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0)); - if (!bank) - { - command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]); - return ERROR_OK; - } + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; status = str9xpec_lock_device(bank); @@ -1237,23 +1056,20 @@ int str9xpec_handle_flash_lock_command(struct command_context_s *cmd_ctx, char * return ERROR_OK; } -int str9xpec_handle_flash_unlock_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(str9xpec_handle_flash_unlock_command) { - u8 status; - flash_bank_t *bank; + uint8_t status; - if (argc < 1) + if (CMD_ARGC < 1) { - command_print(cmd_ctx, "str9xpec unlock "); + command_print(CMD_CTX, "str9xpec unlock "); return ERROR_OK; } - bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0)); - if (!bank) - { - command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]); - return ERROR_OK; - } + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; status = str9xpec_unlock_device(bank); @@ -1263,105 +1079,179 @@ int str9xpec_handle_flash_unlock_command(struct command_context_s *cmd_ctx, char return ERROR_OK; } -int str9xpec_handle_flash_enable_turbo_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(str9xpec_handle_flash_enable_turbo_command) { -#if 1 - command_print( cmd_ctx, "**STR9FLASH is currently broken :-( **"); - return ERROR_OK; -#else - int retval; - flash_bank_t *bank; - jtag_tap_t *tapX; - jtag_tap_t *tap0; - jtag_tap_t *tap1; - jtag_tap_t *tap2; - str9xpec_flash_controller_t *str9xpec_info = NULL; - - if (argc < 1) - { - command_print(cmd_ctx, "str9xpec enable_turbo "); - return ERROR_OK; - } + struct jtag_tap *tap0; + struct jtag_tap *tap1; + struct jtag_tap *tap2; + struct str9xpec_flash_controller *str9xpec_info = NULL; - bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0)); - if (!bank) + if (CMD_ARGC < 1) { - command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]); + command_print(CMD_CTX, "str9xpec enable_turbo "); return ERROR_OK; } + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; + str9xpec_info = bank->driver_priv; - tapX = str9xpec_info->tap; + tap0 = str9xpec_info->tap; /* remove arm core from chain - enter turbo mode */ - // - // At postion +2 in the chain, - // I do not think this is right.. - // I have not tested it... - // and it is a bit wacky right now. - // -- Duane 25/nov/2008 - tap0 = tapX; tap1 = tap0->next_tap; - if( tap1 == NULL ){ - // things are *WRONG* - command_print(cmd_ctx,"**STR9FLASH** (tap1) invalid chain?"); + if (tap1 == NULL) + { + /* things are *WRONG* */ + command_print(CMD_CTX,"**STR9FLASH** (tap1) invalid chain?"); return ERROR_OK; } tap2 = tap1->next_tap; - if( tap2 == NULL ){ - // things are *WRONG* - command_print(cmd_ctx,"**STR9FLASH** (tap2) invalid chain?"); + if (tap2 == NULL) + { + /* things are *WRONG* */ + command_print(CMD_CTX,"**STR9FLASH** (tap2) invalid chain?"); return ERROR_OK; } - // this instruction disables the arm9 tap - str9xpec_set_instr(tap2, 0xD, TAP_RTI); - if ((retval=jtag_execute_queue())!=ERROR_OK) + /* enable turbo mode - TURBO-PROG-ENABLE */ + str9xpec_set_instr(tap2, 0xD, TAP_IDLE); + if ((retval = jtag_execute_queue()) != ERROR_OK) return retval; /* modify scan chain - str9 core has been removed */ - str9xpec_info->devarm = tap1; tap1->enabled = 0; return ERROR_OK; -#endif } -int str9xpec_handle_flash_disable_turbo_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(str9xpec_handle_flash_disable_turbo_command) { - flash_bank_t *bank; - jtag_tap_t *tap; - str9xpec_flash_controller_t *str9xpec_info = NULL; + struct jtag_tap *tap; + struct str9xpec_flash_controller *str9xpec_info = NULL; - if (argc < 1) + if (CMD_ARGC < 1) { - command_print(cmd_ctx, "str9xpec disable_turbo "); + command_print(CMD_CTX, "str9xpec disable_turbo "); return ERROR_OK; } - bank = get_flash_bank_by_num(strtoul(args[0], NULL, 0)); - if (!bank) - { - command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]); - return ERROR_OK; - } + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; str9xpec_info = bank->driver_priv; - tap = str9xpec_info->tap; if (tap == NULL) return ERROR_FAIL; - - /* exit turbo mode via TLR */ - str9xpec_set_instr(tap, ISC_NOOP, TAP_TLR); + /* exit turbo mode via RESET */ + str9xpec_set_instr(tap, ISC_NOOP, TAP_IDLE); + jtag_add_tlr(); jtag_execute_queue(); + /* restore previous scan chain */ - if( tap->next_tap ){ + if (tap->next_tap) { tap->next_tap->enabled = 1; } return ERROR_OK; } + +static const struct command_registration str9xpec_config_command_handlers[] = { + { + .name = "enable_turbo", + .handler = str9xpec_handle_flash_enable_turbo_command, + .mode = COMMAND_EXEC, + .help = "enable str9xpec turbo mode", + }, + { + .name = "disable_turbo", + .handler = str9xpec_handle_flash_disable_turbo_command, + .mode = COMMAND_EXEC, + .help = "disable str9xpec turbo mode", + }, + { + .name = "options_cmap", + .handler = str9xpec_handle_flash_options_cmap_command, + .mode = COMMAND_EXEC, + .help = "configure str9xpec boot sector", + }, + { + .name = "options_lvdthd", + .handler = str9xpec_handle_flash_options_lvdthd_command, + .mode = COMMAND_EXEC, + .help = "configure str9xpec lvd threshold", + }, + { + .name = "options_lvdsel", + .handler = str9xpec_handle_flash_options_lvdsel_command, + .mode = COMMAND_EXEC, + .help = "configure str9xpec lvd selection", + }, + { + .name = "options_lvdwarn", + .handler = str9xpec_handle_flash_options_lvdwarn_command, + .mode = COMMAND_EXEC, + .help = "configure str9xpec lvd warning", + }, + { + .name = "options_read", + .handler = str9xpec_handle_flash_options_read_command, + .mode = COMMAND_EXEC, + .help = "read str9xpec options", + }, + { + .name = "options_write", + .handler = str9xpec_handle_flash_options_write_command, + .mode = COMMAND_EXEC, + .help = "write str9xpec options", + }, + { + .name = "lock", + .handler = str9xpec_handle_flash_lock_command, + .mode = COMMAND_EXEC, + .help = "lock str9xpec device", + }, + { + .name = "unlock", + .handler = str9xpec_handle_flash_unlock_command, + .mode = COMMAND_EXEC, + .help = "unlock str9xpec device", + }, + { + .name = "part_id", + .handler = str9xpec_handle_part_id_command, + .mode = COMMAND_EXEC, + .help = "print part id of str9xpec flash bank ", + }, + COMMAND_REGISTRATION_DONE +}; +static const struct command_registration str9xpec_command_handlers[] = { + { + .name = "str9xpec", + .mode = COMMAND_ANY, + .help = "str9xpec flash command group", + .chain = str9xpec_config_command_handlers, + }, + COMMAND_REGISTRATION_DONE +}; + +struct flash_driver str9xpec_flash = { + .name = "str9xpec", + .commands = str9xpec_command_handlers, + .flash_bank_command = &str9xpec_flash_bank_command, + .erase = &str9xpec_erase, + .protect = &str9xpec_protect, + .write = &str9xpec_write, + .probe = &str9xpec_probe, + .auto_probe = &str9xpec_probe, + .erase_check = &str9xpec_erase_check, + .protect_check = &str9xpec_protect_check, + .info = &str9xpec_info, + };