pure sdk for main

2025-08-27 09:51:58 +01:00
parent f0d033f1c9
commit 0571416e7c
3283 changed files with 1577720 additions and 1 deletions
@@ -0,0 +1,380 @@
+/*
+ * Copyright (c) 2017 Simon Goldschmidt
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the lwIP TCP/IP stack.
+ *
+ * Author: Simon Goldschmidt
+ *
+ */
+
+
+#include <lwip/opt.h>
+#include <lwip/arch.h>
+#if !NO_SYS
+#include <lwip/sys_arch.h>
+#endif
+#include <lwip/stats.h>
+#include <lwip/debug.h>
+#include <lwip/sys.h>
+
+#include <string.h>
+
+/* lwIP includes. */
+#include "lwip/opt.h"
+#include "lwip/debug.h"
+#include "lwip/def.h"
+#include "lwip/sys.h"
+#include "lwip/mem.h"
+
+/* unify os includes. */
+#include "osal/msgqueue.h"
+#include "osal/mutex.h"
+#include "osal/semaphore.h"
+#include "osal/task.h"
+#include "osal/timer.h"
+#include "osal/sleep.h"
+#include "osal/irq.h"
+
+
+u32_t lwip_sys_now = 0;
+static u32_t thread_pool_index = 0;
+static struct os_task thread_pool[LWIP_SYS_THREAD_POOL_N];
+static const u32_t null_mesg;
+static struct os_mutex lwip_sys_mutex;
+
+u32_t
+sys_jiffies(void)
+{
+    lwip_sys_now += 1 + (sys_now() / 10000);
+    return lwip_sys_now;
+}
+
+u32_t
+sys_now(void)
+{
+    return os_jiffies_to_msecs(os_jiffies());
+}
+
+void
+sys_init(void)
+{
+    s32_t ret = 0;
+    lwip_sys_now = 0;
+    ret = os_mutex_init(&lwip_sys_mutex);
+    ASSERT(!ret);
+}
+
+#if !NO_SYS
+
+void sys_msleep(u32_t ms)
+{
+    os_sleep_ms(ms);
+}
+
+err_t
+sys_sem_new(sys_sem_t *sem, u8_t count)
+{
+    ASSERT(sem);
+    memset(sem, 0, sizeof(sys_sem_t));
+    if (RET_OK != os_sema_init(&sem->sem, count)) {
+        lwip_printf("sys_sem_new create error\n");
+        return RET_ERR;
+    }
+    sem->sem_vaild = TRUE;
+    return ERR_OK;
+}
+
+void
+sys_sem_free(sys_sem_t *sem)
+{
+    LWIP_ASSERT("sem != NULL", sem != NULL);
+    if (RET_OK != os_sema_del(&sem->sem)) {
+        lwip_printf("sys_sem_free error!");
+        ASSERT(0);
+    }
+    sem->sem_vaild = FALSE;
+}
+
+void
+sys_sem_set_invalid(sys_sem_t *sem)
+{
+    LWIP_ASSERT("sem != NULL", sem != NULL);
+    sem->sem_vaild = FALSE;
+}
+
+/* semaphores are 1-based because RAM is initialized as 0, which would be valid */
+u32_t
+sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
+{
+    LWIP_ASSERT("sem != NULL", sem != NULL);
+    LWIP_ASSERT("sem->sem_vaild != NULL", sem->sem_vaild != FALSE);
+    u32_t start = sys_now();
+
+    if (os_sema_down(&sem->sem, (timeout != 0) ? (timeout) : (osWaitForever)) < 1) {
+        return SYS_ARCH_TIMEOUT;
+    }
+    return (DIFF_JIFFIES(start, sys_now())) / 1000;
+}
+
+void
+sys_sem_signal(sys_sem_t *sem)
+{
+    LWIP_ASSERT("sem != NULL", sem != NULL);
+    LWIP_ASSERT("sem->sem_vaild != NULL", sem->sem_vaild != FALSE);
+    os_sema_up(&sem->sem);
+}
+
+err_t
+sys_mutex_new(sys_mutex_t *mutex)
+{
+    LWIP_ASSERT("mutex != NULL", mutex != NULL);
+    memset(mutex,0,sizeof(sys_mutex_t));
+    if (RET_OK != os_mutex_init(&mutex->mutex)) {
+        lwip_printf("sys_mutex_new error\n");
+        return ERR_MEM;
+    }
+    mutex->mutex_vaild = TRUE;
+    return ERR_OK;
+}
+
+void
+sys_mutex_free(sys_mutex_t *mutex)
+{
+    /* parameter check */
+    LWIP_ASSERT("mutex != NULL", mutex != NULL);
+    if (RET_OK != os_mutex_del(&mutex->mutex)) {
+        lwip_printf("sys_mutex_free error\n");
+    }
+    mutex->mutex_vaild = FALSE;
+}
+
+void
+sys_mutex_set_invalid(sys_mutex_t *mutex)
+{
+    LWIP_ASSERT("mutex != NULL", mutex != NULL);
+    mutex->mutex_vaild = FALSE;
+}
+
+void
+sys_mutex_lock(sys_mutex_t *mutex)
+{
+    /* nothing to do, no multithreading supported */
+    LWIP_ASSERT("mutex != NULL", mutex != NULL);
+    LWIP_ASSERT("mutex->mutex_vaild != FALSE", mutex->mutex_vaild != FALSE);
+    /* check that the mutext is valid and unlocked (no nested locking) */
+    os_mutex_lock(&mutex->mutex, osWaitForever);
+}
+
+void
+sys_mutex_unlock(sys_mutex_t *mutex)
+{
+    /* nothing to do, no multithreading supported */
+    LWIP_ASSERT("mutex != NULL", mutex != NULL);
+    LWIP_ASSERT("mutex->mutex_vaild != FALSE", mutex->mutex_vaild != FALSE);
+    /* we count down just to check the correct pairing of lock/unlock */
+    os_mutex_unlock(&mutex->mutex);
+}
+
+
+sys_thread_t
+sys_thread_new(const char *name, lwip_thread_fn function, void *arg, int stacksize, int prio)
+{
+	lwip_printf("Check para:name:%s,handle:%p,arg:%p,size:%d,proi:%x\n",
+            name,function,arg,stacksize,prio);
+    /* threads not supported */
+    ASSERT(stacksize > 0);
+
+    sys_thread_t task_hdl = NULL;
+
+    if (thread_pool_index >= LWIP_SYS_THREAD_POOL_N) {
+        //error handle?
+        lwip_printf("calling sys_thread_new too much\n");
+        return NULL;
+    }
+    task_hdl = (sys_thread_t)&thread_pool[thread_pool_index];
+    thread_pool_index++;
+
+    LWIP_DEBUGF(SYS_DEBUG, ("New Thread: %s\n", name));
+
+    OS_TASK_INIT(name, task_hdl, function, *((uint32 *)arg), prio, stacksize);
+
+    return task_hdl;
+}
+
+err_t
+sys_mbox_new(sys_mbox_t *mbox, int size)
+{
+    LWIP_ASSERT("mbox != NULL", mbox != NULL);
+    LWIP_ASSERT("size > 0", size > 0);
+    memset(mbox,0,sizeof(sys_mbox_t));
+    if (RET_OK == os_msgq_init(&mbox->msgq, size)) {
+        mbox->mbox_vaild = TRUE;
+        return ERR_OK;
+    } else {
+        lwip_printf("os_msgq_init error!\n");
+        return ERR_MEM;
+    }
+}
+
+void
+sys_mbox_free(sys_mbox_t *mbox)
+{
+    /* parameter check */
+    LWIP_ASSERT("mbox != NULL", mbox != NULL);
+
+    os_msgq_del(&mbox->msgq);
+    mbox->mbox_vaild = FALSE;
+}
+
+void
+sys_mbox_set_invalid(sys_mbox_t *mbox)
+{
+    LWIP_ASSERT("mbox != NULL", mbox != NULL);
+    mbox->mbox_vaild =  FALSE;
+}
+
+void
+sys_mbox_post(sys_mbox_t *q, void *msg)
+{
+    LWIP_ASSERT("q != NULL", q != NULL);
+    LWIP_ASSERT("q->mbox_vaild != FALSE", q->mbox_vaild != FALSE);
+
+    if (msg == NULL) {
+        msg = (void *)&null_mesg;
+    }
+    os_msgq_put(&q->msgq, (u32_t)msg, osWaitForever);
+}
+
+err_t
+sys_mbox_trypost(sys_mbox_t *q, void *msg)
+{
+    LWIP_ASSERT("q != NULL", q != NULL);
+    LWIP_ASSERT("q->mbox_vaild != FALSE", q->mbox_vaild != FALSE);
+	
+    if (msg == NULL) {
+        msg = (void *)&null_mesg;
+    }
+    return (ERR_OK == os_msgq_put(&q->msgq, (u32_t)msg, 0)) ? (ERR_OK) : (ERR_MEM);
+}
+
+err_t
+sys_mbox_trypost_fromisr(sys_mbox_t *q, void *msg)
+{
+    return sys_mbox_trypost(q, msg);
+}
+
+u32_t
+sys_arch_mbox_fetch(sys_mbox_t *q, void **msg, u32_t timeout)
+{
+    u32_t start     = sys_now();
+    u32_t handle    = 0;
+    LWIP_ASSERT("q != NULL", q != NULL);
+    LWIP_ASSERT("q->mbox_vaild != FALSE", q->mbox_vaild != FALSE);
+
+    handle = os_msgq_get(&q->msgq, (timeout != 0) ? (timeout) : (osWaitForever));
+
+    if (handle != 0) {
+        if (handle == (u32_t)&null_mesg) {
+            *msg = NULL;
+        } else {
+            *msg = (void *)handle;
+        }
+    } else {
+        return SYS_ARCH_TIMEOUT;
+    }
+    return (DIFF_JIFFIES(sys_now(), start)) >> 10;
+}
+
+
+u32_t
+sys_arch_mbox_tryfetch(sys_mbox_t *q, void **msg)
+{
+    LWIP_ASSERT("q != NULL", q != NULL);
+    LWIP_ASSERT("q->mbox_vaild != FALSE", q->mbox_vaild != FALSE);
+
+    uint32 handle = 0;
+    handle = os_msgq_get(&q->msgq, 0);
+
+    if (handle != 0) {
+        if (handle == (u32_t)&null_mesg) {
+            *msg = NULL;
+        } else {
+            *msg = (void *)handle;
+        }
+    } else {
+        return SYS_ARCH_TIMEOUT;
+    }
+    return ERR_OK;
+}
+
+/*---------------------------------------------------------------------------*
+ * Routine:  sys_arch_protect
+ *---------------------------------------------------------------------------*
+ * Description:
+ *      This optional function does a "fast" critical region protection and
+ *      returns the previous protection level. This function is only called
+ *      during very short critical regions. An embedded system which supports
+ *      ISR-based drivers might want to implement this function by disabling
+ *      interrupts. Task-based systems might want to implement this by using
+ *      a mutex or disabling tasking. This function should support recursive
+ *      calls from the same task or interrupt. In other words,
+ *      sys_arch_protect() could be called while already protected. In
+ *      that case the return value indicates that it is already protected.
+ *
+ *      sys_arch_protect() is only required if your port is supporting an
+ *      operating system.
+ * Outputs:
+ *      sys_prot_t              -- Previous protection level (not used here)
+ *---------------------------------------------------------------------------*/
+sys_prot_t sys_arch_protect(void)
+{   
+    //return disable_irq();
+    return os_mutex_lock(&lwip_sys_mutex, osWaitForever);
+}
+
+/*---------------------------------------------------------------------------*
+ * Routine:  sys_arch_unprotect
+ *---------------------------------------------------------------------------*
+ * Description:
+ *      This optional function does a "fast" set of critical region
+ *      protection to the value specified by pval. See the documentation for
+ *      sys_arch_protect() for more information. This function is only
+ *      required if your port is supporting an operating system.
+ * Inputs:
+ *      sys_prot_t              -- Previous protection level (not used here)
+ *---------------------------------------------------------------------------*/
+void sys_arch_unprotect(sys_prot_t p)
+{
+    //enable_irq(p);
+    os_mutex_unlock(&lwip_sys_mutex);
+}
+
+
+#if LWIP_NETCONN_SEM_PER_THREAD
+#error LWIP_NETCONN_SEM_PER_THREAD==1 not supported
+#endif /* LWIP_NETCONN_SEM_PER_THREAD */
+
+#endif /* !NO_SYS */