Merge branch 'master' of https://github.com/littlevgl/lvgl

README.md

@@ -81,7 +81,7 @@ lv_disp_drv_init(&disp_drv);          /*Basic initialization*/
 disp_drv.hor_res = 480;               /*Set the horizontal resolution*/
 disp_drv.ver_res = 320;               /*Set the vertical resolution*/
 disp_drv.flush_cb = my_disp_flush;    /*Set your driver function*/
-disp_drv.buffer = &disp_buf;          /*Assign the buffer to teh display*/
+disp_drv.buffer = &disp_buf;          /*Assign the buffer to the display*/
 lv_disp_drv_register(&disp_drv);      /*Finally register the driver*/
     
 void my_disp_flush(lv_disp_t * disp, const lv_area_t * area, lv_color_t * color_p)

porting/lv_port_fs_template.c

@@ -42,20 +42,20 @@ typedef struct {
  **********************/
 static void fs_init(void);
 
-static lv_fs_res_t fs_open (void * file_p, const char * path, lv_fs_mode_t mode);
+static lv_fs_res_t fs_open (lv_fs_drv_t * drv, void * file_p, const char * path, lv_fs_mode_t mode);
-static lv_fs_res_t fs_close (void * file_p);
+static lv_fs_res_t fs_close (lv_fs_drv_t * drv, void * file_p);
-static lv_fs_res_t fs_read (void * file_p, void * buf, uint32_t btr, uint32_t * br);
+static lv_fs_res_t fs_read (lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br);
-static lv_fs_res_t fs_write(void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw);
-static lv_fs_res_t fs_seek (void * file_p, uint32_t pos);
+static lv_fs_res_t fs_seek (lv_fs_drv_t * drv, void * file_p, uint32_t pos);
-static lv_fs_res_t fs_size (void * file_p, uint32_t * size_p);
+static lv_fs_res_t fs_size (lv_fs_drv_t * drv, void * file_p, uint32_t * size_p);
-static lv_fs_res_t fs_tell (void * file_p, uint32_t * pos_p);
+static lv_fs_res_t fs_tell (lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p);
-static lv_fs_res_t fs_remove (const char *path);
+static lv_fs_res_t fs_remove (lv_fs_drv_t * drv, const char *path);
-static lv_fs_res_t fs_trunc (void * file_p);
+static lv_fs_res_t fs_trunc (lv_fs_drv_t * drv, void * file_p);
-static lv_fs_res_t fs_rename (const char * oldname, const char * newname);
+static lv_fs_res_t fs_rename (lv_fs_drv_t * drv, const char * oldname, const char * newname);
-static lv_fs_res_t fs_free (uint32_t * total_p, uint32_t * free_p);
+static lv_fs_res_t fs_free (lv_fs_drv_t * drv, uint32_t * total_p, uint32_t * free_p);
-static lv_fs_res_t fs_dir_open (void * rddir_p, const char *path);
+static lv_fs_res_t fs_dir_open (lv_fs_drv_t * drv, void * rddir_p, const char *path);
-static lv_fs_res_t fs_dir_read (void * rddir_p, char *fn);
+static lv_fs_res_t fs_dir_read (lv_fs_drv_t * drv, void * rddir_p, char *fn);
-static lv_fs_res_t fs_dir_close (void * rddir_p);
+static lv_fs_res_t fs_dir_close (lv_fs_drv_t * drv, void * rddir_p);
 
 /**********************
  *  STATIC VARIABLES
@@ -125,12 +125,13 @@ static void fs_init(void)
 
 /**
  * Open a file
+ * @param drv pointer to a driver where this function belongs
  * @param file_p pointer to a file_t variable
  * @param path path to the file beginning with the driver letter (e.g. S:/folder/file.txt)
  * @param mode read: FS_MODE_RD, write: FS_MODE_WR, both: FS_MODE_RD | FS_MODE_WR
  * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
-static lv_fs_res_t fs_open (void * file_p, const char * path, lv_fs_mode_t mode)
+static lv_fs_res_t fs_open (lv_fs_drv_t * drv, void * file_p, const char * path, lv_fs_mode_t mode)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 
@@ -159,11 +160,12 @@ static lv_fs_res_t fs_open (void * file_p, const char * path, lv_fs_mode_t mode)
 
 /**
  * Close an opened file
+ * @param drv pointer to a driver where this function belongs
  * @param file_p pointer to a file_t variable. (opened with lv_ufs_open)
  * @return LV_FS_RES_OK: no error, the file is read
  *         any error from lv_fs_res_t enum
  */
-static lv_fs_res_t fs_close (void * file_p)
+static lv_fs_res_t fs_close (lv_fs_drv_t * drv, void * file_p)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 
@@ -174,6 +176,7 @@ static lv_fs_res_t fs_close (void * file_p)
 
 /**
  * Read data from an opened file
+ * @param drv pointer to a driver where this function belongs
  * @param file_p pointer to a file_t variable.
  * @param buf pointer to a memory block where to store the read data
  * @param btr number of Bytes To Read
@@ -181,7 +184,7 @@ static lv_fs_res_t fs_close (void * file_p)
  * @return LV_FS_RES_OK: no error, the file is read
  *         any error from lv_fs_res_t enum
  */
-static lv_fs_res_t fs_read (void * file_p, void * buf, uint32_t btr, uint32_t * br)
+static lv_fs_res_t fs_read (lv_fs_drv_t * drv, void * file_p, void * buf, uint32_t btr, uint32_t * br)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 
@@ -192,13 +195,14 @@ static lv_fs_res_t fs_read (void * file_p, void * buf, uint32_t btr, uint32_t *
 
 /**
  * Write into a file
+ * @param drv pointer to a driver where this function belongs
  * @param file_p pointer to a file_t variable
  * @param buf pointer to a buffer with the bytes to write
  * @param btr Bytes To Write
  * @param br the number of real written bytes (Bytes Written). NULL if unused.
  * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
-static lv_fs_res_t fs_write(void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
+static lv_fs_res_t fs_write(lv_fs_drv_t * drv, void * file_p, const void * buf, uint32_t btw, uint32_t * bw)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 
@@ -209,12 +213,13 @@ static lv_fs_res_t fs_write(void * file_p, const void * buf, uint32_t btw, uint3
 
 /**
  * Set the read write pointer. Also expand the file size if necessary.
+ * @param drv pointer to a driver where this function belongs
  * @param file_p pointer to a file_t variable. (opened with lv_ufs_open )
  * @param pos the new position of read write pointer
  * @return LV_FS_RES_OK: no error, the file is read
  *         any error from lv_fs_res_t enum
  */
-static lv_fs_res_t fs_seek (void * file_p, uint32_t pos)
+static lv_fs_res_t fs_seek (lv_fs_drv_t * drv, void * file_p, uint32_t pos)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 
@@ -225,11 +230,12 @@ static lv_fs_res_t fs_seek (void * file_p, uint32_t pos)
 
 /**
  * Give the size of a file bytes
+ * @param drv pointer to a driver where this function belongs
  * @param file_p pointer to a file_t variable
  * @param size pointer to a variable to store the size
  * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
-static lv_fs_res_t fs_size (void * file_p, uint32_t * size_p)
+static lv_fs_res_t fs_size (lv_fs_drv_t * drv, void * file_p, uint32_t * size_p)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 
@@ -239,12 +245,13 @@ static lv_fs_res_t fs_size (void * file_p, uint32_t * size_p)
 }
 /**
  * Give the position of the read write pointer
+ * @param drv pointer to a driver where this function belongs
  * @param file_p pointer to a file_t variable.
  * @param pos_p pointer to to store the result
  * @return LV_FS_RES_OK: no error, the file is read
  *         any error from lv_fs_res_t enum
  */
-static lv_fs_res_t fs_tell (void * file_p, uint32_t * pos_p)
+static lv_fs_res_t fs_tell (lv_fs_drv_t * drv, void * file_p, uint32_t * pos_p)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 
@@ -255,10 +262,11 @@ static lv_fs_res_t fs_tell (void * file_p, uint32_t * pos_p)
 
 /**
  * Delete a file
+ * @param drv pointer to a driver where this function belongs
  * @param path path of the file to delete
  * @return  LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
-static lv_fs_res_t fs_remove (const char *path)
+static lv_fs_res_t fs_remove (lv_fs_drv_t * drv, const char *path)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 
@@ -269,11 +277,12 @@ static lv_fs_res_t fs_remove (const char *path)
 
 /**
  * Truncate the file size to the current position of the read write pointer
+ * @param drv pointer to a driver where this function belongs
  * @param file_p pointer to an 'ufs_file_t' variable. (opened with lv_fs_open )
  * @return LV_FS_RES_OK: no error, the file is read
  *         any error from lv_fs_res_t enum
  */
-static lv_fs_res_t fs_trunc (void * file_p)
+static lv_fs_res_t fs_trunc (lv_fs_drv_t * drv, void * file_p)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 
@@ -284,11 +293,12 @@ static lv_fs_res_t fs_trunc (void * file_p)
 
 /**
  * Rename a file
+ * @param drv pointer to a driver where this function belongs
  * @param oldname path to the file
  * @param newname path with the new name
  * @return LV_FS_RES_OK or any error from 'fs_res_t'
  */
-static lv_fs_res_t fs_rename (const char * oldname, const char * newname)
+static lv_fs_res_t fs_rename (lv_fs_drv_t * drv, const char * oldname, const char * newname)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 
@@ -299,6 +309,7 @@ static lv_fs_res_t fs_rename (const char * oldname, const char * newname)
 
 /**
  * Get the free and total size of a driver in kB
+ * @param drv pointer to a driver where this function belongs
  * @param letter the driver letter
  * @param total_p pointer to store the total size [kB]
  * @param free_p pointer to store the free size [kB]
@@ -315,11 +326,12 @@ static lv_fs_res_t fs_free (uint32_t * total_p, uint32_t * free_p)
 
 /**
  * Initialize a 'fs_read_dir_t' variable for directory reading
+ * @param drv pointer to a driver where this function belongs
  * @param rddir_p pointer to a 'fs_read_dir_t' variable
  * @param path path to a directory
  * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
-static lv_fs_res_t fs_dir_open (void * rddir_p, const char *path)
+static lv_fs_res_t fs_dir_open (lv_fs_drv_t * drv, void * rddir_p, const char *path)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 
@@ -331,11 +343,12 @@ static lv_fs_res_t fs_dir_open (void * rddir_p, const char *path)
 /**
  * Read the next filename form a directory.
  * The name of the directories will begin with '/'
+ * @param drv pointer to a driver where this function belongs
  * @param rddir_p pointer to an initialized 'fs_read_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
  */
-static lv_fs_res_t fs_dir_read (void * rddir_p, char *fn)
+static lv_fs_res_t fs_dir_read (lv_fs_drv_t * drv, void * rddir_p, char *fn)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 
@@ -346,10 +359,11 @@ static lv_fs_res_t fs_dir_read (void * rddir_p, char *fn)
 
 /**
  * Close the directory reading
+ * @param drv pointer to a driver where this function belongs
  * @param rddir_p pointer to an initialized 'fs_read_dir_t' variable
  * @return LV_FS_RES_OK or any error from lv_fs_res_t enum
  */
-static lv_fs_res_t fs_dir_close (void * rddir_p)
+static lv_fs_res_t fs_dir_close (lv_fs_drv_t * drv, void * rddir_p)
 {
     lv_fs_res_t res = LV_FS_RES_NOT_IMP;
 

src/lv_misc/lv_fs.c

@@ -37,7 +37,6 @@
  *  STATIC PROTOTYPES
  **********************/
 static const char * lv_fs_get_real_path(const char * path);
-static lv_fs_drv_t * lv_fs_get_drv(char letter);
 
 /**********************
  *  STATIC VARIABLES
@@ -493,6 +492,24 @@ void lv_fs_drv_register(lv_fs_drv_t * drv_p)
     memcpy(new_drv, drv_p, sizeof(lv_fs_drv_t));
 }
 
+/**
+ * Give a pointer to a driver from its letter
+ * @param letter the driver letter
+ * @return pointer to a driver or NULL if not found
+ */
+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)
+    {
+        if(drv->letter == letter) {
+            return drv;
+        }
+    }
+
+    return NULL;
+}
 /**
  * Fill a buffer with the letters of existing drivers
  * @param buf buffer to store the letters ('\0' added after the last letter)
@@ -621,23 +638,4 @@ static const char * lv_fs_get_real_path(const char * path)
     return path;
 }
 
-/**
- * Give a pointer to a driver from its letter
- * @param letter the driver letter
- * @return pointer to a driver or NULL if not found
- */
-static 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)
-    {
-        if(drv->letter == letter) {
-            return drv;
-        }
-    }
-
-    return NULL;
-}
-
 #endif /*LV_USE_FILESYSTEM*/

src/lv_misc/lv_fs.h

@@ -126,6 +126,13 @@ void lv_fs_drv_init(lv_fs_drv_t * drv);
  */
 void lv_fs_drv_register(lv_fs_drv_t * drv_p);
 
+/**
+ * Give a pointer to a driver from its letter
+ * @param letter the driver letter
+ * @return pointer to a driver or NULL if not found
+ */
+lv_fs_drv_t * lv_fs_get_drv(char letter);
+
 /**
  * Test if a drive is rady or not. If the `ready` function was not initialized `true` will be
  * returned.