Update i2c driver, add read ACK and BUS status check

1 files changed, 116 insertions, 29 deletions

diff --git a/include/rtthread.h b/include/rtthread.h
index 1e0094e73b..45a7655be9 100644
--- a/include/rtthread.h
+++ b/include/rtthread.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2018, RT-Thread Development Team
+ * Copyright (c) 2006-2021, RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -14,6 +14,8 @@
  * 2013-06-24     Bernard      add rt_kprintf re-define when not use RT_USING_CONSOLE.
  * 2016-08-09     ArdaFu       add new thread and interrupt hook.
  * 2018-11-22     Jesven       add all cpu's lock and ipi handler
+ * 2021-02-28     Meco Man     add RT_KSERVICE_USING_STDLIB
+ * 2021-11-14     Meco Man     add rtlegacy.h for compatibility
  */
 
 #ifndef __RT_THREAD_H__
@@ -24,6 +26,9 @@
 #include <rtdef.h>
 #include <rtservice.h>
 #include <rtm.h>
+#ifdef RT_USING_LEGACY
+#include <rtlegacy.h>
+#endif
 
 #ifdef __cplusplus
 extern "C" {
@@ -47,9 +52,11 @@ void rt_object_init(struct rt_object         *object,
                     enum rt_object_class_type type,
                     const char               *name);
 void rt_object_detach(rt_object_t object);
+#ifdef RT_USING_HEAP
 rt_object_t rt_object_allocate(enum rt_object_class_type type,
                                const char               *name);
 void rt_object_delete(rt_object_t object);
+#endif
 rt_bool_t rt_object_is_systemobject(rt_object_t object);
 rt_uint8_t rt_object_get_type(rt_object_t object);
 rt_object_t rt_object_find(const char *name, rt_uint8_t type);
@@ -89,12 +96,14 @@ void rt_timer_init(rt_timer_t  timer,
                    rt_tick_t   time,
                    rt_uint8_t  flag);
 rt_err_t rt_timer_detach(rt_timer_t timer);
+#ifdef RT_USING_HEAP
 rt_timer_t rt_timer_create(const char *name,
                            void (*timeout)(void *parameter),
                            void       *parameter,
                            rt_tick_t   time,
                            rt_uint8_t  flag);
 rt_err_t rt_timer_delete(rt_timer_t timer);
+#endif
 rt_err_t rt_timer_start(rt_timer_t timer);
 rt_err_t rt_timer_stop(rt_timer_t timer);
 rt_err_t rt_timer_control(rt_timer_t timer, int cmd, void *arg);
@@ -127,17 +136,18 @@ rt_err_t rt_thread_init(struct rt_thread *thread,
                         rt_uint8_t        priority,
                         rt_uint32_t       tick);
 rt_err_t rt_thread_detach(rt_thread_t thread);
+#ifdef RT_USING_HEAP
 rt_thread_t rt_thread_create(const char *name,
                              void (*entry)(void *parameter),
                              void       *parameter,
                              rt_uint32_t stack_size,
                              rt_uint8_t  priority,
                              rt_uint32_t tick);
+rt_err_t rt_thread_delete(rt_thread_t thread);
+#endif
 rt_thread_t rt_thread_self(void);
 rt_thread_t rt_thread_find(char *name);
 rt_err_t rt_thread_startup(rt_thread_t thread);
-rt_err_t rt_thread_delete(rt_thread_t thread);
-
 rt_err_t rt_thread_yield(void);
 rt_err_t rt_thread_delay(rt_tick_t tick);
 rt_err_t rt_thread_delay_until(rt_tick_t *tick, rt_tick_t inc_tick);
@@ -145,7 +155,6 @@ rt_err_t rt_thread_mdelay(rt_int32_t ms);
 rt_err_t rt_thread_control(rt_thread_t thread, int cmd, void *arg);
 rt_err_t rt_thread_suspend(rt_thread_t thread);
 rt_err_t rt_thread_resume(rt_thread_t thread);
-void rt_thread_timeout(void *parameter);
 
 #ifdef RT_USING_SIGNALS
 void rt_thread_alloc_sig(rt_thread_t tid);
@@ -167,7 +176,6 @@ void rt_thread_idle_init(void);
 rt_err_t rt_thread_idle_sethook(void (*hook)(void));
 rt_err_t rt_thread_idle_delhook(void (*hook)(void));
 #endif
-void rt_thread_idle_excute(void);
 rt_thread_t rt_thread_idle_gethandler(void);
 
 /*
@@ -186,6 +194,7 @@ rt_uint16_t rt_critical_level(void);
 
 #ifdef RT_USING_HOOK
 void rt_scheduler_sethook(void (*hook)(rt_thread_t from, rt_thread_t to));
+void rt_scheduler_switch_sethook(void (*hook)(struct rt_thread *tid));
 #endif
 
 #ifdef RT_USING_SMP
@@ -227,10 +236,12 @@ rt_err_t rt_mp_init(struct rt_mempool *mp,
                     rt_size_t          size,
                     rt_size_t          block_size);
 rt_err_t rt_mp_detach(struct rt_mempool *mp);
+#ifdef RT_USING_HEAP
 rt_mp_t rt_mp_create(const char *name,
                      rt_size_t   block_count,
                      rt_size_t   block_size);
 rt_err_t rt_mp_delete(rt_mp_t mp);
+#endif
 
 void *rt_mp_alloc(rt_mp_t mp, rt_int32_t time);
 void rt_mp_free(void *block);
@@ -255,11 +266,11 @@ void *rt_calloc(rt_size_t count, rt_size_t size);
 void *rt_malloc_align(rt_size_t size, rt_size_t align);
 void rt_free_align(void *ptr);
 
-void rt_memory_info(rt_uint32_t *total,
-                    rt_uint32_t *used,
-                    rt_uint32_t *max_used);
+void rt_memory_info(rt_size_t *total,
+                    rt_size_t *used,
+                    rt_size_t *max_used);
 
-#ifdef RT_USING_SLAB
+#if defined(RT_USING_SLAB) && defined(RT_USING_SLAB_AS_HEAP)
 void *rt_page_alloc(rt_size_t npages);
 void rt_page_free(void *addr, rt_size_t npages);
 #endif
@@ -271,6 +282,19 @@ void rt_free_sethook(void (*hook)(void *ptr));
 
 #endif
 
+#ifdef RT_USING_SMALL_MEM
+/**
+ * small memory object interface
+ */
+rt_smem_t rt_smem_init(const char    *name,
+                     void          *begin_addr,
+                     rt_size_t      size);
+rt_err_t rt_smem_detach(rt_smem_t m);
+void *rt_smem_alloc(rt_smem_t m, rt_size_t size);
+void *rt_smem_realloc(rt_smem_t m, void *rmem, rt_size_t newsize);
+void rt_smem_free(void *rmem);
+#endif
+
 #ifdef RT_USING_MEMHEAP
 /**
  * memory heap object interface
@@ -283,6 +307,23 @@ rt_err_t rt_memheap_detach(struct rt_memheap *heap);
 void *rt_memheap_alloc(struct rt_memheap *heap, rt_size_t size);
 void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize);
 void rt_memheap_free(void *ptr);
+void rt_memheap_info(struct rt_memheap *heap,
+                     rt_size_t *total,
+                     rt_size_t *used,
+                     rt_size_t *max_used);
+#endif
+
+#ifdef RT_USING_SLAB
+/**
+ * slab object interface
+ */
+rt_slab_t rt_slab_init(const char *name, void *begin_addr, rt_size_t size);
+rt_err_t rt_slab_detach(rt_slab_t m);
+void *rt_slab_page_alloc(rt_slab_t m, rt_size_t npages);
+void rt_slab_page_free(rt_slab_t m, void *addr, rt_size_t npages);
+void *rt_slab_alloc(rt_slab_t m, rt_size_t size);
+void *rt_slab_realloc(rt_slab_t m, void *ptr, rt_size_t size);
+void rt_slab_free(rt_slab_t m, void *ptr);
 #endif
 
 /**@}*/
@@ -302,8 +343,10 @@ rt_err_t rt_sem_init(rt_sem_t    sem,
                      rt_uint32_t value,
                      rt_uint8_t  flag);
 rt_err_t rt_sem_detach(rt_sem_t sem);
+#ifdef RT_USING_HEAP
 rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag);
 rt_err_t rt_sem_delete(rt_sem_t sem);
