summaryrefslogtreecommitdiffstats
path: root/commands/mem.c
diff options
context:
space:
mode:
Diffstat (limited to 'commands/mem.c')
-rw-r--r--commands/mem.c557
1 files changed, 557 insertions, 0 deletions
diff --git a/commands/mem.c b/commands/mem.c
new file mode 100644
index 0000000000..09565505c4
--- /dev/null
+++ b/commands/mem.c
@@ -0,0 +1,557 @@
+/*
+ * (C) Copyright 2000
+ * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+ *
+ * See file CREDITS for list of people who contributed to this
+ * project.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ * MA 02111-1307 USA
+ */
+
+/*
+ * Memory Functions
+ *
+ * Copied from FADS ROM, Dan Malek (dmalek@jlc.net)
+ */
+
+#include <common.h>
+#include <command.h>
+#include <init.h>
+#include <driver.h>
+#include <malloc.h>
+#include <errno.h>
+#include <fs.h>
+#include <fcntl.h>
+#include <getopt.h>
+#include <linux/stat.h>
+#include <xfuncs.h>
+
+#ifdef CMD_MEM_DEBUG
+#define PRINTF(fmt,args...) printf (fmt ,##args)
+#else
+#define PRINTF(fmt,args...)
+#endif
+
+#define RW_BUF_SIZE (ulong)4096
+static char *rw_buf;
+
+static char *DEVMEM = "/dev/mem";
+
+/* Memory Display
+ *
+ * Syntax:
+ * md{.b, .w, .l} {addr} {len}
+ */
+#define DISP_LINE_LEN 16
+
+int memory_display(char *addr, ulong offs, ulong nbytes, int size)
+{
+ ulong linebytes, i;
+ u_char *cp;
+
+ /* Print the lines.
+ *
+ * We buffer all read data, so we can make sure data is read only
+ * once, and all accesses are with the specified bus width.
+ */
+ do {
+ char linebuf[DISP_LINE_LEN];
+ uint *uip = (uint *)linebuf;
+ ushort *usp = (ushort *)linebuf;
+ u_char *ucp = (u_char *)linebuf;
+
+ printf("%08lx:", offs);
+ linebytes = (nbytes>DISP_LINE_LEN)?DISP_LINE_LEN:nbytes;
+
+ for (i=0; i<linebytes; i+= size) {
+ if (size == 4) {
+ printf(" %08x", (*uip++ = *((uint *)addr)));
+ } else if (size == 2) {
+ printf(" %04x", (*usp++ = *((ushort *)addr)));
+ } else {
+ printf(" %02x", (*ucp++ = *((u_char *)addr)));
+ }
+ addr += size;
+ offs += size;
+ }
+
+ puts (" ");
+ cp = (u_char *)linebuf;
+ for (i=0; i<linebytes; i++) {
+ if ((*cp < 0x20) || (*cp > 0x7e))
+ putchar('.');
+ else
+ printf("%c", *cp);
+ cp++;
+ }
+ putchar('\n');
+ nbytes -= linebytes;
+ if (ctrlc()) {
+ return -EINTR;
+ }
+ } while (nbytes > 0);
+
+ return 0;
+}
+
+int open_and_lseek(const char *filename, int mode, ulong pos)
+{
+ int fd, ret;
+
+ fd = open(filename, mode | O_RDONLY);
+ if (fd < 0) {
+ perror("open");
+ return fd;
+ }
+
+ ret = lseek(fd, pos, SEEK_SET);
+ if (ret < 0) {
+ perror("lseek");
+ close(fd);
+ return ret;
+ }
+
+ return fd;
+}
+
+static int mem_parse_options(int argc, char *argv[], char *optstr, int *mode,
+ char **sourcefile, char **destfile)
+{
+ int opt;
+
+ getopt_reset();
+
+ while((opt = getopt(argc, argv, optstr)) > 0) {
+ switch(opt) {
+ case 'b':
+ *mode = O_RWSIZE_1;
+ break;
+ case 'w':
+ *mode = O_RWSIZE_2;
+ break;
+ case 'l':
+ *mode = O_RWSIZE_4;
+ break;
+ case 's':
+ *sourcefile = optarg;
+ break;
+ case 'd':
+ *destfile = optarg;
+ break;
+ default:
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+static int do_mem_md(cmd_tbl_t *cmdtp, int argc, char *argv[])
+{
+ ulong start = 0, size = 0x100;
+ int r, now;
+ int ret = 0;
+ int fd;
+ char *filename = DEVMEM;
+ int mode = O_RWSIZE_4;
+
+ errno = 0;
+ if (mem_parse_options(argc, argv, "bwls:", &mode, &filename, NULL) < 0)
+ return 1;
+
+ if (optind < argc) {
+ if (parse_area_spec(argv[optind], &start, &size)) {
+ printf("could not parse: %s\n", argv[optind]);
+ return 1;
+ }
+ if (size == ~0)
+ size = 0x100;
+ }
+
+ fd = open_and_lseek(filename, mode | O_RDONLY, start);
+ if (fd < 0)
+ return 1;
+
+ do {
+ now = min(size, RW_BUF_SIZE);
+ r = read(fd, rw_buf, now);
+ if (r < 0) {
+ perror("read");
+ goto out;
+ }
+ if (!r)
+ goto out;
+
+ if ((ret = memory_display(rw_buf, start, r, mode >> O_RWSIZE_SHIFT)))
+ goto out;
+
+ start += r;
+ size -= r;
+ } while (size);
+
+out:
+ close(fd);
+
+ return errno;
+}
+
+static __maybe_unused char cmd_md_help[] =
+"Usage md [OPTIONS] <region>\n"
+"display (hexdump) a memory region.\n"
+"options:\n"
+" -s <file> display file (default /dev/mem)\n"
+" -d <file> write file (default /dev/mem)\n"
+" -b output in bytes\n"
+" -w output in halfwords (16bit)\n"
+" -l output in words (32bit)\n"
+"\n"
+"Memory regions:\n"
+"Memory regions can be specified in two different forms: start+size\n"
+"or start-end, If <start> is ommitted it defaults to 0. If end is ommited it\n"
+"defaults to the end of the device, except for interactive commands like md\n"
+"and mw for which it defaults to 0x100.\n"
+"Sizes can be specified as decimal, or if prefixed with 0x as hexadecimal.\n"
+"an optional suffix of k, M or G is for kibibytes, Megabytes or Gigabytes,\n"
+"respectively\n";
+
+
+U_BOOT_CMD_START(md)
+ .maxargs = CONFIG_MAXARGS,
+ .cmd = do_mem_md,
+ .usage = "memory display",
+ U_BOOT_CMD_HELP(cmd_md_help)
+U_BOOT_CMD_END
+
+static int do_mem_mw ( cmd_tbl_t *cmdtp, int argc, char *argv[])
+{
+ int ret = 0;
+ int fd;
+ char *filename = DEVMEM;
+ int mode = O_RWSIZE_4;
+ ulong adr;
+
+ errno = 0;
+
+ if (mem_parse_options(argc, argv, "bwld:", &mode, NULL, &filename) < 0)
+ return 1;
+
+ if (optind + 1 >= argc) {
+ u_boot_cmd_usage(cmdtp);
+ return 1;
+ }
+
+ adr = strtoul_suffix(argv[optind++], NULL, 0);
+
+ fd = open_and_lseek(filename, mode | O_WRONLY, adr);
+ if (fd < 0)
+ return 1;
+
+ while (optind < argc) {
+ u8 val8;
+ u16 val16;
+ u32 val32;
+ switch (mode) {
+ case O_RWSIZE_1:
+ val8 = simple_strtoul(argv[optind], NULL, 0);
+ ret = write(fd, &val8, 1);
+ break;
+ case O_RWSIZE_2:
+ val16 = simple_strtoul(argv[optind], NULL, 0);
+ ret = write(fd, &val16, 2);
+ break;
+ case O_RWSIZE_4:
+ val32 = simple_strtoul(argv[optind], NULL, 0);
+ ret = write(fd, &val32, 4);
+ break;
+ }
+ if (ret < 0) {
+ perror("write");
+ break;
+ }
+ optind++;
+ }
+
+ return errno;
+}
+
+static __maybe_unused char cmd_mw_help[] =
+"Usage: mw [OPTIONS] <region> <value(s)>\n"
+"Write value(s) to the specifies region.\n"
+"see 'help md' for supported options.\n";
+
+U_BOOT_CMD_START(mw)
+ .maxargs = CONFIG_MAXARGS,
+ .cmd = do_mem_mw,
+ .usage = "memory write (fill)",
+ U_BOOT_CMD_HELP(cmd_mw_help)
+U_BOOT_CMD_END
+
+static int do_mem_cmp(cmd_tbl_t *cmdtp, int argc, char *argv[])
+{
+ ulong addr1, addr2, count = ~0;
+ int mode = O_RWSIZE_1;
+ char *sourcefile = DEVMEM;
+ char *destfile = DEVMEM;
+ int sourcefd, destfd;
+ char *rw_buf1;
+ int ret = 1;
+ int offset = 0;
+ struct stat statbuf;
+
+ if (mem_parse_options(argc, argv, "bwls:d:", &mode, &sourcefile, &destfile) < 0)
+ return 1;
+
+ if (optind + 2 > argc) {
+ u_boot_cmd_usage(cmdtp);
+ return 1;
+ }
+
+ addr1 = simple_strtoul(argv[optind], NULL, 0);
+ addr2 = simple_strtoul(argv[optind + 1], NULL, 0);
+
+ if (optind + 2 == argc) {
+ if (sourcefile == DEVMEM) {
+ printf("source and count not given\n");
+ return 1;
+ }
+ if (stat(sourcefile, &statbuf)) {
+ perror("stat");
+ return 1;
+ }
+ count = statbuf.st_size - addr1;
+ } else {
+ count = simple_strtoul(argv[optind + 2], NULL, 0);
+ }
+
+ sourcefd = open_and_lseek(sourcefile, mode | O_RDONLY, addr1);
+ if (sourcefd < 0)
+ return 1;
+
+ destfd = open_and_lseek(destfile, mode | O_RDONLY, addr2);
+ if (destfd < 0) {
+ close(sourcefd);
+ return 1;
+ }
+
+ rw_buf1 = xmalloc(RW_BUF_SIZE);
+
+ while (count > 0) {
+ int now, r1, r2, i;
+
+ now = min(RW_BUF_SIZE, count);
+
+ r1 = read(sourcefd, rw_buf, now);
+ if (r1 < 0) {
+ perror("read");
+ goto out;
+ }
+
+ r2 = read(destfd, rw_buf1, now);
+ if (r2 < 0) {
+ perror("read");
+ goto out;
+ }
+
+ if (r1 != now || r2 != now) {
+ printf("regions differ in size\n");
+ goto out;
+ }
+
+ for (i = 0; i < now; i++) {
+ if (rw_buf[i] != rw_buf1[i]) {
+ printf("files differ at offset %d\n", offset);
+ goto out;
+ }
+ offset++;
+ }
+
+ count -= now;
+ }
+
+ printf("OK\n");
+ ret = 0;
+out:
+ close(sourcefd);
+ close(destfd);
+ free(rw_buf1);
+
+ return ret;
+}
+
+static __maybe_unused char cmd_memcmp_help[] =
+"Usage: memcmp [OPTIONS] <addr1> <addr2> <count>\n"
+"\n"
+"options:\n"
+" -b, -w, -l use byte, halfword, or word accesses\n"
+" -s <file> source file (default /dev/mem)\n"
+" -d <file> destination file (default /dev/mem)\n"
+"\n"
+"Compare memory regions specified with addr1 and addr2\n"
+"of size <count> bytes. If source is a file count can\n"
+"be left unspecified in which case the whole file is\n"
+"compared\n";
+
+U_BOOT_CMD_START(memcmp)
+ .maxargs = CONFIG_MAXARGS,
+ .cmd = do_mem_cmp,
+ .usage = "memory compare",
+ U_BOOT_CMD_HELP(cmd_memcmp_help)
+U_BOOT_CMD_END
+
+static int do_mem_cp(cmd_tbl_t *cmdtp, int argc, char *argv[])
+{
+ ulong count;
+ ulong dest, src;
+ char *sourcefile = DEVMEM;
+ char *destfile = DEVMEM;
+ int sourcefd, destfd;
+ int mode = O_RWSIZE_1;
+ struct stat statbuf;
+ int ret = 0;
+
+ if (mem_parse_options(argc, argv, "bwls:d:", &mode, &sourcefile, &destfile) < 0)
+ return 1;
+
+ if (optind + 2 > argc) {
+ u_boot_cmd_usage(cmdtp);
+ return 1;
+ }
+
+ src = simple_strtoul(argv[optind], NULL, 0);
+ dest = simple_strtoul(argv[optind + 1], NULL, 0);
+
+ if (optind + 2 == argc) {
+ if (sourcefile == DEVMEM) {
+ printf("source and count not given\n");
+ return 1;
+ }
+ if (stat(sourcefile, &statbuf)) {
+ perror("stat");
+ return 1;
+ }
+ count = statbuf.st_size - src;
+ } else {
+ count = simple_strtoul(argv[optind + 2], NULL, 0);
+ }
+
+ sourcefd = open_and_lseek(sourcefile, mode | O_RDONLY, src);
+ if (sourcefd < 0)
+ return 1;
+
+ destfd = open_and_lseek(destfile, O_WRONLY | O_CREAT | mode, dest);
+ if (destfd < 0) {
+ close(sourcefd);
+ return 1;
+ }
+
+ while (count > 0) {
+ int now, r, w;
+
+ now = min(RW_BUF_SIZE, count);
+
+ if ((r = read(sourcefd, rw_buf, now)) < 0) {
+ perror("read");
+ goto out;
+ }
+
+ if ((w = write(destfd, rw_buf, r)) < 0) {
+ perror("write");
+ goto out;
+ }
+
+ if (r < now)
+ break;
+
+ if (w < r)
+ break;
+
+ count -= now;
+ }
+
+ if (count) {
+ printf("ran out of data\n");
+ ret = 1;
+ }
+
+out:
+ close(sourcefd);
+ close(destfd);
+
+ return ret;
+}
+
+static __maybe_unused char cmd_memcpy_help[] =
+"Usage: memcpy [OPTIONS] <src> <dst> <count>\n"
+"\n"
+"options:\n"
+" -b, -w, -l use byte, halfword, or word accesses\n"
+" -s <file> source file (default /dev/mem)\n"
+" -d <file> destination file (default /dev/mem)\n"
+"\n"
+"Copy memory at <src> of <count> bytes to <dst>\n";
+
+U_BOOT_CMD_START(memcpy)
+ .maxargs = CONFIG_MAXARGS,
+ .cmd = do_mem_cp,
+ .usage = "memory copy",
+ U_BOOT_CMD_HELP(cmd_memcpy_help)
+U_BOOT_CMD_END
+
+static struct device_d mem_dev = {
+ .name = "mem",
+ .id = "mem",
+ .map_base = 0,
+ .size = ~0, /* FIXME: should be 0x100000000, ahem... */
+};
+
+static struct driver_d mem_drv = {
+ .name = "mem",
+ .probe = dummy_probe,
+ .read = mem_read,
+ .write = mem_write,
+};
+
+static struct driver_d ram_drv = {
+ .name = "ram",
+ .probe = dummy_probe,
+ .read = mem_read,
+ .write = mem_write,
+ .type = DEVICE_TYPE_DRAM,
+};
+
+static struct driver_d rom_drv = {
+ .name = "rom",
+ .probe = dummy_probe,
+ .read = mem_read,
+};
+
+static int mem_init(void)
+{
+ rw_buf = malloc(RW_BUF_SIZE);
+ if(!rw_buf) {
+ printf("%s: Out of memory\n", __FUNCTION__);
+ return -1;
+ }
+
+ register_device(&mem_dev);
+ register_driver(&mem_drv);
+ register_driver(&ram_drv);
+ register_driver(&rom_drv);
+ return 0;
+}
+
+device_initcall(mem_init);
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-27 04:07:36 +0000