1 files changed, 82 insertions, 60 deletions

diff --git a/src/libs/lvgl/src/lv_misc/lv_fs.c b/src/libs/lvgl/src/lv_misc/lv_fs.c
index a23081ce..6f66c765 100644
--- a/src/libs/lvgl/src/lv_misc/lv_fs.c
+++ b/src/libs/lvgl/src/lv_misc/lv_fs.c
@@ -9,15 +9,11 @@
 #include "lv_fs.h"
 #if LV_USE_FILESYSTEM
 
-#include "../lv_core/lv_debug.h"
+#include "../lv_misc/lv_debug.h"
 #include "lv_ll.h"
 #include <string.h>
 #include "lv_gc.h"
 
-#if defined(LV_GC_INCLUDE)
-#include LV_GC_INCLUDE
-#endif /* LV_ENABLE_GC */
-
 /*********************
  *      DEFINES
  *********************/
@@ -27,7 +23,7 @@
  * free function, otherwise compilation would fail.
  */
 #ifdef free
-#undef free
+    #undef free
 #endif
 
 /**********************
@@ -54,13 +50,13 @@ static const char * lv_fs_get_real_path(const char * path);
 /**
  * Initialize the File system interface
  */
-void lv_fs_init(void)
+void _lv_fs_init(void)
 {
-    lv_ll_init(&LV_GC_ROOT(_lv_drv_ll), sizeof(lv_fs_drv_t));
+    _lv_ll_init(&LV_GC_ROOT(_lv_drv_ll), sizeof(lv_fs_drv_t));
 }
 
 /**
- * Test if a drive is rady or not. If the `ready` function was not initialized `true` will be
+ * Test if a drive is ready or not. If the `ready` function was not initialized `true` will be
  * returned.
  * @param letter letter of the drive
  * @return true: drive is ready; false: drive is not ready
@@ -95,18 +91,28 @@ lv_fs_res_t lv_fs_open(lv_fs_file_t * file_p, const char * path, lv_fs_mode_t mo
     file_p->drv = lv_fs_get_drv(letter);
 
     if(file_p->drv == NULL) {
-        file_p->file_d = NULL;
         return LV_FS_RES_NOT_EX;
     }
 
     if(file_p->drv->ready_cb != NULL) {
         if(file_p->drv->ready_cb(file_p->drv) == false) {
-            file_p->drv    = NULL;
-            file_p->file_d = NULL;
+            file_p->drv = NULL;
             return LV_FS_RES_HW_ERR;
         }
     }
 
+    if(file_p->drv->open_cb == NULL) {
+        file_p->drv = NULL;
+        return LV_FS_RES_NOT_IMP;
+    }
+
+    const char * real_path = lv_fs_get_real_path(path);
+
+    if(file_p->drv->file_size == 0) {  /*Is file_d zero size?*/
+        /*Pass file_d's address to open_cb, so the implementor can allocate memory byself*/
+        return file_p->drv->open_cb(file_p->drv, &file_p->file_d, real_path, mode);
+    }
+
     file_p->file_d = lv_mem_alloc(file_p->drv->file_size);
     LV_ASSERT_MEM(file_p->file_d);
     if(file_p->file_d == NULL) {
@@ -114,12 +120,7 @@ lv_fs_res_t lv_fs_open(lv_fs_file_t * file_p, const char * path, lv_fs_mode_t mo
         return LV_FS_RES_OUT_OF_MEM; /* Out of memory */
     }
 
-    if(file_p->drv->open_cb == NULL) {
-        return LV_FS_RES_NOT_IMP;
-    }
-
-    const char * real_path = lv_fs_get_real_path(path);
-    lv_fs_res_t res        = file_p->drv->open_cb(file_p->drv, file_p->file_d, real_path, mode);
+    lv_fs_res_t res = file_p->drv->open_cb(file_p->drv, file_p->file_d, real_path, mode);
 
     if(res != LV_FS_RES_OK) {
         lv_mem_free(file_p->file_d);
@@ -133,7 +134,7 @@ lv_fs_res_t lv_fs_open(lv_fs_file_t * file_p, const char * path, lv_fs_mode_t mo
 /**
  * Close an already opened file
  * @param file_p pointer to a lv_fs_file_t variable
- * @return  LV_FS_RES_OK or any error from lv_fs_res_t enum
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
 lv_fs_res_t lv_fs_close(lv_fs_file_t * file_p)
 {
@@ -150,7 +151,6 @@ lv_fs_res_t lv_fs_close(lv_fs_file_t * file_p)
     lv_mem_free(file_p->file_d); /*Clean up*/
     file_p->file_d = NULL;
     file_p->drv    = NULL;
-    file_p->file_d = NULL;
 
     return res;
 }
@@ -158,16 +158,15 @@ lv_fs_res_t lv_fs_close(lv_fs_file_t * file_p)
 /**
  * Delete a file
  * @param path path of the file to delete
- * @return  LV_FS_RES_OK or any error from lv_fs_res_t enum
+ * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
 lv_fs_res_t lv_fs_remove(const char * path)
 {
     if(path == NULL) return LV_FS_RES_INV_PARAM;
-    lv_fs_drv_t * drv = NULL;
 
     char letter = path[0];
 
-    drv = lv_fs_get_drv(letter);
+    lv_fs_drv_t * drv = lv_fs_get_drv(letter);
     if(drv == NULL) return LV_FS_RES_NOT_EX;
     if(drv->ready_cb != NULL) {
         if(drv->ready_cb(drv) == false) return LV_FS_RES_HW_ERR;
@@ -259,12 +258,12 @@ lv_fs_res_t lv_fs_seek(lv_fs_file_t * file_p, uint32_t pos)
 lv_fs_res_t lv_fs_tell(lv_fs_file_t * file_p, uint32_t * pos)
 {
     if(file_p->drv == NULL) {
-        pos = 0;
+        *pos = 0;
         return LV_FS_RES_INV_PARAM;
     }
 
     if(file_p->drv->tell_cb == NULL) {
-        pos = 0;
+        *pos = 0;
         return LV_FS_RES_NOT_IMP;
     }
 
@@ -285,7 +284,7 @@ lv_fs_res_t lv_fs_trunc(lv_fs_file_t * file_p)
         return LV_FS_RES_INV_PARAM;
     }
 
-    if(file_p->drv->tell_cb == NULL) {
+    if(file_p->drv->trunc_cb == NULL) {
         return LV_FS_RES_NOT_IMP;
     }
 
@@ -349,13 +348,16 @@ lv_fs_res_t lv_fs_rename(const char * oldname, const char * newname)
 }
 
 /**
- * Initialize a 'fs_read_dir_t' variable for directory reading
- * @param rddir_p pointer to a 'fs_read_dir_t' variable
+ * Initialize a 'lv_fs_dir_t' variable for directory reading
+ * @param rddir_p pointer to a 'lv_fs_dir_t' variable
  * @param path path to a directory
  * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
 lv_fs_res_t lv_fs_dir_open(lv_fs_dir_t * rddir_p, const char * path)
 {
+    rddir_p->drv   = NULL;
+    rddir_p->dir_d = NULL;
+
     if(path == NULL) return LV_FS_RES_INV_PARAM;
 
     char letter = path[0];
@@ -363,32 +365,50 @@ lv_fs_res_t lv_fs_dir_open(lv_fs_dir_t * rddir_p, const char * path)
     rddir_p->drv = lv_fs_get_drv(letter);
 
     if(rddir_p->drv == NULL) {
-        rddir_p->dir_d = NULL;
         return LV_FS_RES_NOT_EX;
     }
 
-    rddir_p->dir_d = lv_mem_alloc(rddir_p->drv->rddir_size);
-    LV_ASSERT_MEM(rddir_p->dir_d);
-    if(rddir_p->dir_d == NULL) {
-        rddir_p->dir_d = NULL;
-        return LV_FS_RES_OUT_OF_MEM; /* Out of memory */
+    if(rddir_p->drv->ready_cb != NULL) {
+        if(rddir_p->drv->ready_cb(rddir_p->drv) == false) {
+            rddir_p->drv = NULL;
+            return LV_FS_RES_HW_ERR;
+        }
     }
 
     if(rddir_p->drv->dir_open_cb == NULL) {
+        rddir_p->drv = NULL;
         return LV_FS_RES_NOT_IMP;
     }
 
     const char * real_path = lv_fs_get_real_path(path);
 
+    if(rddir_p->drv->rddir_size == 0) {  /*Is dir_d zero size?*/
+        /*Pass dir_d's address to dir_open_cb, so the implementor can allocate memory byself*/
+        return rddir_p->drv->dir_open_cb(rddir_p->drv, &rddir_p->dir_d, real_path);
+    }
+
+    rddir_p->dir_d = lv_mem_alloc(rddir_p->drv->rddir_size);
+    LV_ASSERT_MEM(rddir_p->dir_d);
+    if(rddir_p->dir_d == NULL) {
+        rddir_p->drv = NULL;
+        return LV_FS_RES_OUT_OF_MEM; /* Out of memory */
+    }
+
     lv_fs_res_t res = rddir_p->drv->dir_open_cb(rddir_p->drv, rddir_p->dir_d, real_path);
 
+    if(res != LV_FS_RES_OK) {
+        lv_mem_free(rddir_p->dir_d);
+        rddir_p->dir_d = NULL;
+        rddir_p->drv   = NULL;
+    }
+
     return res;
 }
 
 /**
  * Read the next filename form a directory.
  * The name of the directories will begin with '/'
- * @param rddir_p pointer to an initialized 'fs_read_dir_t' variable
+ * @param rddir_p pointer to an initialized 'lv_fs_dir_t' variable
  * @param fn pointer to a buffer to store the filename
  * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
@@ -400,6 +420,7 @@ lv_fs_res_t lv_fs_dir_read(lv_fs_dir_t * rddir_p, char * fn)
     }
 
     if(rddir_p->drv->dir_read_cb == NULL) {
+        fn[0] = '\0';
         return LV_FS_RES_NOT_IMP;
     }
 
@@ -410,7 +431,7 @@ lv_fs_res_t lv_fs_dir_read(lv_fs_dir_t * rddir_p, char * fn)
 
 /**
  * Close the directory reading
- * @param rddir_p pointer to an initialized 'fs_read_dir_t' variable
+ * @param rddir_p pointer to an initialized 'lv_fs_dir_t' variable
  * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
 lv_fs_res_t lv_fs_dir_close(lv_fs_dir_t * rddir_p)
@@ -419,18 +440,15 @@ lv_fs_res_t lv_fs_dir_close(lv_fs_dir_t * rddir_p)
         return LV_FS_RES_INV_PARAM;
     }
 
-    lv_fs_res_t res;
-
     if(rddir_p->drv->dir_close_cb == NULL) {
-        res = LV_FS_RES_NOT_IMP;
-    } else {
-        res = rddir_p->drv->dir_close_cb(rddir_p->drv, rddir_p->dir_d);
+        return LV_FS_RES_NOT_IMP;
     }
 
+    lv_fs_res_t res = rddir_p->drv->dir_close_cb(rddir_p->drv, rddir_p->dir_d);
+
     lv_mem_free(rddir_p->dir_d); /*Clean up*/
     rddir_p->dir_d = NULL;
     rddir_p->drv   = NULL;
-    rddir_p->dir_d = NULL;
 
     return res;
 }
