/* * save environment buffer back to flash * returns -1 on error, 0 if ok */ int board_env_save(bd_t *bd, env_t *env, int size) { int rc; ulong start_addr, end_addr; #if CFG_ENV_SIZE <= CFG_ENV_SECT_SIZE #error Make sure that CFG_ENV_SIZE <= CFG_ENV_SECT_SIZE #endif start_addr = CFG_ENV_ADDR; end_addr = start_addr + CFG_ENV_SIZE - 1; rc = flash_sect_protect(0, CFG_ENV_ADDR, end_addr); if (rc < 0) return rc; rc = flash_sect_erase(start_addr, end_addr); if (rc < 0) { flash_sect_protect(1, start_addr, end_addr); flash_perror(rc); return rc; } printf("Saving Environment to Flash..."); rc = flash_write((uchar*)env, start_addr, size); if (rc < 0) flash_perror(rc); else printf("done.\n"); (void)flash_sect_protect(1, start_addr, end_addr); return 0; }
int saveenv(void){ char *saved_data = NULL; int rc = 1; char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG; #if CFG_ENV_SECT_SIZE > CFG_ENV_SIZE ulong up_data = 0; up_data = (end_addr_new + 1 - ((long)flash_addr_new + CFG_ENV_SIZE)); if(up_data){ if((saved_data = malloc(up_data)) == NULL){ printf("## Error: unable to save the rest of sector (%ld)\n", up_data); goto Done; } memcpy(saved_data, (void *)((long)flash_addr_new + CFG_ENV_SIZE), up_data); } #endif if(flash_sect_erase((ulong)flash_addr_new, end_addr_new)){ goto Done; } if((rc = flash_write((char *)env_ptr->data, (ulong)&(flash_addr_new->data), sizeof(env_ptr->data))) || (rc = flash_write((char *)&(env_ptr->crc), (ulong)&(flash_addr_new->crc), sizeof(env_ptr->crc))) || (rc = flash_write(&flag, (ulong)&(flash_addr->flags), sizeof(flash_addr->flags))) || (rc = flash_write(&new_flag, (ulong)&(flash_addr_new->flags), sizeof(flash_addr_new->flags)))){ flash_perror(rc); goto Done; } #if CFG_ENV_SECT_SIZE > CFG_ENV_SIZE if(up_data){ /* restore the rest of sector */ if(flash_write(saved_data, (long)flash_addr_new + CFG_ENV_SIZE, up_data)){ flash_perror(rc); goto Done; } } #endif env_t * etmp = flash_addr; ulong ltmp = end_addr; flash_addr = flash_addr_new; flash_addr_new = etmp; end_addr = end_addr_new; end_addr_new = ltmp; rc = 0; Done: if(saved_data){ free(saved_data); } return(rc); }
static __inline__ int store_block (uchar * src, unsigned offset, unsigned len) { ulong newsize = offset + len; #ifdef CONFIG_SYS_DIRECT_FLASH_NFS int i, rc = 0; for (i=0; i<CONFIG_SYS_MAX_FLASH_BANKS; i++) { /* start address in flash? */ if (load_addr + offset >= flash_info[i].start[0]) { rc = 1; break; } } if (rc) { /* Flash is destination for this packet */ rc = flash_write ((uchar *)src, (ulong)(load_addr+offset), len); if (rc) { flash_perror (rc); return -1; } } else #endif /* CONFIG_SYS_DIRECT_FLASH_NFS */ { (void)memcpy ((void *)(load_addr + offset), src, len); } if (NetBootFileXferSize < (offset+len)) NetBootFileXferSize = newsize; return 0; }
/* * Erase environment sector */ int do_default_env(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[]){ int rc, rcode = 0; #if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE) unsigned char env_buffer[CFG_ENV_SECT_SIZE]; #endif #if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE) /* copy whole env sector to temporary buffer */ memcpy(env_buffer, (void *)CFG_ENV_ADDR, CFG_ENV_SECT_SIZE); /* clear env part */ memset(env_buffer, 0xFF, CFG_ENV_SIZE); #endif /* erase whole env sector */ if(flash_sect_erase(CFG_ENV_ADDR, CFG_ENV_ADDR + CFG_ENV_SECT_SIZE - 1)){ rcode = 1; } #if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE) /* restore data from buffer in FLASH */ rc = flash_write((char *)env_buffer, CFG_ENV_ADDR, CFG_ENV_SECT_SIZE); if(rc != 0){ flash_perror(rc); rcode = 1; } #endif return(rcode); }
int do_install ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { int rc; size_t sect_top; if (argc != 1) { printf ("Usage:\n%s\n", cmdtp->usage); return 1; } for(sect_top=0; sect_top<sizeof(u_boot_bin_data); sect_top+=PHYS_FLASH_SECT_SIZE) continue; sect_top--; flash_sect_protect(0, CFG_FLASH_BASE, sect_top); flash_sect_erase(CFG_FLASH_BASE, sect_top); puts ("Copying to Flash... "); rc = flash_write ((uchar *)u_boot_bin_data, CFG_FLASH_BASE, sizeof(u_boot_bin_data)); if (rc != 0) { flash_perror (rc); return (1); } puts ("done\n"); return 0; }
static __inline__ void store_block(unsigned block, uchar * src, unsigned len){ ulong offset = block * TFTP_BLOCK_SIZE + TftpBlockWrapOffset; ulong newsize = offset + len; #ifdef CFG_DIRECT_FLASH_TFTP int i, rc = 0; for(i=0; i<CFG_MAX_FLASH_BANKS; i++){ /* start address in flash? */ if(load_addr + offset >= flash_info[i].start[0]){ rc = 1; break; } } if(rc){ /* Flash is destination for this packet */ rc = flash_write((char *)src, (ulong)(load_addr+offset), len); if(rc){ flash_perror(rc); NetState = NETLOOP_FAIL; return; } } else #endif /* CFG_DIRECT_FLASH_TFTP */ { (void)memcpy((void *)(load_addr + offset), src, len); } if(NetBootFileXferSize < newsize){ NetBootFileXferSize = newsize; } }
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; }
int saveenv(void){ int len, rc; ulong end_addr, flash_sect_addr; #if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE) ulong flash_offset; uchar env_buffer[CFG_ENV_SECT_SIZE]; #else uchar *env_buffer = (uchar *)env_ptr; #endif /* CFG_ENV_SECT_SIZE */ int rcode = 0; #if defined(CFG_ENV_SECT_SIZE) && (CFG_ENV_SECT_SIZE > CFG_ENV_SIZE) flash_offset = ((ulong)flash_addr) & (CFG_ENV_SECT_SIZE-1); flash_sect_addr = ((ulong)flash_addr) & ~(CFG_ENV_SECT_SIZE-1); //debug("copy old content: sect_addr: %08lX env_addr: %08lX offset: %08lX\n", flash_sect_addr, (ulong)flash_addr, flash_offset); /* copy old contents to temporary buffer */ memcpy(env_buffer, (void *)flash_sect_addr, CFG_ENV_SECT_SIZE); /* copy current environment to temporary buffer */ memcpy((uchar *)((unsigned long)env_buffer + flash_offset), env_ptr, CFG_ENV_SIZE); len = CFG_ENV_SECT_SIZE; #else flash_sect_addr = (ulong)flash_addr; len = CFG_ENV_SIZE; #endif /* CFG_ENV_SECT_SIZE */ end_addr = flash_sect_addr + len - 1; if(flash_sect_erase(flash_sect_addr, end_addr)){ return(1); } rc = flash_write((char *)env_buffer, flash_sect_addr, len); if(rc != 0){ flash_perror(rc); rcode = 1; } else { //debug("done\n"); } return(rcode); }
static __inline__ void store_block (unsigned block, uchar * src, unsigned len) { ulong offset = block * TftpBlkSize + TftpBlockWrapOffset; ulong newsize = offset + len; #ifdef CONFIG_SYS_DIRECT_FLASH_TFTP int i, rc = 0; for (i=0; i<CONFIG_SYS_MAX_FLASH_BANKS; i++) { /* start address in flash? */ if (flash_info[i].flash_id == FLASH_UNKNOWN) continue; if (load_addr + offset >= flash_info[i].start[0]) { rc = 1; break; } } if (rc) { /* Flash is destination for this packet */ rc = flash_write ((char *)src, (ulong)(load_addr+offset), len); if (rc) { flash_perror (rc); NetState = NETLOOP_FAIL; return; } } else #endif /* CONFIG_SYS_DIRECT_FLASH_TFTP */ { (void)memcpy((void *)(load_addr + offset), src, len); } #ifdef CONFIG_MCAST_TFTP if (Multicast) ext2_set_bit(block, Bitmap); #endif if (NetBootFileXferSize < newsize) NetBootFileXferSize = newsize; }
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; }
/** Console command to display and set the software reconfigure byte * <pre> * swconfig - display the current value of the software reconfigure byte * swconfig [#] - change the software reconfigure byte to # * </pre> * @param *cmdtp [IN] as passed by run_command (ignored) * @param flag [IN] as passed by run_command (ignored) * @param argc [IN] as passed by run_command if 1, display, if 2 change * @param *argv[] [IN] contains the parameters to use * @return * <pre> * 0 if passed * -1 if failed * </pre> */ int do_swconfigbyte (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[]) { unsigned char *sector_buffer = NULL; unsigned char input_char; int write_result; unsigned int input_uint; /* display value if no argument */ if (argc < 2) { printf ("Software configuration byte is currently: 0x%02x\n", *((unsigned char *) (SW_BYTE_SECTOR_ADDR + SW_BYTE_SECTOR_OFFSET))); return 0; } else if (argc > 3) { printf ("Too many arguments\n"); return -1; } /* if 3 arguments, 3rd argument is the address to use */ if (argc == 3) { input_uint = simple_strtoul (argv[1], NULL, 16); sector_buffer = (unsigned char *) input_uint; } else { sector_buffer = (unsigned char *) DEFAULT_TEMP_ADDR; } input_char = simple_strtoul (argv[1], NULL, 0); if ((input_char & ~SW_BYTE_MASK) != 0) { printf ("Input of 0x%02x will be masked to 0x%02x\n", input_char, (input_char & SW_BYTE_MASK)); input_char = input_char & SW_BYTE_MASK; } memcpy (sector_buffer, (void *) SW_BYTE_SECTOR_ADDR, SW_BYTE_SECTOR_SIZE); sector_buffer[SW_BYTE_SECTOR_OFFSET] = input_char; printf ("Erasing Flash..."); if (flash_sect_erase (SW_BYTE_SECTOR_ADDR, (SW_BYTE_SECTOR_ADDR + SW_BYTE_SECTOR_OFFSET))) { return -1; } printf ("Writing to Flash... "); write_result = flash_write ((char *)sector_buffer, SW_BYTE_SECTOR_ADDR, SW_BYTE_SECTOR_SIZE); if (write_result != 0) { flash_perror (write_result); return -1; } else { printf ("done\n"); printf ("Software configuration byte is now: 0x%02x\n", *((unsigned char *) (SW_BYTE_SECTOR_ADDR + SW_BYTE_SECTOR_OFFSET))); } return 0; }
static int mpl_prg(uchar *src, ulong size) { ulong start; flash_info_t *info; int i, rc; #if defined(CONFIG_PATI) int start_sect; #endif #if defined(CONFIG_PIP405) || defined(CONFIG_MIP405) || defined(CONFIG_PATI) char *copystr = (char *)src; ulong *magic = (ulong *)src; #endif info = &flash_info[0]; #if defined(CONFIG_PIP405) || defined(CONFIG_MIP405) || defined(CONFIG_PATI) if (uimage_to_cpu (magic[0]) != IH_MAGIC) { puts("Bad Magic number\n"); return -1; } /* some more checks before we delete the Flash... */ /* Checking the ISO_STRING prevents to program a * wrong Firmware Image into the flash. */ i = 4; /* skip Magic number */ while (1) { if (strncmp(©str[i], "MEV-", 4) == 0) break; if (i++ >= 0x100) { puts("Firmware Image for unknown Target\n"); return -1; } } /* we have the ISO STRING, check */ if (strncmp(©str[i], CONFIG_ISO_STRING, sizeof(CONFIG_ISO_STRING)-1) != 0) { printf("Wrong Firmware Image: %s\n", ©str[i]); return -1; } #if !defined(CONFIG_PATI) start = 0 - size; for (i = info->sector_count-1; i > 0; i--) { info->protect[i] = 0; /* unprotect this sector */ if (start >= info->start[i]) break; } /* set-up flash location */ /* now erase flash */ printf("Erasing at %lx (sector %d) (start %lx)\n", start,i,info->start[i]); if ((rc = flash_erase (info, i, info->sector_count-1)) != 0) { puts("ERROR "); flash_perror(rc); return (1); } #else /* #if !defined(CONFIG_PATI */ start = FIRM_START; start_sect = -1; for (i = 0; i < info->sector_count; i++) { if (start < info->start[i]) { start_sect = i - 1; break; } } info->protect[i - 1] = 0; /* unprotect this sector */ for (; i < info->sector_count; i++) { if ((start + size) < info->start[i]) break; info->protect[i] = 0; /* unprotect this sector */ } i--; /* set-up flash location */ /* now erase flash */ printf ("Erasing at %lx to %lx (sector %d to %d) (%lx to %lx)\n", start, start + size, start_sect, i, info->start[start_sect], info->start[i]); if ((rc = flash_erase (info, start_sect, i)) != 0) { puts ("ERROR "); flash_perror (rc); return (1); } #endif /* defined(CONFIG_PATI) */ #elif defined(CONFIG_VCMA9) start = 0; for (i = 0; i <info->sector_count; i++) { info->protect[i] = 0; /* unprotect this sector */ if (size < info->start[i]) break; } /* set-up flash location */ /* now erase flash */ printf("Erasing at %lx (sector %d) (start %lx)\n", start,0,info->start[0]); if ((rc = flash_erase (info, 0, i)) != 0) { puts("ERROR "); flash_perror(rc); return (1); } #endif printf("flash erased, programming from 0x%lx 0x%lx Bytes\n", (ulong)src, size); if ((rc = flash_write ((char *)src, start, size)) != 0) { puts("ERROR "); flash_perror(rc); return (1); } puts("OK programming done\n"); return 0; }
int saveenv(void) { int len, rc; ulong end_addr; ulong flash_sect_addr; #if defined(CONFIG_ENV_SECT_SIZE) && (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) ulong flash_offset; uchar env_buffer[CONFIG_ENV_SECT_SIZE]; #else uchar *env_buffer = (uchar *)env_ptr; #endif /* CONFIG_ENV_SECT_SIZE */ int rcode = 0; #if defined(CONFIG_ENV_SECT_SIZE) && (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) flash_offset = ((ulong)flash_addr) & (CONFIG_ENV_SECT_SIZE-1); flash_sect_addr = ((ulong)flash_addr) & ~(CONFIG_ENV_SECT_SIZE-1); debug ( "copy old content: " "sect_addr: %08lX env_addr: %08lX offset: %08lX\n", flash_sect_addr, (ulong)flash_addr, flash_offset); /* copy old contents to temporary buffer */ memcpy (env_buffer, (void *)flash_sect_addr, CONFIG_ENV_SECT_SIZE); /* copy current environment to temporary buffer */ memcpy ((uchar *)((unsigned long)env_buffer + flash_offset), env_ptr, CONFIG_ENV_SIZE); len = CONFIG_ENV_SECT_SIZE; #else flash_sect_addr = (ulong)flash_addr; len = CONFIG_ENV_SIZE; #endif /* CONFIG_ENV_SECT_SIZE */ #ifndef CONFIG_INFERNO end_addr = flash_sect_addr + len - 1; #else /* this is the last sector, and the size is hardcoded here */ /* otherwise we will get stack problems on loading 128 KB environment */ end_addr = flash_sect_addr + CONFIG_INFERNO - 1; #endif debug ("Protect off %08lX ... %08lX\n", (ulong)flash_sect_addr, end_addr); if (flash_sect_protect (0, flash_sect_addr, end_addr)) return 1; puts ("Erasing Flash..."); if (flash_sect_erase (flash_sect_addr, end_addr)) return 1; puts ("Writing to Flash... "); rc = flash_write((char *)env_buffer, flash_sect_addr, len); if (rc != 0) { flash_perror (rc); rcode = 1; } else { puts ("done\n"); } /* try to re-protect */ (void) flash_sect_protect (1, flash_sect_addr, end_addr); return rcode; }
int saveenv(void) { env_t env_new; int rc = 1; char *saved_data = NULL; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE ulong up_data = 0; up_data = end_addr + 1 - ((long)flash_addr + CONFIG_ENV_SIZE); debug("Data to save 0x%lx\n", up_data); if (up_data) { saved_data = malloc(up_data); if (saved_data == NULL) { printf("Unable to save the rest of sector (%ld)\n", up_data); goto done; } memcpy(saved_data, (void *)((long)flash_addr + CONFIG_ENV_SIZE), up_data); debug("Data (start 0x%lx, len 0x%lx) saved at 0x%lx\n", (ulong)flash_addr + CONFIG_ENV_SIZE, up_data, (ulong)saved_data); } #endif /* CONFIG_ENV_SECT_SIZE */ debug("Protect off %08lX ... %08lX\n", (ulong)flash_addr, end_addr); if (flash_sect_protect(0, (long)flash_addr, end_addr)) goto done; rc = env_export(&env_new); if (rc) goto done; puts("Erasing Flash..."); if (flash_sect_erase((long)flash_addr, end_addr)) goto done; puts("Writing to Flash... "); rc = flash_write((char *)&env_new, (long)flash_addr, CONFIG_ENV_SIZE); if (rc != 0) goto perror; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE if (up_data) { /* restore the rest of sector */ debug("Restoring the rest of data to 0x%lx len 0x%lx\n", (ulong)flash_addr + CONFIG_ENV_SIZE, up_data); if (flash_write(saved_data, (long)flash_addr + CONFIG_ENV_SIZE, up_data)) goto perror; } #endif puts("done\n"); rc = 0; goto done; perror: flash_perror(rc); done: if (saved_data) free(saved_data); /* try to re-protect */ flash_sect_protect(1, (long)flash_addr, end_addr); return rc; }
int do_bootloader_update_nor(uint32_t image_addr, int length, uint32_t burn_addr, int failsafe) { #if defined(CONFIG_SYS_NO_FLASH) printf("ERROR: Bootloader not compiled with NOR flash support\n"); return 1; #else uint32_t failsafe_size, failsafe_top_remapped; uint32_t burn_addr_remapped, image_size, normal_top_remapped; flash_info_t *info; char tmp[16] __attribute__ ((unused)); /* to hold 32 bit numbers in hex */ int sector = 0; bootloader_header_t *header; int rc; header = cvmx_phys_to_ptr(image_addr); DBGUPD("%s(0x%x, 0x%x, 0x%x, %s)\n", __func__, image_addr, length, burn_addr, failsafe ? "failsafe" : "normal"); DBGUPD("LOOKUP_STEP 0x%x\n", LOOKUP_STEP); DBGUPD("CFG_FLASH_BASE 0x%x\n", CONFIG_SYS_FLASH_BASE); /* File with rev 1.1 headers are not relocatable, so _must_ be burned * at the address that they are linked at. */ if (header->maj_rev == 1 && header->min_rev == 1) { if (burn_addr && burn_addr != header->address) { printf("ERROR: specified address (0x%x) does not match " "required burn address (0x%llx\n)\n", burn_addr, header->address); return 1; } burn_addr = header->address; } /* If we have at least one bank of non-zero size, we have some NOR */ if (!flash_info[0].size) { puts("ERROR: No NOR Flash detected on board, can't burn NOR " "bootloader image\n"); return 1; } /* check the burn address allignement */ if ((burn_addr & (LOOKUP_STEP - 1)) != 0) { printf("Cannot programm normal image at 0x%x: address must be\n" " 0x%x bytes alligned for normal boot lookup\n", burn_addr, LOOKUP_STEP); return 1; } /* for failsage checks are easy */ if ((failsafe) && (burn_addr != FAILSAFE_BASE)) { printf("ERROR: Failsafe image must be burned to address 0x%x\n", FAILSAFE_BASE); return 1; } if (burn_addr && (burn_addr < FAILSAFE_BASE)) { printf("ERROR: burn address 0x%x out of boot range\n", burn_addr); return 1; } if (!failsafe) { #ifndef CONFIG_OCTEON_NO_FAILSAFE /* find out where failsafe ends */ failsafe_size = get_image_size((bootloader_header_t *) CONFIG_SYS_FLASH_BASE); if (failsafe_size == 0) { /* failsafe does not have header - assume fixed size * old image */ puts("Failsafe has no valid header, assuming old image. " "Using default failsafe size\n"); failsafe_size = CONFIG_SYS_NORMAL_BOOTLOADER_BASE - FAILSAFE_BASE; /* must default to CONFIG_SYS_NORMAL_BOOTLOADER_BASE */ if (!burn_addr) burn_addr = CONFIG_SYS_NORMAL_BOOTLOADER_BASE; else if (CONFIG_SYS_NORMAL_BOOTLOADER_BASE != burn_addr) { printf("WARNING: old failsafe image will not be able to start\n" "image at any address but 0x%x\n", CONFIG_SYS_NORMAL_BOOTLOADER_BASE); #ifdef ERR_ON_OLD_BASE return 1; #endif } } /* old failsafe */ #else failsafe_size = 0; #endif /* CONFIG_OCTEON_NO_FAILSAFE */ DBGUPD("failsafe size is 0x%x\n", failsafe_size); DBGUPD("%s: burn address: 0x%x\n", __func__, burn_addr); /* Locate the next flash sector */ failsafe_top_remapped = CONFIG_SYS_FLASH_BASE + failsafe_size; DBGUPD("failsafe_top_remapped 0x%x\n", failsafe_top_remapped); info = &flash_info[0]; /* no need to look into any other banks */ /* scan flash bank sectors */ for (sector = 0; sector < info->sector_count; ++sector) { DBGUPD("%d: 0x%lx\n", sector, info->start[sector]); if (failsafe_top_remapped <= info->start[sector]) break; } if (sector == info->sector_count) { puts("Failsafe takes all the flash?? Can not burn normal image\n"); return 1; } /* Move failsafe top up to the sector boundary */ failsafe_top_remapped = info->start[sector]; DBGUPD("Found next sector after failsafe is at remapped addr 0x%x\n", failsafe_top_remapped); failsafe_size = failsafe_top_remapped - CONFIG_SYS_FLASH_BASE; DBGUPD("Alligned up failsafe size is 0x%x\n", failsafe_size); /* default to the first sector after the failsafe */ if (!burn_addr) { burn_addr = FAILSAFE_BASE + failsafe_size; DBGUPD("Setting burn address to 0x%x, failsafe size: 0x%x\n", burn_addr, failsafe_size); /* check for overlap */ } else if (FAILSAFE_BASE + failsafe_size > burn_addr) { puts("ERROR: can not burn: image overlaps with failsafe\n"); printf("burn address is 0x%x, in-flash failsafe top is 0x%x\n", burn_addr, FAILSAFE_BASE + failsafe_size); return 1; } /* done with failsafe checks */ } if (length) image_size = length; else image_size = get_image_size((bootloader_header_t *)image_addr); if (!image_size) { /* this is wierd case. Should never happen with good image */ printf("ERROR: image has size field set to 0??\n"); return 1; } /* finally check the burn address' CKSSEG limit */ if ((burn_addr + image_size) >= (uint64_t) CKSSEG) { puts("ERROR: can not burn: image exceeds KSEG1 area\n"); printf("burnadr is 0x%x, top is 0x%x\n", burn_addr, burn_addr + image_size); return 1; } DBGUPD("burn_addr: 0x%x, image_size: 0x%x\n", burn_addr, image_size); /* Look up the last sector to use by the new image */ burn_addr_remapped = burn_addr - FAILSAFE_BASE + CONFIG_SYS_FLASH_BASE; DBGUPD("burn_addr_remapped 0x%x\n", burn_addr_remapped); normal_top_remapped = burn_addr_remapped + image_size; /* continue flash scan - now for normal image top */ if (failsafe) sector = 0; /* is failsafe, we start from first sector here */ for (; sector < info->sector_count; ++sector) { DBGUPD("%d: 0x%lx\n", sector, info->start[sector]); if (normal_top_remapped <= info->start[sector]) break; } if (sector == info->sector_count) { puts("ERROR: not enough room in flash bank for the image??\n"); return 1; } /* align up for environment variable set up */ normal_top_remapped = info->start[sector]; DBGUPD("normal_top_remapped 0x%x\n", normal_top_remapped); /* if there is no header (length != 0) - check burn address and * give warning */ if (length && CONFIG_SYS_NORMAL_BOOTLOADER_BASE != burn_addr) { #ifdef ERR_ON_OLD_BASE puts("ERROR: burning headerless image at other that defailt address\n" "Image look up will not work.\n"); printf("Default burn address: 0x%x requested burn address: 0x%x\n", CONFIG_SYS_NORMAL_BOOTLOADER_BASE, burn_addr); return 1; #else puts("WARNING: burning headerless image at other that defailt address\n" "Image look up will not work.\n"); printf("Default burn address: 0x%x requested burn address: 0x%x\n", CONFIG_SYS_NORMAL_BOOTLOADER_BASE, burn_addr); #endif } printf("Image at 0x%x is ready for burning\n", image_addr); printf(" Header version: %d.%d\n", header->maj_rev, header->min_rev); printf(" Header size %d, data size %d\n", header->hlen, header->dlen); printf(" Header crc 0x%x, data crc 0x%x\n", header->hcrc, header->dcrc); printf(" Image link address is 0x%llx\n", header->address); printf(" Image burn address on flash is 0x%x\n", burn_addr); printf(" Image size on flash 0x%x\n", normal_top_remapped - burn_addr_remapped); DBGUPD("burn_addr_remapped 0x%x normal_top_remapped 0x%x\n", burn_addr_remapped, normal_top_remapped); if (flash_sect_protect(0, burn_addr_remapped, normal_top_remapped - 1)) { puts("Flash unprotect failed\n"); return 1; } if (flash_sect_erase(burn_addr_remapped, normal_top_remapped - 1)) { puts("Flash erase failed\n"); return 1; } puts("Copy to Flash... "); /* Note: Here we copy more than we should - whatever is after the image * in memory gets copied to flash. */ rc = flash_write((char *)image_addr, burn_addr_remapped, normal_top_remapped - burn_addr_remapped); if (rc != 0) { flash_perror(rc); return 1; } puts("done\n"); #ifndef CONFIG_ENV_IS_IN_NAND /* Erase the environment so that older bootloader will use its default * environment. This will ensure that the default * 'bootloader_flash_update' macro is there. HOWEVER, this is only * useful if a legacy sized failsafe u-boot image is present. * If a new larger failsafe is present, then that macro will be incorrect * and will erase part of the failsafe. * The 1.9.0 u-boot needs to have its link address and * normal_bootloader_size/base modified to work with this... */ if (header->maj_rev == 1 && header->min_rev == 1) { puts("Erasing environment due to u-boot downgrade.\n"); flash_sect_protect(0, CONFIG_ENV_ADDR, CONFIG_ENV_ADDR + CONFIG_ENV_SIZE - 1); if (flash_sect_erase (CONFIG_ENV_ADDR, CONFIG_ENV_ADDR + CONFIG_ENV_SIZE - 1)) { puts("Environment erase failed\n"); return 1; } } #endif return 0; #endif }
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; }
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; }
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 saveenv(void) { env_t env_new; ssize_t len; int rc = 1; char *res; char *saved_data = NULL; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE ulong up_data = 0; up_data = (end_addr + 1 - ((long)flash_addr + CONFIG_ENV_SIZE)); debug("Data to save 0x%lx\n", up_data); if (up_data) { if ((saved_data = malloc(up_data)) == NULL) { printf("Unable to save the rest of sector (%ld)\n", up_data); goto done; } memcpy(saved_data, (void *)((long)flash_addr + CONFIG_ENV_SIZE), up_data); debug("Data (start 0x%lx, len 0x%lx) saved at 0x%lx\n", (ulong)flash_addr + CONFIG_ENV_SIZE, up_data, (ulong)saved_data); } #endif /* CONFIG_ENV_SECT_SIZE */ debug("Protect off %08lX ... %08lX\n", (ulong)flash_addr, end_addr); if (flash_sect_protect(0, (long)flash_addr, end_addr)) goto done; res = (char *)&env_new.data; len = hexport_r(&env_htab, '\0', &res, ENV_SIZE); if (len < 0) { error("Cannot export environment: errno = %d\n", errno); goto done; } env_new.crc = crc32(0, env_new.data, ENV_SIZE); puts("Erasing Flash..."); if (flash_sect_erase((long)flash_addr, end_addr)) goto done; puts("Writing to Flash... "); rc = flash_write((char *)&env_new, (long)flash_addr, CONFIG_ENV_SIZE); if (rc != 0) { flash_perror(rc); goto done; } #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE if (up_data) { /* restore the rest of sector */ debug("Restoring the rest of data to 0x%lx len 0x%lx\n", (ulong)flash_addr + CONFIG_ENV_SIZE, up_data); if (flash_write(saved_data, (long)flash_addr + CONFIG_ENV_SIZE, up_data)) { flash_perror(rc); goto done; } } #endif puts("done\n"); rc = 0; done: if (saved_data) free(saved_data); /* try to re-protect */ (void) flash_sect_protect(1, (long)flash_addr, end_addr); return rc; }
int saveenv(void) { env_t env_new; ssize_t len; char *saved_data = NULL; char *res; int rc = 1; char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE ulong up_data = 0; #endif debug("Protect off %08lX ... %08lX\n", (ulong)flash_addr, end_addr); if (flash_sect_protect(0, (ulong)flash_addr, end_addr)) { goto done; } debug("Protect off %08lX ... %08lX\n", (ulong)flash_addr_new, end_addr_new); if (flash_sect_protect(0, (ulong)flash_addr_new, end_addr_new)) { goto done; } res = (char *)&env_new.data; len = hexport_r(&env_htab, '\0', &res, ENV_SIZE); if (len < 0) { error("Cannot export environment: errno = %d\n", errno); goto done; } env_new.crc = crc32(0, env_new.data, ENV_SIZE); env_new.flags = new_flag; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE up_data = (end_addr_new + 1 - ((long)flash_addr_new + CONFIG_ENV_SIZE)); debug("Data to save 0x%lX\n", up_data); if (up_data) { if ((saved_data = malloc(up_data)) == NULL) { printf("Unable to save the rest of sector (%ld)\n", up_data); goto done; } memcpy(saved_data, (void *)((long)flash_addr_new + CONFIG_ENV_SIZE), up_data); debug("Data (start 0x%lX, len 0x%lX) saved at 0x%p\n", (long)flash_addr_new + CONFIG_ENV_SIZE, up_data, saved_data); } #endif puts("Erasing Flash..."); debug(" %08lX ... %08lX ...", (ulong)flash_addr_new, end_addr_new); if (flash_sect_erase((ulong)flash_addr_new, end_addr_new)) { goto done; } puts("Writing to Flash... "); debug(" %08lX ... %08lX ...", (ulong)&(flash_addr_new->data), sizeof(env_ptr->data)+(ulong)&(flash_addr_new->data)); if ((rc = flash_write((char *)&env_new, (ulong)flash_addr_new, sizeof(env_new))) || (rc = flash_write(&flag, (ulong)&(flash_addr->flags), sizeof(flash_addr->flags))) ) { flash_perror(rc); goto done; } #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE if (up_data) { /* restore the rest of sector */ debug("Restoring the rest of data to 0x%lX len 0x%lX\n", (long)flash_addr_new + CONFIG_ENV_SIZE, up_data); if (flash_write(saved_data, (long)flash_addr_new + CONFIG_ENV_SIZE, up_data)) { flash_perror(rc); goto done; } } #endif puts("done\n"); { env_t * etmp = flash_addr; ulong ltmp = end_addr; flash_addr = flash_addr_new; flash_addr_new = etmp; end_addr = end_addr_new; end_addr_new = ltmp; } rc = 0; done: if (saved_data) free(saved_data); /* try to re-protect */ (void) flash_sect_protect(1, (ulong)flash_addr, end_addr); (void) flash_sect_protect(1, (ulong)flash_addr_new, end_addr_new); return rc; }
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 = 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; 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) { 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 saveenv(void) { env_t env_new; char *saved_data = NULL; char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG; int rc = 1; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE ulong up_data = 0; #endif debug("Protect off %08lX ... %08lX\n", (ulong)flash_addr, end_addr); if (flash_sect_protect(0, (ulong)flash_addr, end_addr)) goto done; debug("Protect off %08lX ... %08lX\n", (ulong)flash_addr_new, end_addr_new); if (flash_sect_protect(0, (ulong)flash_addr_new, end_addr_new)) goto done; rc = env_export(&env_new); if (rc) return rc; env_new.flags = new_flag; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE up_data = end_addr_new + 1 - ((long)flash_addr_new + CONFIG_ENV_SIZE); debug("Data to save 0x%lX\n", up_data); if (up_data) { saved_data = malloc(up_data); if (saved_data == NULL) { printf("Unable to save the rest of sector (%ld)\n", up_data); goto done; } memcpy(saved_data, (void *)((long)flash_addr_new + CONFIG_ENV_SIZE), up_data); debug("Data (start 0x%lX, len 0x%lX) saved at 0x%p\n", (long)flash_addr_new + CONFIG_ENV_SIZE, up_data, saved_data); } #endif puts("Erasing Flash..."); debug(" %08lX ... %08lX ...", (ulong)flash_addr_new, end_addr_new); if (flash_sect_erase((ulong)flash_addr_new, end_addr_new)) goto done; puts("Writing to Flash... "); debug(" %08lX ... %08lX ...", (ulong)&(flash_addr_new->data), sizeof(env_ptr->data) + (ulong)&(flash_addr_new->data)); rc = flash_write((char *)&env_new, (ulong)flash_addr_new, sizeof(env_new)); if (rc) goto perror; rc = flash_write(&flag, (ulong)&(flash_addr->flags), sizeof(flash_addr->flags)); if (rc) goto perror; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE if (up_data) { /* restore the rest of sector */ debug("Restoring the rest of data to 0x%lX len 0x%lX\n", (long)flash_addr_new + CONFIG_ENV_SIZE, up_data); if (flash_write(saved_data, (long)flash_addr_new + CONFIG_ENV_SIZE, up_data)) goto perror; } #endif puts("done\n"); { env_t *etmp = flash_addr; ulong ltmp = end_addr; flash_addr = flash_addr_new; flash_addr_new = etmp; end_addr = end_addr_new; end_addr_new = ltmp; } rc = 0; goto done; perror: flash_perror(rc); done: if (saved_data) free(saved_data); /* try to re-protect */ flash_sect_protect(1, (ulong)flash_addr, end_addr); flash_sect_protect(1, (ulong)flash_addr_new, end_addr_new); return rc; }
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; }
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); }
int saveenv(void) { char *saved_data = NULL; int rc = 1; char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG; #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE ulong up_data = 0; #endif debug ("Protect off %08lX ... %08lX\n", (ulong)flash_addr, end_addr); if (flash_sect_protect (0, (ulong)flash_addr, end_addr)) { goto Done; } debug ("Protect off %08lX ... %08lX\n", (ulong)flash_addr_new, end_addr_new); if (flash_sect_protect (0, (ulong)flash_addr_new, end_addr_new)) { goto Done; } #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE up_data = (end_addr_new + 1 - ((long)flash_addr_new + CONFIG_ENV_SIZE)); debug ("Data to save 0x%x\n", up_data); if (up_data) { if ((saved_data = malloc(up_data)) == NULL) { printf("Unable to save the rest of sector (%ld)\n", up_data); goto Done; } memcpy(saved_data, (void *)((long)flash_addr_new + CONFIG_ENV_SIZE), up_data); debug ("Data (start 0x%x, len 0x%x) saved at 0x%x\n", (long)flash_addr_new + CONFIG_ENV_SIZE, up_data, saved_data); } #endif puts ("Erasing Flash..."); debug (" %08lX ... %08lX ...", (ulong)flash_addr_new, end_addr_new); if (flash_sect_erase ((ulong)flash_addr_new, end_addr_new)) { goto Done; } puts ("Writing to Flash... "); debug (" %08lX ... %08lX ...", (ulong)&(flash_addr_new->data), sizeof(env_ptr->data)+(ulong)&(flash_addr_new->data)); if ((rc = flash_write((char *)env_ptr->data, (ulong)&(flash_addr_new->data), sizeof(env_ptr->data))) || (rc = flash_write((char *)&(env_ptr->crc), (ulong)&(flash_addr_new->crc), sizeof(env_ptr->crc))) || (rc = flash_write(&flag, (ulong)&(flash_addr->flags), sizeof(flash_addr->flags))) || (rc = flash_write(&new_flag, (ulong)&(flash_addr_new->flags), sizeof(flash_addr_new->flags)))) { flash_perror (rc); goto Done; } puts ("done\n"); #if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE if (up_data) { /* restore the rest of sector */ debug ("Restoring the rest of data to 0x%x len 0x%x\n", (long)flash_addr_new + CONFIG_ENV_SIZE, up_data); if (flash_write(saved_data, (long)flash_addr_new + CONFIG_ENV_SIZE, up_data)) { flash_perror(rc); goto Done; } } #endif { env_t * etmp = flash_addr; ulong ltmp = end_addr; flash_addr = flash_addr_new; flash_addr_new = etmp; end_addr = end_addr_new; end_addr_new = ltmp; } rc = 0; Done: if (saved_data) free (saved_data); /* try to re-protect */ (void) flash_sect_protect (1, (ulong)flash_addr, end_addr); (void) flash_sect_protect (1, (ulong)flash_addr_new, end_addr_new); return rc; }