zephyr: Add Zephyr RTOS support

This commit add a RTOS called Zephyr[1].  This commit is Zephyr
specific code placed under src/arch/zephyr.  Because Zephyr's build
system is CMake based, this commit doesn't touch other build system
that libcsp supports, Meson and Waf.

To build it for Zephyr you will need Zephyr module code, which will
follow this commit.

This is preliminary and has some minor isues.

- rand_r() and sscanf() are not in Zephyr proper. We have them in
  arch/zephyr/csp_libc.c.  But it still generates implicit declaration
  warnings. For sscanf(), the function is empty and always fails.

- <endian.h> is not provided by the minimal libc. You have to use
  other libc or use the following PR.
  zephyrproject-rtos/zephyr#38939

[1]: https://zephyrproject.org/

Signed-off-by: Yasushi SHOJI <[email protected]>

Author: yashi

CMakeLists.txt

@@ -47,6 +47,8 @@ option(CSP_USE_DEDUP "Packet deduplication" ON)
 
 if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
   set(CSP_POSIX 1)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Zephyr")
+  set(CSP_ZEPHYR 1)
 endif()
 
 if(CMAKE_C_BYTE_ORDER STREQUAL "BIG_ENDIAN")
@@ -72,6 +74,8 @@ target_include_directories(libcsp PUBLIC ${csp_inc})
 
 if(CSP_POSIX)
   set(CSP_C_ARGS -Wshadow -Wcast-align -Wwrite-strings -Wno-unused-parameter)
+elseif(CSP_ZEPHYR)
+  set(CSP_C_ARGS -Wwrite-strings -Wno-unused-parameter)
 endif()
 target_compile_options(libcsp PRIVATE ${CSP_C_ARGS})
 

csp_autoconfig.h.in

@@ -1,4 +1,5 @@
 #cmakedefine01 CSP_POSIX
+#cmakedefine01 CSP_ZEPHYR
 
 #cmakedefine01 CSP_DEBUG
 #cmakedefine01 CSP_LOG_LEVEL_ERROR

include/csp/arch/csp_queue.h

@@ -71,6 +71,9 @@ csp_queue_handle_t csp_queue_create(int length, size_t item_size);
 
 #if (CSP_FREERTOS)
 typedef StaticQueue_t csp_static_queue_t;
+#elif (CSP_ZEPHYR)
+#include <zephyr.h>
+typedef struct k_msgq csp_static_queue_t;
 #else
 typedef void * csp_static_queue_t;
 #endif

include/csp/arch/csp_semaphore.h

@@ -90,6 +90,24 @@ typedef StaticSemaphore_t csp_mutex_buffer_t;
 
 #endif // CSP_FREERTOS
 
+/* Zephyr RTOS Interface */
+#if (CSP_ZEPHYR)
+
+#include <zephyr.h>
+
+#define CSP_SEMAPHORE_OK 	1
+#define CSP_SEMAPHORE_ERROR	2
+
+typedef struct k_mutex csp_mutex_t;
+typedef struct k_sem csp_bin_sem_handle_t;
+
+/* These types are not used for static API */
+struct csp_empty_t {};
+typedef struct csp_empty_t csp_mutex_buffer_t;
+typedef struct csp_empty_t csp_bin_sem_t;
+
+#endif // CSP_ZEPHYR
+
 /**
    Mutex call OK.
 

include/csp/arch/csp_thread.h

@@ -104,6 +104,23 @@ typedef csp_thread_return_t (* csp_thread_func_t)(void *);
 
 #endif // CSP_FREERTOS
 
+/*
+  Zephyr interface
+*/
+#if (CSP_ZEPHYR)
+
+#include <zephyr.h>
+
+typedef k_tid_t csp_thread_handle_t;
+typedef struct k_thread csp_thread_t;
+typedef k_thread_stack_t csp_stack_t;
+typedef k_thread_entry_t csp_thread_func_t;
+
+#define CSP_DEFINE_TASK(task_name) void task_name(void *p1, void *p2, void *p3)
+#define CSP_TASK_RETURN
+
+#endif // CSP_ZEPHYR
+
 /**
    Create thread (task).
 
@@ -117,6 +134,12 @@ typedef csp_thread_return_t (* csp_thread_func_t)(void *);
 */
 int csp_thread_create(csp_thread_func_t func, const char * const name, unsigned int stack_size, void * parameter, unsigned int priority, csp_thread_handle_t * handle);
 