@@ -450,19 +468,23 @@ lv_fs_res_t lv_fs_free_space(char letter, uint32_t * total_p, uint32_t * free_p)
         return LV_FS_RES_INV_PARAM;
     }
 
-    lv_fs_res_t res;
+    if(drv->ready_cb != NULL) {
+        if(drv->ready_cb(drv) == false) {
+            return LV_FS_RES_HW_ERR;
+        }
+    }
 
     if(drv->free_space_cb == NULL) {
-        res = LV_FS_RES_NOT_IMP;
-    } else {
-        uint32_t total_tmp = 0;
-        uint32_t free_tmp  = 0;
-        res                = drv->free_space_cb(drv, &total_tmp, &free_tmp);
-
-        if(total_p != NULL) *total_p = total_tmp;
-        if(free_p != NULL) *free_p = free_tmp;
+        return LV_FS_RES_NOT_IMP;
     }
 
+    uint32_t total_tmp = 0;
+    uint32_t free_tmp  = 0;
+    lv_fs_res_t res    = drv->free_space_cb(drv, &total_tmp, &free_tmp);
+
+    if(total_p != NULL) *total_p = total_tmp;
+    if(free_p != NULL) *free_p = free_tmp;
+
     return res;
 }
 
@@ -474,7 +496,7 @@ lv_fs_res_t lv_fs_free_space(char letter, uint32_t * total_p, uint32_t * free_p)
  */
 void lv_fs_drv_init(lv_fs_drv_t * drv)
 {
-    memset(drv, 0, sizeof(lv_fs_drv_t));
+    _lv_memset_00(drv, sizeof(lv_fs_drv_t));
 }
 
 /**
@@ -486,11 +508,11 @@ void lv_fs_drv_register(lv_fs_drv_t * drv_p)
 {
     /*Save the new driver*/
     lv_fs_drv_t * new_drv;
