summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 260a1ff)
raw | patch | inline | side by side (parent: 260a1ff)
author | Vaibhav Jindal <v-jindal@ti.com> | |
Thu, 12 Jan 2023 17:38:28 +0000 (23:08 +0530) | ||
committer | Misael Lopez Cruz <misael.lopez@ti.com> | |
Tue, 31 Jan 2023 09:13:20 +0000 (03:13 -0600) |
- added sys_arch.c for safertos, implements native api similar to freertos
- added required lwippools.h and lwipopts.h,
to add required macros and lwip memory pools
- added sys_arch.h, perf.h and cc.h,
to add required structures and function definitions
Signed-off-by: Vaibhav Jindal <v-jindal@ti.com>
- added required lwippools.h and lwipopts.h,
to add required macros and lwip memory pools
- added sys_arch.h, perf.h and cc.h,
to add required structures and function definitions
Signed-off-by: Vaibhav Jindal <v-jindal@ti.com>
packages/ti/transport/lwip/lwip-port/makefile | patch | blob | history | |
packages/ti/transport/lwip/lwip-port/safertos/include/arch/cc.h | [new file with mode: 0644] | patch | blob |
packages/ti/transport/lwip/lwip-port/safertos/include/arch/perf.h | [new file with mode: 0644] | patch | blob |
packages/ti/transport/lwip/lwip-port/safertos/include/arch/sys_arch.h | [new file with mode: 0644] | patch | blob |
packages/ti/transport/lwip/lwip-port/safertos/include/lwipopts.h | [new file with mode: 0644] | patch | blob |
packages/ti/transport/lwip/lwip-port/safertos/include/lwippools.h | [new file with mode: 0644] | patch | blob |
packages/ti/transport/lwip/lwip-port/safertos/sys_arch.c | [new file with mode: 0644] | patch | blob |
packages/ti/transport/lwip/lwip_component.mk | patch | blob | history | |
packages/ti/transport/lwip/makefile_contrib | patch | blob | history | |
packages/ti/transport/lwip/makefile_stack | patch | blob | history |
diff --git a/packages/ti/transport/lwip/lwip-port/makefile b/packages/ti/transport/lwip/lwip-port/makefile
index 0829a8e0f0e45cfcd90588694939de05e234c8b7..af154e2bae950aabf6a24f6affa903b5800b0476 100644 (file)
ifeq ($(BUILD_OS_TYPE),freertos)
ENET_CFLAGS += -DFREERTOS
+else ifeq ($(BUILD_OS_TYPE),safertos)
+ ENET_CFLAGS += -DSAFERTOS
endif
# List all the external components/interfaces, whose interface header files
ifeq ($(BUILD_OS_TYPE),freertos)
INCLUDE_EXTERNAL_INTERFACES = pdk osal freertos
endif
+ifeq ($(BUILD_OS_TYPE),safertos)
+ INCLUDE_EXTERNAL_INTERFACES = pdk osal safertos
+endif
ifeq ($(BUILD_OS_TYPE),tirtos)
INCLUDE_EXTERNAL_INTERFACES = pdk xdc osal bios
endif
diff --git a/packages/ti/transport/lwip/lwip-port/safertos/include/arch/cc.h b/packages/ti/transport/lwip/lwip-port/safertos/include/arch/cc.h
--- /dev/null
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
+ * 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: Adam Dunkels <adam@sics.se>
+ *
+ */
+#ifndef LWIP_ARCH_CC_H
+#define LWIP_ARCH_CC_H
+
+/* std.h functions required */
+#include <stdint.h>
+
+/* Disable lwIP's private definition of 'struct timeval' */
+#define LWIP_TIMEVAL_PRIVATE 0
+#include <sys/select.h>
+
+/* Define byte order of the system */
+#define BYTE_ORDER LITTLE_ENDIAN
+
+/* Use lwip provided errors as ti compiler is too granular*/
+#define LWIP_PROVIDE_ERRNO 1
+
+#define LWIP_RAND() ((u32_t)rand())
+
+/* Setup Packing Macros */
+#define PACK_STRUCT_BEGIN
+#define PACK_STRUCT_STRUCT __attribute__ ((__packed__))
+#define PACK_STRUCT_END
+#define PACK_STRUCT_FIELD(x) x
+
+/* Different handling for unit test, normally not needed */
+#ifdef LWIP_NOASSERT_ON_ERROR
+#define LWIP_ERROR(message, expression, handler) do { if (!(expression)) { \
+ handler;}} while(0)
+#endif
+
+struct sio_status_s;
+typedef struct sio_status_s sio_status_t;
+#define sio_fd_t sio_status_t*
+#define __sio_fd_t_defined
+
+typedef uint32_t sys_prot_t;
+
+#endif /* LWIP_ARCH_CC_H */
diff --git a/packages/ti/transport/lwip/lwip-port/safertos/include/arch/perf.h b/packages/ti/transport/lwip/lwip-port/safertos/include/arch/perf.h
--- /dev/null
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
+ * 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: Adam Dunkels <adam@sics.se>
+ *
+ */
+ /*
+ * Optional file defined to make architecture specific measurements.
+ * PERF_START => Start measurement
+ * PERF_STOP(x) => Stop measurement, and record result
+ * Define functions required in perf.c in src/ if required
+ */
+#ifndef LWIP_ARCH_PERF_H
+#define LWIP_ARCH_PERF_H
+
+#include <sys/times.h>
+
+#define PERF_START do { ;} while(0) /* null definition */
+#define PERF_STOP(x) do { ;} while(0) /* null definition */
+
+void perf_print(unsigned long c1l, unsigned long c1h,
+ unsigned long c2l, unsigned long c2h,
+ char *key);
+
+void perf_print_times(struct tms *start, struct tms *end, char *key);
+
+void perf_init(char *fname);
+
+#endif /* LWIP_ARCH_PERF_H */
diff --git a/packages/ti/transport/lwip/lwip-port/safertos/include/arch/sys_arch.h b/packages/ti/transport/lwip/lwip-port/safertos/include/arch/sys_arch.h
--- /dev/null
@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) Texas Instruments Incorporated 2022
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 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.
+ *
+ * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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 COPYRIGHT
+ * OWNER OR CONTRIBUTORS 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.
+ */
+#ifndef LWIP_ARCH_SYS_ARCH_H
+#define LWIP_ARCH_SYS_ARCH_H
+
+#include <stdbool.h>
+#include "lwip/opt.h"
+#include "lwip/arch.h"
+#include "SafeRTOS_API.h"
+#include <ti/osal/QueueP.h>
+
+#define LWIP_SYSARCH_SAFERTOS_MAX2(a,b) ((a) > (b) ? (a) : (b))
+#define LWIP_SYSARCH_SAFERTOS_MAX4(a,b,c,d) (LWIP_SYSARCH_SAFERTOS_MAX2(LWIP_SYSARCH_SAFERTOS_MAX2(a,b),LWIP_SYSARCH_SAFERTOS_MAX2(c,d)))
+#define LWIP_SYSARCH_SAFERTOS_MAX5(a,b,c,d,e) (LWIP_SYSARCH_SAFERTOS_MAX2(LWIP_SYSARCH_SAFERTOS_MAX4(a,b,c,d),e))
+
+#define LWIP_SAFERTOS_MBOX_MAX_MSGCOUNT (LWIP_SYSARCH_SAFERTOS_MAX5(DEFAULT_ACCEPTMBOX_SIZE, \
+ DEFAULT_UDP_RECVMBOX_SIZE, \
+ DEFAULT_RAW_RECVMBOX_SIZE, \
+ DEFAULT_TCP_RECVMBOX_SIZE, \
+ TCPIP_MBOX_SIZE))
+
+void sys_arch_msleep(u32_t delay_ms);
+#define sys_msleep(ms) sys_arch_msleep(ms)
+
+#if !LWIP_COMPAT_MUTEX
+typedef struct _sys_mut {
+ uint64_t mutObj[((safertosapiQUEUE_OVERHEAD_BYTES/sizeof(uint64_t)) + 1)];
+ xMutexHandleType mutHndl;
+} sys_mutex_t;
+
+#define sys_mutex_valid_val(mutex) ((mutex).mutHndl != NULL)
+#define sys_mutex_valid(mutex) (((mutex) != NULL) && sys_mutex_valid_val(*(mutex)))
+#define sys_mutex_set_invalid(mutex) ((mutex)->mutHndl = NULL)
+#endif /* !LWIP_COMPAT_MUTEX */
+
+typedef struct _sys_sem {
+ uint64_t semObj[((safertosapiQUEUE_OVERHEAD_BYTES/sizeof(uint64_t)) + 1)];
+ xSemaphoreHandle semHndl;
+} sys_sem_t;
+
+#define sys_sem_valid_val(sema) ((sema).semHndl != NULL)
+#define sys_sem_valid(sema) (((sema) != NULL) && sys_sem_valid_val(*(sema)))
+#define sys_sem_set_invalid(sema) ((sema)->semHndl = NULL)
+
+typedef struct _sys_mbox {
+ /* Handle through which queue can be referenced */
+ xQueueHandle mailboxHndl;
+ /* Buffer memory */
+ uint64_t queueBuf[((((sizeof(void *) * LWIP_SAFERTOS_MBOX_MAX_MSGCOUNT) + safertosapiQUEUE_OVERHEAD_BYTES)/sizeof(uint64_t)) + 1)];
+} sys_mbox_t;
+
+#define sys_mbox_valid_val(mbox) ((mbox).mailboxHndl != NULL)
+#define sys_mbox_valid(mbox) (((mbox) != NULL) && sys_mbox_valid_val(*(mbox)))
+#define sys_mbox_set_invalid(mbox) ((mbox)->mailboxHndl = NULL)
+
+/* Threads */
+typedef struct _sys_thread {
+ void *thread_handle;
+} sys_thread_t;
+
+struct sys_thread_state {
+ QueueP_Elem queueElement;
+ xTCB tcb;
+ portInt8Type tStack[LWIP_SAFERTOS_MAX_TASK_STACK_SIZE] __attribute__((aligned(LWIP_SAFERTOS_MAX_TASK_STACK_SIZE)));
+ sys_sem_t tlsSemObj;
+};
+
+#if LWIP_NETCONN_SEM_PER_THREAD
+sys_sem_t *sys_arch_netconn_sem_get(void);
+void sys_arch_netconn_sem_alloc(void);
+void sys_arch_netconn_sem_free(void);
+#define LWIP_NETCONN_THREAD_SEM_GET() sys_arch_netconn_sem_get()
+#define LWIP_NETCONN_THREAD_SEM_ALLOC() sys_arch_netconn_sem_alloc()
+#define LWIP_NETCONN_THREAD_SEM_FREE() sys_arch_netconn_sem_free()
+#endif /* LWIP_NETCONN_SEM_PER_THREAD */
+
+#endif /* LWIP_ARCH_SYS_ARCH_H */
diff --git a/packages/ti/transport/lwip/lwip-port/safertos/include/lwipopts.h b/packages/ti/transport/lwip/lwip-port/safertos/include/lwipopts.h
--- /dev/null
@@ -0,0 +1,470 @@
+/*
+ * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
+ * 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: Adam Dunkels <adam@sics.se>
+ *
+ */
+
+/**
+ * Copyright (c) Texas Instruments Incorporated 2022
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 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.
+ *
+ * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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 COPYRIGHT
+ * OWNER OR CONTRIBUTORS 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.
+ */
+#ifndef LWIP_LWIPOPTS_H
+#define LWIP_LWIPOPTS_H
+
+#ifdef LWIP_OPTTEST_FILE
+#include "lwipopts_test.h"
+#else /* LWIP_OPTTEST_FILE */
+
+#define LWIP_IPV4 1
+#define LWIP_IPV6 0
+
+#define NO_SYS 0
+#define LWIP_SOCKET (NO_SYS==0)
+#define LWIP_NETCONN (NO_SYS==0)
+#define LWIP_NETIF_API (NO_SYS==0)
+
+#define LWIP_IGMP LWIP_IPV4
+#define LWIP_ICMP LWIP_IPV4
+
+#define LWIP_DNS LWIP_UDP
+#define LWIP_MDNS_RESPONDER LWIP_UDP
+
+#define LWIP_NUM_NETIF_CLIENT_DATA (LWIP_MDNS_RESPONDER)
+
+#define LWIP_HAVE_LOOPIF 1
+#define LWIP_NETIF_LOOPBACK 1
+#define LWIP_LOOPBACK_MAX_PBUFS 10
+
+#define TCP_LISTEN_BACKLOG 1
+
+#define LWIP_COMPAT_SOCKETS 1
+#define LWIP_SO_RCVTIMEO 1
+#define LWIP_SO_RCVBUF 1
+
+#define LWIP_TCPIP_CORE_LOCKING 1
+//#define LOCK_TCPIP_CORE 1
+
+#define LWIP_NETIF_LINK_CALLBACK 1
+#define LWIP_NETIF_STATUS_CALLBACK 1
+#define LWIP_NETIF_EXT_STATUS_CALLBACK 1
+
+#define LWIP_DEBUG 0
+
+#ifdef LWIP_DEBUG
+
+#define LWIP_DBG_MIN_LEVEL 0
+#define PPP_DEBUG LWIP_DBG_OFF
+#define MEM_DEBUG LWIP_DBG_OFF
+#define MEMP_DEBUG LWIP_DBG_OFF
+#define PBUF_DEBUG LWIP_DBG_OFF
+#define API_LIB_DEBUG LWIP_DBG_OFF
+#define API_MSG_DEBUG LWIP_DBG_OFF
+#define TCPIP_DEBUG LWIP_DBG_OFF
+#define NETIF_DEBUG LWIP_DBG_OFF
+#define SOCKETS_DEBUG LWIP_DBG_OFF
+#define DNS_DEBUG LWIP_DBG_OFF
+#define AUTOIP_DEBUG LWIP_DBG_OFF
+#define DHCP_DEBUG LWIP_DBG_OFF
+#define IP_DEBUG LWIP_DBG_OFF
+#define IP_REASS_DEBUG LWIP_DBG_OFF
+#define ICMP_DEBUG LWIP_DBG_OFF
+#define IGMP_DEBUG LWIP_DBG_OFF
+#define UDP_DEBUG LWIP_DBG_OFF
+#define TCP_DEBUG LWIP_DBG_OFF
+#define TCP_INPUT_DEBUG LWIP_DBG_OFF
+#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF
+#define TCP_RTO_DEBUG LWIP_DBG_OFF
+#define TCP_CWND_DEBUG LWIP_DBG_OFF
+#define TCP_WND_DEBUG LWIP_DBG_OFF
+#define TCP_FR_DEBUG LWIP_DBG_OFF
+#define TCP_QLEN_DEBUG LWIP_DBG_OFF
+#define TCP_RST_DEBUG LWIP_DBG_OFF
+#endif
+
+#define LWIP_DBG_TYPES_ON (LWIP_DBG_ON|LWIP_DBG_TRACE|LWIP_DBG_STATE|LWIP_DBG_FRESH|LWIP_DBG_HALT)
+
+
+/* ---------- Memory options ---------- */
+/* MEM_ALIGNMENT: should be set to the alignment of the CPU for which
+ lwIP is compiled. 4 byte alignment -> define MEM_ALIGNMENT to 4, 2
+ byte alignment -> define MEM_ALIGNMENT to 2. */
+/* MSVC port: intel processors don't need 4-byte alignment,
+ but are faster that way! */
+#define MEM_ALIGNMENT 128U
+
+#define MEM_USE_POOLS 1
+#define MEMP_USE_CUSTOM_POOLS 1
+
+/* MEM_SIZE: the size of the heap memory. If the application will send
+a lot of data that needs to be copied, this should be set high. */
+#define MEM_SIZE 10240
+
+/* Debug checks - will impact throughput if enabled */
+#define MEM_OVERFLOW_CHECK (0)
+#define MEM_SANITY_CHECK (0)
+
+/* MEMP_NUM_PBUF: the number of memp struct pbufs. If the application
+ sends a lot of data out of ROM (or other static memory), this
+ should be set high. */
+#define MEMP_NUM_PBUF 128
+/* MEMP_NUM_RAW_PCB: the number of UDP protocol control blocks. One
+ per active RAW "connection". */
+#define MEMP_NUM_RAW_PCB 3
+/* MEMP_NUM_UDP_PCB: the number of UDP protocol control blocks. One
+ per active UDP "connection". */
+#define MEMP_NUM_UDP_PCB 4
+/* MEMP_NUM_TCP_PCB: the number of simulatenously active TCP
+ connections. */
+#define MEMP_NUM_TCP_PCB 5
+/* MEMP_NUM_TCP_PCB_LISTEN: the number of listening TCP
+ connections. */
+#define MEMP_NUM_TCP_PCB_LISTEN 8
+/* MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP
+ segments. */
+#define MEMP_NUM_TCP_SEG 128
+/* MEMP_NUM_SYS_TIMEOUT: the number of simulateously active
+ timeouts. */
+#define MEMP_NUM_SYS_TIMEOUT 17
+
+/* The following four are used only with the sequential API and can be
+ set to 0 if the application only will use the raw API. */
+/* MEMP_NUM_NETBUF: the number of struct netbufs. */
+#define MEMP_NUM_NETBUF 128
+/* MEMP_NUM_NETCONN: the number of struct netconns. */
+#define MEMP_NUM_NETCONN 10
+/* MEMP_NUM_TCPIP_MSG_*: the number of struct tcpip_msg, which is used
+ for sequential API communication and incoming packets. Used in
+ src/api/tcpip.c. */
+#define MEMP_NUM_TCPIP_MSG_API 128
+#define MEMP_NUM_TCPIP_MSG_INPKT 128
+
+/* Debug checks - will impact throughput if enabled */
+#define MEMP_OVERFLOW_CHECK (0)
+#define MEMP_SANITY_CHECK (0)
+
+/* ---------- Pbuf options ---------- */
+
+/*
+ * PBUF_POOL_SIZE: the number of buffers in the pbuf pool.
+ *
+ * The buffer pool size should taken into account the following requirements:
+ * - TX channel requires LWIP2ENET_TX_PACKETS pbufs
+ * - Each RX channel/flows requires (2 x LWIP2ENET_RX_PACKETS) to avoid running out of
+ * free pbufs to new packets
+ *
+ * PBUF_POOL_SIZE = tx + ((2 * rx) * n)
+ *
+ * For 64 packets per channel and considering 2 RX channels (i.e. j721e):
+ * PBUF_POOL_SIZE = 64 + ((2 * 64) * 2)
+ * PBUF_POOL_SIZE = 320
+ */
+#define PBUF_POOL_SIZE (320U)
+
+/* PBUF_POOL_BUFSIZE: the size of each pbuf in the pbuf pool. */
+#define PBUF_POOL_BUFSIZE (1536U)
+
+/** SYS_LIGHTWEIGHT_PROT
+ * define SYS_LIGHTWEIGHT_PROT in lwipopts.h if you want inter-task protection
+ * for certain critical regions during buffer allocation, deallocation and memory
+ * allocation and deallocation.
+ */
+#define SYS_LIGHTWEIGHT_PROT (NO_SYS==0)
+
+
+/* ---------- TCP options ---------- */
+#define LWIP_TCP 1
+#define TCP_TTL 255
+
+#define LWIP_ALTCP (LWIP_TCP)
+#ifdef LWIP_HAVE_MBEDTLS
+#define LWIP_ALTCP_TLS (LWIP_TCP)
+#define LWIP_ALTCP_TLS_MBEDTLS (LWIP_TCP)
+#endif
+
+/* Length of TCP queue equal to number of listening connections +
+ number of segments to receive*/
+#define TCPIP_MBOX_SIZE (MEMP_NUM_TCP_PCB_LISTEN + MEMP_NUM_TCP_SEG)
+
+/* Number of TCP packets queued for receiving by each TCP connection*/
+#define DEFAULT_TCP_RECVMBOX_SIZE (MEMP_NUM_TCP_SEG)
+
+/* Controls if TCP should queue segments that arrive out of
+ order. Define to 0 if your device is low on memory. */
+#define TCP_QUEUE_OOSEQ 1
+
+/* TCP Maximum segment size. */
+#define TCP_MSS 1460
+
+/* TCP sender buffer space (bytes). */
+#define TCP_SND_BUF (16 * TCP_MSS)
+
+/* TCP sender buffer space (pbufs). This must be at least = 2 *
+ TCP_SND_BUF/TCP_MSS for things to work. */
+#define TCP_SND_QUEUELEN (8 * TCP_SND_BUF/TCP_MSS)
+
+/* TCP writable space (bytes). This must be less than or equal
+ to TCP_SND_BUF. It is the amount of space which must be
+ available in the tcp snd_buf for select to return writable */
+#define TCP_SNDLOWAT (TCP_SND_BUF/2)
+
+/* TCP receive window. */
+#define TCP_WND (20 * 1024)
+
+/* Maximum number of retransmissions of data segments. */
+#define TCP_MAXRTX 12
+
+/* Maximum number of retransmissions of SYN segments. */
+#define TCP_SYNMAXRTX 4
+
+#define DEFAULT_THREAD_STACKSIZE (8 * 1024)
+#define TCPIP_THREAD_STACKSIZE (16 * 1024)
+
+//#define LWIP_SAFERTOS_THREAD_STACKSIZE_IS_STACKWORDS (1)
+
+/* ---------- ARP options ---------- */
+#define LWIP_ARP 1
+#define ARP_TABLE_SIZE 10
+#define ARP_QUEUEING 1
+
+/* Enables Checksum Offload */
+#define LWIP_CHECKSUM_CTRL_PER_NETIF 1
+#define CHECKSUM_CHECK_UDP 0
+#define CHECKSUM_CHECK_TCP 0
+#define CHECKSUM_GEN_UDP 0
+#define CHECKSUM_GEN_TCP 0
+
+/* Checksum on copy from app buffers to pbufs, boosts performance */
+#define LWIP_CHECKSUM_ON_COPY ((CHECKSUM_CHECK_UDP == 1) || (CHECKSUM_CHECK_TCP == 1) || (CHECKSUM_GEN_UDP == 1) || (CHECKSUM_GEN_TCP == 1))
+
+/* ---------- IP options ---------- */
+/* Define IP_FORWARD to 1 if you wish to have the ability to forward
+ IP packets across network interfaces. If you are going to run lwIP
+ on a device with only one network interface, define this to 0. */
+#define IP_FORWARD 1
+
+/* IP reassembly and segmentation.These are orthogonal even
+ * if they both deal with IP fragments */
+#define IP_REASSEMBLY 1
+#define IP_REASS_MAX_PBUFS (10 * ((1500 + PBUF_POOL_BUFSIZE - 1) / PBUF_POOL_BUFSIZE))
+#define MEMP_NUM_REASSDATA IP_REASS_MAX_PBUFS
+#define IP_FRAG 1
+#define IPV6_FRAG_COPYHEADER 1
+
+/* ---------- ICMP options ---------- */
+#define ICMP_TTL 255
+
+
+/* ---------- DHCP options ---------- */
+/* Define LWIP_DHCP to 1 if you want DHCP configuration of
+ interfaces. */
+#define LWIP_DHCP LWIP_UDP
+
+/* 1 if you want to do an ARP check on the offered address
+ (recommended). */
+#define DHCP_DOES_ARP_CHECK (LWIP_DHCP)
+
+
+/* ---------- AUTOIP options ------- */
+#define LWIP_AUTOIP 0
+#define LWIP_DHCP_AUTOIP_COOP (LWIP_DHCP && LWIP_AUTOIP)
+
+
+/* ---------- UDP options ---------- */
+#define LWIP_UDP 1
+#define LWIP_UDPLITE LWIP_UDP
+#define UDP_TTL 255
+
+#define DEFAULT_UDP_RECVMBOX_SIZE 320
+
+/* ---------- RAW options ---------- */
+#define LWIP_RAW 1
+
+#define DEFAULT_RAW_RECVMBOX_SIZE (MEMP_NUM_TCP_SEG)
+
+/* ---------- Statistics options ---------- */
+
+#define LWIP_STATS 1
+#define LWIP_STATS_DISPLAY 1
+
+#if LWIP_STATS
+#define LINK_STATS 1
+#define IP_STATS 1
+#define ICMP_STATS 1
+#define IGMP_STATS 1
+#define IPFRAG_STATS 1
+#define UDP_STATS 1
+#define TCP_STATS 1
+#define MEM_STATS 1
+#define MEMP_STATS 1
+#define PBUF_STATS 1
+#define SYS_STATS 1
+
+#define LWIP_SNMP LWIP_UDP
+#define MIB2_STATS LWIP_SNMP
+#ifdef LWIP_HAVE_MBEDTLS
+#define LWIP_SNMP_V3 (LWIP_SNMP)
+#endif
+
+#endif /* LWIP_STATS */
+
+/* ---------- NETBIOS options ---------- */
+#define LWIP_NETBIOS_RESPOND_NAME_QUERY 1
+
+/* ---------- PPP options ---------- */
+
+#define PPP_SUPPORT 0 /* Set > 0 for PPP */
+
+#if PPP_SUPPORT
+
+#define NUM_PPP 1 /* Max PPP sessions. */
+
+
+/* Select modules to enable. Ideally these would be set in the makefile but
+ * we're limited by the command line length so you need to modify the settings
+ * in this file.
+ */
+#define PPPOE_SUPPORT 1
+#define PPPOS_SUPPORT 1
+
+#define PAP_SUPPORT 1 /* Set > 0 for PAP. */
+#define CHAP_SUPPORT 1 /* Set > 0 for CHAP. */
+#define MSCHAP_SUPPORT 0 /* Set > 0 for MSCHAP */
+#define CBCP_SUPPORT 0 /* Set > 0 for CBCP (NOT FUNCTIONAL!) */
+#define CCP_SUPPORT 0 /* Set > 0 for CCP */
+#define VJ_SUPPORT 1 /* Set > 0 for VJ header compression. */
+#define MD5_SUPPORT 1 /* Set > 0 for MD5 (see also CHAP) */
+
+#endif /* PPP_SUPPORT */
+
+#endif /* LWIP_OPTTEST_FILE */
+
+/* The following defines must be done even in OPTTEST mode: */
+
+#if !defined(NO_SYS) || !NO_SYS /* default is 0 */
+void sys_check_core_locking(void);
+#define LWIP_ASSERT_CORE_LOCKED() sys_check_core_locking()
+void sys_mark_tcpip_thread(void);
+#define LWIP_MARK_TCPIP_THREAD() sys_mark_tcpip_thread()
+
+
+#if !defined(LWIP_TCPIP_CORE_LOCKING) || LWIP_TCPIP_CORE_LOCKING
+void sys_lock_tcpip_core(void);
+#define LOCK_TCPIP_CORE() sys_lock_tcpip_core()
+void sys_unlock_tcpip_core(void);
+#define UNLOCK_TCPIP_CORE() sys_unlock_tcpip_core()
+#endif
+
+#endif
+
+
+/*-------------------------Misc Options-------------------------*/
+/* Enables ARP*/
+#define LWIP_ARP 1
+
+/* Enables a routine to be called when netif is deleted. Used to close Enet */
+#define LWIP_NETIF_REMOVE_CALLBACK 1
+
+/* TCP thread priority level*/
+#define TCPIP_THREAD_PRIO 7
+
+/* Thread priority of any other thread created using the stack functions */
+#define DEFAULT_THREAD_PRIO 1
+
+/* Prevents pbuf chain from getting created thus disabling scatter-gather*/
+#define LWIP_NETIF_TX_SINGLE_PBUF 0
+
+#define DEFAULT_ACCEPTMBOX_SIZE (TCPIP_MBOX_SIZE)
+
+
+/* SafeRTOS specific config options */
+#define LWIP_CHECK_CORE_LOCKING 1
+#define LWIP_SYS_ARCH_PROTECT_USES_MUTEX 1
+#define LWIP_SAFERTOS_SYS_ARCH_PROTECT_SANITY_CHECK 1
+#define LWIP_SAFERTOS_CHECK_QUEUE_EMPTY_ON_FREE 1
+#define LWIP_SAFERTOS_MAX_TASK_STACK_SIZE (16U * 1024U)
+#define LWIP_SAFERTOS_MAX_TASK_COUNT (8U)
+#define LWIP_NETCONN_SEM_PER_THREAD 1
+
+/*---------------------------------------------------------------*/
+
+#if defined(__ARM_ARCH) && (defined(__TI_EABI__) || defined(__clang__))
+ /*------------------------------------------------------------------------*/
+ /* Under EABI, use function to access errno since it likely has TLS in */
+ /* a thread-safe version of the RTS library. */
+ /*------------------------------------------------------------------------*/
+ extern volatile int *__aeabi_errno_addr(void);
+ #define errno (* __aeabi_errno_addr())
+#elif !defined(__C6X_MIGRATION__) && defined(__TMS320C6X__) && defined(__TI_EABI__)
+ /*------------------------------------------------------------------------*/
+ /* Under EABI, use function to access errno since it likely has TLS in */
+ /* a thread-safe version of the RTS library. */
+ /*------------------------------------------------------------------------*/
+ extern int *__c6xabi_errno_addr(void);
+ __TI_TLS_DATA_DECL(int, __errno);
+
+ #define errno (* __c6xabi_errno_addr())
+#else
+ extern _DATA_ACCESS int errno;
+ _TI_PROPRIETARY_PRAGMA("diag_push")
+ /* errno is not allowed under MISRA, anyway */
+ _TI_PROPRIETARY_PRAGMA("CHECK_MISRA(\"-5.6\")") /* duplicated name in another scope (errno) */
+ _TI_PROPRIETARY_PRAGMA("CHECK_MISRA(\"-19.4\")") /* macro expands to parenthesized */
+ #define errno errno
+ _TI_PROPRIETARY_PRAGMA("diag_pop")
+#endif
+
+#endif /* LWIP_LWIPOPTS_H */
+
diff --git a/packages/ti/transport/lwip/lwip-port/safertos/include/lwippools.h b/packages/ti/transport/lwip/lwip-port/safertos/include/lwippools.h
--- /dev/null
@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2001-2004 Swedish Institute of Computer Science.
+ * 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: Adam Dunkels <adam@sics.se>
+ *
+ */
+
+/**
+ * Copyright (c) Texas Instruments Incorporated 2022
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 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.
+ *
+ * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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 COPYRIGHT
+ * OWNER OR CONTRIBUTORS 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.
+ */
+
+/* OPTIONAL: Pools to replace heap allocation
+ * Optional: Pools can be used instead of the heap for mem_malloc. If
+ * so, these should be defined here, in increasing order according to
+ * the pool element size.
+ *
+ * LWIP_MALLOC_MEMPOOL(number_elements, element_size)
+ *
+ * Note: pbuf_malloc() applies memory alignment (LWIP_MEM_ALIGN_SIZE()) separately
+ * to pbuf struct, layer header and payload. For example, for MEM_ALIGMENT of 128B,
+ * this means that a payload of 1460B actually needs a buffer 1792B as follows:
+ * - pbuf struct: size is 16B, due to alignment required an allocation of 128B
+ * - layer hader: different sizes but < 128B, this also becomes 128B due to aligment
+ * - payload: i.e. 1460B becomes 1536B after 128B aligment
+ *
+ * So total buffer size is now: 1536 + 128 + 128 = 1792B.
+ */
+#if MEM_USE_POOLS
+LWIP_MALLOC_MEMPOOL_START
+LWIP_MALLOC_MEMPOOL(100, 512)
+LWIP_MALLOC_MEMPOOL(20, 1024)
+LWIP_MALLOC_MEMPOOL(320, 1792)
+LWIP_MALLOC_MEMPOOL_END
+#endif /* MEM_USE_POOLS */
+
+/* Optional: Your custom pools can go here if you would like to use
+ * lwIP's memory pools for anything else.
+ */
+LWIP_MEMPOOL(SYS_MBOX, 22, 100, "SYS_MBOX")
diff --git a/packages/ti/transport/lwip/lwip-port/safertos/sys_arch.c b/packages/ti/transport/lwip/lwip-port/safertos/sys_arch.c
--- /dev/null
@@ -0,0 +1,702 @@
+/*
+ * Copyright ( C ) 2022 Texas Instruments Incorporated
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 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.
+ *
+ * Neither the name of Texas Instruments Incorporated nor the names of
+ * its contributors may be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "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 COPYRIGHT
+ * OWNER OR CONTRIBUTORS 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.
+ */
+
+/*!
+ * \file sys_arch.c
+ *
+ * \brief Main file for lwIP porting.
+ */
+
+/* ========================================================================== */
+/* Include Files */
+/* ========================================================================== */
+
+#include <string.h>
+
+/* lwIP includes. */
+#include "lwip/debug.h"
+#include "lwip/def.h"
+#include "lwip/sys.h"
+#include "lwip/mem.h"
+#include "lwip/stats.h"
+#include "lwip/tcpip.h"
+
+/* OSAL header files */
+#include <ti/osal/QueueP.h>
+#include <ti/osal/src/safertos/SafeRTOS_priv.h>
+
+#include "SafeRTOS_API.h"
+#include <sys/cdefs.h>
+
+/* ========================================================================== */
+/* Macros & Typedefs */
+/* ========================================================================== */
+
+/** Set this to 1 if you want the stack size passed to sys_thread_new() to be
+ * interpreted as number of stack words (SafeRTOS-like).
+ * Default is that they are interpreted as byte count (lwIP-like). */
+#ifndef LWIP_SAFERTOS_THREAD_STACKSIZE_IS_STACKWORDS
+#define LWIP_SAFERTOS_THREAD_STACKSIZE_IS_STACKWORDS 0
+#endif
+
+/** Set this to 1 to use a mutex for SYS_ARCH_PROTECT() critical regions.
+ * Default is 0 and locks interrupts/scheduler for SYS_ARCH_PROTECT(). */
+#ifndef LWIP_SYS_ARCH_PROTECT_USES_MUTEX
+#define LWIP_SYS_ARCH_PROTECT_USES_MUTEX 0
+#endif
+
+/** Set this to 1 to include a sanity check that SYS_ARCH_PROTECT() and
+ * SYS_ARCH_UNPROTECT() are called matching. */
+#ifndef LWIP_SAFERTOS_SYS_ARCH_PROTECT_SANITY_CHECK
+#define LWIP_SAFERTOS_SYS_ARCH_PROTECT_SANITY_CHECK 0
+#endif
+
+/** Set this to 1 to let sys_mbox_free check that queues are empty when freed */
+#ifndef LWIP_SAFERTOS_CHECK_QUEUE_EMPTY_ON_FREE
+#define LWIP_SAFERTOS_CHECK_QUEUE_EMPTY_ON_FREE 0
+#endif
+
+/** Set this to 1 to enable core locking check functions in this port.
+ * For this to work, you'll have to define LWIP_ASSERT_CORE_LOCKED()
+ * and LWIP_MARK_TCPIP_THREAD() correctly in your lwipopts.h! */
+#ifndef LWIP_CHECK_CORE_LOCKING
+#define LWIP_CHECK_CORE_LOCKING 0
+#endif
+
+/** Set this to 0 to implement sys_now() yourself, e.g. using a hw timer.
+ * Default is 1, where SafeRTOS ticks are used to calculate back to ms. */
+#ifndef LWIP_SAFERTOS_SYS_NOW_FROM_SAFERTOS
+#define LWIP_SAFERTOS_SYS_NOW_FROM_SAFERTOS 1
+#endif
+
+#define LWIP_TASK_PRIORITY_HIGHEST ( configMAX_PRIORITIES - 1 )
+#define LWIP_TASK_PRIORITY_LOWEST ( 0u )
+
+/* ========================================================================== */
+/* Global Variables */
+/* ========================================================================== */
+
+#if SYS_LIGHTWEIGHT_PROT && LWIP_SYS_ARCH_PROTECT_USES_MUTEX
+static uint64_t sys_arch_protect_mutex_buffer[((safertosapiQUEUE_OVERHEAD_BYTES/sizeof(uint64_t)) + 1)] = {0};
+static xMutexHandleType sys_arch_protect_mutex = NULL;
+#endif
+#if SYS_LIGHTWEIGHT_PROT && LWIP_SAFERTOS_SYS_ARCH_PROTECT_SANITY_CHECK
+static sys_prot_t sys_arch_protect_nesting = 0;
+#endif
+
+static struct sys_thread_state sys_thread_state_obj[LWIP_SAFERTOS_MAX_TASK_COUNT];
+static QueueP_Handle sys_thread_state_obj_queue = NULL;
+
+/* ========================================================================== */
+/* Function Definitions */
+/* ========================================================================== */
+
+/* Initialize this module (see description in sys.h) */
+void sys_init(void)
+{
+ QueueP_Params queueParams;
+ int i;
+#if SYS_LIGHTWEIGHT_PROT && LWIP_SYS_ARCH_PROTECT_USES_MUTEX
+ /* initialize sys_arch_protect global mutex */
+ /* Create a mutex. */
+ portBaseType mutexResult = xMutexCreate((portInt8Type *)&sys_arch_protect_mutex_buffer[0], &sys_arch_protect_mutex);
+ LWIP_ASSERT("failed to create sys_arch_protect mutex", mutexResult == pdPASS);
+#endif /* SYS_LIGHTWEIGHT_PROT && LWIP_SYS_ARCH_PROTECT_USES_MUTEX */
+
+ QueueP_Params_init(&queueParams);
+ sys_thread_state_obj_queue = QueueP_create(&queueParams);
+ LWIP_ASSERT("failed to create task queue", sys_thread_state_obj_queue != NULL);
+ for (i = 0; i < LWIP_SAFERTOS_MAX_TASK_COUNT; i++)
+ {
+ QueueP_Status status = QueueP_put(sys_thread_state_obj_queue,&sys_thread_state_obj[i].queueElement);
+ LWIP_ASSERT("task queue insert failed", status == QueueP_OK);
+ }
+}
+
+#if configUSE_16_BIT_TICKS == 1
+#error This port requires 32 bit ticks or timer overflow will fail
+#endif
+
+#if LWIP_SAFERTOS_SYS_NOW_FROM_SAFERTOS
+u32_t sys_now(void)
+{
+ LWIP_ASSERT("error, sys_ now called in ISR", Osal_isInISRContext() == false);
+ return xTaskGetTickCount() * configTICK_RATE_MS;
+}
+#endif
+
+u32_t sys_jiffies(void)
+{
+ LWIP_ASSERT("error, sys_jiffies called in ISR", Osal_isInISRContext() == false);
+ return xTaskGetTickCount();
+}
+
+#if SYS_LIGHTWEIGHT_PROT
+sys_prot_t sys_arch_protect(void)
+{
+#if LWIP_SYS_ARCH_PROTECT_USES_MUTEX
+ portBaseType ret;
+
+ LWIP_ASSERT("sys_arch_protect_mutex != NULL", sys_arch_protect_mutex != NULL);
+ LWIP_ASSERT("error, mutex is in ISR", Osal_isInISRContext() == false);
+
+ ret = xMutexTake(sys_arch_protect_mutex, safertosapiMAX_DELAY);
+ LWIP_ASSERT("sys_arch_protect failed to take the mutex", ret == pdPASS);
+#else /* LWIP_SYS_ARCH_PROTECT_USES_MUTEX */
+ safertosapiENTER_CRITICAL();
+#endif /* LWIP_SYS_ARCH_PROTECT_USES_MUTEX */
+
+#if LWIP_SAFERTOS_SYS_ARCH_PROTECT_SANITY_CHECK
+ {
+ /* every nested call to sys_arch_protect() returns an increased number */
+ sys_prot_t ret = sys_arch_protect_nesting;
+ sys_arch_protect_nesting++;
+ LWIP_ASSERT("sys_arch_protect overflow", sys_arch_protect_nesting > ret);
+ return ret;
+ }
+#else
+ return 1;
+#endif
+}
+
+void sys_arch_unprotect(sys_prot_t pval)
+{
+#if LWIP_SYS_ARCH_PROTECT_USES_MUTEX
+ portBaseType ret;
+#endif
+
+#if LWIP_SAFERTOS_SYS_ARCH_PROTECT_SANITY_CHECK
+ LWIP_ASSERT("unexpected sys_arch_protect_nesting", sys_arch_protect_nesting > 0);
+ sys_arch_protect_nesting--;
+ LWIP_ASSERT("unexpected sys_arch_protect_nesting", sys_arch_protect_nesting == pval);
+#endif
+
+#if LWIP_SYS_ARCH_PROTECT_USES_MUTEX
+ LWIP_ASSERT("sys_arch_protect_mutex != NULL", sys_arch_protect_mutex != NULL);
+ LWIP_ASSERT("error, mutex is in ISR", Osal_isInISRContext() == false);
+ ret = xMutexGive(sys_arch_protect_mutex);
+ LWIP_ASSERT("sys_arch_unprotect failed to give the mutex", ret == pdPASS);
+#else /* LWIP_SYS_ARCH_PROTECT_USES_MUTEX */
+ safertosapiEXIT_CRITICAL();
+#endif /* LWIP_SYS_ARCH_PROTECT_USES_MUTEX */
+
+ LWIP_UNUSED_ARG(pval);
+}
+#endif /* SYS_LIGHTWEIGHT_PROT */
+
+void sys_arch_msleep(u32_t delay_ms)
+{
+ portTickType delay_ticks = delay_ms / configTICK_RATE_MS;
+ xTaskDelay(delay_ticks);
+}
+
+#if !LWIP_COMPAT_MUTEX
+
+/* Create a new mutex*/
+err_t sys_mutex_new(sys_mutex_t *mutex)
+{
+ err_t errStatus = ERR_OK;
+ portBaseType mutexResult;
+
+ LWIP_ASSERT("mutex is NULL", mutex != NULL);
+
+ mutexResult = xMutexCreate((portInt8Type *)&(mutex->mutObj[0]), &mutex->mutHndl);
+ if (mutexResult != pdPASS)
+ {
+ /* falied to create mutex */
+ SYS_STATS_INC(mutex.err);
+ errStatus = ERR_MEM;
+ }
+ else
+ {
+ SYS_STATS_INC_USED(mutex);
+ }
+
+ return errStatus;
+}
+
+void sys_mutex_lock(sys_mutex_t *mutex)
+{
+ portBaseType ret;
+
+ LWIP_ASSERT("mutex is NULL", mutex != NULL);
+ /* Should not be called from ISR */
+ LWIP_ASSERT("error, mutex is in ISR", Osal_isInISRContext() == false);
+
+ ret = xMutexTake(mutex->mutHndl, safertosapiMAX_DELAY);
+ LWIP_ASSERT("failed to take the mutex", ret == pdPASS);
+}
+
+void sys_mutex_unlock(sys_mutex_t *mutex)
+{
+ portBaseType ret;
+
+ LWIP_ASSERT("mutex is NULL", mutex != NULL);
+ /* Should not be called from ISR */
+ LWIP_ASSERT("error, mutex is in ISR", Osal_isInISRContext() == false);
+
+ ret = xMutexGive(mutex->mutHndl);
+ LWIP_ASSERT("failed to give the mutex", ret == pdPASS);
+}
+
+void sys_mutex_free(sys_mutex_t *mutex)
+{
+ LWIP_ASSERT("mutex is NULL", mutex != NULL);
+ LWIP_ASSERT("mutex->mutHndl is NULL", mutex->mutHndl != NULL);
+
+ /* NOTE: Mutex delete is not supported in safertos, we just memset the memory to zero */
+ memset(&mutex->mutObj, 0, sizeof(mutex->mutObj));
+ SYS_STATS_DEC(mutex.used);
+ mutex->mutHndl = NULL;
+}
+
+#endif /* !LWIP_COMPAT_MUTEX */
+
+err_t sys_sem_new(sys_sem_t *sem, u8_t initial_count)
+{
+ err_t errStatus = ERR_OK;
+ portBaseType semResult;
+
+ LWIP_ASSERT("sem is NULL", sem != NULL);
+
+ LWIP_ASSERT("initial_count invalid (not 0 or 1)", (initial_count == 0) || (initial_count == 1));
+ LWIP_ASSERT("error, mutex is in ISR", Osal_isInISRContext() == false);
+
+ semResult = xSemaphoreCreateBinary((portInt8Type *)&(sem->semObj[0]), &sem->semHndl);
+ if (semResult != pdPASS)
+ {
+ /* falied to create mutex */
+ SYS_STATS_INC(sem.err);
+ errStatus = ERR_MEM;
+ }
+ else
+ {
+ SYS_STATS_INC_USED(sem);
+ }
+
+ if ((errStatus == ERR_OK) && (initial_count == 0))
+ {
+ uint32_t isSemTaken;
+
+ LWIP_ASSERT("Could not create a semaphore with initial_count value 0 while in ISR", Osal_isInISRContext() == false);
+
+ /* Binary semaphore creation in SafeRTOS initializes semaphore with count of 1.
+ * If requested initial count is 0, then we need to take semaphore to honor
+ * the requested initial count. */
+ isSemTaken = xSemaphoreTake(sem->semHndl, safertosapiMAX_DELAY);
+ LWIP_ASSERT("sys_sem_new: initial take failed", isSemTaken == true);
+ }
+
+ return errStatus;
+}
+
+void sys_sem_signal(sys_sem_t *sem)
+{
+ portBaseType ret;
+
+ LWIP_ASSERT("sem is NULL", sem != NULL);
+ LWIP_ASSERT("error, semaphore is in ISR", Osal_isInISRContext() == false);
+
+ ret = xSemaphoreGive(sem->semHndl);
+ /* semaphore already given is OK, this is a signal only... */
+ LWIP_ASSERT("sys_sem_signal: sane return value", (ret == pdPASS) || (ret == errSEMAPHORE_ALREADY_GIVEN));
+}
+
+u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout_ms)
+{
+ portBaseType ret;
+ u32_t retVal = ERR_OK;
+
+ LWIP_ASSERT("sem != NULL", sem != NULL);
+ LWIP_ASSERT("error, semaphore is in ISR", Osal_isInISRContext() == false);
+
+ if (!timeout_ms)
+ {
+ /* wait infinite */
+ ret = xSemaphoreTake(sem->semHndl, safertosapiMAX_DELAY);
+ LWIP_ASSERT("taking semaphore failed", ret == pdPASS);
+ }
+ else
+ {
+ portTickType timeout_ticks = timeout_ms / configTICK_RATE_MS;
+
+ ret = xSemaphoreTake(sem->semHndl, timeout_ticks);
+ if (ret != pdPASS)
+ {
+ /* timed out */
+ retVal = SYS_ARCH_TIMEOUT;
+ }
+ }
+
+ return retVal;
+}
+
+void sys_sem_free(sys_sem_t *sem)
+{
+ LWIP_ASSERT("sem is NULL", sem != NULL);
+ LWIP_ASSERT("sem->semHndl is NULL", sem->semHndl != NULL);
+
+ /* NOTE: there is no delete Semaphore API in safertos, we just memset the memory to zero */
+ memset(&sem->semObj, 0, sizeof(sem->semObj));
+ SYS_STATS_DEC(sem.used);
+ sem->semHndl = NULL;
+}
+
+err_t sys_mbox_new(sys_mbox_t *mbox, int size)
+{
+ portBaseType xQueueStatus;
+ portUnsignedBaseType uxBufferLength;
+ err_t errStatus = ERR_OK;
+
+ LWIP_ASSERT("error, empty mail box pointer passed", (mbox != NULL));
+ LWIP_ASSERT("error, queue size is very large", (size <= LWIP_SAFERTOS_MBOX_MAX_MSGCOUNT));
+
+ /* Note: Here buffer size should have addition portQUEUE_OVERHEAD_BYTES */
+ uxBufferLength = size * sizeof(void *) + safertosapiQUEUE_OVERHEAD_BYTES;
+ LWIP_ASSERT("error, queue size is very large",(uxBufferLength <= sizeof(mbox->queueBuf)));
+
+ xQueueStatus = xQueueCreate((portInt8Type *)&(mbox->queueBuf[0]), uxBufferLength, size, sizeof(void *), &mbox->mailboxHndl);
+ if (xQueueStatus != pdPASS)
+ {
+ /* mailbox creating failed */
+ SYS_STATS_INC(mbox.err);
+ errStatus = ERR_MEM;
+ }
+ else
+ {
+ SYS_STATS_INC_USED(mbox);
+ }
+
+ return errStatus;
+}
+
+void sys_mbox_post(sys_mbox_t *mbox, void *msg)
+{
+ portBaseType xQueueStatus;
+
+ LWIP_ASSERT("mbox is NULL", mbox != NULL);
+ LWIP_ASSERT("mbox->mailboxHndl is NULL", mbox->mailboxHndl != NULL);
+ LWIP_ASSERT("error, mailbox is in ISR", Osal_isInISRContext() == false);
+
+ xQueueStatus = xQueueSend(mbox->mailboxHndl, &msg, safertosapiMAX_DELAY);
+ LWIP_ASSERT("mailbox post failed",xQueueStatus == pdPASS);
+}
+
+err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
+{
+ portBaseType xQueueStatus;
+ err_t retVal;
+
+ LWIP_ASSERT("mbox is NULL", mbox != NULL);
+ LWIP_ASSERT("mbox->mailboxHndl is NULL", mbox->mailboxHndl != NULL);
+ LWIP_ASSERT("error, mailbox is in ISR", Osal_isInISRContext() == false);
+
+ /*Call returns immediately if xTicksToWait is 0 and the queue is full.*/
+ xQueueStatus = xQueueSend(mbox->mailboxHndl, &msg, 0);
+ if (xQueueStatus == pdPASS)
+ {
+ retVal = ERR_OK;
+ }
+ else
+ {
+ SYS_STATS_INC(mbox.err);
+ retVal= ERR_MEM;
+ }
+
+ return retVal;
+}
+
+err_t sys_mbox_trypost_fromisr(sys_mbox_t *mbox, void *msg)
+{
+ portBaseType xQueueStatus;
+ err_t retVal;
+
+ LWIP_ASSERT("mbox is NULL", mbox != NULL);
+ LWIP_ASSERT("mbox->mailboxHndl is NULL", mbox->mailboxHndl != NULL);
+ LWIP_ASSERT("error, mailbox is in not ISR", Osal_isInISRContext());
+
+ xQueueStatus = xQueueSendFromISR(mbox->mailboxHndl, &msg);
+ if (xQueueStatus == pdPASS)
+ {
+ /* will cause a context switch only if xQueueSendFromISR() internally requested one */
+ safertosapiYIELD_FROM_ISR();
+ retVal = ERR_OK;
+ }
+ else
+ {
+ SYS_STATS_INC(mbox.err);
+ retVal = ERR_MEM;
+ }
+
+ return retVal;
+}
+
+u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout_ms)
+{
+ portBaseType ret;
+ u32_t retVal = ERR_OK;
+ void *msg_dummy;
+
+ LWIP_ASSERT("mbox is NULL", mbox != NULL);
+ LWIP_ASSERT("error, mailbox is in ISR", Osal_isInISRContext() == false);
+
+ if (!msg)
+ {
+ msg = &msg_dummy;
+ }
+
+ if (!timeout_ms)
+ {
+ /* wait infinite */
+ ret = xQueueReceive(mbox->mailboxHndl, msg, safertosapiMAX_DELAY);
+ LWIP_ASSERT("mbox fetch failed", ret == pdPASS);
+ }
+ else
+ {
+ portTickType timeout_ticks = timeout_ms / configTICK_RATE_MS;
+
+ ret = xQueueReceive(mbox->mailboxHndl, msg, timeout_ticks);
+ if (ret != pdPASS)
+ {
+ /* timed out */
+ *msg = NULL;
+ retVal = SYS_ARCH_TIMEOUT;
+ }
+ }
+
+ return retVal;
+}
+
+u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
+{
+ portBaseType ret;
+ u32_t retVal = ERR_OK;
+ void *msg_dummy;
+
+ LWIP_ASSERT("mbox is NULL", mbox != NULL);
+ LWIP_ASSERT("error, mailbox is in ISR", Osal_isInISRContext() == false);
+
+ if (!msg)
+ {
+ msg = &msg_dummy;
+ }
+
+ /* Call returns immediately if xTicksToWait is 0 and the queue is empty */
+ ret = xQueueReceive(mbox->mailboxHndl, msg, 0);
+ if (ret != pdPASS)
+ {
+ *msg = NULL;
+ retVal = SYS_MBOX_EMPTY;
+ }
+
+ return retVal;
+}
+
+void sys_mbox_free(sys_mbox_t *mbox)
+{
+ portUnsignedBaseType msgs_waiting;
+ portBaseType queueResult;
+
+ LWIP_ASSERT("mbox is NULL", mbox != NULL);
+ LWIP_ASSERT("mbox->mailboxHndl is NULL", mbox->mailboxHndl != NULL);
+ LWIP_ASSERT("error, mailbox is in ISR", Osal_isInISRContext() == false);
+
+#if LWIP_SAFERTOS_CHECK_QUEUE_EMPTY_ON_FREE
+ queueResult = xQueueMessagesWaiting(mbox->mailboxHndl, &msgs_waiting);
+ LWIP_ASSERT("failed to fetch messages", queueResult == pdPASS);
+ LWIP_ASSERT("mbox quence not empty", msgs_waiting == 0);
+#endif
+
+ /* NOTE: there is no delete queue API in safertos */
+ SYS_STATS_DEC(mbox.used);
+}
+
+sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio)
+{
+ portBaseType xCreateResult;
+ portTaskHandleType rtos_task;
+ sys_thread_t lwip_thread;
+ QueueP_Elem *element;
+ struct sys_thread_state *pThreadState;
+
+ LWIP_ASSERT("task queue handle null error", sys_thread_state_obj_queue != NULL);
+
+ element = QueueP_get(sys_thread_state_obj_queue);
+ LWIP_ASSERT("task queue element not found", element != NULL);
+
+ pThreadState = __containerof(element, struct sys_thread_state, queueElement);
+ LWIP_ASSERT("invalid stacksize", stacksize > 0 && sizeof(pThreadState->tStack) >= stacksize);
+ if (prio > LWIP_TASK_PRIORITY_HIGHEST)
+ {
+ prio = LWIP_TASK_PRIORITY_HIGHEST;
+ }
+ if (prio <= LWIP_TASK_PRIORITY_LOWEST)
+ {
+ prio = LWIP_TASK_PRIORITY_LOWEST;
+ }
+
+ /* The structure passed to xTaskCreate() to create the check task. */
+ xTaskParameters taskParams =
+ {
+ thread, /* The function that implements the task being created. */
+ name, /* The name of the task being created. The kernel does not use this itself, its just to assist debugging. */
+ &pThreadState->tcb, /* TCB for the task. */
+ pThreadState->tStack, /* The buffer allocated for use as the task stack. */
+ sizeof(pThreadState->tStack), /* The size of the buffer allocated for use as the task stack - note this is in BYTES! */
+ arg, /* The task parameter. */
+ prio, /* The priority to assigned to the task being created. */
+ &pThreadState->tlsSemObj, /* TLS object, A pointer to user defined data to be associated with this task */
+ pdFALSE, /* Check that task does not use the FPU. */
+ { /* MPU task parameters. */
+ mpuPRIVILEGED_TASK, /* Check task is privileged. */
+ {
+ { NULL, 0U, 0U, 0U }, /* No additional region definitions are required. */
+ { NULL, 0U, 0U, 0U },
+ }
+ }
+ };
+
+ /* Create the check task. */
+ xCreateResult = xTaskCreate(&taskParams, /* The structure containing the task parameters created at the start of this function. */
+ &rtos_task); /* This parameter is used to receive a handle to the created task*/
+ LWIP_ASSERT("error task creation failed", (xCreateResult != pdFAIL) && (rtos_task != NULL));
+ lwip_thread.thread_handle = rtos_task;
+
+ return lwip_thread;
+}
+
+#if LWIP_NETCONN_SEM_PER_THREAD
+
+sys_sem_t *sys_arch_netconn_sem_get(void)
+{
+ sys_sem_t *ret;
+
+ LWIP_ASSERT("error, semaphore is in ISR", Osal_isInISRContext() == false);
+
+ /* Returns a pointer to the local storage object of the currently executing task. */
+ ret = pvTaskTLSObjectGet();
+
+ return ret;
+}
+
+void sys_arch_netconn_sem_alloc(void)
+{
+ sys_sem_t *sem;
+ err_t err;
+
+ LWIP_ASSERT("error, semaphore is in ISR", Osal_isInISRContext() == false);
+
+ sem = pvTaskTLSObjectGet();
+ LWIP_ASSERT("TLS object invalid", sem != NULL);
+
+ err = sys_sem_new(sem, 0);
+ LWIP_ASSERT("error semaphore could not be allocated", err == ERR_OK);
+ LWIP_ASSERT("sem invalid", sys_sem_valid(sem));
+}
+
+void sys_arch_netconn_sem_free(void)
+{
+ void *sem;
+
+ LWIP_ASSERT("error, semaphore is in ISR", Osal_isInISRContext() == false);
+
+ sem = pvTaskTLSObjectGet();
+ if(sem != NULL)
+ {
+ sys_sem_free((sys_sem_t *)sem);
+ }
+}
+
+#endif /* LWIP_NETCONN_SEM_PER_THREAD */
+
+#if LWIP_CHECK_CORE_LOCKING
+#if LWIP_TCPIP_CORE_LOCKING
+
+/** Flag the core lock held. A counter for recursive locks. */
+static u8_t lwip_core_lock_count = 0U;
+static portTaskHandleType lwip_core_lock_holder_thread;
+
+void sys_lock_tcpip_core(void)
+{
+ sys_mutex_lock(&lock_tcpip_core);
+ if (lwip_core_lock_count == 0)
+ {
+ LWIP_ASSERT("error, cannot lock core, in ISR", Osal_isInISRContext() == false);
+ lwip_core_lock_holder_thread = xTaskGetCurrentTaskHandle();
+ }
+ lwip_core_lock_count++;
+}
+
+void sys_unlock_tcpip_core(void)
+{
+ lwip_core_lock_count--;
+ if (lwip_core_lock_count == 0)
+ {
+ lwip_core_lock_holder_thread = 0;
+ }
+ sys_mutex_unlock(&lock_tcpip_core);
+}
+
+#endif /* LWIP_TCPIP_CORE_LOCKING */
+
+#if !NO_SYS
+static portTaskHandleType lwip_tcpip_thread;
+#endif
+
+void sys_mark_tcpip_thread(void)
+{
+#if !NO_SYS
+ LWIP_ASSERT("error, in ISR", Osal_isInISRContext() == false);
+ lwip_tcpip_thread = xTaskGetCurrentTaskHandle();
+#endif
+}
+
+void sys_check_core_locking(void)
+{
+#if !NO_SYS
+ if (lwip_tcpip_thread != 0)
+ {
+ portTaskHandleType current_thread;
+
+ LWIP_ASSERT("error, check core locking failed, in ISR", Osal_isInISRContext() == false);
+
+ current_thread = xTaskGetCurrentTaskHandle();
+#if LWIP_TCPIP_CORE_LOCKING
+ LWIP_ASSERT("Function called without core lock", (current_thread == lwip_core_lock_holder_thread) && (lwip_core_lock_count > 0));
+#else /* LWIP_TCPIP_CORE_LOCKING */
+ LWIP_ASSERT("Function called from wrong thread", current_thread == lwip_tcpip_thread);
+#endif /* LWIP_TCPIP_CORE_LOCKING */
+ }
+#endif /* !NO_SYS */
+}
+
+#endif /* LWIP_CHECK_CORE_LOCKING*/
diff --git a/packages/ti/transport/lwip/lwip_component.mk b/packages/ti/transport/lwip/lwip_component.mk
index 5f25ad03af9f3ba66abdd2bd8bf8047bbe14e5ce..61a9a3b454236c27782c3863efb6dd6069bb69a5 100644 (file)
# List with various rtos_types (such as tirtos(sysbios),freertos,safertos) to build RTOS apps.
# Use the Default List defined in 'ti/build/makerules/component.mk'
# This list will be used to generate RTOS app make rule for each rtos_type.
-drvlwip_RTOS_LIST = $(DEFAULT_RTOS_LIST)
+drvlwip_RTOS_LIST = $(DEFAULT_RTOS_LIST) safertos
drvlwip_SOCLIST = am65xx j721e j7200 j721s2 j784s4
drvlwip_BOARDLIST = am65xx_evm am65xx_idk j721e_evm j7200_evm j721s2_evm j784s4_evm
diff --git a/packages/ti/transport/lwip/makefile_contrib b/packages/ti/transport/lwip/makefile_contrib
index b46853eceb268ca7fe7f78dc86cd31ae03fae822..fa366d6f044cb00639001d5238b0abdfd4dc9329 100644 (file)
ifeq ($(BUILD_OS_TYPE),freertos)
LWIP_CONTRIB_CFLAGS += -DFREERTOS
+else ifeq ($(BUILD_OS_TYPE),safertos)
+ LWIP_CONTRIB_CFLAGS += -DSAFERTOS
endif
ifeq ($(BUILD_OS_TYPE),tirtos)
INCDIR += $(bios_PATH)/packages/ti/posix/ccs
# need to be included for this component
ifeq ($(BUILD_OS_TYPE),freertos)
INCLUDE_EXTERNAL_INTERFACES = pdk osal freertos
-endif
-ifeq ($(BUILD_OS_TYPE),tirtos)
+else ifeq ($(BUILD_OS_TYPE),safertos)
+ INCLUDE_EXTERNAL_INTERFACES = pdk osal safertos
+else ifeq ($(BUILD_OS_TYPE),tirtos)
INCLUDE_EXTERNAL_INTERFACES = pdk xdc osal bios
endif
index b88d6e7096d546dac316e8ee23a85aff69957a82..5e7d9b23b21290c235bd8d2bc8dc6fcf47c1ed0c 100644 (file)
ifeq ($(BUILD_OS_TYPE),freertos)
LWIP_STACK_CFLAGS += -DFREERTOS
+else ifeq ($(BUILD_OS_TYPE),safertos)
+ LWIP_STACK_CFLAGS += -DSAFERTOS
endif
# List all the external components/interfaces, whose interface header files
# need to be included for this component
ifeq ($(BUILD_OS_TYPE),freertos)
INCLUDE_EXTERNAL_INTERFACES = pdk osal freertos
-endif
-ifeq ($(BUILD_OS_TYPE),tirtos)
+else ifeq ($(BUILD_OS_TYPE),safertos)
+ INCLUDE_EXTERNAL_INTERFACES = pdk osal safertos
+else ifeq ($(BUILD_OS_TYPE),tirtos)
INCLUDE_EXTERNAL_INTERFACES = pdk xdc osal bios
endif