X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fflash%2Fmflash.c;h=90e9888bdeb136727bb83645a7f1c111a16f32fd;hp=328e9578934cb16f8f9d87ce9c9ca24590090dca;hb=190986eb8c6967cebafe0b415733c72305489f76;hpb=84df52f9ea78e2d71bde648a16b69d80404c6421 diff --git a/src/flash/mflash.c b/src/flash/mflash.c index 328e957893..90e9888bde 100644 --- a/src/flash/mflash.c +++ b/src/flash/mflash.c @@ -22,33 +22,32 @@ #endif #include "mflash.h" -#include "time_support.h" -#include "fileio.h" -#include "log.h" +#include +#include +#include +#include -static int s3c2440_set_gpio_to_output (mflash_gpio_num_t gpio); -static int s3c2440_set_gpio_output_val (mflash_gpio_num_t gpio, uint8_t val); -static int pxa270_set_gpio_to_output (mflash_gpio_num_t gpio); -static int pxa270_set_gpio_output_val (mflash_gpio_num_t gpio, uint8_t val); +static int s3c2440_set_gpio_to_output (struct mflash_gpio_num gpio); +static int s3c2440_set_gpio_output_val (struct mflash_gpio_num gpio, uint8_t val); +static int pxa270_set_gpio_to_output (struct mflash_gpio_num gpio); +static int pxa270_set_gpio_output_val (struct mflash_gpio_num gpio, uint8_t val); -static command_t *mflash_cmd; +static struct mflash_bank *mflash_bank; -static mflash_bank_t *mflash_bank; - -static mflash_gpio_drv_t pxa270_gpio = { +static struct mflash_gpio_drv pxa270_gpio = { .name = "pxa270", .set_gpio_to_output = pxa270_set_gpio_to_output, .set_gpio_output_val = pxa270_set_gpio_output_val }; -static mflash_gpio_drv_t s3c2440_gpio = { +static struct mflash_gpio_drv s3c2440_gpio = { .name = "s3c2440", .set_gpio_to_output = s3c2440_set_gpio_to_output, .set_gpio_output_val = s3c2440_set_gpio_output_val }; -static mflash_gpio_drv_t *mflash_gpio[] = +static struct mflash_gpio_drv *mflash_gpio[] = { &pxa270_gpio, &s3c2440_gpio, @@ -64,10 +63,10 @@ static mflash_gpio_drv_t *mflash_gpio[] = #define PXA270_GPSR0 0x40E00018 #define PXA270_GPCR0 0x40E00024 -static int pxa270_set_gpio_to_output (mflash_gpio_num_t gpio) +static int pxa270_set_gpio_to_output (struct mflash_gpio_num gpio) { uint32_t addr, value, mask; - target_t *target = mflash_bank->target; + struct target *target = mflash_bank->target; int ret; /* remove alternate function. */ @@ -101,10 +100,10 @@ static int pxa270_set_gpio_to_output (mflash_gpio_num_t gpio) return ret; } -static int pxa270_set_gpio_output_val (mflash_gpio_num_t gpio, uint8_t val) +static int pxa270_set_gpio_output_val (struct mflash_gpio_num gpio, uint8_t val) { uint32_t addr, value, mask; - target_t *target = mflash_bank->target; + struct target *target = mflash_bank->target; int ret; mask = 0x1u << (gpio.num & 0x1F); @@ -130,10 +129,10 @@ static int pxa270_set_gpio_output_val (mflash_gpio_num_t gpio, uint8_t val) #define S3C2440_GPJCON 0x560000d0 #define S3C2440_GPJDAT 0x560000d4 -static int s3c2440_set_gpio_to_output (mflash_gpio_num_t gpio) +static int s3c2440_set_gpio_to_output (struct mflash_gpio_num gpio) { uint32_t data, mask, gpio_con; - target_t *target = mflash_bank->target; + struct target *target = mflash_bank->target; int ret; if (gpio.port[0] >= 'a' && gpio.port[0] <= 'h') { @@ -162,10 +161,10 @@ static int s3c2440_set_gpio_to_output (mflash_gpio_num_t gpio) return ret; } -static int s3c2440_set_gpio_output_val (mflash_gpio_num_t gpio, uint8_t val) +static int s3c2440_set_gpio_output_val (struct mflash_gpio_num gpio, uint8_t val) { uint32_t data, mask, gpio_dat; - target_t *target = mflash_bank->target; + struct target *target = mflash_bank->target; int ret; if (gpio.port[0] >= 'a' && gpio.port[0] <= 'h') { @@ -199,7 +198,7 @@ static int mg_hdrst(uint8_t level) static int mg_init_gpio (void) { int ret; - mflash_gpio_drv_t *gpio_drv = mflash_bank->gpio_drv; + struct mflash_gpio_drv *gpio_drv = mflash_bank->gpio_drv; ret = gpio_drv->set_gpio_to_output(mflash_bank->rst_pin); if (ret != ERROR_OK) @@ -210,18 +209,18 @@ static int mg_init_gpio (void) return ret; } -static int mg_dsk_wait(mg_io_type_wait wait, uint32_t time) +static int mg_dsk_wait(mg_io_type_wait wait, uint32_t time_var) { uint8_t status, error; - target_t *target = mflash_bank->target; + struct target *target = mflash_bank->target; uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET; - duration_t duration; int ret; long long t = 0; - duration_start_measure(&duration); + struct duration bench; + duration_start(&bench); - while (time) { + while (time_var) { ret = target_read_u8(target, mg_task_reg + MG_REG_STATUS, &status); if (ret != ERROR_OK) @@ -275,12 +274,13 @@ static int mg_dsk_wait(mg_io_type_wait wait, uint32_t time) } } - duration_stop_measure(&duration, NULL); - - t = duration.duration.tv_usec/1000; - t += duration.duration.tv_sec*1000; + ret = duration_measure(&bench); + if (ERROR_OK == ret) + t = duration_elapsed(&bench) * 1000.0; + else + LOG_ERROR("mflash: duration measurement failed: %d", ret); - if (t > time) + if (t > time_var) break; } @@ -290,7 +290,7 @@ static int mg_dsk_wait(mg_io_type_wait wait, uint32_t time) static int mg_dsk_srst(uint8_t on) { - target_t *target = mflash_bank->target; + struct target *target = mflash_bank->target; uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET; uint8_t value; int ret; @@ -310,7 +310,7 @@ static int mg_dsk_srst(uint8_t on) static int mg_dsk_io_cmd(uint32_t sect_num, uint32_t cnt, uint8_t cmd) { - target_t *target = mflash_bank->target; + struct target *target = mflash_bank->target; uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET; uint8_t value; int ret; @@ -335,22 +335,24 @@ static int mg_dsk_io_cmd(uint32_t sect_num, uint32_t cnt, uint8_t cmd) static int mg_dsk_drv_info(void) { - target_t *target = mflash_bank->target; + struct target *target = mflash_bank->target; uint32_t mg_buff = mflash_bank->base + MG_BUFFER_OFFSET; int ret; if ((ret = mg_dsk_io_cmd(0, 1, mg_io_cmd_identify)) != ERROR_OK) return ret; - if ((ret = mg_dsk_wait(mg_io_wait_drq, MG_OEM_DISK_WAIT_TIME_NORMAL)) != ERROR_OK) + ret = mg_dsk_wait(mg_io_wait_drq, MG_OEM_DISK_WAIT_TIME_NORMAL); + if (ret != ERROR_OK) return ret; LOG_INFO("mflash: read drive info"); if (! mflash_bank->drv_info) - mflash_bank->drv_info = malloc(sizeof(mg_drv_info_t)); + mflash_bank->drv_info = malloc(sizeof(struct mg_drv_info)); - target_read_memory(target, mg_buff, 2, sizeof(mg_io_type_drv_info) >> 1, + ret = target_read_memory(target, mg_buff, 2, + sizeof(mg_io_type_drv_info) >> 1, (uint8_t *)&mflash_bank->drv_info->drv_id); if (ret != ERROR_OK) return ret; @@ -407,15 +409,15 @@ static int mg_mflash_probe(void) return mg_dsk_drv_info(); } -static int mg_probe_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(mg_probe_cmd) { int ret; ret = mg_mflash_probe(); if (ret == ERROR_OK) { - command_print(cmd_ctx, "mflash (total %" PRIu32 " sectors) found at 0x%8.8" PRIx32 "", - mflash_bank->drv_info->tot_sects, mflash_bank->base ); + command_print(CMD_CTX, "mflash (total %" PRIu32 " sectors) found at 0x%8.8" PRIx32 "", + mflash_bank->drv_info->tot_sects, mflash_bank->base); } return ret; @@ -425,16 +427,16 @@ static int mg_mflash_do_read_sects(void *buff, uint32_t sect_num, uint32_t sect_ { uint32_t i, address; int ret; - target_t *target = mflash_bank->target; + struct target *target = mflash_bank->target; uint8_t *buff_ptr = buff; - duration_t duration; - if ((ret = mg_dsk_io_cmd(sect_num, sect_cnt, mg_io_cmd_read)) != ERROR_OK ) + if ((ret = mg_dsk_io_cmd(sect_num, sect_cnt, mg_io_cmd_read)) != ERROR_OK) return ret; address = mflash_bank->base + MG_BUFFER_OFFSET; - duration_start_measure(&duration); + struct duration bench; + duration_start(&bench); for (i = 0; i < sect_cnt; i++) { ret = mg_dsk_wait(mg_io_wait_drq, MG_OEM_DISK_WAIT_TIME_NORMAL); @@ -453,11 +455,10 @@ static int mg_mflash_do_read_sects(void *buff, uint32_t sect_num, uint32_t sect_ LOG_DEBUG("mflash: %" PRIu32 " (0x%8.8" PRIx32 ") sector read", sect_num + i, (sect_num + i) * MG_MFLASH_SECTOR_SIZE); - duration_stop_measure(&duration, NULL); - - if ((duration.duration.tv_sec * 1000 + duration.duration.tv_usec / 1000) > 3000) { + ret = duration_measure(&bench); + if ((ERROR_OK == ret) && (duration_elapsed(&bench) > 3)) { LOG_INFO("mflash: read %" PRIu32 "'th sectors", sect_num + i); - duration_start_measure(&duration); + duration_start(&bench); } } @@ -474,8 +475,8 @@ static int mg_mflash_read_sects(void *buff, uint32_t sect_num, uint32_t sect_cnt residue = sect_cnt % 256; for (i = 0; i < quotient; i++) { - LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : 0x%0lx", sect_num, - (unsigned long)buff_ptr); + LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : %p", + sect_num, buff_ptr); ret = mg_mflash_do_read_sects(buff_ptr, sect_num, 256); if (ret != ERROR_OK) return ret; @@ -485,8 +486,8 @@ static int mg_mflash_read_sects(void *buff, uint32_t sect_num, uint32_t sect_cnt } if (residue) { - LOG_DEBUG("mflash: sect num : %" PRIx32 " buff : %0lx", sect_num, - (unsigned long)buff_ptr); + LOG_DEBUG("mflash: sect num : %" PRIx32 " buff : %p", + sect_num, buff_ptr); return mg_mflash_do_read_sects(buff_ptr, sect_num, residue); } @@ -498,16 +499,16 @@ static int mg_mflash_do_write_sects(void *buff, uint32_t sect_num, uint32_t sect { uint32_t i, address; int ret; - target_t *target = mflash_bank->target; + struct target *target = mflash_bank->target; uint8_t *buff_ptr = buff; - duration_t duration; - if ((ret = mg_dsk_io_cmd(sect_num, sect_cnt, cmd)) != ERROR_OK ) + if ((ret = mg_dsk_io_cmd(sect_num, sect_cnt, cmd)) != ERROR_OK) return ret; address = mflash_bank->base + MG_BUFFER_OFFSET; - duration_start_measure(&duration); + struct duration bench; + duration_start(&bench); for (i = 0; i < sect_cnt; i++) { ret = mg_dsk_wait(mg_io_wait_drq, MG_OEM_DISK_WAIT_TIME_NORMAL); @@ -517,7 +518,7 @@ static int mg_mflash_do_write_sects(void *buff, uint32_t sect_num, uint32_t sect ret = target_write_memory(target, address, 2, MG_MFLASH_SECTOR_SIZE / 2, buff_ptr); if (ret != ERROR_OK) return ret; - + buff_ptr += MG_MFLASH_SECTOR_SIZE; ret = target_write_u8(target, mflash_bank->base + MG_REG_OFFSET + MG_REG_COMMAND, mg_io_cmd_confirm_write); @@ -526,11 +527,10 @@ static int mg_mflash_do_write_sects(void *buff, uint32_t sect_num, uint32_t sect LOG_DEBUG("mflash: %" PRIu32 " (0x%8.8" PRIx32 ") sector write", sect_num + i, (sect_num + i) * MG_MFLASH_SECTOR_SIZE); - duration_stop_measure(&duration, NULL); - - if ((duration.duration.tv_sec * 1000 + duration.duration.tv_usec / 1000) > 3000) { + ret = duration_measure(&bench); + if ((ERROR_OK == ret) && (duration_elapsed(&bench) > 3)) { LOG_INFO("mflash: wrote %" PRIu32 "'th sectors", sect_num + i); - duration_start_measure(&duration); + duration_start(&bench); } } @@ -552,7 +552,7 @@ static int mg_mflash_write_sects(void *buff, uint32_t sect_num, uint32_t sect_cn residue = sect_cnt % 256; for (i = 0; i < quotient; i++) { - LOG_DEBUG("mflash: sect num : %" PRIu32 "buff : %p", sect_num, + LOG_DEBUG("mflash: sect num : %" PRIu32 "buff : %p", sect_num, buff_ptr); ret = mg_mflash_do_write_sects(buff_ptr, sect_num, 256, mg_io_cmd_write); if (ret != ERROR_OK) @@ -563,7 +563,7 @@ static int mg_mflash_write_sects(void *buff, uint32_t sect_num, uint32_t sect_cn } if (residue) { - LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : %p", sect_num, + LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : %p", sect_num, buff_ptr); return mg_mflash_do_write_sects(buff_ptr, sect_num, residue, mg_io_cmd_write); } @@ -703,22 +703,20 @@ static int mg_mflash_write(uint32_t addr, uint8_t *buff, uint32_t len) return ret; } -static int mg_write_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(mg_write_cmd) { - uint32_t address, buf_cnt, cnt, res, i; + uint32_t address, cnt, res, i; uint8_t *buffer; - fileio_t fileio; - duration_t duration; - char *duration_text; + struct fileio fileio; int ret; - if (argc != 3) { + if (CMD_ARGC != 3) { return ERROR_COMMAND_SYNTAX_ERROR; } - address = strtoul(args[2], NULL, 0); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], address); - ret = fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY); + ret = fileio_open(&fileio, CMD_ARGV[1], FILEIO_READ, FILEIO_BINARY); if (ret != ERROR_OK) return ret; @@ -731,8 +729,10 @@ static int mg_write_cmd(struct command_context_s *cmd_ctx, char *cmd, char **arg cnt = fileio.size / MG_FILEIO_CHUNK; res = fileio.size % MG_FILEIO_CHUNK; - duration_start_measure(&duration); + struct duration bench; + duration_start(&bench); + size_t buf_cnt; for (i = 0; i < cnt; i++) { if ((ret = fileio_read(&fileio, MG_FILEIO_CHUNK, buffer, &buf_cnt)) != ERROR_OK) @@ -741,55 +741,51 @@ static int mg_write_cmd(struct command_context_s *cmd_ctx, char *cmd, char **arg goto mg_write_cmd_err; address += MG_FILEIO_CHUNK; } - + if (res) { if ((ret = fileio_read(&fileio, res, buffer, &buf_cnt)) != ERROR_OK) - goto mg_write_cmd_err; + goto mg_write_cmd_err; if ((ret = mg_mflash_write(address, buffer, res)) != ERROR_OK) goto mg_write_cmd_err; } - duration_stop_measure(&duration, &duration_text); - - command_print(cmd_ctx, "wrote %lli byte from file %s in %s (%f kB/s)", - fileio.size, args[1], duration_text, - (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0))); + if (duration_measure(&bench) == ERROR_OK) + { + command_print(CMD_CTX, "wrote %ld bytes from file %s " + "in %fs (%0.3f kB/s)", (long)fileio.size, CMD_ARGV[1], + duration_elapsed(&bench), duration_kbps(&bench, fileio.size)); + } - free(duration_text); free(buffer); fileio_close(&fileio); return ERROR_OK; mg_write_cmd_err: - duration_stop_measure(&duration, &duration_text); - free(duration_text); - free(buffer); + free(buffer); fileio_close(&fileio); return ret; } -static int mg_dump_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(mg_dump_cmd) { - uint32_t address, size_written, size, cnt, res, i; + uint32_t address, size, cnt, res, i; uint8_t *buffer; - fileio_t fileio; - duration_t duration; - char *duration_text; + struct fileio fileio; int ret; - if (argc != 4) { + if (CMD_ARGC != 4) { return ERROR_COMMAND_SYNTAX_ERROR; } - address = strtoul(args[2], NULL, 0); - size = strtoul(args[3], NULL, 0); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], address); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], size); - ret = fileio_open(&fileio, args[1], FILEIO_WRITE, FILEIO_BINARY); + ret = fileio_open(&fileio, CMD_ARGV[1], FILEIO_WRITE, FILEIO_BINARY); if (ret != ERROR_OK) return ret; - + buffer = malloc(MG_FILEIO_CHUNK); if (!buffer) { fileio_close(&fileio); @@ -798,9 +794,11 @@ static int mg_dump_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args cnt = size / MG_FILEIO_CHUNK; res = size % MG_FILEIO_CHUNK; - - duration_start_measure(&duration); + struct duration bench; + duration_start(&bench); + + size_t size_written; for (i = 0; i < cnt; i++) { if ((ret = mg_mflash_read(address, buffer, MG_FILEIO_CHUNK)) != ERROR_OK) goto mg_dump_cmd_err; @@ -809,7 +807,7 @@ static int mg_dump_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args goto mg_dump_cmd_err; address += MG_FILEIO_CHUNK; } - + if (res) { if ((ret = mg_mflash_read(address, buffer, res)) != ERROR_OK) goto mg_dump_cmd_err; @@ -817,30 +815,29 @@ static int mg_dump_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args goto mg_dump_cmd_err; } - duration_stop_measure(&duration, &duration_text); - - command_print(cmd_ctx, "dump image (address 0x%8.8" PRIx32 " size %" PRIu32 ") to file %s in %s (%f kB/s)", - address, size, args[1], duration_text, - (float)size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0))); + if (duration_measure(&bench) == ERROR_OK) + { + command_print(CMD_CTX, "dump image (address 0x%8.8" PRIx32 " " + "size %" PRIu32 ") to file %s in %fs (%0.3f kB/s)", + address, size, CMD_ARGV[1], + duration_elapsed(&bench), duration_kbps(&bench, size)); + } - free(duration_text); free(buffer); fileio_close(&fileio); return ERROR_OK; mg_dump_cmd_err: - duration_stop_measure(&duration, &duration_text); - free(duration_text); - free(buffer); + free(buffer); fileio_close(&fileio); - - return ret; + + return ret; } static int mg_set_feature(mg_feature_id feature, mg_feature_val config) { - target_t *target = mflash_bank->target; + struct target *target = mflash_bank->target; uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET; int ret; @@ -923,7 +920,7 @@ static double mg_do_calc_pll(double XIN, mg_pll_t * p_pll_val, int is_approximat CLK_OUT = XIN * ((double)M / N) / NO; - if ((int)((CLK_OUT+ROUND) / DIV) + if ((int)((CLK_OUT + ROUND) / DIV) == (int)(MG_PLL_CLK_OUT / DIV)) { if (mg_is_valid_pll(XIN, N, CLK_OUT, NO) == ERROR_OK) { @@ -959,7 +956,7 @@ static int mg_verify_interface(void) uint16_t buff[MG_MFLASH_SECTOR_SIZE >> 1]; uint16_t i, j; uint32_t address = mflash_bank->base + MG_BUFFER_OFFSET; - target_t *target = mflash_bank->target; + struct target *target = mflash_bank->target; int ret; for (j = 0; j < 10; j++) { @@ -1214,8 +1211,7 @@ static int mg_erase_nand(void) return ret; } -int mg_config_cmd(struct command_context_s *cmd_ctx, char *cmd, - char **args, int argc) +COMMAND_HANDLER(mg_config_cmd) { double fin, fout; mg_pll_t pll; @@ -1227,18 +1223,20 @@ int mg_config_cmd(struct command_context_s *cmd_ctx, char *cmd, if ((ret = mg_mflash_rst()) != ERROR_OK) return ret; - switch (argc) { + switch (CMD_ARGC) { case 2: - if (!strcmp(args[1], "boot")) + if (!strcmp(CMD_ARGV[1], "boot")) return mg_boot_config(); - else if (!strcmp(args[1], "storage")) + else if (!strcmp(CMD_ARGV[1], "storage")) return mg_storage_config(); else return ERROR_COMMAND_NOTFOUND; break; case 3: - if (!strcmp(args[1], "pll")) { - fin = strtoul(args[2], NULL, 0); + if (!strcmp(CMD_ARGV[1], "pll")) { + unsigned long freq; + COMMAND_PARSE_NUMBER(ulong, CMD_ARGV[2], freq); + fin = freq; if (fin > MG_PLL_CLK_OUT) { LOG_ERROR("mflash: input freq. is too large"); @@ -1252,7 +1250,7 @@ int mg_config_cmd(struct command_context_s *cmd_ctx, char *cmd, return ERROR_MG_INVALID_PLL; } - LOG_INFO("mflash: Fout=%" PRIu32 " Hz, feedback=%u," + LOG_INFO("mflash: Fout=%" PRIu32 " Hz, feedback=%u," "indiv=%u, outdiv=%u, lock=%u", (uint32_t)fout, pll.feedback_div, pll.input_div, pll.output_div, @@ -1270,64 +1268,131 @@ int mg_config_cmd(struct command_context_s *cmd_ctx, char *cmd, } } -int mflash_init_drivers(struct command_context_s *cmd_ctx) +static const struct command_registration mflash_exec_command_handlers[] = { + { + .name = "probe", + .handler = mg_probe_cmd, + .mode = COMMAND_EXEC, + .help = "Detect bank configuration information", + }, + { + .name = "write", + .handler = mg_write_cmd, + .mode = COMMAND_EXEC, + /* FIXME bank_num is unused */ + .usage = "bank_num filename address", + .help = "Write binary file at the specified address.", + }, + { + .name = "dump", + .handler = mg_dump_cmd, + .mode = COMMAND_EXEC, + /* FIXME bank_num is unused */ + .usage = "bank_num filename address size", + .help = "Write specified number of bytes from a binary file " + "to the specified, address.", + }, + { + .name = "config", + .handler = mg_config_cmd, + .mode = COMMAND_EXEC, + .help = "Configure MFLASH options.", + .usage = "('boot'|'storage'|'pll' frequency)", + }, + COMMAND_REGISTRATION_DONE +}; + +static int mflash_init_drivers(struct command_context *cmd_ctx) { - if (mflash_bank) { - register_command(cmd_ctx, mflash_cmd, "probe", mg_probe_cmd, COMMAND_EXEC, NULL); - register_command(cmd_ctx, mflash_cmd, "write", mg_write_cmd, COMMAND_EXEC, - "mflash write
"); - register_command(cmd_ctx, mflash_cmd, "dump", mg_dump_cmd, COMMAND_EXEC, - "mflash dump
"); - register_command(cmd_ctx, mflash_cmd, "config", mg_config_cmd, - COMMAND_EXEC, "mflash config "); + if (!mflash_bank) + return ERROR_OK; + return register_commands(cmd_ctx, NULL, mflash_exec_command_handlers); +} + +COMMAND_HANDLER(handle_mflash_init_command) +{ + if (CMD_ARGC != 0) + return ERROR_COMMAND_SYNTAX_ERROR; + + static bool mflash_initialized = false; + if (mflash_initialized) + { + LOG_INFO("'mflash init' has already been called"); + return ERROR_OK; } + mflash_initialized = true; - return ERROR_OK; + LOG_DEBUG("Initializing mflash devices..."); + return mflash_init_drivers(CMD_CTX); } -static int mg_bank_cmd(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(mg_bank_cmd) { - target_t *target; - char *str; + struct target *target; int i; - if (argc < 4) + if (CMD_ARGC < 4) { return ERROR_COMMAND_SYNTAX_ERROR; } - if ((target = get_target(args[3])) == NULL) + if ((target = get_target(CMD_ARGV[3])) == NULL) { - LOG_ERROR("target '%s' not defined", args[3]); + LOG_ERROR("target '%s' not defined", CMD_ARGV[3]); return ERROR_FAIL; } - mflash_bank = calloc(sizeof(mflash_bank_t), 1); - mflash_bank->base = strtoul(args[1], NULL, 0); - mflash_bank->rst_pin.num = strtoul(args[2], &str, 0); + mflash_bank = calloc(sizeof(struct mflash_bank), 1); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], mflash_bank->base); + /// @todo Verify how this parsing should work, then document it. + char *str; + mflash_bank->rst_pin.num = strtoul(CMD_ARGV[2], &str, 0); if (*str) - mflash_bank->rst_pin.port[0] = (uint16_t)tolower(str[0]); + mflash_bank->rst_pin.port[0] = (uint16_t) + tolower((unsigned)str[0]); mflash_bank->target = target; for (i = 0; mflash_gpio[i] ; i++) { - if (! strcmp(mflash_gpio[i]->name, args[0])) { + if (! strcmp(mflash_gpio[i]->name, CMD_ARGV[0])) { mflash_bank->gpio_drv = mflash_gpio[i]; } } if (! mflash_bank->gpio_drv) { - LOG_ERROR("%s is unsupported soc", args[0]); + LOG_ERROR("%s is unsupported soc", CMD_ARGV[0]); return ERROR_MG_UNSUPPORTED_SOC; } return ERROR_OK; } -int mflash_register_commands(struct command_context_s *cmd_ctx) +static const struct command_registration mflash_config_command_handlers[] = { + { + .name = "bank", + .handler = mg_bank_cmd, + .mode = COMMAND_CONFIG, + .help = "configure a mflash device bank", + .usage = "soc_type base_addr pin_id target", + }, + { + .name = "init", + .mode = COMMAND_CONFIG, + .handler = handle_mflash_init_command, + .help = "initialize mflash devices", + }, + COMMAND_REGISTRATION_DONE +}; +static const struct command_registration mflash_command_handler[] = { + { + .name = "mflash", + .mode = COMMAND_ANY, + .help = "mflash command group", + .chain = mflash_config_command_handlers, + }, + COMMAND_REGISTRATION_DONE +}; +int mflash_register_commands(struct command_context *cmd_ctx) { - mflash_cmd = register_command(cmd_ctx, NULL, "mflash", NULL, COMMAND_ANY, NULL); - register_command(cmd_ctx, mflash_cmd, "bank", mg_bank_cmd, COMMAND_CONFIG, - "mflash bank "); - return ERROR_OK; + return register_commands(cmd_ctx, NULL, mflash_command_handler); }