s32 FS_Move( char *sPath, char *dPath ) { switch( f_rename( sPath, dPath ) ) { case FR_OK: return FS_SUCCESS; case FR_NO_PATH: case FR_NO_FILE: return FS_ENOENT2; case FR_EXIST: //On normal IOS Rename overwrites the target! if( f_unlink( dPath ) == FR_OK ) { if( f_rename( sPath, dPath ) == FR_OK ) { return FS_SUCCESS; } } default: break; } return FS_EFATAL; }
/** * Moves file from source <code>srcPath</code> to destination <code>destPath</code>. * * @param srcPath source full file path. * @param destPath destination full file path. * @param overwrite whether to overwrite existing file. * @throws IOException exception is thrown if overwrite flag is set to false and destination file already exists. * Or the file move operation failed. */ void digidoc::util::File::moveFile(const std::string& srcPath, const std::string& destPath, bool overwrite) throw(IOException) { if(!fileExists(srcPath)) { THROW_IOEXCEPTION("Source file '%s' does not exist.", srcPath.c_str()); } if(!overwrite && fileExists(destPath)) { THROW_IOEXCEPTION("Destination file exists '%s' can not move to there. Overwrite flag is set to false.", destPath.c_str()); } f_string _srcPath = encodeName(srcPath); f_string _destPath = encodeName(destPath); int result = f_rename(_srcPath.c_str(), _destPath.c_str()); if ( result != 0 ) { // -=K=-: copy and remove source should work as move between different partitions copyFile( srcPath, destPath, overwrite ); result = f_remove( _srcPath.c_str() ); } if ( result != 0 ) { // -=K=-: suceeded to copy, failed to remove. Should we throw or warn? WARN( "Failed to remove source file '%s' when moving it to '%s'.", _srcPath.c_str(), _destPath.c_str() ); } }
int cfg_validity_check_recent_games() { int err = 0, index, index_max, write_indices[10], rewrite_lastfile = 0; TCHAR fntmp[10][256]; file_open(LAST_FILE, FA_READ); if(file_status == FILE_ERR) { return 0; } for(index = 0; index < 10 && !f_eof(&file_handle); index++) { f_gets(fntmp[index], 255, &file_handle); } if(!f_eof(&file_handle)) index_max = 10; else index_max = index; file_close(); for(index = 0; index < index_max; index++) { file_open((uint8_t*)fntmp[index], FA_READ); write_indices[index] = file_status; if(file_status != FILE_OK) rewrite_lastfile = 1; file_close(); } if(rewrite_lastfile) { f_rename ((TCHAR*)LAST_FILE, (TCHAR*)LAST_FILE_BAK); file_open(LAST_FILE, FA_CREATE_ALWAYS | FA_WRITE); for(index = 0; index < index_max; index++) { if(write_indices[index] == FILE_OK) { err = f_puts(fntmp[index], &file_handle); err = f_putc(0, &file_handle); } } file_close(); } return err; }
int dfs_elm_rename(struct dfs_filesystem *fs, const char *oldpath, const char *newpath) { FRESULT result; #if _VOLUMES > 1 char *drivers_oldfn; const char *drivers_newfn; int vol; extern int elm_get_vol(FATFS *fat); /* add path for ELM FatFS driver support */ vol = elm_get_vol((FATFS *)fs->data); if (vol < 0) return -DFS_STATUS_ENOENT; drivers_oldfn = rt_malloc(256); if (drivers_oldfn == RT_NULL) return -DFS_STATUS_ENOMEM; drivers_newfn = newpath; rt_snprintf(drivers_oldfn, 256, "%d:%s", vol, oldpath); #else const char *drivers_oldfn, *drivers_newfn; drivers_oldfn = oldpath; drivers_newfn = newpath; #endif result = f_rename(drivers_oldfn, drivers_newfn); #if _VOLUMES > 1 rt_free(drivers_oldfn); #endif return elm_result_to_dfs(result); }
void check_sd_firmware() { int r; printf("Check SD\n"); f_mount(0, &fat); if ((r = f_open(&file, firmware_file, FA_READ)) == FR_OK) { printf("Flashing firmware...\n"); uint8_t buf[512]; unsigned int r = sizeof(buf); uint32_t address = USER_FLASH_START; while (r == sizeof(buf)) { if (f_read(&file, buf, sizeof(buf), &r) != FR_OK) { f_close(&file); return; } setleds((address - USER_FLASH_START) >> 15); printf("\t0x%lx\n", address); write_flash((void *) address, (char *)buf, sizeof(buf)); address += r; } f_close(&file); if (address > USER_FLASH_START) { printf("Complete!\n"); r = f_unlink(firmware_old); r = f_rename(firmware_file, firmware_old); } }
int FATFileSystem::rename(const char *oldname, const char *newname) { FRESULT res = f_rename(oldname, newname); if (res) { debug_if(FFS_DBG, "f_rename() failed: %d\n", res); return -1; } return 0; }
static bool_t fatfsRename(const char* oldname, const char* newname) { FRESULT ferr; ferr = f_rename( (const TCHAR*)oldname, (const TCHAR*)newname ); if (ferr != FR_OK) return FALSE; return TRUE; }
bool TestExtFile::test_rename() { if (f_file_exists("test/test_ext_file2.tmp")) { f_unlink("test/test_ext_file2.tmp"); VERIFY(!f_file_exists("test/test_ext_file2.tmp")); } f_touch("test/test_ext_file.tmp"); f_rename("test/test_ext_file.tmp", "test/test_ext_file2.tmp"); VERIFY(f_file_exists("test/test_ext_file2.tmp")); VERIFY(!f_file_exists("test/test_ext_file.tmp")); return Count(true); }
/* * ======== ffcio_rename ======== */ int ffcio_rename(const char *old_name, const char *new_name) { FRESULT result; result = f_rename(old_name, new_name); if (result != FR_OK) { return (-1); } else { return (0); } }
int FATFileSystem::rename(const char *oldpath, const char *newpath) { Deferred<const char*> oldfpath = fat_path_prefix(_id, oldpath); Deferred<const char*> newfpath = fat_path_prefix(_id, newpath); lock(); FRESULT res = f_rename(oldfpath, newfpath); unlock(); if (res != FR_OK) { debug_if(FFS_DBG, "f_rename() failed: %d\n", res); } return fat_error_remap(res); }
void restore(void){ drawString(TITLE, 10, 10, COLOR_TITLE); pos_y = drawString("Press SELECT to restore arm9loaderhax.bin", 10, 40, COLOR_WHITE); pos_y = drawString("Press any other button to shutdown", 10, pos_y, COLOR_WHITE); if(waitInput() != BUTTON_SELECT) shutdown(0, NULL); const char *path; FILINFO fno; path = "arm9loaderhax.bin.bak"; if(f_stat(path, &fno) == FR_NO_FILE) { shutdown(1, "Error: arm9loaderhax.bin.bak doesn't exist"); } f_rename("arm9loaderhax.bin", "arm9loaderhax.bin.tmp"); f_rename("arm9loaderhax.bin.bak", "arm9loaderhax.bin"); f_rename("arm9loaderhax.bin.tmp", "arm9loaderhax.bin.bak"); reboot(2, "Restore: success!"); }
/** * @brief fatfs_mv rename a file * @param fc the current FAT session * @param cmd the command name for error messages * @param from_name original filename * @param to_name new filename * @param force set to true to rename the file even if to_name exists * @return 0 on success */ int fatfs_mv(struct block_cache *output, off_t block_offset, const char *cmd, const char *from_name, const char *to_name, bool force) { close_open_files(); MAYBE_MOUNT(output, block_offset); // If forcing, remove the file first. if (force && fatfs_rm(output, block_offset, cmd, to_name, false)) return -1; CHECK(cmd, from_name, f_rename(from_name, to_name)); return 0; }
static int _rename(vfs_mount_t *mountp, const char *from_path, const char *to_path) { char fatfs_abs_path_to[FATFS_MAX_ABS_PATH_SIZE]; fatfs_desc_t *fs_desc = (fatfs_desc_t *)mountp->private_data; snprintf(fs_desc->abs_path_str_buff, FATFS_MAX_ABS_PATH_SIZE, "%d:/%s", fs_desc->vol_idx, from_path); snprintf(fatfs_abs_path_to, sizeof(fatfs_abs_path_to), "%d:/%s", fs_desc->vol_idx, to_path); return fatfs_err_to_errno(f_rename(fs_desc->abs_path_str_buff, fatfs_abs_path_to)); }
// Rename a file or directory bool MassStorage::Rename(const char *oldFilename, const char *newFilename) { if (newFilename[0] >= '0' && newFilename[0] <= '9' && newFilename[1] == ':') { // Workaround for DWC 1.13 which send a volume specification at the start of the new path. // f_rename can't handle this, so skip past the volume specification. // We are assuming that the user isn't really trying to rename across volumes. This is a safe assumption when the client is DWC. newFilename += 2; } if (f_rename(oldFilename, newFilename) != FR_OK) { reprap.GetPlatform().MessageF(ErrorMessage, "Failed to rename file or directory %s to %s\n", oldFilename, newFilename); return false; } return true; }
FIO_status curve_rename(file_list_type *cur_list, char *new_name){ char name[MAX_FNAME]; char path_old[64] = "0:/" CURVE_DIR_NAME "/"; char path_new[64] = "0:/" CURVE_DIR_NAME "/"; strcpy(name,new_name); strcat(name, CURVE_EXT); //add file name to path strcat(path_old, cur_list->names[cur_list->pos]); //add file name to path; strcat(path_new, name); //add file name to path; FRESULT res = f_rename(path_old, path_new); if (res == FR_OK) { strcpy(cur_list->names[cur_list->pos], name); return FIO_OK; } else { return FIO_RENAME_ERROR; } }
FS_i32 FS_Rename(const TCHAR *OldName,const TCHAR *NewName) { FRESULT res ; FS_X_OS_LockDirHandle(); res =f_rename ( OldName, /* Pointer to old object name */ NewName /* Pointer to new object name */ ); FS_X_OS_UnlockDirHandle(); if(res!=FR_OK) return -1; return 0; }
/** * Renames a file to new name. * * \param char* nfile_to_change - original file name * \param char* nfile_new_name - new file name or file path/name * \return TRUE - operation success * \return FALSE - operation failed */ BOOL SDFileRename(char* nfile_to_change, char* nfile_new_name) { #if ((_FS_MINIMIZE != 0)||(_FS_TINY == 1)||(_FS_READONLY == 1)) return FALSE; #else if (fObj.flag == 0) { fRes = f_rename(nfile_to_change, nfile_new_name); if(fRes != FR_OK) { SDdebug("ERROR on SDFileRename\n"); errManager(); return FALSE; } return TRUE; } else return FALSE; #endif }
void OnRename(nwazetMessageContext_t* nmc){ uint8_t res = (uint8_t) FR_OK; uint8_t isTextASCII = 0; uint16_t textLength = 0; const char* oldObjName = (const char*)GetStringReference(nmc->cmdContext, &textLength, &isTextASCII); if(!oldObjName || !isTextASCII){ res = FR_INVALID_NAME; fsCheckSuccess(__func__, "oldObjName", res, oldObjName); StartResponse(nmc, res, true); return; } const char* newObjName = (const char*)GetStringReference(nmc->cmdContext, &textLength, &isTextASCII); if(!newObjName || !isTextASCII){ res = FR_INVALID_NAME; fsCheckSuccess(__func__, "newObjName", res, newObjName); StartResponse(nmc, res, true); return; } res = fsCheckSuccess(__func__, "f_rename", f_rename(oldObjName, newObjName), oldObjName); StartResponse(nmc, res, true); }
bool folder_rename(const char* old_folder_path,const char* new_folder_path) { return (FR_OK==f_rename(old_folder_path,new_folder_path))?true:false; }
void write_config (void) { char line[80]; char bLine[80]; char *pToken; char *pLine; unsigned j; unsigned len; /* initialize SPI for SDCard */ spi_init(); /* access to "config.txt" file on SDCard */ FATFS fs; /* Work area (file system object) for logical drive */ FIL file_in; /* file object */ FIL file_out; /* file object */ FRESULT res; /* FatFs function common result code */ /* Register a work area for logical drive 0 */ res = f_mount(0, &fs); if(res){ debug("Err mount fs\n"); }//no need for else //delete the old backup and make a new one res = f_unlink ("config.bck"); if(res){ debug("Err deleting file.\n"); }//no need for else res = f_rename("config.txt","config.bck"); if(res){ debug("Err renaming file.\n"); }//no need for else /* Open in file */ res = f_open(&file_in, "config.bck", FA_OPEN_EXISTING | FA_READ); if (res){ debug("Error opening config.bck\n"); }//no need for else /* Open out file */ res = f_open(&file_out, "config.txt", FA_WRITE|FA_OPEN_ALWAYS); if (res){ debug("Error opening config.txt\n"); }//no need for else /* * Read/Write/Backup Loop Start * */ bool found; pLine = f_gets(line, sizeof(line), &file_in); /* read one line */ strcpy(bLine, pLine); while (pLine) { if (strlen(pLine)==0) { f_printf(&file_out, "%s","\n"); }else{ pToken = get_token (pLine); if (*pToken == '#') { f_printf(&file_out, "%s",bLine); }else{ for (j=0; (j < NUM_TOKENS) && !found; j++) { if (stricmp (pToken, config_lookup[j].name) == 0) { switch (config_lookup[j].type) { case TYPE_INT: { int32_t *pVal = config_lookup[j].pValue; f_printf(&file_out, "%s = %d\n", config_lookup[j].name, *pVal); break; } case TYPE_DOUBLE: { double *pVal = config_lookup[j].pValue; double v = *pVal; f_printf(&file_out, "%s = ", config_lookup[j].name); if (v < 0) { f_printf(&file_out,'-'); v = -v; } /* print first part before '.' */ f_printf(&file_out,"%d",(uint32_t) v); /* print the '.' */ f_printf(&file_out,"."); /* print last part after '.' */ v = v - (int32_t)v; v = v * 1000.0; if (v < 100.0){ f_printf(&file_out,"0");} if (v < 10.0){ f_printf(&file_out,"0");} f_printf(&file_out,"%d\n",(uint32_t) v); break; } } } } } } pLine = f_gets(line, sizeof(line), &file_in); /* read next line */ strcpy(bLine, pLine); if (strlen(pLine)<3) { f_printf(&file_out, "%s","\n"); } } res = f_close(&file_in); if (res){ debug("Error closing foo.txt\n"); }//no need for else res = f_close(&file_out); if (res){ debug("Error closing foo.txt\n"); }//no need for else }
/** *************************************************************************************************** * @todo Validation */ CSV_Status_e CSV_WriteString( const TCHAR* FileName, /**<[in] Nom vers le fichier CSV.*/ uint32_t Indice_Ligne, /**<[in] Numero de ligne.*/ uint32_t Indice_Colonne, /**<[in] Numero de colonne.*/ const char* str /**<[in] Chaine a ecrire. */ ) { // Declaration des variables uint32_t b_reecriture; uint32_t ToCursorLength; uint32_t ColumnLength; FRESULT Test_Retour; FIL File_Pointer_Origine; FIL File_Pointer_Destination; uint8_t Ligne[1]; uint8_t* pLigne = Ligne; UINT Nb_Reads = 0, Nb_Writes = 0; memset(pLigne, 0, 1); // Test sur le fichier demande if(__IsFileAskedForNotA_CSV(FileName)) return CSV_Status_FichierNonCSV; // Ouverture du fichier Test_Retour = f_open(&File_Pointer_Origine, FileName, FA_OPEN_EXISTING | FA_READ); if(Test_Retour != FR_OK) return CSV_Status_OuvertureImpossible; // Creation d'un fichier temporaire Test_Retour = f_open(&File_Pointer_Destination, "csv.tmp", FA_CREATE_ALWAYS | FA_WRITE); if(Test_Retour != FR_OK) return CSV_Status_OuvertureImpossible; // Placement du curseur ligne ToCursorLength = CSV_Ecriture_PlaceCursor(&File_Pointer_Origine, Indice_Ligne, Indice_Colonne); // Ecriture jusqu'a l'emplacement choisi f_lseek(&File_Pointer_Origine, 0); for(b_reecriture=0; b_reecriture<ToCursorLength ;b_reecriture++) { f_read(&File_Pointer_Origine, pLigne, 1, &Nb_Reads); f_write(&File_Pointer_Destination, pLigne, 1, &Nb_Writes); } // Ecriture de la nouvelle donnee //f_puts(";", &File_Pointer_Destination); f_puts(str, &File_Pointer_Destination); f_puts(";", &File_Pointer_Destination); // Ecriture de la fin f_lseek(&File_Pointer_Origine, 0); ColumnLength = CSV_Lecture_PlaceCursor(&File_Pointer_Origine, Indice_Ligne, Indice_Colonne); f_lseek(&File_Pointer_Origine, f_tell(&File_Pointer_Origine) + ColumnLength /*+ 1*/); for(b_reecriture=0; b_reecriture<NB_CHAR_CSV_MAX-ToCursorLength ;b_reecriture++) { f_read(&File_Pointer_Origine, pLigne, 1, &Nb_Reads); f_write(&File_Pointer_Destination, pLigne, 1, &Nb_Writes); if(f_eof(&File_Pointer_Origine) == 1) b_reecriture = NB_CHAR_CSV_MAX - ToCursorLength; } // Fermeture des fichier Test_Retour = f_close(&File_Pointer_Origine); if(Test_Retour != FR_OK) return CSV_Status_FermetureFichierImpossible; Test_Retour = f_close(&File_Pointer_Destination); if(Test_Retour != FR_OK) return CSV_Status_FermetureFichierImpossible; // Renomage du fichier de sortie et effacement du fichier temporaire Test_Retour = f_unlink(FileName); if(Test_Retour != FR_OK) return CSV_Status_RenommageImpossible; Test_Retour = f_rename("csv.tmp", FileName); if(Test_Retour != FR_OK) return CSV_Status_RenommageImpossible; return CSV_Status_Operation_OK; }
void menuGeneralSdManager(uint8_t _event) { if (s_warning_result) { s_warning_result = 0; displayPopup(STR_FORMATTING); closeLogs(); audioQueue.stopSD(); if (f_mkfs(0, 1, 0) == FR_OK) { f_chdir("/"); REFRESH_FILES(); } else { POPUP_WARNING(STR_SDCARD_ERROR); } } int lastPos = m_posVert; uint8_t event = (EVT_KEY_MASK(_event) == KEY_ENTER ? 0 : _event); SIMPLE_MENU(SD_IS_HC() ? STR_SDHC_CARD : STR_SD_CARD, menuTabGeneral, e_Sd, reusableBuffer.sdmanager.count); int index = m_posVert-s_pgOfs; switch(_event) { case EVT_ENTRY: f_chdir(ROOT_PATH); REFRESH_FILES(); lastPos = -1; break; case EVT_KEY_LONG(KEY_MENU): if (!READ_ONLY() && s_editMode == 0) { killEvents(_event); MENU_ADD_ITEM(STR_SD_INFO); MENU_ADD_ITEM(STR_SD_FORMAT); menuHandler = onSdManagerMenu; } break; case EVT_KEY_BREAK(KEY_EXIT): REFRESH_FILES(); break; case EVT_KEY_BREAK(KEY_ENTER): if (s_editMode > 0) { break; } else { if (!reusableBuffer.sdmanager.lines[index][SD_SCREEN_FILE_LENGTH+1]) { f_chdir(reusableBuffer.sdmanager.lines[index]); s_pgOfs = 0; m_posVert = 1; index = 1; REFRESH_FILES(); killEvents(_event); return; } } // no break case EVT_KEY_LONG(KEY_ENTER): if (s_editMode == 0) { killEvents(_event); char *line = reusableBuffer.sdmanager.lines[index]; char *ext = getFileExtension(line, SD_SCREEN_FILE_LENGTH+1); if (ext) { if (!strcasecmp(ext, SOUNDS_EXT)) { MENU_ADD_ITEM(STR_PLAY_FILE); } else if (!strcasecmp(ext, BITMAPS_EXT)) { if (!READ_ONLY() && (ext-line) <= (int)sizeof(g_model.header.bitmap)) { MENU_ADD_ITEM(STR_ASSIGN_BITMAP); } } else if (!strcasecmp(ext, TEXT_EXT)) { MENU_ADD_ITEM(STR_VIEW_TEXT); } #if defined(LUA) else if (!strcasecmp(ext, SCRIPTS_EXT)) { MENU_ADD_ITEM(STR_EXECUTE_FILE); } #endif else if (!READ_ONLY() && !strcasecmp(ext, FIRMWARE_EXT)) { TCHAR lfn[_MAX_LFN + 1]; getSelectionFullPath(lfn); if (isBootloader(lfn)) { MENU_ADD_ITEM(STR_FLASH_BOOTLOADER); } } else if (!READ_ONLY() && !strcasecmp(ext, SPORT_FIRMWARE_EXT)) { MENU_ADD_ITEM(STR_FLASH_EXTERNAL_DEVICE); MENU_ADD_ITEM(STR_FLASH_INTERNAL_MODULE); } } if (!READ_ONLY()) { if (line[SD_SCREEN_FILE_LENGTH+1]) // it's a file MENU_ADD_ITEM(STR_COPY_FILE); if (clipboard.type == CLIPBOARD_TYPE_SD_FILE) MENU_ADD_ITEM(STR_PASTE); MENU_ADD_ITEM(STR_RENAME_FILE); MENU_ADD_ITEM(STR_DELETE_FILE); } menuHandler = onSdManagerMenu; } break; } if (reusableBuffer.sdmanager.offset != s_pgOfs) { FILINFO fno; DIR dir; char *fn; /* This function is assuming non-Unicode cfg. */ TCHAR lfn[_MAX_LFN + 1]; fno.lfname = lfn; fno.lfsize = sizeof(lfn); if (s_pgOfs == 0) { reusableBuffer.sdmanager.offset = 0; memset(reusableBuffer.sdmanager.lines, 0, sizeof(reusableBuffer.sdmanager.lines)); } else if (s_pgOfs == reusableBuffer.sdmanager.count-7) { reusableBuffer.sdmanager.offset = s_pgOfs; memset(reusableBuffer.sdmanager.lines, 0, sizeof(reusableBuffer.sdmanager.lines)); } else if (s_pgOfs > reusableBuffer.sdmanager.offset) { memmove(reusableBuffer.sdmanager.lines[0], reusableBuffer.sdmanager.lines[1], 6*sizeof(reusableBuffer.sdmanager.lines[0])); memset(reusableBuffer.sdmanager.lines[6], 0xff, SD_SCREEN_FILE_LENGTH); reusableBuffer.sdmanager.lines[6][SD_SCREEN_FILE_LENGTH+1] = 1; } else { memmove(reusableBuffer.sdmanager.lines[1], reusableBuffer.sdmanager.lines[0], 6*sizeof(reusableBuffer.sdmanager.lines[0])); memset(reusableBuffer.sdmanager.lines[0], 0, sizeof(reusableBuffer.sdmanager.lines[0])); } reusableBuffer.sdmanager.count = 0; FRESULT res = f_opendir(&dir, "."); /* Open the directory */ if (res == FR_OK) { for (;;) { res = f_readdir(&dir, &fno); /* Read a directory item */ if (res != FR_OK || fno.fname[0] == 0) break; /* Break on error or end of dir */ if (fno.fname[0] == '.' && fno.fname[1] == '\0') continue; /* Ignore dot entry */ #if _USE_LFN fn = *fno.lfname ? fno.lfname : fno.fname; #else fn = fno.fname; #endif if (strlen(fn) > SD_SCREEN_FILE_LENGTH) continue; reusableBuffer.sdmanager.count++; bool isfile = !(fno.fattrib & AM_DIR); if (s_pgOfs == 0) { for (int i=0; i<NUM_BODY_LINES; i++) { char *line = reusableBuffer.sdmanager.lines[i]; if (line[0] == '\0' || isFilenameLower(isfile, fn, line)) { if (i < 6) memmove(reusableBuffer.sdmanager.lines[i+1], line, sizeof(reusableBuffer.sdmanager.lines[i]) * (6-i)); memset(line, 0, sizeof(reusableBuffer.sdmanager.lines[i])); strcpy(line, fn); line[SD_SCREEN_FILE_LENGTH+1] = isfile; break; } } } else if (reusableBuffer.sdmanager.offset == s_pgOfs) { for (int8_t i=6; i>=0; i--) { char *line = reusableBuffer.sdmanager.lines[i]; if (line[0] == '\0' || isFilenameGreater(isfile, fn, line)) { if (i > 0) memmove(reusableBuffer.sdmanager.lines[0], reusableBuffer.sdmanager.lines[1], sizeof(reusableBuffer.sdmanager.lines[0]) * i); memset(line, 0, sizeof(reusableBuffer.sdmanager.lines[i])); strcpy(line, fn); line[SD_SCREEN_FILE_LENGTH+1] = isfile; break; } } } else if (s_pgOfs > reusableBuffer.sdmanager.offset) { if (isFilenameGreater(isfile, fn, reusableBuffer.sdmanager.lines[5]) && isFilenameLower(isfile, fn, reusableBuffer.sdmanager.lines[6])) { memset(reusableBuffer.sdmanager.lines[6], 0, sizeof(reusableBuffer.sdmanager.lines[0])); strcpy(reusableBuffer.sdmanager.lines[6], fn); reusableBuffer.sdmanager.lines[6][SD_SCREEN_FILE_LENGTH+1] = isfile; } } else { if (isFilenameLower(isfile, fn, reusableBuffer.sdmanager.lines[1]) && isFilenameGreater(isfile, fn, reusableBuffer.sdmanager.lines[0])) { memset(reusableBuffer.sdmanager.lines[0], 0, sizeof(reusableBuffer.sdmanager.lines[0])); strcpy(reusableBuffer.sdmanager.lines[0], fn); reusableBuffer.sdmanager.lines[0][SD_SCREEN_FILE_LENGTH+1] = isfile; } } } } } reusableBuffer.sdmanager.offset = s_pgOfs; for (int i=0; i<NUM_BODY_LINES; i++) { coord_t y = MENU_HEADER_HEIGHT + 1 + i*FH; lcdNextPos = 0; LcdFlags attr = (index == i ? BSS|INVERS : BSS); if (reusableBuffer.sdmanager.lines[i][0]) { if (!reusableBuffer.sdmanager.lines[i][SD_SCREEN_FILE_LENGTH+1]) { lcd_putcAtt(0, y, '[', s_editMode == EDIT_MODIFY_STRING ? 0 : attr); } if (s_editMode == EDIT_MODIFY_STRING && attr) { editName(lcdNextPos, y, reusableBuffer.sdmanager.lines[i], SD_SCREEN_FILE_LENGTH-4, _event, attr, 0); if (s_editMode == 0) { unsigned int len = effectiveLen(reusableBuffer.sdmanager.lines[i], SD_SCREEN_FILE_LENGTH-LEN_FILE_EXTENSION); char * ext = getFileExtension(reusableBuffer.sdmanager.originalName, sizeof(reusableBuffer.sdmanager.originalName)); if (ext) { strAppend(&reusableBuffer.sdmanager.lines[i][len], ext); } f_rename(reusableBuffer.sdmanager.originalName, reusableBuffer.sdmanager.lines[i]); REFRESH_FILES(); } } else { lcd_putsAtt(lcdNextPos, y, reusableBuffer.sdmanager.lines[i], attr); } if (!reusableBuffer.sdmanager.lines[i][SD_SCREEN_FILE_LENGTH+1]) { lcd_putcAtt(lcdNextPos, y, ']', s_editMode == EDIT_MODIFY_STRING ? 0 : attr); } } } char *ext = getFileExtension(reusableBuffer.sdmanager.lines[index], SD_SCREEN_FILE_LENGTH+1); if (ext && !strcasecmp(ext, BITMAPS_EXT)) { if (lastPos != m_posVert) { if (bmpLoad(modelBitmap, reusableBuffer.sdmanager.lines[index], MODEL_BITMAP_WIDTH, MODEL_BITMAP_HEIGHT)) { memcpy(modelBitmap, logo_taranis, MODEL_BITMAP_SIZE); } } lcd_bmp(22*FW+2, 2*FH+FH/2, modelBitmap); } }
int main(int oargc, char* oargv[]) { int ret; int argc = oargc - 1; char** argv = oargv + 1; // first parameter must be the image file. if (argc == 0) { fprintf(stderr, "Error: First parameter must be a filename.\n"); PRINT_HELP_AND_QUIT(); } if (is_command(argv[0])) { fprintf(stderr, "Error: First parameter must be a filename, found '%s' instead.\n", argv[0]); PRINT_HELP_AND_QUIT(); } if (disk_openimage(0, argv[0])) { fprintf(stderr, "Error: Could not open image file '%s'.\n", argv[0]); ret = 1; goto exit; } argc--; argv++; while (argc > 0) { char* parg = *argv; int nargs = 0; int i = 0; if (!is_command(parg)) { fprintf(stderr, "Error: Expected a command, found '%s' instead.\n", parg); PRINT_HELP_AND_QUIT(); } parg++; argv++; argc--; // find next command, to calculare number of args while ((argv[i] != NULL) && !is_command(argv[i++])) nargs++; if (strcmp(parg, "format") == 0) { // NOTE: The fs driver detects which FAT format fits best based on size int sectors; NEED_PARAMS(1, 2); // Arg 1: number of sectors sectors = atoi(argv[0]); if (sectors <= 0) { fprintf(stderr, "Error: Sectors must be > 0\n"); ret = 1; goto exit; } if (disk_ioctl(0, SET_SECTOR_COUNT, §ors)) { fprintf(stderr, "Error: Failed to set sector count to %d.\n", sectors); ret = 1; goto exit; } NEED_MOUNT(); ret = f_mkfs("0:", 1, sectors < 4096 ? 1 : 8); if (ret) { fprintf(stderr, "Error: Formatting drive: %d.\n", ret); goto exit; } // Arg 2: custom header label (optional) if (nargs > 1) { #define FAT_VOL_LABEL_LEN 11 char vol_label[2 + FAT_VOL_LABEL_LEN + 1]; // Null-terminated buffer char* label = vol_label + 2; // The first two characters are reserved for the drive number "0:" char ch; int i, invalid = 0; int len = strlen(argv[1]); if (len <= FAT_VOL_LABEL_LEN) { // Verify each character (should be printable ASCII) // and copy it in uppercase. for (i = 0; i < len; i++) { ch = toupper(argv[1][i]); if ((ch < 0x20) || !isprint(ch)) { invalid = 1; break; } label[i] = ch; } if (!invalid) { // Pad the label with spaces while (len < FAT_VOL_LABEL_LEN) { label[len++] = ' '; } } } else { invalid = 1; } if (invalid) { fprintf(stderr, "Error: Header label is limited to 11 printable uppercase ASCII symbols."); ret = 1; goto exit; } if (disk_read(0, buff, 0, 1)) { fprintf(stderr, "Error: Unable to read existing boot sector from image."); ret = 1; goto exit; } if (g_Filesystem.fs_type == FS_FAT32) { memcpy(buff + 71, label, FAT_VOL_LABEL_LEN); } else { memcpy(buff + 43, label, FAT_VOL_LABEL_LEN); } if (disk_write(0, buff, 0, 1)) { fprintf(stderr, "Error: Unable to write new boot sector to image."); ret = 1; goto exit; } // Set also the directory volume label memcpy(vol_label, "0:", 2); vol_label[2 + FAT_VOL_LABEL_LEN] = '\0'; if (f_setlabel(vol_label)) { fprintf(stderr, "Error: Unable to set the volume label."); ret = 1; goto exit; } } } else if (strcmp(parg, "boot") == 0) { FILE* fe; BYTE* temp = buff + 1024; NEED_PARAMS(1, 1); // Arg 1: boot file fe = fopen(argv[0], "rb"); if (!fe) { fprintf(stderr, "Error: Unable to open external file '%s' for reading.", argv[0]); ret = 1; goto exit; } if (!fread(buff, 512, 1, fe)) { fprintf(stderr, "Error: Unable to read boot sector from file '%s'.", argv[0]); fclose(fe); ret = 1; goto exit; } fclose(fe); NEED_MOUNT(); if (disk_read(0, temp, 0, 1)) { fprintf(stderr, "Error: Unable to read existing boot sector from image."); ret = 1; goto exit; } if (g_Filesystem.fs_type == FS_FAT32) { printf("TODO: Writing boot sectors for FAT32 images not yet supported."); ret = 1; goto exit; } else { #define FAT16_HEADER_START 3 #define FAT16_HEADER_END 62 memcpy(buff + FAT16_HEADER_START, temp + FAT16_HEADER_START, FAT16_HEADER_END - FAT16_HEADER_START); } if (disk_write(0, buff, 0, 1)) { fprintf(stderr, "Error: Unable to write new boot sector to image."); ret = 1; goto exit; } } else if (strcmp(parg, "add") == 0) { FILE* fe; FIL fv = { 0 }; UINT rdlen = 0; UINT wrlen = 0; NEED_PARAMS(2, 2); NEED_MOUNT(); // Arg 1: external file to add // Arg 2: virtual filename fe = fopen(argv[0], "rb"); if (!fe) { fprintf(stderr, "Error: Unable to open external file '%s' for reading.", argv[0]); ret = 1; goto exit; } if (f_open(&fv, argv[1], FA_WRITE | FA_CREATE_ALWAYS)) { fprintf(stderr, "Error: Unable to open file '%s' for writing.", argv[1]); fclose(fe); ret = 1; goto exit; } while ((rdlen = fread(buff, 1, sizeof(buff), fe)) > 0) { if (f_write(&fv, buff, rdlen, &wrlen) || wrlen < rdlen) { fprintf(stderr, "Error: Unable to write '%d' bytes to disk.", wrlen); ret = 1; goto exit; } } fclose(fe); f_close(&fv); } else if (strcmp(parg, "extract") == 0) { FIL fe = { 0 }; FILE* fv; UINT rdlen = 0; UINT wrlen = 0; NEED_PARAMS(2, 2); NEED_MOUNT(); // Arg 1: virtual file to extract // Arg 2: external filename if (f_open(&fe, argv[0], FA_READ)) { fprintf(stderr, "Error: Unable to open file '%s' for reading.", argv[0]); ret = 1; goto exit; } fv = fopen(argv[1], "wb"); if (!fv) { fprintf(stderr, "Error: Unable to open external file '%s' for writing.", argv[1]); f_close(&fe); ret = 1; goto exit; } while ((f_read(&fe, buff, sizeof(buff), &rdlen) == 0) && (rdlen > 0)) { if (fwrite(buff, 1, rdlen, fv) < rdlen) { fprintf(stderr, "Error: Unable to write '%d' bytes to file.", rdlen); ret = 1; goto exit; } } f_close(&fe); fclose(fv); } else if (strcmp(parg, "move") == 0) { NEED_PARAMS(2, 2); NEED_MOUNT(); // Arg 1: src path & filename // Arg 2: new path & filename if (f_rename(argv[0], argv[1])) { fprintf(stderr, "Error: Unable to move/rename '%s' to '%s'", argv[0], argv[1]); ret = 1; goto exit; } } else if (strcmp(parg, "copy") == 0) { FIL fe = { 0 }; FIL fv = { 0 }; UINT rdlen = 0; UINT wrlen = 0; NEED_PARAMS(2, 2); NEED_MOUNT(); // Arg 1: src path & filename // Arg 2: new path & filename if (f_open(&fe, argv[0], FA_READ)) { fprintf(stderr, "Error: Unable to open file '%s' for reading.", argv[0]); ret = 1; goto exit; } if (f_open(&fv, argv[1], FA_WRITE | FA_CREATE_ALWAYS)) { fprintf(stderr, "Error: Unable to open file '%s' for writing.", argv[1]); f_close(&fe); ret = 1; goto exit; } while ((f_read(&fe, buff, sizeof(buff), &rdlen) == 0) && (rdlen > 0)) { if (f_write(&fv, buff, rdlen, &wrlen) || wrlen < rdlen) { fprintf(stderr, "Error: Unable to write '%d' bytes to disk.", wrlen); ret = 1; goto exit; } } f_close(&fe); f_close(&fv); } else if (strcmp(parg, "mkdir") == 0) { NEED_PARAMS(1, 1); NEED_MOUNT(); // Arg 1: folder path if (f_mkdir(argv[0])) { fprintf(stderr, "Error: Unable to create directory."); ret = 1; goto exit; } } else if (strcmp(parg, "delete") == 0) { NEED_PARAMS(1, 1); NEED_MOUNT(); // Arg 1: file/folder path (cannot delete non-empty folders) if (f_unlink(argv[0])) { fprintf(stderr, "Error: Unable to delete file or directory."); ret = 1; goto exit; } } else if (strcmp(parg, "list") == 0) { char* root = "/"; DIR dir = { 0 }; FILINFO info = { 0 }; char lfname[257]; NEED_PARAMS(0, 1); // Arg 1: folder path (optional) if (nargs == 1) { root = argv[0]; } if (f_opendir(&dir, root)) { fprintf(stderr, "Error: Unable to opening directory '%s' for listing.\n", root); ret = 1; goto exit; } printf("Listing directory contents of: %s\n", root); info.lfname = lfname; info.lfsize = sizeof(lfname)-1; while ((!f_readdir(&dir, &info)) && (strlen(info.fname) > 0)) { if (strlen(info.lfname) > 0) printf(" - %s (%s)\n", info.lfname, info.fname); else printf(" - %s\n", info.fname); } } else { fprintf(stderr, "Error: Unknown or invalid command: %s\n", argv[-1]); PRINT_HELP_AND_QUIT(); } argv += nargs; argc -= nargs; } ret = 0; exit: disk_cleanup(0); return ret; }
//修改文件/目录名字(如果目录不同,还可以移动文件哦!) //oldname:之前的名字 //newname:新名字 //返回值:执行结果 u8 mf_rename(u8 *oldname,u8* newname) { return f_rename((const TCHAR *)oldname,(const TCHAR *)newname); }
int main( void ) { volatile unsigned long ul; // Initialize address and notify host pCurrent = (u08*)vStart; u32 kopycounter=0; prvSetupHardware( ); // Version Controll debug_msg( "NowBoot V1.2; Compiled at: "__DATE__" "__TIME__"\r"); wait_ms(1000); debug_msg("NowBoot: Running drives and filesystem."); StorageInit(); wait_ms(100); debug_msg("NowBoot: Checking for new firmware..."); //f_rename ( "1:fmw/fmw_n.old", "fmw/fmw_n.bin" ); //For tests only res = f_open(&firmwarefile, "1:fmw/fmw_n.bin", FA_OPEN_EXISTING | FA_READ); if(res != FR_OK){ f_close(&firmwarefile); debug_msg("NowBoot: Can`t find new firmware."); debug_msg("NowBoot: Checking for in-flash firmware"); if((*((u08*)vStart+4)==0xFF)&&(*((u08*)(vStart+5))==0xff)){ debug_msg("NowBoot: Flash is empty!"); debug_msg("NowBoot: Opening default firmware!"); res = f_open(&firmwarefile, "1:fmw/fmw_0.bin", FA_OPEN_EXISTING | FA_READ); if(res != FR_OK){ f_close(&firmwarefile); debug_msg("NowBoot: Can`t find any firmware file... Nothing to do."); for(;;)AT91C_BASE_SYS->WDTC_WDCR = 0xA5000001; //endless loop } goto fmw_prog; } else{ debug_msg("NowBoot: Flash contain firmware."); goto app_now; } }else{ debug_msg("NowBoot: Found new firmware."); fmw_prog: debug_msg("NowBoot: Start programming..."); wait_ms(300); debug_txt("\rCopying page: "); for (;;) { debug_txt("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\bKopiuje strone: "); debug32_tdec(kopycounter++); res = f_read(&firmwarefile, page, sizeof(page), &br); /* Read a chunk of src file */ if (res || br == 0) { wait_ms(100); debug_msg("NowBoot: Copying finshed."); break; /* error or eof */ } //memset(page,0xff,sizeof(page)); //for tests only flash_write(pCurrent , (void *) page ); pCurrent+= MEMORY_PAGE_SIZE; } } f_close(&firmwarefile); /* TO DO: MD5 verification */ wait_ms(300); debug_msg("NowBoot: Firmware upgrade successful."); debug_msg("NowBoot: Removing firmware file."); f_unlink ( "1:fmw/fmw_n.old" ); //removeing old firmware f_rename ( "1:fmw/fmw_n.bin", "fmw/fmw_n.old" ); app_now: wait_ms(100); debug_msg("NowBoot: End of Boot."); spiInit(); wait_ms(1000); AT91C_BASE_SYS->WDTC_WDCR = 0xA5000001; //WDT restart asm volatile( "LDR pc, =0x00108000" //Jump to firmware start ); debug_msg("NowBoot: Something bad happened! I should never be here."); wait_ms(100); vPortSoftReset(); return 0; }
FRESULT DFATFS::fsrename(const char* path_old, const char* path_new) { return(f_rename(path_old, path_new)); }
static msg_t ThreadFatFSWorker(void *arg) { (void)arg; Thread* p; chRegSetThreadName("fatfsWorker"); while (!chThdShouldTerminate()) { /* Wait for msg with work to do. */ p = chMsgWait(); struct wrapper_msg_base* msg = (struct wrapper_msg_base*) chMsgGet(p); msg->result = FR_INVALID_PARAMETER; switch(msg->action) { case eTERMINATE: { break; } #if HAS_MOUNT case eFMOUNT: { const struct wrapper_msg_vBYTEpFATFS* exmsg = \ (const struct wrapper_msg_vBYTEpFATFS*) msg; msg->result = f_mount(exmsg->byte, exmsg->fatfsp); break; } #endif /* HAS_MOUNT */ #if HAS_OPEN case eFOPEN: { const struct wrapper_msg_pFILpTCHARvBYTE* exmsg = \ (const struct wrapper_msg_pFILpTCHARvBYTE*) msg; msg->result = f_open(exmsg->filep, exmsg->string, exmsg->byte); break; } #endif /* HAS_OPEN */ #if HAS_READ case eFREAD: { const struct wrapper_msg_pFILpVOIDvUINTpUINT* exmsg = \ (const struct wrapper_msg_pFILpVOIDvUINTpUINT*) msg; msg->result = f_read(exmsg->filep, exmsg->voidp, exmsg->uint, exmsg->uintp); break; } #endif /* HAS_READ */ #if HAS_WRITE case eFWRITE: { const struct wrapper_msg_pFILpVOIDvUINTpUINT* exmsg = \ (const struct wrapper_msg_pFILpVOIDvUINTpUINT*) msg; msg->result = f_write(exmsg->filep, exmsg->voidp, exmsg->uint, exmsg->uintp); break; } #endif /* HAD_WRITE */ #if HAS_SYNC case eFSYNC: { const struct wrapper_msg_pFIL* exmsg = \ (const struct wrapper_msg_pFIL*) msg; msg->result = f_sync(exmsg->filep); break; } #endif /* HAS_SYNC */ #if HAS_CHDRIVE case eFCHDRIVE: { const struct wrapper_msg_vBYTE* exmsg = \ (const struct wrapper_msg_vBYTE*) msg; msg->result = f_chdrive(exmsg->byte); break; } #endif #if HAS_CHDIR case eFCHDIR: { const struct wrapper_msg_pTCHAR* exmsg = \ (const struct wrapper_msg_pTCHAR*) msg; msg->result = f_chdir(exmsg->string); break; } #endif /* HAS_CHDIR */ #if HAS_GETCWD case eFGETCWD: { const struct wrapper_msg_pTCHARvUINT* exmsg = \ (const struct wrapper_msg_pTCHARvUINT*) msg; msg->result = f_getcwd(exmsg->string, exmsg->uint); break; } #endif #if HAS_LSEEK case eFLSEEK: { const struct wrapper_msg_pFILvDWORD* exmsg = \ (const struct wrapper_msg_pFILvDWORD*) msg; msg->result = f_lseek(exmsg->filep, exmsg->dword); break; } #endif /* HAS_LSEEK */ #if HAS_CLOSE case eFCLOSE: { const struct wrapper_msg_pFIL* exmsg = \ (const struct wrapper_msg_pFIL*) msg; msg->result = f_close(exmsg->filep); break; } #endif /* HAS_CLOSE */ #if HAS_OPENDIR case eFOPENDIR: { const struct wrapper_msg_pDIRpTCHAR* exmsg = \ (const struct wrapper_msg_pDIRpTCHAR*) msg; msg->result = f_opendir(exmsg->dirp, exmsg->string); break; } #endif /* HAD_OPENDIR */ #if HAS_READDIR case eFREADDIR: { const struct wrapper_msg_pDIRpFILINFO* exmsg = \ (const struct wrapper_msg_pDIRpFILINFO*) msg; msg->result = f_readdir(exmsg->dirp, exmsg->filinfop); break; } #endif /* HAS_READDIR */ #if HAS_STAT case eFSTAT: { const struct wrapper_msg_pTCHARpFILINFO* exmsg = \ (const struct wrapper_msg_pTCHARpFILINFO*) msg; msg->result = f_stat(exmsg->string, exmsg->filinfop); break; } #endif /* HAS_STAT */ #if HAS_GETFREE case eFGETFREE: { const struct wrapper_msg_pTCHARpDWORDppFATFS* exmsg = \ (const struct wrapper_msg_pTCHARpDWORDppFATFS*) msg; msg->result = f_getfree(exmsg->string, exmsg->dwordp, exmsg->fatfspp); break; } #endif /* HAS_GETFREE */ #if HAS_TRUNCATE case eFTRUNCATE: { const struct wrapper_msg_pFIL* exmsg = \ (const struct wrapper_msg_pFIL*) msg; msg->result = f_truncate(exmsg->filep); break; } #endif /* HAS_TRUNCATE */ #if HAS_UNLINK case eFUNLINK: { const struct wrapper_msg_pTCHAR* exmsg = \ (const struct wrapper_msg_pTCHAR*) msg; msg->result = f_unlink(exmsg->string); break; } #endif /* HAS_UNLINK */ #if HAS_MKDIR case eFMKDIR: { const struct wrapper_msg_pTCHAR* exmsg = \ (const struct wrapper_msg_pTCHAR*) msg; msg->result = f_mkdir(exmsg->string); break; } #endif /* HAS_MKDIR */ #if HAS_CHMOD case eFCHMOD: { const struct wrapper_msg_pTCHARvBYTEvBYTE* exmsg = \ (const struct wrapper_msg_pTCHARvBYTEvBYTE*) msg; msg->result = f_chmod(exmsg->string, exmsg->byte1, exmsg->byte2); break; } #endif /* HAS_CHMOD */ #if HAS_UTIME case eFUTIME: { const struct wrapper_msg_pTCHARpFILINFO* exmsg = \ (const struct wrapper_msg_pTCHARpFILINFO*) msg; msg->result = f_utime(exmsg->string, exmsg->filinfop); break; } #endif /* HAD_UTIME */ #if HAS_RENAME case eFRENAME: { const struct wrapper_msg_pTCHARpTCHAR* exmsg = \ (const struct wrapper_msg_pTCHARpTCHAR*) msg; msg->result = f_rename(exmsg->string1, exmsg->string2); break; } #endif /* HAS_RENAME */ #if HAS_MKFS case eFMKFS: { const struct wrapper_msg_vBYTEvBYTEvUINT* exmsg = \ (const struct wrapper_msg_vBYTEvBYTEvUINT*) msg; msg->result = f_mkfs(exmsg->byte1, exmsg->byte2, exmsg->uint); break; } #endif /* HAS_MKFS */ #if HAS_FDISK case eFFDISK: { const struct wrapper_msg_vBYTEpDWORDpVOID* exmsg = \ (const struct wrapper_msg_vBYTEpDWORDpVOID*) msg; msg->result = f_fdisk(exmsg->byte, exmsg->dwordp, exmsg->voidp); break; } #endif /* HAS_FDISK */ #if HAS_GETS case eFGETS: { struct wrapper_msg_pTCHARvINTpFILpTCHAR* exmsg = \ (struct wrapper_msg_pTCHARvINTpFILpTCHAR*) msg; exmsg->string2 = f_gets(exmsg->string, exmsg->n, exmsg->filep); break; } #endif /* HAS_GETS */ #if HAS_PUTC case eFPUTC: { const struct wrapper_msg_vTCHARpFIL* exmsg = \ (const struct wrapper_msg_vTCHARpFIL*) msg; msg->result = f_putc(exmsg->tchar, exmsg->filep); break; } #endif /* HAS_PUTC */ #if HAS_PUTS case eFPUTS: { const struct wrapper_msg_pTCHARpFIL* exmsg = \ (const struct wrapper_msg_pTCHARpFIL*) msg; msg->result = f_puts(exmsg->string, exmsg->filep); break; } #endif /* HAS_PUTS */ } /* Done, release msg again. */ chMsgRelease(p, 0); } return 0; }
int main() { // DeInit NVIC and SCBNVIC NVIC_DeInit(); NVIC_SCBDeInit(); /* Configure the NVIC Preemption Priority Bits: * two (2) bits of preemption priority, six (6) bits of sub-priority. * Since the Number of Bits used for Priority Levels is five (5), so the * actual bit number of sub-priority is three (3) */ NVIC_SetPriorityGrouping(0x05); NVIC_SetVTOR(0x00000000); #ifdef UARTDEBUG uart_init(); #endif BlockDevInit(); #ifdef UARTDEBUG if (1) { U32 size; BlockDevGetSize(&size); DBG("Found SD card of size %d", size); BlockDevGetBlockLength(&size); DBG("block length %d", size); } #endif if (bootloader_button_pressed() || (user_code_present() == 0)) { DBG("entering bootloader"); init_usb_msc_device(); for (;usb_msc_not_ejected();) USBHwISR(); DBG("usb ejected, rebooting"); USBHwConnect(FALSE); spi_close(); } else { if ((r = f_mount(0, &fatfs)) == FR_OK) { if ((r = f_open(&f, "/firmware.bin", FA_READ | FA_OPEN_EXISTING)) == FR_OK) { unsigned int fs = f_size(&f); DBG("found firmware.bin with %u bytes", fs); if ((fs > 0) && (fs <= USER_FLASH_SIZE)) { U8 buffer[FLASH_BUF_SIZE]; for (unsigned int i = 0; i < fs; i += FLASH_BUF_SIZE) { unsigned int j = FLASH_BUF_SIZE; if (i + j > fs) j = fs - i; DBG("writing %d-%d", i, i+j); if ((r = f_read(&f, buffer, j, &j)) == FR_OK) { // pad last block to a full sector size while (j < FLASH_BUF_SIZE) { buffer[j++] = 0xFF; } write_flash((unsigned int *) (USER_FLASH_START + i), (char *) &buffer, j); } else { DBG("read failed: %d", r); i = fs; } } r = f_close(&f); r = f_unlink("/firmware.bck"); r = f_rename("/firmware.bin", "/firmware.bck"); } } else { DBG("open \"/firmware.bin\" failed: %d", r); } #ifdef GENERATE_FIRMWARE_CUR if (f_open(&f, "/firmware.bck", FA_READ | FA_OPEN_EXISTING)) { f_close(&f); } else { // no firmware.bck, generate one! if (f_open(&f, "/firmware.bck", FA_WRITE | FA_CREATE_NEW) == FR_OK) { U8 *flash = (U8 *) USER_FLASH_START; f_close(&f); } } #endif // elm-chan's fatfs doesn't have an unmount function // f_umount(&fatfs); } else { DBG("mount failed: %d", r); } spi_close(); if (user_code_present()) { DBG("starting user code..."); execute_user_code(); } else { DBG("user code invalid, rebooting"); } } NVIC_SystemReset(); }
int vfs_rename( int *fd, char *oldname, const char *newname ) { return(f_rename( (const TCHAR *)oldname, (const TCHAR *)newname )-FR_OK); }
FRESULT FatFs::rename(const char* oldPath, const char* newPath) { return f_rename(oldPath, newPath); }