-    new_drv = lv_ll_ins_head(&LV_GC_ROOT(_lv_drv_ll));
+    new_drv = _lv_ll_ins_head(&LV_GC_ROOT(_lv_drv_ll));
     LV_ASSERT_MEM(new_drv);
     if(new_drv == NULL) return;
 
-    memcpy(new_drv, drv_p, sizeof(lv_fs_drv_t));
+    _lv_memcpy(new_drv, drv_p, sizeof(lv_fs_drv_t));
 }
 
 /**
@@ -502,8 +524,7 @@ lv_fs_drv_t * lv_fs_get_drv(char letter)
 {
     lv_fs_drv_t * drv;
 
-    LV_LL_READ(LV_GC_ROOT(_lv_drv_ll), drv)
-    {
+    _LV_LL_READ(LV_GC_ROOT(_lv_drv_ll), drv) {
         if(drv->letter == letter) {
             return drv;
         }
@@ -521,8 +542,7 @@ char * lv_fs_get_letters(char * buf)
     lv_fs_drv_t * drv;
     uint8_t i = 0;
 
-    LV_LL_READ(LV_GC_ROOT(_lv_drv_ll), drv)
-    {
+    _LV_LL_READ(LV_GC_ROOT(_lv_drv_ll), drv) {
         buf[i] = drv->letter;
         i++;
     }
@@ -543,7 +563,8 @@ const char * lv_fs_get_ext(const char * fn)
     for(i = strlen(fn); i > 0; i--) {
         if(fn[i] == '.') {
             return &fn[i + 1];
-        } else if(fn[i] == '/' || fn[i] == '\\') {
+        }
+        else if(fn[i] == '/' || fn[i] == '\\') {
             return ""; /*No extension if a '\' or '/' found*/
         }
     }
@@ -631,7 +652,8 @@ static const char * lv_fs_get_real_path(const char * path)
     while(*path != '\0') {
         if(*path == ':' || *path == '\\' || *path == '/') {
             path++;
-        } else {
+        }
+        else {
             break;
         }
     }