diff --git a/samples/drivers/flash_shell/prj.conf b/samples/drivers/flash_shell/prj.conf index 7b470f4bfac48..1c70335b3f760 100644 --- a/samples/drivers/flash_shell/prj.conf +++ b/samples/drivers/flash_shell/prj.conf @@ -1,11 +1,10 @@ CONFIG_PRINTK=y -CONFIG_CONSOLE_SHELL=y -CONFIG_KERNEL_SHELL=y +CONFIG_SHELL=y +CONFIG_SERIAL=y +CONFIG_LOG=y CONFIG_FLASH=y # Your flash driver may not enable this, even if it's supported. # If that's the case and you're interested in the flash layout, enable # it here. # CONFIG_FLASH_PAGE_LAYOUT=y CONFIG_MPU_ALLOW_FLASH_WRITE=y - -CONFIG_LOG=y diff --git a/samples/drivers/flash_shell/src/main.c b/samples/drivers/flash_shell/src/main.c index efffadabef071..9b128ca959b7e 100644 --- a/samples/drivers/flash_shell/src/main.c +++ b/samples/drivers/flash_shell/src/main.c @@ -9,13 +9,27 @@ #include #include -#include +#include +#include +#include #include #include #include +#include + +LOG_MODULE_REGISTER(app); -#define THIS_MODULE_NAME "flash" +SHELL_UART_DEFINE(shell_transport_uart); +SHELL_DEFINE(uart_shell, "uart:~$ ", &shell_transport_uart, 10); +#define PR_SHELL(shell, fmt, ...) \ + shell_fprintf(shell, SHELL_NORMAL, fmt, ##__VA_ARGS__) +#define PR_ERROR(shell, fmt, ...) \ + shell_fprintf(shell, SHELL_ERROR, fmt, ##__VA_ARGS__) +#define PR_INFO(fshell, fmt, ...) \ + shell_fprintf(shell, SHELL_INFO, fmt, ##__VA_ARGS__) +#define PR_WARNING(shell, fmt, ...) \ + shell_fprintf(shell, SHELL_WARNING, fmt, ##__VA_ARGS__) /* * When FLASH_DEV_NAME is available, we use it here. Otherwise, * the device can be set at runtime with the set_device command. @@ -26,10 +40,10 @@ /* Command usage info. */ #define WRITE_BLOCK_SIZE_HELP \ - ("Print the device's write block size. This is the smallest amount\n" \ - "of data which may be written to the device, in bytes.") + ("Print the device's write block size. This is the smallest amount" \ + " of data which may be written to the device, in bytes.") #define READ_HELP \ - (" \n\n" \ + (" \n" \ "Read bytes from device offset .") #define ERASE_HELP \ (" \n\n" \ @@ -44,82 +58,69 @@ "\n\nPrint the number of pages on the flash device." #define PAGE_LAYOUT_HELP \ ("[start_page] [end_page]\n\n" \ - "Print layout of flash pages in the range [start_page, end_page],\n" \ - "which is inclusive. By default, all pages are printed.") -#define READ_PAGE_HELP \ + "Print layout of flash pages in the range [start_page, end_page]," \ + " which is inclusive. By default, all pages are printed.") +#define PAGE_READ_HELP \ (" OR \n\n" \ - "Read bytes from given page, starting at page offset ,\n" \ - "or offset 0 if not given. No checks are made that bytes read are\n" \ - "all within the page.") -#define ERASE_PAGE_HELP \ + "Read bytes from given page, starting at page offset ," \ + "or offset 0 if not given. No checks are made that bytes read are" \ + " all within the page.") +#define PAGE_ERASE_HELP \ (" [num]\n\n" \ "Erase [num] pages (default 1), starting at page .") -#define WRITE_PAGE_HELP \ +#define PAGE_WRITE_HELP \ (" [... byteN]\n\n" \ - "Write given bytes to given page, starting at page offset .\n" \ - "No checks are made that the bytes all fall within the page.\n" \ - "Pages must be erased before they can be written.") + "Write given bytes to given page, starting at page offset ." \ + " No checks are made that the bytes all fall within the page." \ + " Pages must be erased before they can be written.") #endif -#define SET_DEVICE_HELP \ +#define SET_DEV_HELP \ ("\n\n" \ - "Set flash device by name. If a flash device was not found,\n" \ - "this command must be run first to bind a device to this module.") + "Set flash device by name. If a flash device was not found," \ + " this command must be run first to bind a device to this module.") -/* - * Canonicalize argc/argv. - * - * When run as " ", i.e. after running "select - * flash", the module name is not part of argv. When run as "flash - * ", it is. Normalize argc and argv to skip - * "flash" regardless of the case. - */ -#define CANONICALIZE_ARGS(argc, argv) do { \ - if (!strcmp(argv[0], THIS_MODULE_NAME)) { \ - argc--; \ - argv++; \ - } \ - /* Skip the command name as well. */ \ - argc--; \ - argv++; \ - } while (0) - -#define ARGC_MAX 10 /* from shell.c */ +#if (CONFIG_SHELL_ARGC_MAX > 4) +#define ARGC_MAX (CONFIG_SHELL_ARGC_MAX - 4) +#else +#error Please increase CONFIG_SHELL_ARGC_MAX parameter. +#endif static struct device *flash_device; -static int check_flash_device(void) +static int check_flash_device(const struct shell *shell) { if (flash_device == NULL) { - printk("Flash device is unknown. Run set_device first.\n"); + PR_ERROR(shell, "Flash device is unknown." + " Run set_device first.\r\n"); return -ENODEV; } return 0; } -static void dump_buffer(u8_t *buf, size_t size) +static void dump_buffer(const struct shell *shell, u8_t *buf, size_t size) { bool newline = false; u8_t *p = buf; while (size >= 8) { - printk("%02x %02x %02x %02x | %02x %02x %02x %02x\n", + PR_SHELL(shell, "%02x %02x %02x %02x | %02x %02x %02x %02x\r\n", p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]); p += 8; size -= 8; } if (size > 4) { - printk("%02x %02x %02x %02x | ", + PR_SHELL(shell, "%02x %02x %02x %02x | ", p[0], p[1], p[2], p[3]); p += 4; size -= 4; newline = true; } while (size--) { - printk("%02x ", *p++); + PR_SHELL(shell, "%02x ", *p++); newline = true; } if (newline) { - printk("\n"); + PR_SHELL(shell, "\r\n"); } } @@ -141,6 +142,7 @@ static int parse_ul(const char *str, unsigned long *result) static int parse_u8(const char *str, u8_t *result) { unsigned long val; + if (parse_ul(str, &val) || val > 0xff) { return -EINVAL; } @@ -149,7 +151,7 @@ static int parse_u8(const char *str, u8_t *result) } /* Read bytes, dumping contents to console and printing on error. */ -static int do_read(off_t offset, size_t len) +static int do_read(const struct shell *shell, off_t offset, size_t len) { u8_t buf[64]; int ret; @@ -159,7 +161,7 @@ static int do_read(off_t offset, size_t len) if (ret) { goto err_read; } - dump_buffer(buf, sizeof(buf)); + dump_buffer(shell, buf, sizeof(buf)); len -= sizeof(buf); offset += sizeof(buf); } @@ -167,192 +169,228 @@ static int do_read(off_t offset, size_t len) if (ret) { goto err_read; } - dump_buffer(buf, len); + dump_buffer(shell, buf, len); return 0; err_read: - printk("flash_read: %d\n", ret); - return 0; + PR_ERROR(shell, "flash_read error: %d\r\n", ret); + return ret; } /* Erase area, handling write protection and printing on error. */ -static int do_erase(off_t offset, size_t size) +static int do_erase(const struct shell *shell, off_t offset, size_t size) { int ret; ret = flash_write_protection_set(flash_device, false); if (ret) { - printk("flash_write_protection_set: %d (can't disable)\n", ret); + PR_ERROR(shell, "Failed to disable flash protection (err: %d)." + "\r\n", ret); return ret; } ret = flash_erase(flash_device, offset, size); if (ret) { - printk("flash_erase: %d\n", ret); + PR_ERROR(shell, "flash_erase failed (err:%d).\r\n", ret); return ret; } ret = flash_write_protection_set(flash_device, true); if (ret) { - printk("flash_write_protection_set: %d (can't enable)\n", ret); + PR_ERROR(shell, "Failed to enable flash protection (err: %d)." + "\r\n", ret); } return ret; } /* Write bytes, handling write protection and printing on error. */ -static int do_write(off_t offset, u8_t *buf, size_t len, bool read_back) +static int do_write(const struct shell *shell, off_t offset, u8_t *buf, + size_t len, bool read_back) { int ret; ret = flash_write_protection_set(flash_device, false); if (ret) { - printk("flash_write_protection_set: %d (can't disable)\n", ret); + PR_ERROR(shell, "Failed to disable flash protection (err: %d)." + "\r\n", ret); return ret; } ret = flash_write(flash_device, offset, buf, len); if (ret) { - printk("flash_write: %d\n", ret); + PR_ERROR(shell, "flash_write failed (err:%d).\r\n", ret); return ret; } ret = flash_write_protection_set(flash_device, true); if (ret) { - printk("flash_write_protection_set: %d (can't enable)\n", ret); + PR_ERROR(shell, "Failed to enable flash protection (err: %d)." + "\r\n", ret); return ret; } if (read_back) { - printk("Reading back written bytes:\n"); - ret = do_read(offset, len); + PR_SHELL(shell, "Reading back written bytes:\r\n"); + ret = do_read(shell, offset, len); } return ret; } -static int flash_shell_write_block_size(int argc, char *argv[]) +static int cmd_flash(const struct shell *shell, size_t argc, char **argv) { - if (check_flash_device()) { + ARG_UNUSED(argc); + ARG_UNUSED(argv); + + shell_help_print(shell, NULL, 0); + return 0; +} + + +static int cmd_write_block_size(const struct shell *shell, size_t argc, + char **argv) +{ + int err; + + if (!shell_cmd_precheck(shell, argc == 1, NULL, 0)) { return 0; } - CANONICALIZE_ARGS(argc, argv); - if (argc) { - printk("No arguments expected.\n"); - return 0; + err = check_flash_device(shell); + if (!err) { + PR_SHELL(shell, "%d\r\n", + flash_get_write_block_size(flash_device)); } - printk("%d\n", flash_get_write_block_size(flash_device)); - return 0; + return err; } -static int flash_shell_read(int argc, char *argv[]) +static int cmd_read(const struct shell *shell, size_t argc, char **argv) { - long unsigned int offset, len; + unsigned long int offset, len; + int err; - if (check_flash_device()) { + if (!shell_cmd_precheck(shell, argc == 3, NULL, 0)) { return 0; } - CANONICALIZE_ARGS(argc, argv); - if (argc != 2 || parse_ul(argv[0], &offset) || - parse_ul(argv[1], &len)) { - goto bail; + err = check_flash_device(shell); + if (err) { + goto exit; } - do_read(offset, len); - return 0; + if (parse_ul(argv[1], &offset) || parse_ul(argv[2], &len)) { + PR_ERROR(shell, "Invalid arguments.\r\n"); + err = -EINVAL; + goto exit; + } - bail: - printk("Invalid arguments.\n"); - return -EINVAL; + err = do_read(shell, offset, len); + +exit: + return err; } -static int flash_shell_erase(int argc, char *argv[]) +static int cmd_erase(const struct shell *shell, size_t argc, char **argv) { - long unsigned int offset, size; + unsigned long int offset, size; + int err; - if (check_flash_device()) { - return 0; + if (!shell_cmd_precheck(shell, argc == 3, NULL, 0)) { + return 0 ; } - CANONICALIZE_ARGS(argc, argv); - if (argc != 2 || parse_ul(argv[0], &offset) || - parse_ul(argv[1], &size)) { - goto bail; + err = check_flash_device(shell); + if (err) { + goto exit; } - do_erase((off_t)offset, (size_t)size); - return 0; + if (parse_ul(argv[1], &offset) || parse_ul(argv[2], &size)) { + PR_ERROR(shell, "Invalid arguments.\r\n"); + err = -EINVAL; + goto exit; + } - bail: - printk("Invalid arguments.\n"); - return -EINVAL; + err = do_erase(shell, (off_t)offset, (size_t)size); +exit: + return err; } -static int flash_shell_write(int argc, char *argv[]) +static int cmd_write(const struct shell *shell, size_t argc, char **argv) { + unsigned long int i, offset; u8_t buf[ARGC_MAX]; - long unsigned int i, offset; + int err = 0; - if (check_flash_device()) { + if (!shell_cmd_precheck(shell, argc > 2, NULL, 0)) { return 0; } - CANONICALIZE_ARGS(argc, argv); - if (argc < 2 || parse_ul(argv[0], &offset)) { - goto bail; - } else if (argc - 1 > sizeof(buf)) { + err = check_flash_device(shell); + if (err) { + goto exit; + } + + err = parse_ul(argv[1], &offset); + if (err) { + PR_ERROR(shell, "Invalid argument.\r\n"); + goto exit; + } + + if ((argc - 2) > ARGC_MAX) { /* Can only happen if Zephyr limit is increased. */ - printk("At most %lu bytes can be written.\n", - (unsigned long)sizeof(buf)); - return -EINVAL; + PR_ERROR(shell, "At most %lu bytes can be written.\r\n" + "In order to write more bytes please increase" + " parameter: CONFIG_SHELL_ARGC_MAX.\r\n", + (unsigned long)ARGC_MAX); + err = -EINVAL; + goto exit; } - argc--; - argv++; + + /* skip cmd name and offset */ + argc -= 2; + argv += 2; for (i = 0; i < argc; i++) { if (parse_u8(argv[i], &buf[i])) { - printk("Argument %lu (%s) is not a byte.\n", - i + 1, argv[i]); - goto bail; + PR_ERROR(shell, "Argument %lu (%s) is not a byte.\r\n" + "Bytes shall be passed in decimal" + " notation.\r\n", + i + 1, argv[i]); + err = -EINVAL; + goto exit; } } - do_write(offset, buf, i, true); - return 0; + err = do_write(shell, offset, buf, i, true); - bail: - printk("Invalid arguments.\n"); - return -EINVAL; +exit: + return err; } #ifdef CONFIG_FLASH_PAGE_LAYOUT -static int flash_shell_page_count(int argc, char *argv[]) +static int cmd_page_count(const struct shell *shell, size_t argc, char **argv) { size_t page_count; + int err; - if (check_flash_device()) { + if (!shell_cmd_precheck(shell, argc == 1, NULL, 0)) { return 0; } - CANONICALIZE_ARGS(argc, argv); - if (argc) { - goto bail; + err = check_flash_device(shell); + if (!err) { + page_count = flash_get_page_count(flash_device); + PR_SHELL(shell, "Flash device contains %lu pages.\r\n", + (unsigned long int)page_count); } - page_count = flash_get_page_count(flash_device); - printk("Flash device contains %lu pages.\n", - (long unsigned int)page_count); - return 0; - - bail: - printk("Invalid arguments.\n"); - return -EINVAL; + return err; } struct page_layout_data { - long unsigned int start_page; - long unsigned int end_page; + unsigned long int start_page; + unsigned long int end_page; + const struct shell *shell; }; static bool page_layout_cb(const struct flash_pages_info *info, void *datav) { struct page_layout_data *data = datav; - long unsigned int sz; + unsigned long int sz; if (info->index < data->start_page) { return true; @@ -361,217 +399,224 @@ static bool page_layout_cb(const struct flash_pages_info *info, void *datav) } sz = info->size; - printk("\tPage %u: start 0x%08x, length 0x%lx (%lu, %lu KB)\n", - info->index, info->start_offset, sz, sz, sz / KB(1)); + PR_SHELL(data->shell, + "\tPage %u: start 0x%08x, length 0x%lx (%lu, %lu KB)\r\n", + info->index, info->start_offset, sz, sz, sz / KB(1)); return true; } -static int flash_shell_page_layout(int argc, char *argv[]) +static int cmd_page_layout(const struct shell *shell, size_t argc, char **argv) { - long unsigned int start_page, end_page; + unsigned long int start_page, end_page; struct page_layout_data data; + int err = 0; - if (check_flash_device()) { - return 0; + if (!shell_cmd_precheck(shell, argc <= 3, NULL, 0)) { + return 0 ; + } + + err = check_flash_device(shell); + if (err) { + goto bail; } - CANONICALIZE_ARGS(argc, argv); switch (argc) { - case 0: + case 1: start_page = 0; end_page = flash_get_page_count(flash_device) - 1; break; - case 1: - if (parse_ul(argv[0], &start_page)) { + case 2: + if (parse_ul(argv[1], &start_page)) { + err = -EINVAL; goto bail; } end_page = flash_get_page_count(flash_device) - 1; break; - case 2: - if (parse_ul(argv[0], &start_page) || - parse_ul(argv[1], &end_page)) { + case 3: + if (parse_ul(argv[1], &start_page) || + parse_ul(argv[2], &end_page)) { + err = -EINVAL; goto bail; } break; default: - goto bail; + PR_ERROR(shell, "Invalid argument count.\r\n"); + return -EINVAL; } data.start_page = start_page; data.end_page = end_page; + data.shell = shell; flash_page_foreach(flash_device, page_layout_cb, &data); return 0; - bail: - printk("Invalid arguments.\n"); - return -EINVAL; +bail: + PR_ERROR(shell, "Invalid arguments.\r\n"); + return err; } -static int flash_shell_read_page(int argc, char *argv[]) +static int cmd_page_read(const struct shell *shell, size_t argc, char **argv) { - long unsigned int page, offset, len; + unsigned long int page, offset, len; struct flash_pages_info info; int ret; - if (check_flash_device()) { - return 0; + ret = check_flash_device(shell); + if (ret) { + return ret; } - CANONICALIZE_ARGS(argc, argv); - if (argc != 2 && argc != 3) { - goto bail; + if (!shell_cmd_precheck(shell, (argc == 3) || (argc == 4), NULL, 0)) { + return 0; } - if (argc == 2) { - if (parse_ul(argv[0], &page) || parse_ul(argv[1], &len)) { + + if (argc == 3) { + if (parse_ul(argv[1], &page) || parse_ul(argv[2], &len)) { + ret = -EINVAL; goto bail; } offset = 0; - } else if (parse_ul(argv[0], &page) || parse_ul(argv[1], &offset) || - parse_ul(argv[2], &len)) { + } else if (parse_ul(argv[1], &page) || parse_ul(argv[2], &offset) || + parse_ul(argv[3], &len)) { + ret = -EINVAL; goto bail; } ret = flash_get_page_info_by_idx(flash_device, page, &info); if (ret) { - printk("flash_page_info_by_idx: %d\n", ret); - return 0; + PR_ERROR(shell, "Function flash_page_info_by_idx returned an" + " error: %d\r\n", ret); + return ret; } offset += info.start_offset; - do_read(offset, len); - return 0; + ret = do_read(shell, offset, len); + return ret; bail: - printk("Invalid arguments.\n"); - return -EINVAL; + PR_ERROR(shell, "Invalid arguments.\r\n"); + return ret; } -static int flash_shell_erase_page(int argc, char *argv[]) +static int cmd_page_erase(const struct shell *shell, size_t argc, char **argv) { struct flash_pages_info info; - long unsigned int i, page, num; + unsigned long int i, page, num; int ret; - if (check_flash_device()) { + ret = check_flash_device(shell); + if (ret) { + return ret; + } + + if (!shell_cmd_precheck(shell, (argc == 2) || (argc == 3), NULL, 0)) { return 0; } - CANONICALIZE_ARGS(argc, argv); - if (argc < 1 || parse_ul(argv[0], &page)) { + if (parse_ul(argv[1], &page)) { + ret = -EINVAL; goto bail; } - if (argc == 1) { + if (argc == 2) { num = 1; - } else if (parse_ul(argv[1], &num)) { + } else if (parse_ul(argv[2], &num)) { goto bail; } for (i = 0; i < num; i++) { ret = flash_get_page_info_by_idx(flash_device, page + i, &info); if (ret) { - printk("flash_get_page_info_by_idx: %d\n", ret); - return 0; + PR_ERROR(shell, "flash_get_page_info_by_idx error:" + " %d\r\n", ret); + return ret; } - printk("Erasing page %u (start offset 0x%x, size 0x%x)\n", + PR_SHELL(shell, "Erasing page %u (start offset 0x%x," + " size 0x%x)\r\n", info.index, info.start_offset, info.size); - ret = do_erase(info.start_offset, info.size); + ret = do_erase(shell, info.start_offset, info.size); if (ret) { - return 0; + return ret; } } - return 0; + return ret; bail: - printk("Invalid arguments.\n"); - return -EINVAL; + PR_ERROR(shell, "Invalid arguments.\r\n"); + return ret; } -static int flash_shell_write_page(int argc, char *argv[]) +static int cmd_page_write(const struct shell *shell, size_t argc, char **argv) { struct flash_pages_info info; - long unsigned int page, off; + unsigned long int page, off; u8_t buf[ARGC_MAX]; size_t i; int ret; - if (check_flash_device()) { + ret = check_flash_device(shell); + if (ret) { + return ret; + } + + if (!shell_cmd_precheck(shell, (argc > 2), NULL, 0)) { return 0; } - CANONICALIZE_ARGS(argc, argv); - if (argc < 2 || parse_ul(argv[0], &page) || parse_ul(argv[1], &off)) { + if (argc < 2 || parse_ul(argv[1], &page) || parse_ul(argv[2], &off)) { + ret = -EINVAL; goto bail; } - argc -= 2; - argv += 2; + argc -= 3; + argv += 3; for (i = 0; i < argc; i++) { if (parse_u8(argv[i], &buf[i])) { - printk("Argument %d (%s) is not a byte.\n", - i + 2, argv[i]); + PR_ERROR(shell, "Argument %d (%s) is not a byte.\r\n", + i + 2, argv[i]); + ret = -EINVAL; goto bail; } } ret = flash_get_page_info_by_idx(flash_device, page, &info); if (ret) { - printk("flash_get_page_info_by_idx: %d\n", ret); - return 0; + PR_ERROR(shell, "flash_get_page_info_by_idx: %d\r\n", ret); + return ret; } - do_write(info.start_offset + off, buf, i, true); - return 0; + ret = do_write(shell, info.start_offset + off, buf, i, true); + return ret; bail: - printk("Invalid arguments.\n"); - return -EINVAL; + PR_ERROR(shell, "Invalid arguments.\r\n"); + return ret; } #endif /* CONFIG_FLASH_PAGE_LAYOUT */ -static int flash_shell_set_device(int argc, char *argv[]) +static int cmd_set_dev(const struct shell *shell, size_t argc, char **argv) { struct device *dev; const char *name; - /* Parse arguments. */ - CANONICALIZE_ARGS(argc, argv); - if (argc != 1) { - goto bail; + if (!shell_cmd_precheck(shell, (argc == 2), NULL, 0)) { + return 0; } - name = argv[0]; + + name = argv[1]; /* Run command. */ dev = device_get_binding(name); if (!dev) { - printk("No device named %s.\n", name); - return -EINVAL; + PR_ERROR(shell, "No device named %s.\r\n", name); + return -ENOEXEC; } if (flash_device) { - printk("Leaving behind device %s", flash_device->config->name); + PR_SHELL(shell, "Leaving behind device %s\r\n", + flash_device->config->name); } flash_device = dev; - return 0; - bail: - printk("Invalid arguments.\n"); - return -EINVAL; + return 0; } -static struct shell_cmd commands[] = { - { "write_block_size", flash_shell_write_block_size, - WRITE_BLOCK_SIZE_HELP }, - { "read", flash_shell_read, READ_HELP }, - { "erase", flash_shell_erase, ERASE_HELP }, - { "write", flash_shell_write, WRITE_HELP }, -#ifdef CONFIG_FLASH_PAGE_LAYOUT - { "page_count", flash_shell_page_count, PAGE_COUNT_HELP }, - { "page_layout", flash_shell_page_layout, PAGE_LAYOUT_HELP }, - { "read_page", flash_shell_read_page, READ_PAGE_HELP }, - { "erase_page", flash_shell_erase_page, ERASE_PAGE_HELP }, - { "write_page", flash_shell_write_page, WRITE_PAGE_HELP }, -#endif /* CONFIG_FLASH_PAGE_LAYOUT */ - { "set_device", flash_shell_set_device, SET_DEVICE_HELP }, - { NULL, NULL, NULL }, -}; - void main(void) { flash_device = device_get_binding(FLASH_DEV_NAME); @@ -584,5 +629,28 @@ void main(void) "before using other commands.\n"); } - SHELL_REGISTER(THIS_MODULE_NAME, commands); + (void)shell_init(&uart_shell, NULL, true, true, LOG_LEVEL_INF); } + + +SHELL_CREATE_STATIC_SUBCMD_SET(sub_flash) +{ + /* Alphabetically sorted to ensure correct Tab autocompletion. */ + SHELL_CMD(erase, NULL, ERASE_HELP, cmd_erase), +#ifdef CONFIG_FLASH_PAGE_LAYOUT + SHELL_CMD(page_count, NULL, PAGE_COUNT_HELP, cmd_page_count), + SHELL_CMD(page_errase, NULL, PAGE_ERASE_HELP, cmd_page_erase), + SHELL_CMD(page_layout, NULL, PAGE_LAYOUT_HELP, cmd_page_layout), + SHELL_CMD(page_read, NULL, PAGE_READ_HELP, cmd_page_read), + SHELL_CMD(page_write, NULL, PAGE_WRITE_HELP, cmd_page_write), +#endif + SHELL_CMD(read, NULL, READ_HELP, cmd_read), + SHELL_CMD(set_device, NULL, SET_DEV_HELP, cmd_set_dev), + SHELL_CMD(write, NULL, WRITE_HELP, cmd_write), + SHELL_CMD(write_block_size, NULL, WRITE_BLOCK_SIZE_HELP, + cmd_write_block_size), + SHELL_SUBCMD_SET_END /* Array terminated. */ +}; + +SHELL_CMD_REGISTER(flash, &sub_flash, "Flash realated commands.", cmd_flash); +