| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| #include <inttypes.h> |
| #include "os/mynewt.h" |
| #include <console/console.h> |
| #include <hal/hal_bsp.h> |
| #include <hal/hal_flash.h> |
| #include <hal/hal_flash_int.h> |
| #include <shell/shell.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| static int flash_cli_cmd(int argc, char **argv); |
| static struct shell_cmd flash_cmd_struct = { |
| .sc_cmd = "flash", |
| .sc_cmd_func = flash_cli_cmd |
| }; |
| |
| static int |
| flash_cli_cmd(int argc, char **argv) |
| { |
| const struct hal_flash *hf; |
| uint32_t off = 0; |
| uint32_t sz = 1; |
| int sec_cnt; |
| int i; |
| int devid; |
| int soff; |
| char *eptr; |
| char tmp_buf[32]; |
| char pr_str[80]; |
| |
| if (argc > 1 && (!strcmp(argv[1], "?") || !strcmp(argv[1], "help"))) { |
| console_printf("Commands Available\n"); |
| console_printf("flash [flash-id] -- dumps sector map \n"); |
| console_printf("flash <flash-id> read <offset> <size> -- reads bytes from flash \n"); |
| console_printf("flash <flash-id> write <offset> <size> -- writes incrementing data pattern 0-8 to flash \n"); |
| console_printf("flash <flash-id> erase <offset> <size> -- erases flash \n"); |
| return 0; |
| } |
| |
| devid = 0; |
| if (argc < 3) { |
| if (argc == 2) { |
| devid = strtoul(argv[1], &eptr, 0); |
| if (*eptr != 0) { |
| console_printf("Invalid flash id %s\n", argv[1]); |
| return 0; |
| } |
| } |
| do { |
| hf = hal_bsp_flash_dev(devid); |
| if (!hf) { |
| if (argc == 2) { |
| console_printf("Flash device not present\n"); |
| } |
| return 0; |
| } |
| console_printf("Flash %d at 0x%lx size 0x%lx with %d sectors," |
| " alignment req %d bytes\n", |
| devid, |
| (long unsigned int) hf->hf_base_addr, |
| (long unsigned int) hf->hf_size, |
| hf->hf_sector_cnt, |
| hf->hf_align); |
| sec_cnt = hf->hf_sector_cnt; |
| if (sec_cnt > 32) { |
| sec_cnt = 32; |
| } |
| for (i = 0; i < sec_cnt; i++) { |
| console_printf(" %d: %lx\n", i, |
| (long unsigned int) hal_flash_sector_size(hf, i)); |
| } |
| if (sec_cnt != hf->hf_sector_cnt) { |
| console_printf("... %d: %lx\n", hf->hf_sector_cnt - 1, |
| (long unsigned int) hal_flash_sector_size(hf, hf->hf_sector_cnt - 1)); |
| } |
| ++devid; |
| } while(argc == 1); |
| |
| return 0; |
| } |
| |
| if (argc > 1) { |
| devid = strtoul(argv[1], &eptr, 0); |
| if (*eptr != 0) { |
| console_printf("Invalid flash id %s\n", argv[1]); |
| goto err; |
| } |
| } |
| if (argc > 3) { |
| off = strtoul(argv[3], &eptr, 0); |
| if (*eptr != '\0') { |
| console_printf("Invalid offset %s\n", argv[2]); |
| goto err; |
| } |
| } |
| if (argc > 4) { |
| sz = strtoul(argv[4], &eptr, 0); |
| if (*eptr != '\0') { |
| console_printf("Invalid size %s\n", argv[3]); |
| goto err; |
| } |
| } |
| if (!strcmp(argv[2], "erase")) { |
| console_printf("Erase 0x%lx + %lx\n", |
| (long unsigned int) off, (long unsigned int) sz); |
| |
| if (hal_flash_erase(devid, off, sz)) { |
| console_printf("Flash erase failed\n"); |
| } |
| console_printf("Done!\n"); |
| } else if (!strcmp(argv[2], "read")) { |
| console_printf("Read 0x%lx + %lx\n", |
| (long unsigned int) off, (long unsigned int) sz); |
| sz += off; |
| while (off < sz) { |
| sec_cnt = min(sizeof(tmp_buf), sz - off); |
| if (hal_flash_read(devid, off, tmp_buf, sec_cnt)) { |
| console_printf("flash read failure at %lx\n", |
| (long unsigned int) off); |
| break; |
| } |
| for (i = 0, soff = 0; i < sec_cnt; i++) { |
| soff += snprintf(pr_str + soff, sizeof(pr_str) - soff, |
| "0x%02x ", tmp_buf[i] & 0xff); |
| if (i % 8 == 7) { |
| console_printf(" 0x%lx: %s\n", |
| (long unsigned int) off, pr_str); |
| soff = 0; |
| off += 8; |
| } |
| } |
| if (i % 8) { |
| console_printf(" 0x%lx: %s\n", |
| (long unsigned int) off, pr_str); |
| off += i; |
| } |
| } |
| } else if (!strcmp(argv[2], "write")) { |
| console_printf("Write 0x%lx + %lx\n", |
| (long unsigned int) off, (long unsigned int) sz); |
| |
| sz += off; |
| for (i = 0; i < sizeof(tmp_buf); i++) { |
| tmp_buf[i] = i + 1; |
| } |
| |
| while (off < sz) { |
| sec_cnt = min(sizeof(tmp_buf), sz - off); |
| if (hal_flash_write(devid, off, tmp_buf, sec_cnt)) { |
| console_printf("flash write failure at %lx\n", |
| (long unsigned int) off); |
| } |
| off += sec_cnt; |
| } |
| console_printf("Done!\n"); |
| } |
| return 0; |
| err: |
| return -1; |
| } |
| |
| |
| /* |
| * Returns # of ops done within 2 seconds. |
| */ |
| int |
| flash_speed_test(int flash_dev, uint32_t addr, int sz, int move) |
| { |
| int rc; |
| int cnt = 0; |
| int off = 0; |
| int start_time; |
| int end_time; |
| void *data_buf; |
| |
| data_buf = malloc(sz); |
| if (!data_buf) { |
| return -1; |
| } |
| |
| /* |
| * Catch start of a tick. |
| */ |
| start_time = os_time_get(); |
| while (1) { |
| end_time = os_time_get(); |
| if (end_time != start_time) { |
| start_time = end_time; |
| break; |
| } |
| } |
| |
| /* |
| * Measure for 2 secs. |
| */ |
| do { |
| rc = hal_flash_read(flash_dev, addr + off, data_buf, sz); |
| if (rc) { |
| console_printf("hal_flash_read(%d, 0x%x, %d) = %d\n", |
| flash_dev, (unsigned int)addr + off, (unsigned int)sz, rc); |
| return -1; |
| } |
| if (move) { |
| off++; |
| if (off > 16) { |
| off = 0; |
| } |
| } |
| end_time = os_time_get(); |
| cnt++; |
| } while (end_time - start_time < 2 * OS_TICKS_PER_SEC); |
| |
| free(data_buf); |
| return cnt; |
| } |
| |
| static int |
| flash_speed_test_cli(int argc, char **argv) |
| { |
| char *ep; |
| int flash_dev; |
| uint32_t addr; |
| uint32_t sz; |
| int move; |
| int cnt; |
| int i; |
| |
| if (argc < 4) { |
| console_printf("flash_speed <flash_id> <addr> <rd_sz>|range [move]\n"); |
| return 0; |
| } |
| |
| flash_dev = strtoul(argv[1], &ep, 10); |
| if (*ep != '\0') { |
| console_printf("Invalid flash_id: %s\n", argv[1]); |
| return 0; |
| } |
| |
| addr = strtoul(argv[2], &ep, 0); |
| if (*ep != '\0') { |
| console_printf("Invalid address: %s\n", argv[2]); |
| return 0; |
| } |
| |
| if (!strcmp(argv[3], "range")) { |
| i = 1; |
| } else { |
| i = 0; |
| sz = strtoul(argv[3], &ep, 0); |
| if (*ep != '\0') { |
| console_printf("Invalid read size: %s\n", argv[3]); |
| return 0; |
| } |
| } |
| if (argc > 4 && !strcmp(argv[4], "move")) { |
| move = 1; |
| } else { |
| move = 0; |
| } |
| |
| if (i == 0) { |
| console_printf("Speed test, hal_flash_read(%d, 0x%x%s, %d)\n", |
| flash_dev, (unsigned int)addr, move?"..":"", (unsigned int)sz); |
| cnt = flash_speed_test(flash_dev, addr, sz, move); |
| console_printf("%d\n", cnt >> 1); |
| } else { |
| uint32_t sizes[] = { |
| 1, 2, 4, 8, 16, 24, 32, 48, 64, 96, 128, 192, 256 |
| }; |
| |
| console_printf("Speed test, hal_flash_read(%d, 0x%x%s, X)\n", |
| flash_dev, (unsigned int)addr, move?"..":""); |
| |
| for (i = 0; i < sizeof(sizes) / sizeof(sizes[0]); i++) { |
| cnt = flash_speed_test(flash_dev, addr, sizes[i], move); |
| console_printf("%3d %d\n", (int)sizes[i], cnt >> 1); |
| os_time_delay(OS_TICKS_PER_SEC / 8); |
| } |
| } |
| return 0; |
| } |
| |
| static struct shell_cmd flash_speed_cli_struct = { |
| .sc_cmd = "flash_speed", |
| .sc_cmd_func = flash_speed_test_cli |
| }; |
| |
| /* |
| * Initialize the package. Only called from sysinit(). |
| */ |
| void |
| flash_test_init(void) |
| { |
| shell_cmd_register(&flash_cmd_struct); |
| shell_cmd_register(&flash_speed_cli_struct); |
| } |
