/*
* Copy memory to flash.
* Make sure all target addresses are within Flash bounds,
* and no protected sectors are hit.
* Returns:
* ERR_OK 0 - OK
* ERR_TIMOUT 1 - write timeout
* ERR_NOT_ERASED 2 - Flash not erased
* ERR_PROTECTED 4 - target range includes protected sectors
* ERR_INVAL 8 - target address not in Flash memory
* ERR_ALIGN 16 - target address not aligned on boundary
* (only some targets require alignment)
*/
int flash_write(char *src, ulong addr, ulong cnt)
{
int i;
ulong end = addr + cnt - 1;
flash_info_t *info_first = addr2info(addr);
flash_info_t *info_last = addr2info(end);
flash_info_t *info;
if (cnt == 0)
return ERR_OK;
if (!info_first || !info_last)
return ERR_INVAL;
/* Finally write data to flash */
for (info = info_first; info <= info_last && cnt > 0; ++info) {
ulong len = info->start[0] + info->size - addr;
if (len > cnt)
len = cnt;
if ((i = write_buff(info, (uchar *)src, addr, len)) != 0)
return i;
cnt -= len;
addr += len;
src += len;
}
return ERR_OK;
}
/*-----------------------------------------------------------------------
* Copy memory to flash.
* Make sure all target addresses are within Flash bounds,
* and no protected sectors are hit.
* Returns:
* ERR_OK 0 - OK
* ERR_TIMOUT 1 - write timeout
* ERR_NOT_ERASED 2 - Flash not erased
* ERR_PROTECTED 4 - target range includes protected sectors
* ERR_INVAL 8 - target address not in Flash memory
* ERR_ALIGN 16 - target address not aligned on boundary
* (only some targets require alignment)
*/
int
flash_write (char *src, ulong addr, ulong cnt)
{
int i;
ulong end = addr + cnt - 1;
flash_info_t *info_first = addr2info (addr);
flash_info_t *info_last = addr2info (end );
flash_info_t *info;
__maybe_unused char *src_orig = src;
__maybe_unused char *addr_orig = (char *)addr;
__maybe_unused ulong cnt_orig = cnt;
if (cnt == 0) {
return (ERR_OK);
}
if (!info_first || !info_last) {
return (ERR_INVAL);
}
for (info = info_first; info <= info_last; ++info) {
ulong b_end = info->start[0] + info->size; /* bank end addr */
short s_end = info->sector_count - 1;
for (i=0; i<info->sector_count; ++i) {
ulong e_addr = (i == s_end) ? b_end : info->start[i + 1];
if ((end >= info->start[i]) && (addr < e_addr) &&
(info->protect[i] != 0) ) {
return (ERR_PROTECTED);
}
}
}
/* finally write data to flash */
for (info = info_first; info <= info_last && cnt>0; ++info) {
ulong len;
len = info->start[0] + info->size - addr;
if (len > cnt)
len = cnt;
if ((i = write_buff(info, (uchar *)src, addr, len)) != 0) {
return (i);
}
cnt -= len;
addr += len;
src += len;
}
#if defined(CONFIG_FLASH_VERIFY)
if (memcmp(src_orig, addr_orig, cnt_orig)) {
printf("\nVerify failed!\n");
return ERR_PROG_ERROR;
}
#endif /* CONFIG_SYS_FLASH_VERIFY_AFTER_WRITE */
return (ERR_OK);
}
/*-----------------------------------------------------------------------
* Copy memory to flash.
* Make sure all target addresses are within Flash bounds,
* and no protected sectors are hit.
* Returns:
* ERR_OK 0 - OK
* ERR_TIMOUT 1 - write timeout
* ERR_NOT_ERASED 2 - Flash not erased
* ERR_PROTECTED 4 - target range includes protected sectors
* ERR_INVAL 8 - target address not in Flash memory
* ERR_ALIGN 16 - target address not aligned on boundary
* (only some targets require alignment)
*/
int
flash_write (char *src, ulong addr, ulong cnt)
{
#ifdef CONFIG_SPD823TS
return (ERR_TIMOUT); /* any other error codes are possible as well */
#else
int i;
ulong end = addr + cnt - 1;
flash_info_t *info_first = addr2info (addr);
flash_info_t *info_last = addr2info (end );
flash_info_t *info;
int j;
if (cnt == 0) {
return (ERR_OK);
}
if (!info_first || !info_last) {
return (ERR_INVAL);
}
for (info = info_first; info <= info_last; ++info) {
ulong b_end = info->start[0] + info->size; /* bank end addr */
short s_end = info->sector_count - 1;
for (i=0; i<info->sector_count; ++i) {
ulong e_addr = (i == s_end) ? b_end : info->start[i + 1];
if ((end >= info->start[i]) && (addr < e_addr) &&
(info->protect[i] != 0) ) {
return (ERR_PROTECTED);
}
}
}
printf("\rWriting ");
for (j=0; j<20; j++) putc(177);
printf("\rWriting ");
/* finally write data to flash */
for (info = info_first; info <= info_last && cnt>0; ++info) {
ulong len;
len = info->start[0] + info->size - addr;
if (len > cnt)
len = cnt;
if ((i = write_buff(info, src, addr, len)) != 0) {
return (i);
}
cnt -= len;
addr += len;
src += len;
}
return (ERR_OK);
#endif /* CONFIG_SPD823TS */
}
int do_mem_cp(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
ulong addr, dest, count;
int size;
if (argc != 4) {
print_cmd_help(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);
dest = simple_strtoul(argv[2], NULL, 16);
count = simple_strtoul(argv[3], NULL, 16);
if (count == 0) {
puts("## Error: zero length?\n");
return 1;
}
#if !defined(CFG_NO_FLASH)
/* check if we are copying to Flash */
if (addr2info(dest) != NULL) {
int rc;
puts("Copying to FLASH...\n");
rc = flash_write((char *)addr, dest, count * size);
if (rc != 0) {
flash_perror(rc);
return 1;
}
puts("Done!\n\n");
return 0;
}
#endif /* !CFG_NO_FLASH */
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;
}
/*-----------------------------------------------------------------------
* Copy memory to flash.
* Make sure all target addresses are within Flash bounds,
* and no protected sectors are hit.
* Returns:
* ERR_OK 0 - OK
* ERR_TIMOUT 1 - write timeout
* ERR_NOT_ERASED 2 - Flash not erased
* ERR_PROTECTED 4 - target range includes protected sectors
* ERR_INVAL 8 - target address not in Flash memory
* ERR_ALIGN 16 - target address not aligned on boundary
* (only some targets require alignment)
*/
int flash_write(char *src, ulong addr, ulong cnt){
int i;
ulong end = addr + cnt - 1;
flash_info_t *info_first = addr2info(addr);
flash_info_t *info_last = addr2info(end);
flash_info_t *info;
if(cnt == 0){
return(ERR_OK);
}
if(!info_first || !info_last){
return(ERR_INVAL);
}
for(info = info_first; info <= info_last; ++info){
ulong b_end = info->start[0] + info->size; /* bank end addr */
short s_end = info->sector_count - 1;
for(i = 0; i < info->sector_count; ++i){
ulong e_addr = (i == s_end) ? b_end : info->start[i + 1];
if((end >= info->start[i]) && (addr < e_addr) && (info->protect[i] != 0)){
return(ERR_PROTECTED);
}
}
}
/* finally write data to flash */
for(info = info_first; info <= info_last && cnt > 0; ++info){
ulong len;
len = info->start[0] + info->size - addr;
if(len > cnt){
len = cnt;
}
if((i = write_buff(info, (uchar *)src, addr, len)) != 0){
return(i);
}
cnt -= len;
addr += len;
src += len;
}
return(ERR_OK);
}
int do_mem_cp64 ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
uint64_t addr, dest, count;
int size;
if (argc != 4)
return CMD_RET_USAGE;
/* Check for size specification.
*/
if ((size = cmd_get_data_size(argv[0], 8)) < 0)
return 1;
addr = simple_strtoull(argv[1], NULL, 16);
addr |= base_address64;
dest = simple_strtoull(argv[2], NULL, 16);
dest |= base_address64;
count = simple_strtoull(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 ( (dest < 0xc0000000 && addr2info(dest) != NULL)
#ifdef CONFIG_HAS_DATAFLASH
&& (!addr_dataflash(dest))
#endif
) {
int rc;
if (addr + count >= 0x100000000ull) {
puts("Source address too high to copy to flash\n");
return 1;
}
puts ("Copy to Flash... ");
rc = flash_write ((char *)((uint32_t)addr), (uint32_t)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 ((dest < 0xc0000000) &&
addr_dataflash((uint32_t)dest) && !addr_dataflash((uint32_t)addr)) {
int rc;
if (addr + count >= 0x100000000ull) {
puts("Source address is too high to copy to flash\n");
return 1;
}
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 < 0xc0000000) && addr_dataflash((uint32_t)addr) &&
(dest + count < 0x100000000ull) && !addr_dataflash((uint32_t)dest)
#ifndef CONFIG_SYS_NO_FLASH
&& (addr2info((uint32_t)dest) == NULL)
#endif
) {
int rc;
rc = read_dataflash((uint32_t)addr, count * size,
(char *)((uint32_t)dest));
if (rc != 1) {
dataflash_perror (rc);
return (1);
}
return 0;
}
if ((addr | dest) < 0x10000000ull &&
addr_dataflash(addr) && addr_dataflash(dest)) {
puts ("Unsupported combination of source/destination.\n\r");
return 1;
}
#endif
while (count-- > 0) {
if (size == 8)
cvmx_write_csr(dest, cvmx_read_csr(addr));
else if (size == 4)
cvmx_write64_uint32(dest, cvmx_read64_uint32(addr));
else if (size == 2)
cvmx_write64_uint16(dest, cvmx_read64_uint16(addr));
else
cvmx_write64_uint8(dest, cvmx_read64_uint8(addr));
addr += size;
dest += size;
/* reset watchdog from time to time */
if ((count % (64 << 10)) == 0)
WATCHDOG_RESET();
}
return 0;
}
void do_saveenv (cmd_tbl_t *cmdtp, bd_t *bd, int flag, int argc, char *argv[])
{
int rc;
extern void flash_sect_protect (int p, ulong addr_first, ulong addr_last);
extern void flash_sect_erase (ulong addr_first, ulong addr_last);
#if defined(CFG_FLASH_ENV_BUF)
uchar *sector_buffer;
#endif /* CFG_FLASH_ENV_BUF */
#if defined(CFG_FLASH_ENV_ADDR)
uchar *environment = env_init();
#endif /* CFG_FLASH_ENV_BUF */
#ifdef CONFIG_4xx
uchar *ed_buf;
/*
* On ppc4xx still saved somewhere within a flash sector (no sector
* reserved for the environment variables). This will be changed in a
* future release.
*/
ulong sector_flash_addr;
ulong sector_flash_size;
ulong sector_flash_offs;
int i;
flash_info_t *info;
# ifndef CFG_FLASH_ENV_ADDR
env_init();
# endif
/*
* Calculate environment variables sector address and size
*/
info = addr2info((ulong)flash_addr);
for (i=0; i<info->sector_count; i++)
{
if (info->start[i] >= (ulong)flash_addr)
break;
}
sector_flash_addr = info->start[i-1];
sector_flash_size = info->start[i] - info->start[i-1];
sector_flash_offs = (ulong)flash_addr - info->start[i-1];
/*
* Allocate temp buffer to edit environment
*/
if ((ed_buf = malloc(sector_flash_size)) == NULL) {
printf ("## malloc(%lu) failed\n", sector_flash_size);
return;
}
/*
* Copy sector down to ram
*/
memcpy(ed_buf, (uchar *)sector_flash_addr, sector_flash_size);
/*
* Copy new environment variables to ram image of flash sector
*/
memcpy(ed_buf+sector_flash_offs, (uchar *)environment, env_size);
flash_sect_protect (0, sector_flash_addr, sector_flash_addr+sector_flash_size-1);
printf ("Erasing Flash...");
flash_sect_erase (sector_flash_addr, sector_flash_addr+sector_flash_size-1);
printf ("Saving Environment to Flash...\n");
switch (rc = flash_write (ed_buf, sector_flash_addr, sector_flash_size)) {
case 0: break;
case 1: printf ("Timeout writing to Flash\n");
break;
case 2: printf ("Flash not Erased\n");
break;
case 4: printf ("Can't write to protected Flash sectors\n");
break;
default:
printf ("%s[%d] FIXME: rc=%d\n",__FILE__,__LINE__,rc);
}
free (ed_buf);
flash_sect_protect (1, sector_flash_addr, sector_flash_addr+sector_flash_size-1);
#else /* ! CONFIG_4xx */
# ifndef CFG_FLASH_ENV_ADDR
env_init();
# endif
# if defined(CFG_FLASH_ENV_BUF)
/* this buffer area was reserved in board_init_f() */
sector_buffer = (uchar *)((ulong)bd - CFG_FLASH_ENV_BUF);
/* copy the environment into the sector buffer */
memcpy(sector_buffer, environment, env_size);
/* override the old names */
# define environment sector_buffer
# define env_size CFG_FLASH_ENV_BUF
# endif /* CFG_FLASH_ENV_BUF */
flash_sect_protect (0, (ulong)flash_addr, (ulong)flash_addr+env_size-1);
printf ("Erasing Flash...");
flash_sect_erase ((ulong)flash_addr, (ulong)flash_addr+env_size-1);
printf ("Saving Environment to Flash...\n");
switch (rc = flash_write (environment, (ulong)flash_addr, env_size)) {
case 0: break;
case 1: printf ("Timeout writing to Flash\n");
break;
case 2: printf ("Flash not Erased\n");
break;
case 4: printf ("Can't write to protected Flash sectors\n");
break;
case 8: printf ("Outside available Flash\n");
return;
default:
printf ("%s[%d] FIXME: rc=%d\n",__FILE__,__LINE__,rc);
}
flash_sect_protect (1, (ulong)flash_addr, (ulong)flash_addr+env_size-1);
# if defined(CFG_FLASH_ENV_BUF)
# undef environment
# undef env_size
# endif /* CFG_FLASH_ENV_BUF */
#endif /* CONFIG_4xx */
}
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 ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
ulong addr = 0, dest = 0, count = 0;
int size;
if(!memcmp(argv[0],"cp.linux",sizeof("cp.linux")))
{
/* 8M/16 flash:
* -write linux kernel and file system separately
* -kernel starts at PHYS_FLASH_1 and file system starts at PHYS_FLASH_2
*/
#if (defined (RT2880_ASIC_BOARD) || defined (RT2880_FPGA_BOARD) || defined (RT3052_MP1)) && (defined ON_BOARD_8M_FLASH_COMPONENT || defined ON_BOARD_16M_FLASH_COMPONENT)
int rc;
ulong kernsz = 0x3B0000;
addr += base_address;
addr += CFG_LOAD_ADDR;
dest = dest + CFG_KERN_ADDR + base_address;
if (NetBootFileXferSize <= kernsz)
count = NetBootFileXferSize;
else
count = kernsz;
size = 1;
printf("\n Copy linux image[%d byte] to Flash[0x%08X].... \n",count,dest);
puts ("Copy to Flash... ");
printf ("\n Copy %d bytes to Flash... ", count);
rc = flash_write ((uchar *)addr, dest, count);
if (rc != 0) {
flash_perror (rc);
return (1);
}
if (count < kernsz)
return 0;
addr += kernsz;
dest = PHYS_FLASH_2;
count = NetBootFileXferSize - kernsz;
printf("\n Copy linux file system[%d byte] to Flash[0x%08X].... \n",count,dest);
puts ("Copy to Flash... ");
printf ("\n Copy %d bytes to Flash... ", count);
rc = flash_write ((uchar *)addr, dest, count);
if (rc != 0) {
flash_perror (rc);
return (1);
}
puts ("done\n");
return 0;
#endif
addr += base_address;
addr += CFG_LOAD_ADDR;
dest = dest + CFG_KERN_ADDR + base_address;
printf("\n Copy linux image[%d byte] to Flash[0x%08X].... \n",NetBootFileXferSize,dest);
count = NetBootFileXferSize;
size = 1;
goto RT2880_START_WRITE_FLASH;
}
/* flash layout remove cramfs, by bruce */
/*
else if(!memcmp(argv[0],"cp.cramfs",sizeof("cp.cramfs")))
{
addr += base_address;
addr += CFG_LOAD_ADDR;
dest = dest + 0xBC530000 + base_address;
printf("\n Copy File System image[%d byte] to Flash[0x%08X].... \n",NetBootFileXferSize,dest);
count = NetBootFileXferSize;
size = 1;
goto RT2880_START_WRITE_FLASH;
}
*/
else if(!memcmp(argv[0],"cp.uboot",sizeof("cp.uboot")))
{
addr += base_address;
addr += CFG_LOAD_ADDR;
dest = dest + CFG_FLASH_BASE + base_address;
printf("\n Copy uboot[%d byte] to Flash[0x%08X].... \n",NetBootFileXferSize,dest);
count = NetBootFileXferSize;
size = 1;
goto RT2880_START_WRITE_FLASH;
}
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)
{
puts (" cmd error\n");
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);
RT2880_START_WRITE_FLASH:
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(addr))
#endif
) {
int rc;
puts ("Copy to Flash... ");
printf ("\n Copy %d byte to Flash... ",count*size);
rc = flash_write ((uchar *)addr, dest, count*size);
if (rc != 0) {
flash_perror (rc);
return (1);
}
puts ("done\n");
return 0;
}
#endif
#if (CONFIG_COMMANDS & CFG_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
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 ( 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;
}
int do_dma_cp ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
ulong addr, dest, count , tempaddr;
int size;
unsigned int ChannelNo;
struct dma_device_cfg configuration = {
MEMORY_DMA_REQ,
(DMA_WRAP_1|DMA_BURST_8|DMA_SIZE_32|DMA_SG_MODE|DMA_SW_REQ),
Source1,
Destination1,
} ;
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;
}
count *= size;
#ifndef CFG_NO_FLASH
/* check if we are copying to Flash */
if ( (addr2info(dest) != NULL)
#ifdef CONFIG_HAS_DATAFLASH
&& (!addr_dataflash(addr))
#endif
) {
int rc;
puts ("Copy to Flash... ");
rc = flash_write ((char *)addr, dest, count);
if (rc != 0) {
flash_perror (rc);
return (1);
}
puts ("done\n");
return 0;
}
#endif
init_dma();
if(addr >= 0xFE000000){
*(volatile unsigned int *)(0xD8330000) = 0x33013301;
*(volatile unsigned int *)(0xD8330008) = 0x10004;
*(volatile unsigned int *)(0xD8330010) = 0x10004;
*(volatile unsigned int *)(0xD8330020) = 0x809;
*(volatile unsigned int *)(0xD8330028) = 0x809;
request_dma(&ChannelNo, "dmacp", I2S_TX_DMA_REQ);
}
else
request_dma(&ChannelNo, "dmacp", MEMORY_DMA_REQ);
if(addr >= 0xFE000000){
configuration.DeviceReqType = I2S_TX_DMA_REQ;
configuration.DefaultCCR = (DMA_WRAP_1|DMA_BURST_8|DMA_SIZE_32|DMA_SG_MODE|DMA_UP_MEMREG_EN|DEVICE_TO_MEM);
tempaddr = addr;
addr = dest;
dest = tempaddr;
}
init_descriptstack(ChannelNo);
setup_dma(ChannelNo, configuration);
//printf("ISR ch%d = %x\n", ChannelNo, pDma_Reg->DMA_ISR);
//printf("IER ch%d = %x\n", ChannelNo, pDma_Reg->DMA_IER);
//printf("CCR ch%d = %x\n", ChannelNo, pDma_Reg->DMA_CCR_CH[ChannelNo]);
//{
// start_dma(ChannelNo, (unsigned long)addr, (unsigned long)dest, count);
// printf("DMA%d : handle irq begin\n", ChannelNo);
// handle_dma_irq(ChannelNo);
// printf("DMA%d : handle irq OK\n", ChannelNo);
/*******************************************
* wait for dma transfer complete and terminal count
********************************************/
// while (1) {
// if (dma_busy(ChannelNo) != 1)
// break;
// }
// printf("DMA%d : no busy\n", ChannelNo);
// while (1) {
// if (dma_complete(ChannelNo) == 0)
// break;
// }
//}
handle_transfer(ChannelNo, (unsigned long)addr, (unsigned long)dest, count);
reset_descriptstack(ChannelNo);
printf("DMA%d : transfer OK\n", ChannelNo);
return 0;
}
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;
}
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(addr))
#endif
) {
int rc;
puts ("Copy to Flash... ");
#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) */
rc = flash_write ((char *)addr, dest, count*size);
if (rc != 0) {
flash_perror (rc);
return (1);
}
puts ("done\n");
return 0;
}
#endif
#if (CONFIG_COMMANDS & CFG_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
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;
}
/*-----------------------------------------------------------------------
* Copy memory to flash.
* Make sure all target addresses are within Flash bounds,
* and no protected sectors are hit.
* Returns:
* ERR_OK 0 - OK
* ERR_TIMOUT 1 - write timeout
* ERR_NOT_ERASED 2 - Flash not erased
* ERR_PROTECTED 4 - target range includes protected sectors
* ERR_INVAL 8 - target address not in Flash memory
* ERR_ALIGN 16 - target address not aligned on boundary
* (only some targets require alignment)
*/
int flash_write (char *src, ulong addr, ulong cnt)
{
int i;
ulong end = addr + cnt - 1;
flash_info_t *info_first = addr2info (addr);
flash_info_t *info_last = addr2info (end );
flash_info_t *info;
if (cnt == 0)
{
return (ERR_OK);
}
if (!info_first || !info_last)
{
return (ERR_INVAL);
}
for (info = info_first; info <= info_last; ++info)
{
ulong b_end = info->start[0] + info->size; /* bank end addr */
short s_end = info->sector_count - 1;
for (i=0; i<info->sector_count; ++i)
{
ulong e_addr = (i == s_end) ? b_end : info->start[i + 1];
if ((end >= info->start[i]) && (addr < e_addr) &&(info->protect[i] != 0) )
{
return (ERR_PROTECTED);
}
}
}
/* finally write data to flash */
for (info = info_first; info <= info_last && cnt>0; ++info)
{
ulong len;
len = info->start[0] + info->size - addr;
if (len > cnt)
len = cnt;
/*-----------------------------------------------------------------------
* FUNCTION:flash_program_buf
* Copy memory to flash, returns:
* 0 - OK
* 1 - write timeout
* 2 - Flash not erased
*/
if( ( ( unsigned int ) src >= info_first->start[0] ) && ( ( unsigned int ) src <= info_first->start[0] + info_first->size ) )
{
unsigned int *p=NULL;
unsigned int i,j,tmp,addr_tmp,src_tmp;
addr_tmp=addr;
src_tmp = ( unsigned int ) src;
for(i=0;i<(cnt>>10);i++)
{
p=malloc(1024);
flash_read_buf( info , src , ( unsigned char *) p , 1024 );
if ( ( j = flash_program_buf( ( unsigned char *) addr , ( unsigned char *) p , 1024 ) ) != 0)
{
return (j);
}
src+=1024;
addr+=1024;
free(p);
}
if(len%1024!=0)
{
tmp=len%1024;
p=malloc(tmp);
flash_read_buf(info,src,p,tmp);
if ((j = flash_program_buf( addr , p , tmp )) != 0)
{
return (j);
}
free(p);
}
addr=addr_tmp;
src=src_tmp;
}
else
{
if ((i = flash_program_buf(addr,src,cnt)) != 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;
}
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_cp(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]){
ulong addr, dest, count;
int size;
if(argc != 4){
#ifdef CFG_LONGHELP
if(cmdtp->help != NULL){
printf("Usage:\n%s %s\n", cmdtp->name, cmdtp->help);
} else {
printf("Usage:\n%s %s\n", cmdtp->name, cmdtp->usage);
}
#else
printf("Usage:\n%s %s\n", cmdtp->name, cmdtp->usage);
#endif
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);
dest = simple_strtoul(argv[2], NULL, 16);
count = simple_strtoul(argv[3], NULL, 16);
if(count == 0){
puts("## Error: zero length?\n");
return(1);
}
#ifndef CFG_NO_FLASH
/* check if we are copying to Flash */
if(addr2info(dest) != NULL){
int rc;
puts("Copying to flash...\n");
rc = flash_write((char *)addr, dest, count * size);
if(rc != 0){
flash_perror(rc);
return(1);
}
puts("Done!\n\n");
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);
}
