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