[FL-1191][FL-1524] Filesystem rework (#568)
* FS-Api: removed datetime manipulation functions and most of the file flags * Filesystem: common proxy api * Filesystem: renamed to Storage. Work has begun on a glue layer. Added functions for reentrance. * Storage: sd mount and sd file open * Storage: sd file close * Storage: temporary test app * Storage: free filedata on close * Storage: sd file read and write * Storage: added internal storage (LittleFS) * Storage: renamed internal commands * Storage: seek, tell, truncate, size, sync, eof * Storage: error descriptions * Storage: directory management api (open, close, read, rewind) * Storage: common management api (stat, fs_stat, remove, rename, mkdir) * Dolphin app and Notifications app now use raw storage. * Storage: storage statuses renamed. Implemented sd card icon. * Storage: added raw sd-card api. * Storage settings: work started * Assets: use new icons approach * Storage settings: working storage settings * Storage: completely redesigned api, no longer sticking out FS_Api * Storage: more simplified api, getting error_id from file is hidden from user, pointer to api is hidden inside file * Storage: cli info and format commands * Storage-cli: file list * Storage: a simpler and more reliable api * FatFS: slightly lighter and faster config. Also disabled reentrancy and file locking functions. They moved to a storage service. * Storage-cli: accommodate to the new cli api. * Storage: filesystem api is separated into internal and common api. * Cli: added the ability to print the list of free heap blocks * Storage: uses a list instead of an array to store the StorageFile. Rewrote api calls to use semaphores instead of thread flags. * Storage settings: added the ability to benchmark the SD card. * Gui module file select: uses new storage api * Apps: removed deprecated sd_card_test application * Args lib: support for enquoted arguments * Dialogs: a new gui app for simple non-asynchronous apps * Dialogs: view holder for easy single view work * File worker: use new storage api * IButton and lfrrfid apps: save keys to any storage * Apps: fix ibutton and lfrfid stack, remove sd_card_test. * SD filesystem: app removed * File worker: fixed api pointer type * Subghz: loading assets using the new storage api * NFC: use the new storage api * Dialogs: the better api for the message element * Archive: use new storage api * Irda: changed assest path, changed app path * FileWorker: removed unused file_buf_cnt * Storage: copying and renaming files now works between storages * Storage cli: read, copy, remove, rename commands * Archive: removed commented code * Storage cli: write command * Applications: add SRV_STORAGE and SRV_DIALOGS * Internal-storage: removed * Storage: improved api * Storage app: changed api pointer from StorageApp to Storage * Storage: better file_id handling * Storage: more consistent errors * Loader: support for NULL icons * Storage: do nothing with the lfs file or directory if it is not open * Storage: fix typo * Storage: minor float usage cleanup, rename some symbols. * Storage: compact doxygen comments. Co-authored-by: あく <alleteam@gmail.com>
This commit is contained in:
SG
GitHub
82
applications/storage/storages/sd-notify.c
Normal file
82
applications/storage/storages/sd-notify.c
Normal file
@@ -0,0 +1,82 @@
|
||||
#include "sd-notify.h"
|
||||
|
||||
static const NotificationSequence sd_sequence_success = {
|
||||
&message_green_255,
|
||||
&message_delay_50,
|
||||
&message_green_0,
|
||||
&message_delay_50,
|
||||
&message_green_255,
|
||||
&message_delay_50,
|
||||
&message_green_0,
|
||||
&message_delay_50,
|
||||
&message_green_255,
|
||||
&message_delay_50,
|
||||
&message_green_0,
|
||||
&message_delay_50,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static const NotificationSequence sd_sequence_error = {
|
||||
&message_red_255,
|
||||
&message_delay_50,
|
||||
&message_red_0,
|
||||
&message_delay_50,
|
||||
&message_red_255,
|
||||
&message_delay_50,
|
||||
&message_red_0,
|
||||
&message_delay_50,
|
||||
&message_red_255,
|
||||
&message_delay_50,
|
||||
&message_red_0,
|
||||
&message_delay_50,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static const NotificationSequence sd_sequence_eject = {
|
||||
&message_blue_255,
|
||||
&message_delay_50,
|
||||
&message_blue_0,
|
||||
&message_delay_50,
|
||||
&message_blue_255,
|
||||
&message_delay_50,
|
||||
&message_blue_0,
|
||||
&message_delay_50,
|
||||
&message_blue_255,
|
||||
&message_delay_50,
|
||||
&message_blue_0,
|
||||
&message_delay_50,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static const NotificationSequence sd_sequence_wait = {
|
||||
&message_red_255,
|
||||
&message_blue_255,
|
||||
&message_do_not_reset,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static const NotificationSequence sd_sequence_wait_off = {
|
||||
&message_red_0,
|
||||
&message_blue_0,
|
||||
NULL,
|
||||
};
|
||||
|
||||
void sd_notify_wait(NotificationApp* notifications) {
|
||||
notification_message(notifications, &sd_sequence_wait);
|
||||
}
|
||||
|
||||
void sd_notify_wait_off(NotificationApp* notifications) {
|
||||
notification_message(notifications, &sd_sequence_wait_off);
|
||||
}
|
||||
|
||||
void sd_notify_success(NotificationApp* notifications) {
|
||||
notification_message(notifications, &sd_sequence_success);
|
||||
}
|
||||
|
||||
void sd_notify_eject(NotificationApp* notifications) {
|
||||
notification_message(notifications, &sd_sequence_eject);
|
||||
}
|
||||
|
||||
void sd_notify_error(NotificationApp* notifications) {
|
||||
notification_message(notifications, &sd_sequence_error);
|
||||
}
|
||||
17
applications/storage/storages/sd-notify.h
Normal file
17
applications/storage/storages/sd-notify.h
Normal file
@@ -0,0 +1,17 @@
|
||||
#pragma once
|
||||
#include <furi.h>
|
||||
#include <notification/notification-messages.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void sd_notify_wait(NotificationApp* notifications);
|
||||
void sd_notify_wait_off(NotificationApp* notifications);
|
||||
void sd_notify_success(NotificationApp* notifications);
|
||||
void sd_notify_eject(NotificationApp* notifications);
|
||||
void sd_notify_error(NotificationApp* notifications);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
547
applications/storage/storages/storage-ext.c
Normal file
547
applications/storage/storages/storage-ext.c
Normal file
@@ -0,0 +1,547 @@
|
||||
#include "fatfs.h"
|
||||
#include "../filesystem-api-internal.h"
|
||||
#include "storage-ext.h"
|
||||
#include <api-hal.h>
|
||||
#include "sd-notify.h"
|
||||
#include <api-hal-sd.h>
|
||||
|
||||
typedef FIL SDFile;
|
||||
typedef DIR SDDir;
|
||||
typedef FILINFO SDFileInfo;
|
||||
typedef FRESULT SDError;
|
||||
|
||||
#define TAG "storage-ext"
|
||||
#define STORAGE_PATH "/ext"
|
||||
/********************* Definitions ********************/
|
||||
|
||||
typedef struct {
|
||||
FATFS* fs;
|
||||
const char* path;
|
||||
bool sd_was_present;
|
||||
} SDData;
|
||||
|
||||
static FS_Error storage_ext_parse_error(SDError error);
|
||||
|
||||
/******************* Core Functions *******************/
|
||||
|
||||
static bool sd_mount_card(StorageData* storage, bool notify) {
|
||||
bool result = false;
|
||||
const uint8_t max_init_counts = 10;
|
||||
uint8_t counter = max_init_counts;
|
||||
uint8_t bsp_result;
|
||||
SDData* sd_data = storage->data;
|
||||
|
||||
storage_data_lock(storage);
|
||||
|
||||
while(result == false && counter > 0 && hal_sd_detect()) {
|
||||
if(notify) {
|
||||
NotificationApp* notification = furi_record_open("notification");
|
||||
sd_notify_wait(notification);
|
||||
furi_record_close("notification");
|
||||
}
|
||||
|
||||
if((counter % 2) == 0) {
|
||||
// power reset sd card
|
||||
bsp_result = BSP_SD_Init(true);
|
||||
} else {
|
||||
bsp_result = BSP_SD_Init(false);
|
||||
}
|
||||
|
||||
if(bsp_result) {
|
||||
// bsp error
|
||||
storage->status = StorageStatusErrorInternal;
|
||||
} else {
|
||||
SDError status = f_mount(sd_data->fs, sd_data->path, 1);
|
||||
|
||||
if(status == FR_OK || status == FR_NO_FILESYSTEM) {
|
||||
FATFS* fs;
|
||||
uint32_t free_clusters;
|
||||
|
||||
status = f_getfree(sd_data->path, &free_clusters, &fs);
|
||||
|
||||
if(status == FR_OK || status == FR_NO_FILESYSTEM) {
|
||||
result = true;
|
||||
}
|
||||
|
||||
if(status == FR_OK) {
|
||||
storage->status = StorageStatusOK;
|
||||
} else if(status == FR_NO_FILESYSTEM) {
|
||||
storage->status = StorageStatusNoFS;
|
||||
} else {
|
||||
storage->status = StorageStatusNotAccessible;
|
||||
}
|
||||
} else {
|
||||
storage->status = StorageStatusNotMounted;
|
||||
}
|
||||
}
|
||||
|
||||
if(notify) {
|
||||
NotificationApp* notification = furi_record_open("notification");
|
||||
sd_notify_wait_off(notification);
|
||||
furi_record_close("notification");
|
||||
}
|
||||
|
||||
if(!result) {
|
||||
delay(1000);
|
||||
FURI_LOG_E(
|
||||
TAG, "init cycle %d, error: %s", counter, storage_data_status_text(storage));
|
||||
counter--;
|
||||
}
|
||||
}
|
||||
|
||||
storage_data_unlock(storage);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
FS_Error sd_unmount_card(StorageData* storage) {
|
||||
SDData* sd_data = storage->data;
|
||||
SDError error;
|
||||
|
||||
storage_data_lock(storage);
|
||||
error = storage->status = StorageStatusNotReady;
|
||||
|
||||
// TODO do i need to close the files?
|
||||
|
||||
f_mount(0, sd_data->path, 0);
|
||||
storage_data_unlock(storage);
|
||||
return storage_ext_parse_error(error);
|
||||
}
|
||||
|
||||
FS_Error sd_format_card(StorageData* storage) {
|
||||
uint8_t* work_area;
|
||||
SDData* sd_data = storage->data;
|
||||
SDError error;
|
||||
|
||||
storage_data_lock(storage);
|
||||
|
||||
work_area = malloc(_MAX_SS);
|
||||
error = f_mkfs(sd_data->path, FM_ANY, 0, work_area, _MAX_SS);
|
||||
free(work_area);
|
||||
|
||||
do {
|
||||
storage->status = StorageStatusNotAccessible;
|
||||
if(error != FR_OK) break;
|
||||
storage->status = StorageStatusNoFS;
|
||||
error = f_setlabel("Flipper SD");
|
||||
if(error != FR_OK) break;
|
||||
storage->status = StorageStatusNotMounted;
|
||||
error = f_mount(sd_data->fs, sd_data->path, 1);
|
||||
if(error != FR_OK) break;
|
||||
storage->status = StorageStatusOK;
|
||||
} while(false);
|
||||
|
||||
storage_data_unlock(storage);
|
||||
|
||||
return storage_ext_parse_error(error);
|
||||
}
|
||||
|
||||
FS_Error sd_card_info(StorageData* storage, SDInfo* sd_info) {
|
||||
uint32_t free_clusters, free_sectors, total_sectors;
|
||||
FATFS* fs;
|
||||
SDData* sd_data = storage->data;
|
||||
SDError error;
|
||||
|
||||
// clean data
|
||||
memset(sd_info, 0, sizeof(SDInfo));
|
||||
|
||||
// get fs info
|
||||
storage_data_lock(storage);
|
||||
error = f_getlabel(sd_data->path, sd_info->label, NULL);
|
||||
if(error == FR_OK) {
|
||||
error = f_getfree(sd_data->path, &free_clusters, &fs);
|
||||
}
|
||||
storage_data_unlock(storage);
|
||||
|
||||
if(error == FR_OK) {
|
||||
// calculate size
|
||||
total_sectors = (fs->n_fatent - 2) * fs->csize;
|
||||
free_sectors = free_clusters * fs->csize;
|
||||
|
||||
uint16_t sector_size = _MAX_SS;
|
||||
#if _MAX_SS != _MIN_SS
|
||||
sector_size = fs->ssize;
|
||||
#endif
|
||||
|
||||
sd_info->fs_type = fs->fs_type;
|
||||
|
||||
sd_info->kb_total = total_sectors / 1024 * sector_size;
|
||||
sd_info->kb_free = free_sectors / 1024 * sector_size;
|
||||
sd_info->cluster_size = fs->csize;
|
||||
sd_info->sector_size = sector_size;
|
||||
}
|
||||
|
||||
return storage_ext_parse_error(error);
|
||||
}
|
||||
|
||||
static void storage_ext_tick_internal(StorageData* storage, bool notify) {
|
||||
SDData* sd_data = storage->data;
|
||||
|
||||
if(sd_data->sd_was_present) {
|
||||
if(hal_sd_detect()) {
|
||||
FURI_LOG_I(TAG, "card detected");
|
||||
sd_mount_card(storage, notify);
|
||||
|
||||
if(storage->status != StorageStatusOK) {
|
||||
FURI_LOG_E(TAG, "sd init error: %s", storage_data_status_text(storage));
|
||||
if(notify) {
|
||||
NotificationApp* notification = furi_record_open("notification");
|
||||
sd_notify_error(notification);
|
||||
furi_record_close("notification");
|
||||
}
|
||||
} else {
|
||||
FURI_LOG_I(TAG, "card mounted");
|
||||
if(notify) {
|
||||
NotificationApp* notification = furi_record_open("notification");
|
||||
sd_notify_success(notification);
|
||||
furi_record_close("notification");
|
||||
}
|
||||
}
|
||||
|
||||
sd_data->sd_was_present = false;
|
||||
|
||||
if(!hal_sd_detect()) {
|
||||
FURI_LOG_I(TAG, "card removed while mounting");
|
||||
sd_unmount_card(storage);
|
||||
sd_data->sd_was_present = true;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if(!hal_sd_detect()) {
|
||||
FURI_LOG_I(TAG, "card removed");
|
||||
sd_data->sd_was_present = true;
|
||||
|
||||
sd_unmount_card(storage);
|
||||
if(notify) {
|
||||
NotificationApp* notification = furi_record_open("notification");
|
||||
sd_notify_eject(notification);
|
||||
furi_record_close("notification");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void storage_ext_tick(StorageData* storage) {
|
||||
storage_ext_tick_internal(storage, true);
|
||||
}
|
||||
|
||||
/****************** Common Functions ******************/
|
||||
|
||||
static FS_Error storage_ext_parse_error(SDError error) {
|
||||
FS_Error result;
|
||||
switch(error) {
|
||||
case FR_OK:
|
||||
result = FSE_OK;
|
||||
break;
|
||||
case FR_NOT_READY:
|
||||
result = FSE_NOT_READY;
|
||||
break;
|
||||
case FR_NO_FILE:
|
||||
case FR_NO_PATH:
|
||||
case FR_NO_FILESYSTEM:
|
||||
result = FSE_NOT_EXIST;
|
||||
break;
|
||||
case FR_EXIST:
|
||||
result = FSE_EXIST;
|
||||
break;
|
||||
case FR_INVALID_NAME:
|
||||
result = FSE_INVALID_NAME;
|
||||
break;
|
||||
case FR_INVALID_OBJECT:
|
||||
case FR_INVALID_PARAMETER:
|
||||
result = FSE_INVALID_PARAMETER;
|
||||
break;
|
||||
case FR_DENIED:
|
||||
result = FSE_DENIED;
|
||||
break;
|
||||
default:
|
||||
result = FSE_INTERNAL;
|
||||
break;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/******************* File Functions *******************/
|
||||
|
||||
static bool storage_ext_file_open(
|
||||
void* ctx,
|
||||
File* file,
|
||||
const char* path,
|
||||
FS_AccessMode access_mode,
|
||||
FS_OpenMode open_mode) {
|
||||
StorageData* storage = ctx;
|
||||
uint8_t _mode = 0;
|
||||
|
||||
if(access_mode & FSAM_READ) _mode |= FA_READ;
|
||||
if(access_mode & FSAM_WRITE) _mode |= FA_WRITE;
|
||||
if(open_mode & FSOM_OPEN_EXISTING) _mode |= FA_OPEN_EXISTING;
|
||||
if(open_mode & FSOM_OPEN_ALWAYS) _mode |= FA_OPEN_ALWAYS;
|
||||
if(open_mode & FSOM_OPEN_APPEND) _mode |= FA_OPEN_APPEND;
|
||||
if(open_mode & FSOM_CREATE_NEW) _mode |= FA_CREATE_NEW;
|
||||
if(open_mode & FSOM_CREATE_ALWAYS) _mode |= FA_CREATE_ALWAYS;
|
||||
|
||||
SDFile* file_data = malloc(sizeof(SDFile));
|
||||
storage_set_storage_file_data(file, file_data, storage);
|
||||
|
||||
file->internal_error_id = f_open(file_data, path, _mode);
|
||||
file->error_id = storage_ext_parse_error(file->internal_error_id);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static bool storage_ext_file_close(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
SDFile* file_data = storage_get_storage_file_data(file, storage);
|
||||
file->internal_error_id = f_close(file_data);
|
||||
file->error_id = storage_ext_parse_error(file->internal_error_id);
|
||||
free(file_data);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static uint16_t
|
||||
storage_ext_file_read(void* ctx, File* file, void* buff, uint16_t const bytes_to_read) {
|
||||
StorageData* storage = ctx;
|
||||
SDFile* file_data = storage_get_storage_file_data(file, storage);
|
||||
uint16_t bytes_readed = 0;
|
||||
file->internal_error_id = f_read(file_data, buff, bytes_to_read, &bytes_readed);
|
||||
file->error_id = storage_ext_parse_error(file->internal_error_id);
|
||||
return bytes_readed;
|
||||
}
|
||||
|
||||
static uint16_t
|
||||
storage_ext_file_write(void* ctx, File* file, const void* buff, uint16_t const bytes_to_write) {
|
||||
StorageData* storage = ctx;
|
||||
SDFile* file_data = storage_get_storage_file_data(file, storage);
|
||||
uint16_t bytes_written = 0;
|
||||
file->internal_error_id = f_write(file_data, buff, bytes_to_write, &bytes_written);
|
||||
file->error_id = storage_ext_parse_error(file->internal_error_id);
|
||||
return bytes_written;
|
||||
}
|
||||
|
||||
static bool
|
||||
storage_ext_file_seek(void* ctx, File* file, const uint32_t offset, const bool from_start) {
|
||||
StorageData* storage = ctx;
|
||||
SDFile* file_data = storage_get_storage_file_data(file, storage);
|
||||
|
||||
if(from_start) {
|
||||
file->internal_error_id = f_lseek(file_data, offset);
|
||||
} else {
|
||||
uint64_t position = f_tell(file_data);
|
||||
position += offset;
|
||||
file->internal_error_id = f_lseek(file_data, position);
|
||||
}
|
||||
|
||||
file->error_id = storage_ext_parse_error(file->internal_error_id);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static uint64_t storage_ext_file_tell(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
SDFile* file_data = storage_get_storage_file_data(file, storage);
|
||||
|
||||
uint64_t position = 0;
|
||||
position = f_tell(file_data);
|
||||
file->error_id = FSE_OK;
|
||||
return position;
|
||||
}
|
||||
|
||||
static bool storage_ext_file_truncate(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
SDFile* file_data = storage_get_storage_file_data(file, storage);
|
||||
|
||||
file->internal_error_id = f_truncate(file_data);
|
||||
file->error_id = storage_ext_parse_error(file->internal_error_id);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static bool storage_ext_file_sync(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
SDFile* file_data = storage_get_storage_file_data(file, storage);
|
||||
|
||||
file->internal_error_id = f_sync(file_data);
|
||||
file->error_id = storage_ext_parse_error(file->internal_error_id);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static uint64_t storage_ext_file_size(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
SDFile* file_data = storage_get_storage_file_data(file, storage);
|
||||
|
||||
uint64_t size = 0;
|
||||
size = f_size(file_data);
|
||||
file->error_id = FSE_OK;
|
||||
return size;
|
||||
}
|
||||
|
||||
static bool storage_ext_file_eof(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
SDFile* file_data = storage_get_storage_file_data(file, storage);
|
||||
|
||||
bool eof = f_eof(file_data);
|
||||
file->internal_error_id = 0;
|
||||
file->error_id = FSE_OK;
|
||||
return eof;
|
||||
}
|
||||
|
||||
/******************* Dir Functions *******************/
|
||||
|
||||
static bool storage_ext_dir_open(void* ctx, File* file, const char* path) {
|
||||
StorageData* storage = ctx;
|
||||
|
||||
SDDir* file_data = malloc(sizeof(SDDir));
|
||||
storage_set_storage_file_data(file, file_data, storage);
|
||||
file->internal_error_id = f_opendir(file_data, path);
|
||||
file->error_id = storage_ext_parse_error(file->internal_error_id);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static bool storage_ext_dir_close(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
SDDir* file_data = storage_get_storage_file_data(file, storage);
|
||||
|
||||
file->internal_error_id = f_closedir(file_data);
|
||||
file->error_id = storage_ext_parse_error(file->internal_error_id);
|
||||
free(file_data);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static bool storage_ext_dir_read(
|
||||
void* ctx,
|
||||
File* file,
|
||||
FileInfo* fileinfo,
|
||||
char* name,
|
||||
const uint16_t name_length) {
|
||||
StorageData* storage = ctx;
|
||||
SDDir* file_data = storage_get_storage_file_data(file, storage);
|
||||
|
||||
SDFileInfo _fileinfo;
|
||||
file->internal_error_id = f_readdir(file_data, &_fileinfo);
|
||||
file->error_id = storage_ext_parse_error(file->internal_error_id);
|
||||
|
||||
if(fileinfo != NULL) {
|
||||
fileinfo->size = _fileinfo.fsize;
|
||||
fileinfo->flags = 0;
|
||||
|
||||
if(_fileinfo.fattrib & AM_DIR) fileinfo->flags |= FSF_DIRECTORY;
|
||||
}
|
||||
|
||||
if(name != NULL) {
|
||||
snprintf(name, name_length, "%s", _fileinfo.fname);
|
||||
}
|
||||
|
||||
if(_fileinfo.fname[0] == 0) {
|
||||
file->error_id = FSE_NOT_EXIST;
|
||||
}
|
||||
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static bool storage_ext_dir_rewind(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
SDDir* file_data = storage_get_storage_file_data(file, storage);
|
||||
|
||||
file->internal_error_id = f_readdir(file_data, NULL);
|
||||
file->error_id = storage_ext_parse_error(file->internal_error_id);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
/******************* Common FS Functions *******************/
|
||||
|
||||
static FS_Error storage_ext_common_stat(void* ctx, const char* path, FileInfo* fileinfo) {
|
||||
SDFileInfo _fileinfo;
|
||||
SDError result = f_stat(path, &_fileinfo);
|
||||
|
||||
if(fileinfo != NULL) {
|
||||
fileinfo->size = _fileinfo.fsize;
|
||||
fileinfo->flags = 0;
|
||||
|
||||
if(_fileinfo.fattrib & AM_DIR) fileinfo->flags |= FSF_DIRECTORY;
|
||||
}
|
||||
|
||||
return storage_ext_parse_error(result);
|
||||
}
|
||||
|
||||
static FS_Error storage_ext_common_remove(void* ctx, const char* path) {
|
||||
SDError result = f_unlink(path);
|
||||
return storage_ext_parse_error(result);
|
||||
}
|
||||
|
||||
static FS_Error storage_ext_common_rename(void* ctx, const char* old_path, const char* new_path) {
|
||||
SDError result = f_rename(old_path, new_path);
|
||||
return storage_ext_parse_error(result);
|
||||
}
|
||||
|
||||
static FS_Error storage_ext_common_mkdir(void* ctx, const char* path) {
|
||||
SDError result = f_mkdir(path);
|
||||
return storage_ext_parse_error(result);
|
||||
}
|
||||
|
||||
static FS_Error storage_ext_common_fs_info(
|
||||
void* ctx,
|
||||
const char* fs_path,
|
||||
uint64_t* total_space,
|
||||
uint64_t* free_space) {
|
||||
StorageData* storage = ctx;
|
||||
SDData* sd_data = storage->data;
|
||||
|
||||
DWORD free_clusters;
|
||||
FATFS* fs;
|
||||
|
||||
SDError fresult = f_getfree(sd_data->path, &free_clusters, &fs);
|
||||
if((FRESULT)fresult == FR_OK) {
|
||||
uint32_t total_sectors = (fs->n_fatent - 2) * fs->csize;
|
||||
uint32_t free_sectors = free_clusters * fs->csize;
|
||||
|
||||
uint16_t sector_size = _MAX_SS;
|
||||
#if _MAX_SS != _MIN_SS
|
||||
sector_size = fs->ssize;
|
||||
#endif
|
||||
|
||||
if(total_space != NULL) {
|
||||
*total_space = (uint64_t)total_sectors * (uint64_t)sector_size;
|
||||
}
|
||||
|
||||
if(free_space != NULL) {
|
||||
*free_space = (uint64_t)free_sectors * (uint64_t)sector_size;
|
||||
}
|
||||
}
|
||||
|
||||
return storage_ext_parse_error(fresult);
|
||||
}
|
||||
|
||||
/******************* Init Storage *******************/
|
||||
|
||||
void storage_ext_init(StorageData* storage) {
|
||||
SDData* sd_data = malloc(sizeof(SDData));
|
||||
sd_data->fs = &USERFatFS;
|
||||
sd_data->path = "0:/";
|
||||
sd_data->sd_was_present = true;
|
||||
|
||||
storage->data = sd_data;
|
||||
storage->api.tick = storage_ext_tick;
|
||||
storage->fs_api.file.open = storage_ext_file_open;
|
||||
storage->fs_api.file.close = storage_ext_file_close;
|
||||
storage->fs_api.file.read = storage_ext_file_read;
|
||||
storage->fs_api.file.write = storage_ext_file_write;
|
||||
storage->fs_api.file.seek = storage_ext_file_seek;
|
||||
storage->fs_api.file.tell = storage_ext_file_tell;
|
||||
storage->fs_api.file.truncate = storage_ext_file_truncate;
|
||||
storage->fs_api.file.size = storage_ext_file_size;
|
||||
storage->fs_api.file.sync = storage_ext_file_sync;
|
||||
storage->fs_api.file.eof = storage_ext_file_eof;
|
||||
|
||||
storage->fs_api.dir.open = storage_ext_dir_open;
|
||||
storage->fs_api.dir.close = storage_ext_dir_close;
|
||||
storage->fs_api.dir.read = storage_ext_dir_read;
|
||||
storage->fs_api.dir.rewind = storage_ext_dir_rewind;
|
||||
|
||||
storage->fs_api.common.stat = storage_ext_common_stat;
|
||||
storage->fs_api.common.mkdir = storage_ext_common_mkdir;
|
||||
storage->fs_api.common.rename = storage_ext_common_rename;
|
||||
storage->fs_api.common.remove = storage_ext_common_remove;
|
||||
storage->fs_api.common.fs_info = storage_ext_common_fs_info;
|
||||
|
||||
hal_sd_detect_init();
|
||||
|
||||
// do not notify on first launch, notifications app is waiting for our thread to read settings
|
||||
storage_ext_tick_internal(storage, false);
|
||||
}
|
||||
16
applications/storage/storages/storage-ext.h
Normal file
16
applications/storage/storages/storage-ext.h
Normal file
@@ -0,0 +1,16 @@
|
||||
#pragma once
|
||||
#include <furi.h>
|
||||
#include "../storage-glue.h"
|
||||
#include "../storage-sd-api.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void storage_ext_init(StorageData* storage);
|
||||
FS_Error sd_unmount_card(StorageData* storage);
|
||||
FS_Error sd_format_card(StorageData* storage);
|
||||
FS_Error sd_card_info(StorageData* storage, SDInfo* sd_info);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
690
applications/storage/storages/storage-int.c
Normal file
690
applications/storage/storages/storage-int.c
Normal file
@@ -0,0 +1,690 @@
|
||||
#include "storage-int.h"
|
||||
#include <lfs.h>
|
||||
#include <api-hal.h>
|
||||
|
||||
#define TAG "storage-int"
|
||||
#define STORAGE_PATH "/int"
|
||||
|
||||
typedef struct {
|
||||
const size_t start_address;
|
||||
const size_t start_page;
|
||||
struct lfs_config config;
|
||||
lfs_t lfs;
|
||||
} LFSData;
|
||||
|
||||
typedef struct {
|
||||
void* data;
|
||||
bool open;
|
||||
} LFSHandle;
|
||||
|
||||
static LFSHandle* lfs_handle_alloc_file() {
|
||||
LFSHandle* handle = furi_alloc(sizeof(LFSHandle));
|
||||
handle->data = furi_alloc(sizeof(lfs_file_t));
|
||||
return handle;
|
||||
}
|
||||
|
||||
static LFSHandle* lfs_handle_alloc_dir() {
|
||||
LFSHandle* handle = furi_alloc(sizeof(LFSHandle));
|
||||
handle->data = furi_alloc(sizeof(lfs_dir_t));
|
||||
return handle;
|
||||
}
|
||||
|
||||
/* INTERNALS */
|
||||
|
||||
static lfs_dir_t* lfs_handle_get_dir(LFSHandle* handle) {
|
||||
return handle->data;
|
||||
}
|
||||
|
||||
static lfs_file_t* lfs_handle_get_file(LFSHandle* handle) {
|
||||
return handle->data;
|
||||
}
|
||||
|
||||
static void lfs_handle_free(LFSHandle* handle) {
|
||||
free(handle->data);
|
||||
free(handle);
|
||||
}
|
||||
|
||||
static void lfs_handle_set_open(LFSHandle* handle) {
|
||||
handle->open = true;
|
||||
}
|
||||
|
||||
static bool lfs_handle_is_open(LFSHandle* handle) {
|
||||
return handle->open;
|
||||
}
|
||||
|
||||
static lfs_t* lfs_get_from_storage(StorageData* storage) {
|
||||
return &((LFSData*)storage->data)->lfs;
|
||||
}
|
||||
|
||||
static LFSData* lfs_data_get_from_storage(StorageData* storage) {
|
||||
return (LFSData*)storage->data;
|
||||
}
|
||||
|
||||
static int storage_int_device_read(
|
||||
const struct lfs_config* c,
|
||||
lfs_block_t block,
|
||||
lfs_off_t off,
|
||||
void* buffer,
|
||||
lfs_size_t size) {
|
||||
LFSData* lfs_data = c->context;
|
||||
size_t address = lfs_data->start_address + block * c->block_size + off;
|
||||
|
||||
FURI_LOG_D(
|
||||
TAG,
|
||||
"Device read: block %d, off %d, buffer: %p, size %d, translated address: %p",
|
||||
block,
|
||||
off,
|
||||
buffer,
|
||||
size,
|
||||
address);
|
||||
|
||||
memcpy(buffer, (void*)address, size);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int storage_int_device_prog(
|
||||
const struct lfs_config* c,
|
||||
lfs_block_t block,
|
||||
lfs_off_t off,
|
||||
const void* buffer,
|
||||
lfs_size_t size) {
|
||||
LFSData* lfs_data = c->context;
|
||||
size_t address = lfs_data->start_address + block * c->block_size + off;
|
||||
|
||||
FURI_LOG_D(
|
||||
TAG,
|
||||
"Device prog: block %d, off %d, buffer: %p, size %d, translated address: %p",
|
||||
block,
|
||||
off,
|
||||
buffer,
|
||||
size,
|
||||
address);
|
||||
|
||||
int ret = 0;
|
||||
while(size > 0) {
|
||||
if(!api_hal_flash_write_dword(address, *(uint64_t*)buffer)) {
|
||||
ret = -1;
|
||||
break;
|
||||
}
|
||||
address += c->prog_size;
|
||||
buffer += c->prog_size;
|
||||
size -= c->prog_size;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int storage_int_device_erase(const struct lfs_config* c, lfs_block_t block) {
|
||||
LFSData* lfs_data = c->context;
|
||||
size_t page = lfs_data->start_page + block;
|
||||
|
||||
FURI_LOG_D(TAG, "Device erase: page %d, translated page: %d", block, page);
|
||||
|
||||
if(api_hal_flash_erase(page, 1)) {
|
||||
return 0;
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
static int storage_int_device_sync(const struct lfs_config* c) {
|
||||
FURI_LOG_D(TAG, "Device sync: skipping, cause ");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static LFSData* storage_int_lfs_data_alloc() {
|
||||
LFSData* lfs_data = furi_alloc(sizeof(LFSData));
|
||||
|
||||
// Internal storage start address
|
||||
*(size_t*)(&lfs_data->start_address) = api_hal_flash_get_free_page_start_address();
|
||||
*(size_t*)(&lfs_data->start_page) =
|
||||
(lfs_data->start_address - api_hal_flash_get_base()) / api_hal_flash_get_page_size();
|
||||
|
||||
// LFS configuration
|
||||
// Glue and context
|
||||
lfs_data->config.context = lfs_data;
|
||||
lfs_data->config.read = storage_int_device_read;
|
||||
lfs_data->config.prog = storage_int_device_prog;
|
||||
lfs_data->config.erase = storage_int_device_erase;
|
||||
lfs_data->config.sync = storage_int_device_sync;
|
||||
|
||||
// Block device description
|
||||
lfs_data->config.read_size = api_hal_flash_get_read_block_size();
|
||||
lfs_data->config.prog_size = api_hal_flash_get_write_block_size();
|
||||
lfs_data->config.block_size = api_hal_flash_get_page_size();
|
||||
lfs_data->config.block_count = api_hal_flash_get_free_page_count();
|
||||
lfs_data->config.block_cycles = api_hal_flash_get_cycles_count();
|
||||
lfs_data->config.cache_size = 16;
|
||||
lfs_data->config.lookahead_size = 16;
|
||||
|
||||
return lfs_data;
|
||||
};
|
||||
|
||||
static void storage_int_lfs_mount(LFSData* lfs_data, StorageData* storage) {
|
||||
int err;
|
||||
ApiHalBootFlag boot_flags = api_hal_boot_get_flags();
|
||||
lfs_t* lfs = &lfs_data->lfs;
|
||||
|
||||
if(boot_flags & ApiHalBootFlagFactoryReset) {
|
||||
// Factory reset
|
||||
err = lfs_format(lfs, &lfs_data->config);
|
||||
if(err == 0) {
|
||||
FURI_LOG_I(TAG, "Factory reset: Format successful, trying to mount");
|
||||
api_hal_boot_set_flags(boot_flags & ~ApiHalBootFlagFactoryReset);
|
||||
err = lfs_mount(lfs, &lfs_data->config);
|
||||
if(err == 0) {
|
||||
FURI_LOG_I(TAG, "Factory reset: Mounted");
|
||||
storage->status = StorageStatusOK;
|
||||
} else {
|
||||
FURI_LOG_E(TAG, "Factory reset: Mount after format failed");
|
||||
storage->status = StorageStatusNotMounted;
|
||||
}
|
||||
} else {
|
||||
FURI_LOG_E(TAG, "Factory reset: Format failed");
|
||||
storage->status = StorageStatusNoFS;
|
||||
}
|
||||
} else {
|
||||
// Normal
|
||||
err = lfs_mount(lfs, &lfs_data->config);
|
||||
if(err == 0) {
|
||||
FURI_LOG_I(TAG, "Mounted");
|
||||
storage->status = StorageStatusOK;
|
||||
} else {
|
||||
FURI_LOG_E(TAG, "Mount failed, formatting");
|
||||
err = lfs_format(lfs, &lfs_data->config);
|
||||
if(err == 0) {
|
||||
FURI_LOG_I(TAG, "Format successful, trying to mount");
|
||||
err = lfs_mount(lfs, &lfs_data->config);
|
||||
if(err == 0) {
|
||||
FURI_LOG_I(TAG, "Mounted");
|
||||
storage->status = StorageStatusOK;
|
||||
} else {
|
||||
FURI_LOG_E(TAG, "Mount after format failed");
|
||||
storage->status = StorageStatusNotMounted;
|
||||
}
|
||||
} else {
|
||||
FURI_LOG_E(TAG, "Format failed");
|
||||
storage->status = StorageStatusNoFS;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/****************** Common Functions ******************/
|
||||
|
||||
static FS_Error storage_int_parse_error(int error) {
|
||||
FS_Error result = FSE_INTERNAL;
|
||||
|
||||
if(error >= LFS_ERR_OK) {
|
||||
result = FSE_OK;
|
||||
} else {
|
||||
switch(error) {
|
||||
case LFS_ERR_IO:
|
||||
result = FSE_INTERNAL;
|
||||
break;
|
||||
case LFS_ERR_CORRUPT:
|
||||
result = FSE_INTERNAL;
|
||||
break;
|
||||
case LFS_ERR_NOENT:
|
||||
result = FSE_NOT_EXIST;
|
||||
break;
|
||||
case LFS_ERR_EXIST:
|
||||
result = FSE_EXIST;
|
||||
break;
|
||||
case LFS_ERR_NOTDIR:
|
||||
result = FSE_INVALID_NAME;
|
||||
break;
|
||||
case LFS_ERR_ISDIR:
|
||||
result = FSE_INVALID_NAME;
|
||||
break;
|
||||
case LFS_ERR_NOTEMPTY:
|
||||
result = FSE_DENIED;
|
||||
break;
|
||||
case LFS_ERR_BADF:
|
||||
result = FSE_INVALID_NAME;
|
||||
break;
|
||||
case LFS_ERR_FBIG:
|
||||
result = FSE_INTERNAL;
|
||||
break;
|
||||
case LFS_ERR_INVAL:
|
||||
result = FSE_INVALID_PARAMETER;
|
||||
break;
|
||||
case LFS_ERR_NOSPC:
|
||||
result = FSE_INTERNAL;
|
||||
break;
|
||||
case LFS_ERR_NOMEM:
|
||||
result = FSE_INTERNAL;
|
||||
break;
|
||||
case LFS_ERR_NOATTR:
|
||||
result = FSE_INVALID_PARAMETER;
|
||||
break;
|
||||
case LFS_ERR_NAMETOOLONG:
|
||||
result = FSE_INVALID_NAME;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/******************* File Functions *******************/
|
||||
|
||||
static bool storage_int_file_open(
|
||||
void* ctx,
|
||||
File* file,
|
||||
const char* path,
|
||||
FS_AccessMode access_mode,
|
||||
FS_OpenMode open_mode) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
|
||||
int flags = 0;
|
||||
|
||||
if(access_mode & FSAM_READ) flags |= LFS_O_RDONLY;
|
||||
if(access_mode & FSAM_WRITE) flags |= LFS_O_WRONLY;
|
||||
|
||||
if(open_mode & FSOM_OPEN_EXISTING) flags = flags;
|
||||
if(open_mode & FSOM_OPEN_ALWAYS) flags |= LFS_O_CREAT;
|
||||
if(open_mode & FSOM_OPEN_APPEND) flags |= LFS_O_CREAT | LFS_O_APPEND;
|
||||
if(open_mode & FSOM_CREATE_NEW) flags |= LFS_O_CREAT | LFS_O_EXCL;
|
||||
if(open_mode & FSOM_CREATE_ALWAYS) flags |= LFS_O_CREAT | LFS_O_TRUNC;
|
||||
|
||||
LFSHandle* handle = lfs_handle_alloc_file();
|
||||
storage_set_storage_file_data(file, handle, storage);
|
||||
file->internal_error_id = lfs_file_open(lfs, lfs_handle_get_file(handle), path, flags);
|
||||
|
||||
if(file->internal_error_id >= LFS_ERR_OK) {
|
||||
lfs_handle_set_open(handle);
|
||||
}
|
||||
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static bool storage_int_file_close(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSHandle* handle = storage_get_storage_file_data(file, storage);
|
||||
|
||||
if(lfs_handle_is_open(handle)) {
|
||||
file->internal_error_id = lfs_file_close(lfs, lfs_handle_get_file(handle));
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_BADF;
|
||||
}
|
||||
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
lfs_handle_free(handle);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static uint16_t
|
||||
storage_int_file_read(void* ctx, File* file, void* buff, uint16_t const bytes_to_read) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSHandle* handle = storage_get_storage_file_data(file, storage);
|
||||
|
||||
uint16_t bytes_readed = 0;
|
||||
|
||||
if(lfs_handle_is_open(handle)) {
|
||||
file->internal_error_id =
|
||||
lfs_file_read(lfs, lfs_handle_get_file(handle), buff, bytes_to_read);
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_BADF;
|
||||
}
|
||||
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
|
||||
if(file->error_id == FSE_OK) {
|
||||
bytes_readed = file->internal_error_id;
|
||||
file->internal_error_id = 0;
|
||||
}
|
||||
return bytes_readed;
|
||||
}
|
||||
|
||||
static uint16_t
|
||||
storage_int_file_write(void* ctx, File* file, const void* buff, uint16_t const bytes_to_write) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSHandle* handle = storage_get_storage_file_data(file, storage);
|
||||
|
||||
uint16_t bytes_written = 0;
|
||||
|
||||
if(lfs_handle_is_open(handle)) {
|
||||
file->internal_error_id =
|
||||
lfs_file_write(lfs, lfs_handle_get_file(handle), buff, bytes_to_write);
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_BADF;
|
||||
}
|
||||
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
|
||||
if(file->error_id == FSE_OK) {
|
||||
bytes_written = file->internal_error_id;
|
||||
file->internal_error_id = 0;
|
||||
}
|
||||
return bytes_written;
|
||||
}
|
||||
|
||||
static bool
|
||||
storage_int_file_seek(void* ctx, File* file, const uint32_t offset, const bool from_start) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSHandle* handle = storage_get_storage_file_data(file, storage);
|
||||
|
||||
if(lfs_handle_is_open(handle)) {
|
||||
if(from_start) {
|
||||
file->internal_error_id =
|
||||
lfs_file_seek(lfs, lfs_handle_get_file(handle), offset, LFS_SEEK_SET);
|
||||
} else {
|
||||
file->internal_error_id =
|
||||
lfs_file_seek(lfs, lfs_handle_get_file(handle), offset, LFS_SEEK_CUR);
|
||||
}
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_BADF;
|
||||
}
|
||||
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static uint64_t storage_int_file_tell(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSHandle* handle = storage_get_storage_file_data(file, storage);
|
||||
|
||||
if(lfs_handle_is_open(handle)) {
|
||||
file->internal_error_id = lfs_file_tell(lfs, lfs_handle_get_file(handle));
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_BADF;
|
||||
}
|
||||
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
|
||||
int32_t position = 0;
|
||||
if(file->error_id == FSE_OK) {
|
||||
position = file->internal_error_id;
|
||||
file->internal_error_id = 0;
|
||||
}
|
||||
|
||||
return position;
|
||||
}
|
||||
|
||||
static bool storage_int_file_truncate(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSHandle* handle = storage_get_storage_file_data(file, storage);
|
||||
|
||||
if(lfs_handle_is_open(handle)) {
|
||||
file->internal_error_id = lfs_file_tell(lfs, lfs_handle_get_file(handle));
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
|
||||
if(file->error_id == FSE_OK) {
|
||||
uint32_t position = file->internal_error_id;
|
||||
file->internal_error_id =
|
||||
lfs_file_truncate(lfs, lfs_handle_get_file(handle), position);
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
}
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_BADF;
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
}
|
||||
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static bool storage_int_file_sync(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSHandle* handle = storage_get_storage_file_data(file, storage);
|
||||
|
||||
if(lfs_handle_is_open(handle)) {
|
||||
file->internal_error_id = lfs_file_sync(lfs, lfs_handle_get_file(handle));
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_BADF;
|
||||
}
|
||||
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static uint64_t storage_int_file_size(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSHandle* handle = storage_get_storage_file_data(file, storage);
|
||||
|
||||
if(lfs_handle_is_open(handle)) {
|
||||
file->internal_error_id = lfs_file_size(lfs, lfs_handle_get_file(handle));
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_BADF;
|
||||
}
|
||||
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
|
||||
uint32_t size = 0;
|
||||
if(file->error_id == FSE_OK) {
|
||||
size = file->internal_error_id;
|
||||
file->internal_error_id = 0;
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
static bool storage_int_file_eof(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSHandle* handle = storage_get_storage_file_data(file, storage);
|
||||
|
||||
bool eof = true;
|
||||
|
||||
if(lfs_handle_is_open(handle)) {
|
||||
int32_t position = lfs_file_tell(lfs, lfs_handle_get_file(handle));
|
||||
int32_t size = lfs_file_size(lfs, lfs_handle_get_file(handle));
|
||||
|
||||
if(position < 0) {
|
||||
file->internal_error_id = position;
|
||||
} else if(size < 0) {
|
||||
file->internal_error_id = size;
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_OK;
|
||||
eof = (position >= size);
|
||||
}
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_BADF;
|
||||
}
|
||||
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
return eof;
|
||||
}
|
||||
|
||||
/******************* Dir Functions *******************/
|
||||
|
||||
static bool storage_int_dir_open(void* ctx, File* file, const char* path) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
|
||||
LFSHandle* handle = lfs_handle_alloc_dir();
|
||||
storage_set_storage_file_data(file, handle, storage);
|
||||
|
||||
file->internal_error_id = lfs_dir_open(lfs, lfs_handle_get_dir(handle), path);
|
||||
if(file->internal_error_id >= LFS_ERR_OK) {
|
||||
lfs_handle_set_open(handle);
|
||||
}
|
||||
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static bool storage_int_dir_close(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSHandle* handle = storage_get_storage_file_data(file, storage);
|
||||
|
||||
if(lfs_handle_is_open(handle)) {
|
||||
file->internal_error_id = lfs_dir_close(lfs, lfs_handle_get_dir(handle));
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_BADF;
|
||||
}
|
||||
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
lfs_handle_free(handle);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static bool storage_int_dir_read(
|
||||
void* ctx,
|
||||
File* file,
|
||||
FileInfo* fileinfo,
|
||||
char* name,
|
||||
const uint16_t name_length) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSHandle* handle = storage_get_storage_file_data(file, storage);
|
||||
|
||||
if(lfs_handle_is_open(handle)) {
|
||||
struct lfs_info _fileinfo;
|
||||
|
||||
// LFS returns virtual directories "." and "..", so we read until we get something meaningful or an empty string
|
||||
do {
|
||||
file->internal_error_id = lfs_dir_read(lfs, lfs_handle_get_dir(handle), &_fileinfo);
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
} while(strcmp(_fileinfo.name, ".") == 0 || strcmp(_fileinfo.name, "..") == 0);
|
||||
|
||||
if(fileinfo != NULL) {
|
||||
fileinfo->size = _fileinfo.size;
|
||||
fileinfo->flags = 0;
|
||||
if(_fileinfo.type & LFS_TYPE_DIR) fileinfo->flags |= FSF_DIRECTORY;
|
||||
}
|
||||
|
||||
if(name != NULL) {
|
||||
snprintf(name, name_length, "%s", _fileinfo.name);
|
||||
}
|
||||
|
||||
// set FSE_NOT_EXIST error on end of directory
|
||||
if(file->internal_error_id == 0) {
|
||||
file->error_id = FSE_NOT_EXIST;
|
||||
}
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_BADF;
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
}
|
||||
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
static bool storage_int_dir_rewind(void* ctx, File* file) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSHandle* handle = storage_get_storage_file_data(file, storage);
|
||||
|
||||
if(lfs_handle_is_open(handle)) {
|
||||
file->internal_error_id = lfs_dir_rewind(lfs, lfs_handle_get_dir(handle));
|
||||
} else {
|
||||
file->internal_error_id = LFS_ERR_BADF;
|
||||
}
|
||||
|
||||
file->error_id = storage_int_parse_error(file->internal_error_id);
|
||||
return (file->error_id == FSE_OK);
|
||||
}
|
||||
|
||||
/******************* Common FS Functions *******************/
|
||||
|
||||
static FS_Error storage_int_common_stat(void* ctx, const char* path, FileInfo* fileinfo) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
struct lfs_info _fileinfo;
|
||||
int result = lfs_stat(lfs, path, &_fileinfo);
|
||||
|
||||
if(fileinfo != NULL) {
|
||||
fileinfo->size = _fileinfo.size;
|
||||
fileinfo->flags = 0;
|
||||
if(_fileinfo.type & LFS_TYPE_DIR) fileinfo->flags |= FSF_DIRECTORY;
|
||||
}
|
||||
|
||||
return storage_int_parse_error(result);
|
||||
}
|
||||
|
||||
static FS_Error storage_int_common_remove(void* ctx, const char* path) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
int result = lfs_remove(lfs, path);
|
||||
return storage_int_parse_error(result);
|
||||
}
|
||||
|
||||
static FS_Error storage_int_common_rename(void* ctx, const char* old_path, const char* new_path) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
int result = lfs_rename(lfs, old_path, new_path);
|
||||
return storage_int_parse_error(result);
|
||||
}
|
||||
|
||||
static FS_Error storage_int_common_mkdir(void* ctx, const char* path) {
|
||||
StorageData* storage = ctx;
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
int result = lfs_mkdir(lfs, path);
|
||||
return storage_int_parse_error(result);
|
||||
}
|
||||
|
||||
static FS_Error storage_int_common_fs_info(
|
||||
void* ctx,
|
||||
const char* fs_path,
|
||||
uint64_t* total_space,
|
||||
uint64_t* free_space) {
|
||||
StorageData* storage = ctx;
|
||||
|
||||
lfs_t* lfs = lfs_get_from_storage(storage);
|
||||
LFSData* lfs_data = lfs_data_get_from_storage(storage);
|
||||
|
||||
*total_space = lfs_data->config.block_size * lfs_data->config.block_count;
|
||||
|
||||
lfs_ssize_t result = lfs_fs_size(lfs);
|
||||
if(result >= 0) {
|
||||
*free_space = *total_space - (result * lfs_data->config.block_size);
|
||||
}
|
||||
|
||||
return storage_int_parse_error(result);
|
||||
}
|
||||
|
||||
/******************* Init Storage *******************/
|
||||
|
||||
void storage_int_init(StorageData* storage) {
|
||||
FURI_LOG_I(TAG, "Starting");
|
||||
LFSData* lfs_data = storage_int_lfs_data_alloc();
|
||||
FURI_LOG_I(
|
||||
TAG,
|
||||
"Config: start %p, read %d, write %d, page size: %d, page count: %d, cycles: %d",
|
||||
lfs_data->start_address,
|
||||
lfs_data->config.read_size,
|
||||
lfs_data->config.prog_size,
|
||||
lfs_data->config.block_size,
|
||||
lfs_data->config.block_count,
|
||||
lfs_data->config.block_cycles);
|
||||
|
||||
storage_int_lfs_mount(lfs_data, storage);
|
||||
|
||||
storage->data = lfs_data;
|
||||
storage->api.tick = NULL;
|
||||
storage->fs_api.file.open = storage_int_file_open;
|
||||
storage->fs_api.file.close = storage_int_file_close;
|
||||
storage->fs_api.file.read = storage_int_file_read;
|
||||
storage->fs_api.file.write = storage_int_file_write;
|
||||
storage->fs_api.file.seek = storage_int_file_seek;
|
||||
storage->fs_api.file.tell = storage_int_file_tell;
|
||||
storage->fs_api.file.truncate = storage_int_file_truncate;
|
||||
storage->fs_api.file.size = storage_int_file_size;
|
||||
storage->fs_api.file.sync = storage_int_file_sync;
|
||||
storage->fs_api.file.eof = storage_int_file_eof;
|
||||
|
||||
storage->fs_api.dir.open = storage_int_dir_open;
|
||||
storage->fs_api.dir.close = storage_int_dir_close;
|
||||
storage->fs_api.dir.read = storage_int_dir_read;
|
||||
storage->fs_api.dir.rewind = storage_int_dir_rewind;
|
||||
|
||||
storage->fs_api.common.stat = storage_int_common_stat;
|
||||
storage->fs_api.common.mkdir = storage_int_common_mkdir;
|
||||
storage->fs_api.common.rename = storage_int_common_rename;
|
||||
storage->fs_api.common.remove = storage_int_common_remove;
|
||||
storage->fs_api.common.fs_info = storage_int_common_fs_info;
|
||||
}
|
||||
13
applications/storage/storages/storage-int.h
Normal file
13
applications/storage/storages/storage-int.h
Normal file
@@ -0,0 +1,13 @@
|
||||
#pragma once
|
||||
#include <furi.h>
|
||||
#include "../storage-glue.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void storage_int_init(StorageData* storage);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user