/* * 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); }