+csp_thread_handle_t
+csp_thread_create_static(csp_thread_t *new_thread, const char * const name,
+			 csp_stack_t *stack, unsigned int stack_size,
+			 csp_thread_func_t func, void * parameter,
+			 unsigned int priority);
+
 /**
    Exit current thread.
    @note Not supported on all platforms.

src/arch/CMakeLists.txt

@@ -10,6 +10,9 @@ elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
 elseif(CMAKE_SYSTEM_NAME STREQUAL "FreeRTOS")
   set(CSP_FREERTOS 1)
   add_subdirectory(freertos)
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Zephyr")
+  set(CSP_Zephyr 1)
+  add_subdirectory(zephyr)
 else()
   message(FATAL_ERROR "invalid system ${CMAKE_SYSTEM_NAME}")
 endif()

src/arch/zephyr/CMakeLists.txt

@@ -0,0 +1,10 @@
+target_sources(libcsp PRIVATE
+  csp_clock.c
+  csp_libc.c
+  csp_queue.c
+  csp_semaphore.c
+  csp_system.c
+  csp_thread.c
+  csp_time.c
+  csp_zephyr_init.c
+  )

src/arch/zephyr/csp_clock.c

@@ -0,0 +1,56 @@
+/*
+ * Cubesat Space Protocol - A small network-layer protocol designed for Cubesats
+ * Copyright (C) 2021 Space Cubics, LLC.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <csp/arch/csp_clock.h>
+
+#include <zephyr.h>
+#include <posix/time.h>
+#include <logging/log.h>
+LOG_MODULE_DECLARE(libcsp);
+
+__attribute__((weak)) void csp_clock_get_time(csp_timestamp_t *time)
+{
+	struct timespec ts;
+	int ret;
+
+	ret = clock_gettime(CLOCK_REALTIME, &ts);
+	if (ret < 0) {
+		LOG_WRN("clock_gettime() failed, retruning with 0s");
+		time->tv_sec = 0;
+		time->tv_nsec = 0;
+	} else {
+		time->tv_sec = ts.tv_sec;
+		time->tv_nsec = ts.tv_nsec;
+	}
+}
+
+__attribute__((weak)) int csp_clock_set_time(const csp_timestamp_t *time)
+{
+	int ret;
+	struct timespec ts;
+
+	ts.tv_sec = time->tv_sec;
+	ts.tv_nsec = time->tv_nsec;
+
+	ret = clock_settime(CLOCK_REALTIME, &ts);
+	if (ret < 0) {
+		return CSP_ERR_INVAL;
+	}
+
+	return CSP_ERR_NONE;
+}

src/arch/zephyr/csp_libc.c

@@ -0,0 +1,30 @@
+/*
+ * Cubesat Space Protocol - A small network-layer protocol designed for Cubesats
+ * Copyright (C) 2021 Space Cubics, LLC.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+
+int sscanf(const char *s, const char *format, ...)
+{
+	return 0;
+}
+
+int rand_r(unsigned int *seedp)
+{
+	srand(*seedp);
+	return rand();
+}

src/arch/zephyr/csp_queue.c

@@ -0,0 +1,102 @@
+/*
+ * Cubesat Space Protocol - A small network-layer protocol designed for Cubesats
+ * Copyright (C) 2021 Space Cubics, LLC.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <csp/arch/csp_queue.h>
+
+#include <zephyr.h>
+#include <logging/log.h>
+LOG_MODULE_DECLARE(libcsp);
+
+csp_queue_handle_t csp_queue_create_static(int length, size_t item_size,
+					   char *buf, csp_static_queue_t *queue)
+{
+	struct k_msgq *q = (struct k_msgq *)queue;
+
+	k_msgq_init(q, buf, item_size, length);
+
+	return q;
+}
+
+static int csp_errno_zephyr_to_csp(int err)
+{
+	int ret;
+
+	if (err == 0) {
+		ret = CSP_QUEUE_OK;
+	} else {
+		ret = CSP_QUEUE_ERROR;
+	}
+
+	return ret;
+}
+
+int csp_queue_enqueue(csp_queue_handle_t queue, const void * value, uint32_t timeout)
+{
+	int ret;
+	struct k_msgq *q = (struct k_msgq *)queue;
+
+	ret = k_msgq_put(q, value, K_MSEC(timeout));
+
+	return csp_errno_zephyr_to_csp(ret);
+}
+
+int csp_queue_enqueue_isr(csp_queue_handle_t queue, const void *value, int *unused)
+{
+	int ret;
+	struct k_msgq *q = (struct k_msgq *)queue;
+
+	ARG_UNUSED(unused);
+
+	ret = k_msgq_put(q, value, K_NO_WAIT);
+
+	return csp_errno_zephyr_to_csp(ret);
+}
+
+int csp_queue_dequeue(csp_queue_handle_t queue, void * buf, uint32_t timeout)
+{
+	int ret;
+	struct k_msgq *q = (struct k_msgq *)queue;
+
+	ret = k_msgq_get(q, buf, K_MSEC(timeout));
+
+	return csp_errno_zephyr_to_csp(ret);
+}
+
+int csp_queue_dequeue_isr(csp_queue_handle_t queue, void *buf, int *unused)
+{
+	int ret;
+	struct k_msgq *q = (struct k_msgq *)queue;
+
+	ARG_UNUSED(unused);
+
+	ret = k_msgq_get(q, buf, K_NO_WAIT);
+
+	return csp_errno_zephyr_to_csp(ret);
+}
+
+int csp_queue_size(csp_queue_handle_t queue)
+{
+	struct k_msgq *q = (struct k_msgq *)queue;
+
+	return k_msgq_num_used_get(q);
+}
+
+int csp_queue_size_isr(csp_queue_handle_t queue)
+{
+	return csp_queue_size(queue);
+}