+#endif
 
 rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time);
 rt_err_t rt_sem_trytake(rt_sem_t sem);
@@ -317,10 +360,13 @@ rt_err_t rt_sem_control(rt_sem_t sem, int cmd, void *arg);
  */
 rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag);
 rt_err_t rt_mutex_detach(rt_mutex_t mutex);
+#ifdef RT_USING_HEAP
 rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag);
 rt_err_t rt_mutex_delete(rt_mutex_t mutex);
+#endif
 
 rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time);
+rt_err_t rt_mutex_trytake(rt_mutex_t mutex);
 rt_err_t rt_mutex_release(rt_mutex_t mutex);
 rt_err_t rt_mutex_control(rt_mutex_t mutex, int cmd, void *arg);
 #endif
@@ -331,8 +377,10 @@ rt_err_t rt_mutex_control(rt_mutex_t mutex, int cmd, void *arg);
  */
 rt_err_t rt_event_init(rt_event_t event, const char *name, rt_uint8_t flag);
 rt_err_t rt_event_detach(rt_event_t event);
+#ifdef RT_USING_HEAP
 rt_event_t rt_event_create(const char *name, rt_uint8_t flag);
 rt_err_t rt_event_delete(rt_event_t event);
+#endif
 
 rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set);
 rt_err_t rt_event_recv(rt_event_t   event,
@@ -353,13 +401,16 @@ rt_err_t rt_mb_init(rt_mailbox_t mb,
                     rt_size_t    size,
                     rt_uint8_t   flag);
 rt_err_t rt_mb_detach(rt_mailbox_t mb);
+#ifdef RT_USING_HEAP
 rt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag);
 rt_err_t rt_mb_delete(rt_mailbox_t mb);
