int do_mem_cp ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { ulong addr, dest, count; int size; if (argc != 4) { cmd_usage(cmdtp); return 1; } /* Check for size specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; addr = simple_strtoul(argv[1], NULL, 16); addr += base_address; dest = simple_strtoul(argv[2], NULL, 16); dest += base_address; count = simple_strtoul(argv[3], NULL, 16); if (count == 0) { puts ("Zero length ???\n"); return 1; } #ifndef CONFIG_SYS_NO_FLASH /* check if we are copying to Flash */ if ( (addr2info(dest) != NULL) #ifdef CONFIG_HAS_DATAFLASH && (!addr_dataflash(dest)) #endif ) { int rc; puts ("Copy to Flash... "); rc = flash_write ((char *)addr, dest, count*size); if (rc != 0) { flash_perror (rc); return (1); } puts ("done\n"); return 0; } #endif #ifdef CONFIG_HAS_DATAFLASH /* Check if we are copying from RAM or Flash to DataFlash */ if (addr_dataflash(dest) && !addr_dataflash(addr)){ int rc; puts ("Copy to DataFlash... "); rc = write_dataflash (dest, addr, count*size); if (rc != 1) { dataflash_perror (rc); return (1); } puts ("done\n"); return 0; } /* Check if we are copying from DataFlash to RAM */ if (addr_dataflash(addr) && !addr_dataflash(dest) #ifndef CONFIG_SYS_NO_FLASH && (addr2info(dest) == NULL) #endif ){ int rc; rc = read_dataflash(addr, count * size, (char *) dest); if (rc != 1) { dataflash_perror (rc); return (1); } return 0; } if (addr_dataflash(addr) && addr_dataflash(dest)){ puts ("Unsupported combination of source/destination.\n\r"); return 1; } #endif #ifdef CONFIG_BLACKFIN /* See if we're copying to/from L1 inst */ if (addr_bfin_on_chip_mem(dest) || addr_bfin_on_chip_mem(addr)) { memcpy((void *)dest, (void *)addr, count * size); return 0; } #endif #ifdef CONFIG_SPIFI if (spifi_addr(dest) || spifi_addr(dest + count)) { if (spifi_addr(addr) || spifi_addr(addr + count)) { puts ("Cannot copy from SPIFI to SPIFI, aborting.\n\r"); return 1; } if (!spifi_addr(dest) || !spifi_addr(dest + count)) { puts ("Cannot copy across SPIFI boundaries, aborting.\n\r"); return 1; } return spifi_write(dest, (void *)addr, count); } #endif while (count-- > 0) { if (size == 4) *((ulong *)dest) = *((ulong *)addr); else if (size == 2) *((ushort *)dest) = *((ushort *)addr); else *((u_char *)dest) = *((u_char *)addr); addr += size; dest += size; } return 0; }
int do_mem_md ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { ulong addr, length; #if defined(CONFIG_HAS_DATAFLASH) ulong nbytes, linebytes; #endif int size; int rc = 0; /* We use the last specified parameters, unless new ones are * entered. */ addr = dp_last_addr; size = dp_last_size; length = dp_last_length; if (argc < 2) { cmd_usage(cmdtp); return 1; } if ((flag & CMD_FLAG_REPEAT) == 0) { /* New command specified. Check for a size specification. * Defaults to long if no or incorrect specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; /* Address is specified since argc > 1 */ addr = simple_strtoul(argv[1], NULL, 16); addr += base_address; /* If another parameter, it is the length to display. * Length is the number of objects, not number of bytes. */ if (argc > 2) length = simple_strtoul(argv[2], NULL, 16); } #if defined(CONFIG_HAS_DATAFLASH) /* 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. */ nbytes = length * size; do { char linebuf[DISP_LINE_LEN]; void* p; linebytes = (nbytes>DISP_LINE_LEN)?DISP_LINE_LEN:nbytes; rc = read_dataflash(addr, (linebytes/size)*size, linebuf); p = (rc == DATAFLASH_OK) ? linebuf : (void*)addr; print_buffer(addr, p, size, linebytes/size, DISP_LINE_LEN/size); nbytes -= linebytes; addr += linebytes; if (ctrlc()) { rc = 1; break; } } while (nbytes > 0); #else # if defined(CONFIG_BLACKFIN) /* See if we're trying to display L1 inst */ if (addr_bfin_on_chip_mem(addr)) { char linebuf[DISP_LINE_LEN]; ulong linebytes, nbytes = length * size; do { linebytes = (nbytes > DISP_LINE_LEN) ? DISP_LINE_LEN : nbytes; memcpy(linebuf, (void *)addr, linebytes); print_buffer(addr, linebuf, size, linebytes/size, DISP_LINE_LEN/size); nbytes -= linebytes; addr += linebytes; if (ctrlc()) { rc = 1; break; } } while (nbytes > 0); } else # endif { /* Print the lines. */ print_buffer(addr, (void*)addr, size, length, DISP_LINE_LEN/size); addr += size*length; } #endif dp_last_addr = addr; dp_last_length = length; dp_last_size = size; return (rc); }
/* Modify memory. * * Syntax: * mm{.b, .w, .l} {addr} * nm{.b, .w, .l} {addr} */ static int mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char *argv[]) { ulong addr, i; int nbytes, size; extern char console_buffer[]; if (argc != 2) { cmd_usage(cmdtp); return 1; } #ifdef CONFIG_BOOT_RETRY_TIME reset_cmd_timeout(); /* got a good command to get here */ #endif /* We use the last specified parameters, unless new ones are * entered. */ addr = mm_last_addr; size = mm_last_size; if ((flag & CMD_FLAG_REPEAT) == 0) { /* New command specified. Check for a size specification. * Defaults to long if no or incorrect specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; /* Address is specified since argc > 1 */ addr = simple_strtoul(argv[1], NULL, 16); addr += base_address; } #ifdef CONFIG_HAS_DATAFLASH if (addr_dataflash(addr)){ puts ("Can't modify DataFlash in place. Use cp instead.\n\r"); return 0; } #endif #ifdef CONFIG_BLACKFIN if (addr_bfin_on_chip_mem(addr)) { puts ("Can't modify L1 instruction in place. Use cp instead.\n\r"); return 0; } #endif /* Print the address, followed by value. Then accept input for * the next value. A non-converted value exits. */ do { printf("%08lx:", addr); if (size == 4) printf(" %08x", *((uint *)addr)); else if (size == 2) printf(" %04x", *((ushort *)addr)); else printf(" %02x", *((u_char *)addr)); nbytes = readline (" ? "); if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) { /* <CR> pressed as only input, don't modify current * location and move to next. "-" pressed will go back. */ if (incrflag) addr += nbytes ? -size : size; nbytes = 1; #ifdef CONFIG_BOOT_RETRY_TIME reset_cmd_timeout(); /* good enough to not time out */ #endif } #ifdef CONFIG_BOOT_RETRY_TIME else if (nbytes == -2) { break; /* timed out, exit the command */ } #endif else { char *endp; i = simple_strtoul(console_buffer, &endp, 16); nbytes = endp - console_buffer; if (nbytes) { #ifdef CONFIG_BOOT_RETRY_TIME /* good enough to not time out */ reset_cmd_timeout(); #endif if (size == 4) *((uint *)addr) = i; else if (size == 2) *((ushort *)addr) = i; else *((u_char *)addr) = i; if (incrflag) addr += size; } } } while (nbytes); mm_last_addr = addr; mm_last_size = size; return 0; }
int do_mem_cmp (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { ulong addr1, addr2, count, ngood; int size; int rcode = 0; if (argc != 4) { cmd_usage(cmdtp); return 1; } /* Check for size specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; addr1 = simple_strtoul(argv[1], NULL, 16); addr1 += base_address; addr2 = simple_strtoul(argv[2], NULL, 16); addr2 += base_address; count = simple_strtoul(argv[3], NULL, 16); #ifdef CONFIG_HAS_DATAFLASH if (addr_dataflash(addr1) | addr_dataflash(addr2)){ puts ("Comparison with DataFlash space not supported.\n\r"); return 0; } #endif #ifdef CONFIG_BLACKFIN if (addr_bfin_on_chip_mem(addr1) || addr_bfin_on_chip_mem(addr2)) { puts ("Comparison with L1 instruction memory not supported.\n\r"); return 0; } #endif ngood = 0; while (count-- > 0) { if (size == 4) { ulong word1 = *(ulong *)addr1; ulong word2 = *(ulong *)addr2; if (word1 != word2) { printf("word at 0x%08lx (0x%08lx) " "!= word at 0x%08lx (0x%08lx)\n", addr1, word1, addr2, word2); rcode = 1; break; } } else if (size == 2) { ushort hword1 = *(ushort *)addr1; ushort hword2 = *(ushort *)addr2; if (hword1 != hword2) { printf("halfword at 0x%08lx (0x%04x) " "!= halfword at 0x%08lx (0x%04x)\n", addr1, hword1, addr2, hword2); rcode = 1; break; } } else { u_char byte1 = *(u_char *)addr1; u_char byte2 = *(u_char *)addr2; if (byte1 != byte2) { printf("byte at 0x%08lx (0x%02x) " "!= byte at 0x%08lx (0x%02x)\n", addr1, byte1, addr2, byte2); rcode = 1; break; } } ngood++; addr1 += size; addr2 += size; } printf("Total of %ld %s%s were the same\n", ngood, size == 4 ? "word" : size == 2 ? "halfword" : "byte", ngood == 1 ? "" : "s"); return rcode; }
int do_mem_cp ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { ulong addr, dest, count; int size; if (argc != 4) { printf ("Usage:\n%s\n", cmdtp->usage); return 1; } /* Check for size specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; addr = simple_strtoul(argv[1], NULL, 16); addr += base_address; dest = simple_strtoul(argv[2], NULL, 16); dest += base_address; count = simple_strtoul(argv[3], NULL, 16); if (count == 0) { puts ("Zero length ???\n"); return 1; } #ifndef CFG_NO_FLASH /* check if we are copying to Flash */ if ( (addr2info(dest) != NULL) #ifdef CONFIG_HAS_DATAFLASH && (!addr_dataflash(dest)) #endif ) { int rc; puts ("Copy to Flash... "); rc = flash_write ((char *)addr, dest, count*size); if (rc != 0) { flash_perror (rc); return (1); } puts ("done\n"); return 0; } #endif #if defined(CONFIG_CMD_MMC) if (mmc2info(dest)) { int rc; puts ("Copy to MMC... "); switch (rc = mmc_write ((uchar *)addr, dest, count*size)) { case 0: putc ('\n'); return 1; case -1: puts ("failed\n"); return 1; default: printf ("%s[%d] FIXME: rc=%d\n",__FILE__,__LINE__,rc); return 1; } puts ("done\n"); return 0; } if (mmc2info(addr)) { int rc; puts ("Copy from MMC... "); switch (rc = mmc_read (addr, (uchar *)dest, count*size)) { case 0: putc ('\n'); return 1; case -1: puts ("failed\n"); return 1; default: printf ("%s[%d] FIXME: rc=%d\n",__FILE__,__LINE__,rc); return 1; } puts ("done\n"); return 0; } #endif #ifdef CONFIG_HAS_DATAFLASH /* Check if we are copying from RAM or Flash to DataFlash */ if (addr_dataflash(dest) && !addr_dataflash(addr)){ int rc; puts ("Copy to DataFlash... "); rc = write_dataflash (dest, addr, count*size); if (rc != 1) { dataflash_perror (rc); return (1); } puts ("done\n"); return 0; } /* Check if we are copying from DataFlash to RAM */ if (addr_dataflash(addr) && !addr_dataflash(dest) && (addr2info(dest)==NULL) ){ int rc; rc = read_dataflash(addr, count * size, (char *) dest); if (rc != 1) { dataflash_perror (rc); return (1); } return 0; } if (addr_dataflash(addr) && addr_dataflash(dest)){ puts ("Unsupported combination of source/destination.\n\r"); return 1; } #endif #ifdef CONFIG_BLACKFIN /* See if we're copying to/from L1 inst */ if (addr_bfin_on_chip_mem(dest) || addr_bfin_on_chip_mem(addr)) { memcpy((void *)dest, (void *)addr, count * size); return 0; } #endif while (count-- > 0) { if (size == 4) *((ulong *)dest) = *((ulong *)addr); else if (size == 2) *((ushort *)dest) = *((ushort *)addr); else *((u_char *)dest) = *((u_char *)addr); addr += size; dest += size; } return 0; }
int do_mem_cp (struct cmd_ctx *ctx, int argc, char * const argv[]) { ulong addr, dest, count; int size; if (argc != 4) return cmd_usage(ctx->cmdtp); /* Check for size specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; addr = simple_strtoul(argv[1], NULL, 16); addr += base_address; dest = simple_strtoul(argv[2], NULL, 16); dest += base_address; count = simple_strtoul(argv[3], NULL, 16); if (count == 0) { puts ("Zero length ???\n"); return 1; } #ifndef CONFIG_SYS_NO_FLASH /* check if we are copying to Flash */ if ( (addr2info(dest) != NULL) #ifdef CONFIG_HAS_DATAFLASH && (!addr_dataflash(dest)) #endif ) { int rc; puts ("Copy to Flash... "); rc = flash_write ((char *)addr, dest, count*size); if (rc != 0) { flash_perror (rc); return (1); } puts ("done\n"); return 0; } #endif #ifdef CONFIG_HAS_DATAFLASH /* Check if we are copying from RAM or Flash to DataFlash */ if (addr_dataflash(dest) && !addr_dataflash(addr)){ int rc; puts ("Copy to DataFlash... "); rc = write_dataflash (dest, addr, count*size); if (rc != 1) { dataflash_perror (rc); return (1); } puts ("done\n"); return 0; } /* Check if we are copying from DataFlash to RAM */ if (addr_dataflash(addr) && !addr_dataflash(dest) #ifndef CONFIG_SYS_NO_FLASH && (addr2info(dest) == NULL) #endif ){ int rc; rc = read_dataflash(addr, count * size, (char *) dest); if (rc != 1) { dataflash_perror (rc); return (1); } return 0; } if (addr_dataflash(addr) && addr_dataflash(dest)){ puts ("Unsupported combination of source/destination.\n\r"); return 1; } #endif #ifdef CONFIG_BLACKFIN /* See if we're copying to/from L1 inst */ if (addr_bfin_on_chip_mem(dest) || addr_bfin_on_chip_mem(addr)) { memcpy((void *)dest, (void *)addr, count * size); return 0; } #endif while (count-- > 0) { if (size == 4) *((ulong *)dest) = *((ulong *)addr); else if (size == 2) *((ushort *)dest) = *((ushort *)addr); else *((u_char *)dest) = *((u_char *)addr); addr += size; dest += size; /* reset watchdog from time to time */ if ((count % (64 << 10)) == 0) WATCHDOG_RESET(); } return 0; }
static int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { ulong addr1, addr2, count, ngood; int size; int rcode = 0; const char *type; if (argc != 4) return CMD_RET_USAGE; /* Check for size specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; type = size == 4 ? "word" : size == 2 ? "halfword" : "byte"; addr1 = simple_strtoul(argv[1], NULL, 16); addr1 += base_address; addr2 = simple_strtoul(argv[2], NULL, 16); addr2 += base_address; count = simple_strtoul(argv[3], NULL, 16); #ifdef CONFIG_HAS_DATAFLASH if (addr_dataflash(addr1) | addr_dataflash(addr2)){ puts ("Comparison with DataFlash space not supported.\n\r"); return 0; } #endif #ifdef CONFIG_BLACKFIN if (addr_bfin_on_chip_mem(addr1) || addr_bfin_on_chip_mem(addr2)) { puts ("Comparison with L1 instruction memory not supported.\n\r"); return 0; } #endif for (ngood = 0; ngood < count; ++ngood) { ulong word1, word2; if (size == 4) { word1 = *(ulong *)addr1; word2 = *(ulong *)addr2; } else if (size == 2) { word1 = *(ushort *)addr1; word2 = *(ushort *)addr2; } else { word1 = *(u_char *)addr1; word2 = *(u_char *)addr2; } if (word1 != word2) { printf("%s at 0x%08lx (%#0*lx) != %s at 0x%08lx (%#0*lx)\n", type, addr1, size, word1, type, addr2, size, word2); rcode = 1; break; } addr1 += size; addr2 += size; /* reset watchdog from time to time */ if ((ngood % (64 << 10)) == 0) WATCHDOG_RESET(); } printf("Total of %ld %s(s) were the same\n", ngood, type); return rcode; }
int do_mem_cp ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { ulong addr, dest, count; int size; if (argc != 4) { cmd_usage(cmdtp); return 1; } /* Check for size specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; addr = simple_strtoul(argv[1], NULL, 16); addr += base_address; dest = simple_strtoul(argv[2], NULL, 16); dest += base_address; count = simple_strtoul(argv[3], NULL, 16); if (count == 0) { puts ("Zero length ???\n"); return 1; } #ifndef CONFIG_SYS_NO_FLASH /* check if we are copying to Flash */ if ( (addr2info(dest) != NULL) #ifdef CONFIG_HAS_DATAFLASH && (!addr_dataflash(dest)) #endif ) { int rc; int i, diff; int step = 131072; //arbitrary value - //found to be good for gauging time in flash transfer puts ("Copy to Flash...\n"); /*rc = flash_write ((char *)addr, dest, count*size); if(rc != 0){ flash_perror (rc); return (1); } */ for(i = 0; i < count; i+= step*size) { if((diff = (count - i)) >= step*size) { rc = flash_write ((char *)addr+i*size, dest+i*size, step*size); } else { rc = flash_write ((char *)addr+i*size, dest+i*size, diff*size); } if (rc != 0) { flash_perror (rc); return (1); } puts ("."); } puts (" done\n"); return 0; } #endif #ifdef CONFIG_HAS_DATAFLASH /* Check if we are copying from RAM or Flash to DataFlash */ if (addr_dataflash(dest) && !addr_dataflash(addr)){ int rc; puts ("Copy to DataFlash... "); rc = write_dataflash (dest, addr, count*size); if (rc != 1) { dataflash_perror (rc); return (1); } puts ("done\n"); return 0; } /* Check if we are copying from DataFlash to RAM */ if (addr_dataflash(addr) && !addr_dataflash(dest) #ifndef CONFIG_SYS_NO_FLASH && (addr2info(dest) == NULL) #endif ){ int rc; rc = read_dataflash(addr, count * size, (char *) dest); if (rc != 1) { dataflash_perror (rc); return (1); } return 0; } if (addr_dataflash(addr) && addr_dataflash(dest)){ puts ("Unsupported combination of source/destination.\n\r"); return 1; } #endif #ifdef CONFIG_BLACKFIN /* See if we're copying to/from L1 inst */ if (addr_bfin_on_chip_mem(dest) || addr_bfin_on_chip_mem(addr)) { memcpy((void *)dest, (void *)addr, count * size); return 0; } #endif while (count-- > 0) { if (size == 4) *((ulong *)dest) = *((ulong *)addr); else if (size == 2) *((ushort *)dest) = *((ushort *)addr); else *((u_char *)dest) = *((u_char *)addr); addr += size; dest += size; } return 0; }
static int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { ulong addr, dest, count, bytes; int size; const void *src; void *buf; if (argc != 4) return CMD_RET_USAGE; /* Check for size specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; addr = simple_strtoul(argv[1], NULL, 16); addr += base_address; dest = simple_strtoul(argv[2], NULL, 16); dest += base_address; count = simple_strtoul(argv[3], NULL, 16); if (count == 0) { puts ("Zero length ???\n"); return 1; } #ifndef CONFIG_SYS_NO_FLASH /* check if we are copying to Flash */ if ( (addr2info(dest) != NULL) #ifdef CONFIG_HAS_DATAFLASH && (!addr_dataflash(dest)) #endif ) { int rc; puts ("Copy to Flash... "); rc = flash_write ((char *)addr, dest, count*size); if (rc != 0) { flash_perror (rc); return (1); } puts ("done\n"); return 0; } #endif #ifdef CONFIG_HAS_DATAFLASH /* Check if we are copying from RAM or Flash to DataFlash */ if (addr_dataflash(dest) && !addr_dataflash(addr)){ int rc; puts ("Copy to DataFlash... "); rc = write_dataflash (dest, addr, count*size); if (rc != 1) { dataflash_perror (rc); return (1); } puts ("done\n"); return 0; } /* Check if we are copying from DataFlash to RAM */ if (addr_dataflash(addr) && !addr_dataflash(dest) #ifndef CONFIG_SYS_NO_FLASH && (addr2info(dest) == NULL) #endif ){ int rc; rc = read_dataflash(addr, count * size, (char *) dest); if (rc != 1) { dataflash_perror (rc); return (1); } return 0; } if (addr_dataflash(addr) && addr_dataflash(dest)){ puts ("Unsupported combination of source/destination.\n\r"); return 1; } #endif #ifdef CONFIG_BLACKFIN /* See if we're copying to/from L1 inst */ if (addr_bfin_on_chip_mem(dest) || addr_bfin_on_chip_mem(addr)) { memcpy((void *)dest, (void *)addr, count * size); return 0; } #endif bytes = size * count; buf = map_sysmem(dest, bytes); src = map_sysmem(addr, bytes); while (count-- > 0) { if (size == 4) *((u32 *)buf) = *((u32 *)src); #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA else if (size == 8) *((u64 *)buf) = *((u64 *)src); #endif else if (size == 2) *((u16 *)buf) = *((u16 *)src); else *((u8 *)buf) = *((u8 *)src); src += size; buf += size; /* reset watchdog from time to time */ if ((count % (64 << 10)) == 0) WATCHDOG_RESET(); } unmap_sysmem(buf); unmap_sysmem(src); return 0; }
static int do_mem_cmp(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { ulong addr1, addr2, count, ngood, bytes; int size; int rcode = 0; const char *type; const void *buf1, *buf2, *base; #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA u64 word1, word2; #else ulong word1, word2; #endif if (argc != 4) return CMD_RET_USAGE; /* Check for size specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; type = size == 8 ? "double word" : size == 4 ? "word" : size == 2 ? "halfword" : "byte"; addr1 = simple_strtoul(argv[1], NULL, 16); addr1 += base_address; addr2 = simple_strtoul(argv[2], NULL, 16); addr2 += base_address; count = simple_strtoul(argv[3], NULL, 16); #ifdef CONFIG_HAS_DATAFLASH if (addr_dataflash(addr1) | addr_dataflash(addr2)){ puts ("Comparison with DataFlash space not supported.\n\r"); return 0; } #endif #ifdef CONFIG_BLACKFIN if (addr_bfin_on_chip_mem(addr1) || addr_bfin_on_chip_mem(addr2)) { puts ("Comparison with L1 instruction memory not supported.\n\r"); return 0; } #endif bytes = size * count; base = buf1 = map_sysmem(addr1, bytes); buf2 = map_sysmem(addr2, bytes); for (ngood = 0; ngood < count; ++ngood) { if (size == 4) { word1 = *(u32 *)buf1; word2 = *(u32 *)buf2; #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA } else if (size == 8) { word1 = *(u64 *)buf1; word2 = *(u64 *)buf2; #endif } else if (size == 2) { word1 = *(u16 *)buf1; word2 = *(u16 *)buf2; } else { word1 = *(u8 *)buf1; word2 = *(u8 *)buf2; } if (word1 != word2) { ulong offset = buf1 - base; #ifdef CONFIG_SYS_SUPPORT_64BIT_DATA printf("%s at 0x%p (%#0*"PRIx64") != %s at 0x%p (%#0*" PRIx64 ")\n", type, (void *)(addr1 + offset), size, word1, type, (void *)(addr2 + offset), size, word2); #else printf("%s at 0x%08lx (%#0*lx) != %s at 0x%08lx (%#0*lx)\n", type, (ulong)(addr1 + offset), size, word1, type, (ulong)(addr2 + offset), size, word2); #endif rcode = 1; break; } buf1 += size; buf2 += size; /* reset watchdog from time to time */ if ((ngood % (64 << 10)) == 0) WATCHDOG_RESET(); } unmap_sysmem(buf1); unmap_sysmem(buf2); printf("Total of %ld %s(s) were the same\n", ngood, type); return rcode; }
int do_mem_cp ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { ulong addr, dest, count; int size; if (argc != 4) { cmd_usage(cmdtp); return 1; } /* Check for size specification. */ if ((size = cmd_get_data_size(argv[0], 4)) < 0) return 1; addr = simple_strtoul(argv[1], NULL, 16); addr += base_address; dest = simple_strtoul(argv[2], NULL, 16); dest += base_address; count = simple_strtoul(argv[3], NULL, 16); if (count == 0) { puts ("Zero length ???\n"); return 1; } #ifndef CONFIG_SYS_NO_FLASH /* check if we are copying to Flash */ if ( (addr2info(dest) != NULL) #ifdef CONFIG_HAS_DATAFLASH && (!addr_dataflash(dest)) #endif ) { int rc; puts ("Copy to Flash... "); #if 0 #if defined(CONFIG_MARVELL) /* If source addr is flash copy data to memory first */ if (addr2info(addr) != NULL) { char* tmp_buff; int i; if (NULL == (tmp_buff = malloc(count*size))) { puts (" Copy fail, NULL pointer buffer\n"); return (1); } for( i = 0 ; i < (count*size); i++) *(tmp_buff + i) = *((char *)addr + i); rc = flash_write (tmp_buff, dest, count*size); free(tmp_buff); } else #endif /* defined(CONFIG_MARVELL) */ #endif rc = flash_write ((char *)addr, dest, count*size); if (rc != 0) { flash_perror (rc); return (1); } puts ("done\n"); return 0; } #endif #ifdef CONFIG_HAS_DATAFLASH /* Check if we are copying from RAM or Flash to DataFlash */ if (addr_dataflash(dest) && !addr_dataflash(addr)){ int rc; puts ("Copy to DataFlash... "); rc = write_dataflash (dest, addr, count*size); if (rc != 1) { dataflash_perror (rc); return (1); } puts ("done\n"); return 0; } /* Check if we are copying from DataFlash to RAM */ if (addr_dataflash(addr) && !addr_dataflash(dest) #ifndef CONFIG_SYS_NO_FLASH && (addr2info(dest) == NULL) #endif ){ int rc; rc = read_dataflash(addr, count * size, (char *) dest); if (rc != 1) { dataflash_perror (rc); return (1); } return 0; } if (addr_dataflash(addr) && addr_dataflash(dest)){ puts ("Unsupported combination of source/destination.\n\r"); return 1; } #endif #ifdef CONFIG_BLACKFIN /* See if we're copying to/from L1 inst */ if (addr_bfin_on_chip_mem(dest) || addr_bfin_on_chip_mem(addr)) { memcpy((void *)dest, (void *)addr, count * size); return 0; } #endif while (count-- > 0) { if (size == 4) *((ulong *)dest) = *((ulong *)addr); else if (size == 2) *((ushort *)dest) = *((ushort *)addr); else *((u_char *)dest) = *((u_char *)addr); addr += size; dest += size; } return 0; }