[fal] using rt-thread raw API instead of std API

mysterywolf · mysterywolf · commit 206fae07dc03 · 2024-11-23T14:38:44.000-05:00
diff --git a/components/fal/Kconfig b/components/fal/Kconfig
@@ -5,14 +5,10 @@ menuconfig RT_USING_FAL
     default n
 
 if RT_USING_FAL
-    config FAL_DEBUG_CONFIG
+    config FAL_USING_DEBUG
         bool "Enable debug log output"
-        default y
-
-    config FAL_DEBUG
-       int
-       default 1    if FAL_DEBUG_CONFIG
-       default 0
+        default y if RT_USING_DEBUG
+        default n
 
     config FAL_PART_HAS_TABLE_CFG
         bool "FAL partition table config has defined on 'fal_cfg.h'"
diff --git a/components/fal/inc/fal_def.h b/components/fal/inc/fal_def.h
@@ -15,58 +15,13 @@
 #include <stdio.h>
 #include <rtthread.h>
 
-#define FAL_PRINTF      rt_kprintf
-#define FAL_MALLOC      rt_malloc
-#define FAL_CALLOC      rt_calloc
-#define FAL_REALLOC     rt_realloc
-#define FAL_FREE        rt_free
-
-#ifndef FAL_DEBUG
-#define FAL_DEBUG                      0
-#endif
-
-#if FAL_DEBUG
-#ifdef assert
-#undef assert
-#endif
-#define assert(EXPR)                                                           \
-if (!(EXPR))                                                                   \
-{                                                                              \
-    FAL_PRINTF("(%s) has assert failed at %s.\n", #EXPR, __FUNCTION__);        \
-    while (1);                                                                 \
-}
-
-/* debug level log */
-#ifdef  log_d
-#undef  log_d
-#endif
-#define log_d(...)                     FAL_PRINTF("[D/FAL] (%s:%d) ", __FUNCTION__, __LINE__);           FAL_PRINTF(__VA_ARGS__);FAL_PRINTF("\n")
-
+#define DBG_TAG "FAL"
+#ifdef FAL_USING_DEBUG
+#define DBG_LVL DBG_LOG
 #else
-
-#ifdef assert
-#undef assert
-#endif
-#define assert(EXPR)                   ((void)0);
-
-/* debug level log */
-#ifdef  log_d
-#undef  log_d
-#endif
-#define log_d(...)
-#endif /* FAL_DEBUG */
-
-/* error level log */
-#ifdef  log_e
-#undef  log_e
-#endif
-#define log_e(...)                     FAL_PRINTF("\033[31;22m[E/FAL] (%s:%d) ", __FUNCTION__, __LINE__);FAL_PRINTF(__VA_ARGS__);FAL_PRINTF("\033[0m\n")
-
-/* info level log */
-#ifdef  log_i
-#undef  log_i
+#define DBG_LVL DBG_INFO
 #endif
-#define log_i(...)                     FAL_PRINTF("\033[32;22m[I/FAL] ");                                FAL_PRINTF(__VA_ARGS__);FAL_PRINTF("\033[0m\n")
+#include <rtdbg.h>
 
 /* FAL flash and partition device name max length */
 #ifndef FAL_DEV_NAME_MAX
diff --git a/components/fal/samples/porting/fal_flash_sfud_port.c b/components/fal/samples/porting/fal_flash_sfud_port.c
@@ -62,17 +62,17 @@ static int init(void)
 
 static int read(long offset, uint8_t *buf, size_t size)
 {
-    assert(sfud_dev);
-    assert(sfud_dev->init_ok);
+    RT_ASSERT(sfud_dev);
+    RT_ASSERT(sfud_dev->init_ok);
     sfud_read(sfud_dev, nor_flash0.addr + offset, size, buf);
 
     return size;
 }
 
 static int write(long offset, const uint8_t *buf, size_t size)
 {
-    assert(sfud_dev);
-    assert(sfud_dev->init_ok);
+    RT_ASSERT(sfud_dev);
+    RT_ASSERT(sfud_dev->init_ok);
     if (sfud_write(sfud_dev, nor_flash0.addr + offset, size, buf) != SFUD_SUCCESS)
     {
         return -1;
@@ -83,8 +83,8 @@ static int write(long offset, const uint8_t *buf, size_t size)
 
 static int erase(long offset, size_t size)
 {
-    assert(sfud_dev);
-    assert(sfud_dev->init_ok);
+    RT_ASSERT(sfud_dev);
+    RT_ASSERT(sfud_dev->init_ok);
     if (sfud_erase(sfud_dev, nor_flash0.addr + offset, size) != SFUD_SUCCESS)
     {
         return -1;
diff --git a/components/fal/samples/porting/fal_flash_stm32f2_port.c b/components/fal/samples/porting/fal_flash_stm32f2_port.c
@@ -97,7 +97,7 @@ static uint32_t stm32_get_sector(uint32_t address)
  * @return sector size
  */
 static uint32_t stm32_get_sector_size(uint32_t sector) {
-    assert(IS_FLASH_SECTOR(sector));
+    RT_ASSERT(IS_FLASH_SECTOR(sector));
 
     switch (sector) {
     case FLASH_Sector_0: return 16 * 1024;
diff --git a/components/fal/src/fal.c b/components/fal/src/fal.c
@@ -40,12 +40,12 @@ int fal_init(void)
     if ((result > 0) && (!init_ok))
     {
         init_ok = 1;
-        log_i("RT-Thread Flash Abstraction Layer initialize success.");
+        LOG_I("RT-Thread Flash Abstraction Layer initialize success.");
     }
     else if(result <= 0)
     {
         init_ok = 0;
-        log_e("RT-Thread Flash Abstraction Layer initialize failed.");
+        LOG_E("RT-Thread Flash Abstraction Layer initialize failed.");
     }
 
     return result;
diff --git a/components/fal/src/fal_flash.c b/components/fal/src/fal_flash.c
@@ -36,15 +36,15 @@ int fal_flash_init(void)
 
     for (i = 0; i < device_table_len; i++)
     {
-        assert(device_table[i]->ops.read);
-        assert(device_table[i]->ops.write);
-        assert(device_table[i]->ops.erase);
+        RT_ASSERT(device_table[i]->ops.read);
+        RT_ASSERT(device_table[i]->ops.write);
+        RT_ASSERT(device_table[i]->ops.erase);
         /* init flash device on flash table */
         if (device_table[i]->ops.init)
         {
             device_table[i]->ops.init();
         }
-        log_d("Flash device | %*.*s | addr: 0x%08lx | len: 0x%08x | blk_size: 0x%08x |initialized finish.",
+        LOG_D("Flash device | %*.*s | addr: 0x%08lx | len: 0x%08x | blk_size: 0x%08x |initialized finish.",
                 FAL_DEV_NAME_MAX, FAL_DEV_NAME_MAX, device_table[i]->name, device_table[i]->addr, device_table[i]->len,
                 device_table[i]->blk_size);
         offset = 0;
@@ -57,12 +57,12 @@ int fal_flash_init(void)
 
             if(offset > device_table[i]->len)
             {
-                log_i("Flash device %*.*s: add block failed, offset %d > len %d.",
+                LOG_I("Flash device %*.*s: add block failed, offset %d > len %d.",
                 FAL_DEV_NAME_MAX, FAL_DEV_NAME_MAX, device_table[i]->name, device_table[i]->addr, offset, device_table[i]->len);
                 break;
             }
 
-            log_d("                  blk%2d | addr: 0x%08lx | len: 0x%08x | blk_size: 0x%08x |initialized finish.",
+            LOG_D("                  blk%2d | addr: 0x%08lx | len: 0x%08x | blk_size: 0x%08x |initialized finish.",
                     j, device_table[i]->addr + offset, blk_len, blk->size);
             offset += blk_len;
         }
@@ -82,8 +82,8 @@ int fal_flash_init(void)
  */
 const struct fal_flash_dev *fal_flash_device_find(const char *name)
 {
-    assert(init_ok);
-    assert(name);
+    RT_ASSERT(init_ok);
+    RT_ASSERT(name);
 
     size_t i;
 
diff --git a/components/fal/src/fal_partition.c b/components/fal/src/fal_partition.c
diff --git a/components/fal/src/fal_rtt.c b/components/fal/src/fal_rtt.c

Original file line number	Diff line number	Diff line change
`@@ -62,17 +62,17 @@ static int init(void)`
`62`	`62`
`63`	`63`	`static int read(long offset, uint8_t *buf, size_t size)`
`64`	`64`	`{`
`65`		`- assert(sfud_dev);`
`66`		`- assert(sfud_dev->init_ok);`
	`65`	`+ RT_ASSERT(sfud_dev);`
	`66`	`+ RT_ASSERT(sfud_dev->init_ok);`
`67`	`67`	`sfud_read(sfud_dev, nor_flash0.addr + offset, size, buf);`
`68`	`68`
`69`	`69`	`return size;`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`static int write(long offset, const uint8_t *buf, size_t size)`
`73`	`73`	`{`
`74`		`- assert(sfud_dev);`
`75`		`- assert(sfud_dev->init_ok);`
	`74`	`+ RT_ASSERT(sfud_dev);`
	`75`	`+ RT_ASSERT(sfud_dev->init_ok);`
`76`	`76`	`if (sfud_write(sfud_dev, nor_flash0.addr + offset, size, buf) != SFUD_SUCCESS)`
`77`	`77`	`{`
`78`	`78`	`return -1;`
`@@ -83,8 +83,8 @@ static int write(long offset, const uint8_t *buf, size_t size)`
`83`	`83`
`84`	`84`	`static int erase(long offset, size_t size)`
`85`	`85`	`{`
`86`		`- assert(sfud_dev);`
`87`		`- assert(sfud_dev->init_ok);`
	`86`	`+ RT_ASSERT(sfud_dev);`
	`87`	`+ RT_ASSERT(sfud_dev->init_ok);`
`88`	`88`	`if (sfud_erase(sfud_dev, nor_flash0.addr + offset, size) != SFUD_SUCCESS)`
`89`	`89`	`{`
`90`	`90`	`return -1;`
Original file line number	Diff line number	Diff line change
`@@ -40,12 +40,12 @@ int fal_init(void)`
`40`	`40`	`if ((result > 0) && (!init_ok))`
`41`	`41`	`{`
`42`	`42`	`init_ok = 1;`
`43`		`- log_i("RT-Thread Flash Abstraction Layer initialize success.");`
	`43`	`+ LOG_I("RT-Thread Flash Abstraction Layer initialize success.");`
`44`	`44`	`}`
`45`	`45`	`else if(result <= 0)`
`46`	`46`	`{`
`47`	`47`	`init_ok = 0;`
`48`		`- log_e("RT-Thread Flash Abstraction Layer initialize failed.");`
	`48`	`+ LOG_E("RT-Thread Flash Abstraction Layer initialize failed.");`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`return result;`
Original file line number	Diff line number	Diff line change
`@@ -36,15 +36,15 @@ int fal_flash_init(void)`
`36`	`36`
`37`	`37`	`for (i = 0; i < device_table_len; i++)`
`38`	`38`	`{`
`39`		`- assert(device_table[i]->ops.read);`
`40`		`- assert(device_table[i]->ops.write);`
`41`		`- assert(device_table[i]->ops.erase);`
	`39`	`+ RT_ASSERT(device_table[i]->ops.read);`
	`40`	`+ RT_ASSERT(device_table[i]->ops.write);`
	`41`	`+ RT_ASSERT(device_table[i]->ops.erase);`
`42`	`42`	`/* init flash device on flash table */`
`43`	`43`	`if (device_table[i]->ops.init)`
`44`	`44`	`{`
`45`	`45`	`device_table[i]->ops.init();`
`46`	`46`	`}`
`47`		`- log_d("Flash device \| %.s \| addr: 0x%08lx \| len: 0x%08x \| blk_size: 0x%08x \|initialized finish.",`
	`47`	`+ LOG_D("Flash device \| %.s \| addr: 0x%08lx \| len: 0x%08x \| blk_size: 0x%08x \|initialized finish.",`
`48`	`48`	`FAL_DEV_NAME_MAX, FAL_DEV_NAME_MAX, device_table[i]->name, device_table[i]->addr, device_table[i]->len,`
`49`	`49`	`device_table[i]->blk_size);`
`50`	`50`	`offset = 0;`
`@@ -57,12 +57,12 @@ int fal_flash_init(void)`
`57`	`57`
`58`	`58`	`if(offset > device_table[i]->len)`
`59`	`59`	`{`
`60`		`- log_i("Flash device %.s: add block failed, offset %d > len %d.",`
	`60`	`+ LOG_I("Flash device %.s: add block failed, offset %d > len %d.",`
`61`	`61`	`FAL_DEV_NAME_MAX, FAL_DEV_NAME_MAX, device_table[i]->name, device_table[i]->addr, offset, device_table[i]->len);`
`62`	`62`	`break;`
`63`	`63`	`}`
`64`	`64`
`65`		`- log_d(" blk%2d \| addr: 0x%08lx \| len: 0x%08x \| blk_size: 0x%08x \|initialized finish.",`
	`65`	`+ LOG_D(" blk%2d \| addr: 0x%08lx \| len: 0x%08x \| blk_size: 0x%08x \|initialized finish.",`
`66`	`66`	`j, device_table[i]->addr + offset, blk_len, blk->size);`
`67`	`67`	`offset += blk_len;`
`68`	`68`	`}`
`@@ -82,8 +82,8 @@ int fal_flash_init(void)`
`82`	`82`	`*/`
`83`	`83`	`const struct fal_flash_dev fal_flash_device_find(const char name)`
`84`	`84`	`{`
`85`		`- assert(init_ok);`
`86`		`- assert(name);`
	`85`	`+ RT_ASSERT(init_ok);`
	`86`	`+ RT_ASSERT(name);`
`87`	`87`
`88`	`88`	`size_t i;`
`89`	`89`