+#endif
 
 rt_err_t rt_mb_send(rt_mailbox_t mb, rt_ubase_t value);
 rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
                          rt_ubase_t  value,
                          rt_int32_t   timeout);
+rt_err_t rt_mb_urgent(rt_mailbox_t mb, rt_ubase_t value);
 rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout);
 rt_err_t rt_mb_control(rt_mailbox_t mb, int cmd, void *arg);
 #endif
@@ -375,11 +426,13 @@ rt_err_t rt_mq_init(rt_mq_t     mq,
                     rt_size_t   pool_size,
                     rt_uint8_t  flag);
 rt_err_t rt_mq_detach(rt_mq_t mq);
+#ifdef RT_USING_HEAP
 rt_mq_t rt_mq_create(const char *name,
                      rt_size_t   msg_size,
                      rt_size_t   max_msgs,
                      rt_uint8_t  flag);
 rt_err_t rt_mq_delete(rt_mq_t mq);
+#endif
 
 rt_err_t rt_mq_send(rt_mq_t mq, const void *buffer, rt_size_t size);
 rt_err_t rt_mq_send_wait(rt_mq_t     mq,
@@ -394,6 +447,10 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
 rt_err_t rt_mq_control(rt_mq_t mq, int cmd, void *arg);
 #endif
 
+/* defunct */
+void rt_thread_defunct_enqueue(rt_thread_t thread);
+rt_thread_t rt_thread_defunct_dequeue(void);
+
 /*
  * spinlock
  */
@@ -434,10 +491,10 @@ rt_err_t rt_device_register(rt_device_t dev,
                             rt_uint16_t flags);
 rt_err_t rt_device_unregister(rt_device_t dev);
 
+#ifdef RT_USING_HEAP
 rt_device_t rt_device_create(int type, int attach_size);
 void rt_device_destroy(rt_device_t device);
-
-rt_err_t rt_device_init_all(void);
+#endif
 
 rt_err_t
 rt_device_set_rx_indicate(rt_device_t dev,
@@ -514,13 +571,14 @@ void rt_components_board_init(void);
 #define rt_kprintf(...)
 #define rt_kputs(str)
 #else
-void rt_kprintf(const char *fmt, ...);
+int rt_kprintf(const char *fmt, ...);
 void rt_kputs(const char *str);
 #endif
-rt_int32_t rt_vsprintf(char *dest, const char *format, va_list arg_ptr);
-rt_int32_t rt_vsnprintf(char *buf, rt_size_t size, const char *fmt, va_list args);
-rt_int32_t rt_sprintf(char *buf, const char *format, ...);
-rt_int32_t rt_snprintf(char *buf, rt_size_t size, const char *format, ...);
+
+int rt_vsprintf(char *dest, const char *format, va_list arg_ptr);
+int rt_vsnprintf(char *buf, rt_size_t size, const char *fmt, va_list args);
+int rt_sprintf(char *buf, const char *format, ...);
+int rt_snprintf(char *buf, rt_size_t size, const char *format, ...);
 
 #if defined(RT_USING_DEVICE) && defined(RT_USING_CONSOLE)
 rt_device_t rt_console_set_device(const char *name);
@@ -538,25 +596,54 @@ int *_rt_errno(void);
 
 int __rt_ffs(int value);
 
+#ifndef RT_KSERVICE_USING_STDLIB_MEMSET
 void *rt_memset(void *src, int c, rt_ubase_t n);
+#endif /* RT_KSERVICE_USING_STDLIB_MEMSET */
+#ifndef RT_KSERVICE_USING_STDLIB_MEMCPY
 void *rt_memcpy(void *dest, const void *src, rt_ubase_t n);
+#endif /* RT_KSERVICE_USING_STDLIB_MEMCPY */
+char *rt_strdup(const char *s);
 
-rt_int32_t rt_strncmp(const char *cs, const char *ct, rt_ubase_t count);
+#ifndef RT_KSERVICE_USING_STDLIB
+void *rt_memmove(void *dest, const void *src, rt_size_t n);
+rt_int32_t rt_memcmp(const void *cs, const void *ct, rt_size_t count);
+char *rt_strstr(const char *str1, const char *str2);
+rt_int32_t rt_strcasecmp(const char *a, const char *b);
+char *rt_strcpy(char *dst, const char *src);
+char *rt_strncpy(char *dest, const char *src, rt_size_t n);
+rt_int32_t rt_strncmp(const char *cs, const char *ct, rt_size_t count);
 rt_int32_t rt_strcmp(const char *cs, const char *ct);
 rt_size_t rt_strlen(const char *src);
+#else
+#include <string.h>
+#ifdef RT_KSERVICE_USING_STDLIB_MEMSET
+#define rt_memset(s, c, count)      memset(s, c, count)
+#endif /* RT_KSERVICE_USING_STDLIB_MEMSET */
+#ifdef RT_KSERVICE_USING_STDLIB_MEMCPY
+#define rt_memcpy(dst, src, count)  memcpy(dst, src, count)
+#endif /* RT_KSERVICE_USING_STDLIB_MEMCPY */
+#define rt_memmove(dest, src, n)    memmove(dest, src, n)
+#define rt_memcmp(cs, ct, count)    memcmp(cs, ct, count)
+#define rt_strstr(str1, str2)       strstr(str1, str2)
+#define rt_strcasecmp(a, b)         strcasecmp(a, b)
+#define rt_strcpy(dest, src)        strcpy(dest, src)
+#define rt_strncpy(dest, src, n)    strncpy(dest, src, n)
+#define rt_strncmp(cs, ct, count)   strncmp(cs, ct, count)
+#define rt_strcmp(cs, ct)           strcmp(cs, ct)
+#define rt_strlen(src)              strlen(src)
+#endif /*RT_KSERVICE_USING_STDLIB*/
+
+#if !defined(RT_KSERVICE_USING_STDLIB) || defined(__ARMCC_VERSION)
 rt_size_t rt_strnlen(const char *s, rt_ubase_t maxlen);
-char *rt_strdup(const char *s);
-#if defined(__CC_ARM) || defined(__CLANG_ARM)
-/* leak strdup interface */
-char* strdup(const char* str);
-#endif
+#else
+#define rt_strnlen(s, maxlen)       strnlen(s, maxlen)
+#endif /* !defined(RT_KSERVICE_USING_STDLIB) || defined(__ARMCC_VERSION) */
 
-char *rt_strstr(const char *str1, const char *str2);
-rt_int32_t rt_sscanf(const char *buf, const char *fmt, ...);
-char *rt_strncpy(char *dest, const char *src, rt_ubase_t n);
-void *rt_memmove(void *dest, const void *src, rt_ubase_t n);
-rt_int32_t rt_memcmp(const void *cs, const void *ct, rt_ubase_t count);
-rt_int32_t rt_strcasecmp(const char *a, const char *b);
+#ifdef __ARMCC_VERSION
+/* MDK doesn't have these APIs */
+char* strdup(const char* str);
+rt_size_t strnlen(const char *s, rt_size_t maxlen);
+#endif /* __ARMCC_VERSION */
 
 void rt_show_version(void);
 
@@ -568,7 +655,7 @@ void rt_assert_handler(const char *ex, const char *func, rt_size_t line);
 #endif /* RT_DEBUG */
 
 #ifdef RT_USING_FINSH
-#include <finsh_api.h>
+#include <finsh.h>
 #endif
 
 /**@}*/