1 | /*
|
---|
2 | * Copyright (c) 2017 Simon Goldschmidt
|
---|
3 | * All rights reserved.
|
---|
4 | *
|
---|
5 | * Redistribution and use in source and binary forms, with or without modification,
|
---|
6 | * are permitted provided that the following conditions are met:
|
---|
7 | *
|
---|
8 | * 1. Redistributions of source code must retain the above copyright notice,
|
---|
9 | * this list of conditions and the following disclaimer.
|
---|
10 | * 2. Redistributions in binary form must reproduce the above copyright notice,
|
---|
11 | * this list of conditions and the following disclaimer in the documentation
|
---|
12 | * and/or other materials provided with the distribution.
|
---|
13 | * 3. The name of the author may not be used to endorse or promote products
|
---|
14 | * derived from this software without specific prior written permission.
|
---|
15 | *
|
---|
16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
---|
17 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
---|
18 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
---|
19 | * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
---|
20 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
---|
21 | * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
---|
22 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
---|
23 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
---|
24 | * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
|
---|
25 | * OF SUCH DAMAGE.
|
---|
26 | *
|
---|
27 | * This file is part of the lwIP TCP/IP stack.
|
---|
28 | *
|
---|
29 | * Author: Simon Goldschmidt <goldsimon@gmx.de>
|
---|
30 | *
|
---|
31 | */
|
---|
32 |
|
---|
33 | /* lwIP includes. */
|
---|
34 | #include "lwip/debug.h"
|
---|
35 | #include "lwip/def.h"
|
---|
36 | #include "lwip/sys.h"
|
---|
37 | #include "lwip/mem.h"
|
---|
38 | #include "lwip/stats.h"
|
---|
39 | #include "FreeRTOS.h"
|
---|
40 | #include "semphr.h"
|
---|
41 | #include "task.h"
|
---|
42 |
|
---|
43 | /** Set this to 1 if you want the stack size passed to sys_thread_new() to be
|
---|
44 | * interpreted as number of stack words (FreeRTOS-like).
|
---|
45 | * Default is that they are interpreted as byte count (lwIP-like).
|
---|
46 | */
|
---|
47 | #ifndef LWIP_FREERTOS_THREAD_STACKSIZE_IS_STACKWORDS
|
---|
48 | #define LWIP_FREERTOS_THREAD_STACKSIZE_IS_STACKWORDS 0
|
---|
49 | #endif
|
---|
50 |
|
---|
51 | /** Set this to 1 to use a mutex for SYS_ARCH_PROTECT() critical regions.
|
---|
52 | * Default is 0 and locks interrupts/scheduler for SYS_ARCH_PROTECT().
|
---|
53 | */
|
---|
54 | #ifndef LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX
|
---|
55 | #define LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX 0
|
---|
56 | #endif
|
---|
57 |
|
---|
58 | /** Set this to 1 to include a sanity check that SYS_ARCH_PROTECT() and
|
---|
59 | * SYS_ARCH_UNPROTECT() are called matching.
|
---|
60 | */
|
---|
61 | #ifndef LWIP_FREERTOS_SYS_ARCH_PROTECT_SANITY_CHECK
|
---|
62 | #define LWIP_FREERTOS_SYS_ARCH_PROTECT_SANITY_CHECK 0
|
---|
63 | #endif
|
---|
64 |
|
---|
65 | /** Set this to 1 to let sys_mbox_free check that queues are empty when freed */
|
---|
66 | #ifndef LWIP_FREERTOS_CHECK_QUEUE_EMPTY_ON_FREE
|
---|
67 | #define LWIP_FREERTOS_CHECK_QUEUE_EMPTY_ON_FREE 0
|
---|
68 | #endif
|
---|
69 |
|
---|
70 | /** Set this to 1 to enable core locking check functions in this port.
|
---|
71 | * For this to work, you'll have to define LWIP_ASSERT_CORE_LOCKED()
|
---|
72 | * and LWIP_MARK_TCPIP_THREAD() correctly in your lwipopts.h! */
|
---|
73 | #ifndef LWIP_FREERTOS_CHECK_CORE_LOCKING
|
---|
74 | #define LWIP_FREERTOS_CHECK_CORE_LOCKING 0
|
---|
75 | #endif
|
---|
76 |
|
---|
77 | /** Set this to 0 to implement sys_now() yourself, e.g. using a hw timer.
|
---|
78 | * Default is 1, where FreeRTOS ticks are used to calculate back to ms.
|
---|
79 | */
|
---|
80 | #ifndef LWIP_FREERTOS_SYS_NOW_FROM_FREERTOS
|
---|
81 | #define LWIP_FREERTOS_SYS_NOW_FROM_FREERTOS 1
|
---|
82 | #endif
|
---|
83 |
|
---|
84 | #if !configSUPPORT_DYNAMIC_ALLOCATION
|
---|
85 | # error "lwIP FreeRTOS port requires configSUPPORT_DYNAMIC_ALLOCATION"
|
---|
86 | #endif
|
---|
87 | #if !INCLUDE_vTaskDelay
|
---|
88 | # error "lwIP FreeRTOS port requires INCLUDE_vTaskDelay"
|
---|
89 | #endif
|
---|
90 | #if !INCLUDE_vTaskSuspend
|
---|
91 | # error "lwIP FreeRTOS port requires INCLUDE_vTaskSuspend"
|
---|
92 | #endif
|
---|
93 | #if LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX || !LWIP_COMPAT_MUTEX
|
---|
94 | #if !configUSE_MUTEXES
|
---|
95 | # error "lwIP FreeRTOS port requires configUSE_MUTEXES"
|
---|
96 | #endif
|
---|
97 | #endif
|
---|
98 |
|
---|
99 | #if SYS_LIGHTWEIGHT_PROT && LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX
|
---|
100 | static SemaphoreHandle_t sys_arch_protect_mutex;
|
---|
101 | #endif
|
---|
102 | #if SYS_LIGHTWEIGHT_PROT && LWIP_FREERTOS_SYS_ARCH_PROTECT_SANITY_CHECK
|
---|
103 | static sys_prot_t sys_arch_protect_nesting;
|
---|
104 | #endif
|
---|
105 |
|
---|
106 | /* Initialize this module (see description in sys.h) */
|
---|
107 | void
|
---|
108 | sys_init(void)
|
---|
109 | {
|
---|
110 | #if SYS_LIGHTWEIGHT_PROT && LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX
|
---|
111 | /* initialize sys_arch_protect global mutex */
|
---|
112 | sys_arch_protect_mutex = xSemaphoreCreateRecursiveMutex();
|
---|
113 | LWIP_ASSERT("failed to create sys_arch_protect mutex",
|
---|
114 | sys_arch_protect_mutex != NULL);
|
---|
115 | #endif /* SYS_LIGHTWEIGHT_PROT && LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX */
|
---|
116 | }
|
---|
117 |
|
---|
118 | #if configUSE_16_BIT_TICKS == 1
|
---|
119 | #error This port requires 32 bit ticks or timer overflow will fail
|
---|
120 | #endif
|
---|
121 |
|
---|
122 | #if LWIP_FREERTOS_SYS_NOW_FROM_FREERTOS
|
---|
123 | u32_t
|
---|
124 | sys_now(void)
|
---|
125 | {
|
---|
126 | return xTaskGetTickCount() * portTICK_PERIOD_MS;
|
---|
127 | }
|
---|
128 | #endif
|
---|
129 |
|
---|
130 | u32_t
|
---|
131 | sys_jiffies(void)
|
---|
132 | {
|
---|
133 | return xTaskGetTickCount();
|
---|
134 | }
|
---|
135 |
|
---|
136 | #if SYS_LIGHTWEIGHT_PROT
|
---|
137 |
|
---|
138 | sys_prot_t
|
---|
139 | sys_arch_protect(void)
|
---|
140 | {
|
---|
141 | #if LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX
|
---|
142 | BaseType_t ret;
|
---|
143 | LWIP_ASSERT("sys_arch_protect_mutex != NULL", sys_arch_protect_mutex != NULL);
|
---|
144 |
|
---|
145 | ret = xSemaphoreTakeRecursive(sys_arch_protect_mutex, portMAX_DELAY);
|
---|
146 | LWIP_ASSERT("sys_arch_protect failed to take the mutex", ret == pdTRUE);
|
---|
147 | #else /* LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX */
|
---|
148 | taskENTER_CRITICAL();
|
---|
149 | #endif /* LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX */
|
---|
150 | #if LWIP_FREERTOS_SYS_ARCH_PROTECT_SANITY_CHECK
|
---|
151 | {
|
---|
152 | /* every nested call to sys_arch_protect() returns an increased number */
|
---|
153 | sys_prot_t ret = sys_arch_protect_nesting;
|
---|
154 | sys_arch_protect_nesting++;
|
---|
155 | LWIP_ASSERT("sys_arch_protect overflow", sys_arch_protect_nesting > ret);
|
---|
156 | return ret;
|
---|
157 | }
|
---|
158 | #else
|
---|
159 | return 1;
|
---|
160 | #endif
|
---|
161 | }
|
---|
162 |
|
---|
163 | void
|
---|
164 | sys_arch_unprotect(sys_prot_t pval)
|
---|
165 | {
|
---|
166 | #if LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX
|
---|
167 | BaseType_t ret;
|
---|
168 | #endif
|
---|
169 | #if LWIP_FREERTOS_SYS_ARCH_PROTECT_SANITY_CHECK
|
---|
170 | LWIP_ASSERT("unexpected sys_arch_protect_nesting", sys_arch_protect_nesting > 0);
|
---|
171 | sys_arch_protect_nesting--;
|
---|
172 | LWIP_ASSERT("unexpected sys_arch_protect_nesting", sys_arch_protect_nesting == pval);
|
---|
173 | #endif
|
---|
174 |
|
---|
175 | #if LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX
|
---|
176 | LWIP_ASSERT("sys_arch_protect_mutex != NULL", sys_arch_protect_mutex != NULL);
|
---|
177 |
|
---|
178 | ret = xSemaphoreGiveRecursive(sys_arch_protect_mutex);
|
---|
179 | LWIP_ASSERT("sys_arch_unprotect failed to give the mutex", ret == pdTRUE);
|
---|
180 | #else /* LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX */
|
---|
181 | taskEXIT_CRITICAL();
|
---|
182 | #endif /* LWIP_FREERTOS_SYS_ARCH_PROTECT_USES_MUTEX */
|
---|
183 | LWIP_UNUSED_ARG(pval);
|
---|
184 | }
|
---|
185 |
|
---|
186 | #endif /* SYS_LIGHTWEIGHT_PROT */
|
---|
187 |
|
---|
188 | void
|
---|
189 | sys_arch_msleep(u32_t delay_ms)
|
---|
190 | {
|
---|
191 | TickType_t delay_ticks = delay_ms / portTICK_RATE_MS;
|
---|
192 | vTaskDelay(delay_ticks);
|
---|
193 | }
|
---|
194 |
|
---|
195 | #if !LWIP_COMPAT_MUTEX
|
---|
196 |
|
---|
197 | /* Create a new mutex*/
|
---|
198 | err_t
|
---|
199 | sys_mutex_new(sys_mutex_t *mutex)
|
---|
200 | {
|
---|
201 | LWIP_ASSERT("mutex != NULL", mutex != NULL);
|
---|
202 |
|
---|
203 | mutex->mut = xSemaphoreCreateRecursiveMutex();
|
---|
204 | if(mutex->mut == NULL) {
|
---|
205 | SYS_STATS_INC(mutex.err);
|
---|
206 | return ERR_MEM;
|
---|
207 | }
|
---|
208 | SYS_STATS_INC_USED(mutex);
|
---|
209 | return ERR_OK;
|
---|
210 | }
|
---|
211 |
|
---|
212 | void
|
---|
213 | sys_mutex_lock(sys_mutex_t *mutex)
|
---|
214 | {
|
---|
215 | BaseType_t ret;
|
---|
216 | LWIP_ASSERT("mutex != NULL", mutex != NULL);
|
---|
217 | LWIP_ASSERT("mutex->mut != NULL", mutex->mut != NULL);
|
---|
218 |
|
---|
219 | ret = xSemaphoreTakeRecursive(mutex->mut, portMAX_DELAY);
|
---|
220 | LWIP_ASSERT("failed to take the mutex", ret == pdTRUE);
|
---|
221 | }
|
---|
222 |
|
---|
223 | void
|
---|
224 | sys_mutex_unlock(sys_mutex_t *mutex)
|
---|
225 | {
|
---|
226 | BaseType_t ret;
|
---|
227 | LWIP_ASSERT("mutex != NULL", mutex != NULL);
|
---|
228 | LWIP_ASSERT("mutex->mut != NULL", mutex->mut != NULL);
|
---|
229 |
|
---|
230 | ret = xSemaphoreGiveRecursive(mutex->mut);
|
---|
231 | LWIP_ASSERT("failed to give the mutex", ret == pdTRUE);
|
---|
232 | }
|
---|
233 |
|
---|
234 | void
|
---|
235 | sys_mutex_free(sys_mutex_t *mutex)
|
---|
236 | {
|
---|
237 | LWIP_ASSERT("mutex != NULL", mutex != NULL);
|
---|
238 | LWIP_ASSERT("mutex->mut != NULL", mutex->mut != NULL);
|
---|
239 |
|
---|
240 | SYS_STATS_DEC(mutex.used);
|
---|
241 | vSemaphoreDelete(mutex->mut);
|
---|
242 | mutex->mut = NULL;
|
---|
243 | }
|
---|
244 |
|
---|
245 | #endif /* !LWIP_COMPAT_MUTEX */
|
---|
246 |
|
---|
247 | err_t
|
---|
248 | sys_sem_new(sys_sem_t *sem, u8_t initial_count)
|
---|
249 | {
|
---|
250 | LWIP_ASSERT("sem != NULL", sem != NULL);
|
---|
251 | LWIP_ASSERT("initial_count invalid (not 0 or 1)",
|
---|
252 | (initial_count == 0) || (initial_count == 1));
|
---|
253 |
|
---|
254 | sem->sem = xSemaphoreCreateBinary();
|
---|
255 | if(sem->sem == NULL) {
|
---|
256 | SYS_STATS_INC(sem.err);
|
---|
257 | return ERR_MEM;
|
---|
258 | }
|
---|
259 | SYS_STATS_INC_USED(sem);
|
---|
260 |
|
---|
261 | if(initial_count == 1) {
|
---|
262 | BaseType_t ret = xSemaphoreGive(sem->sem);
|
---|
263 | LWIP_ASSERT("sys_sem_new: initial give failed", ret == pdTRUE);
|
---|
264 | }
|
---|
265 | return ERR_OK;
|
---|
266 | }
|
---|
267 |
|
---|
268 | void
|
---|
269 | sys_sem_signal(sys_sem_t *sem)
|
---|
270 | {
|
---|
271 | BaseType_t ret;
|
---|
272 | LWIP_ASSERT("sem != NULL", sem != NULL);
|
---|
273 | LWIP_ASSERT("sem->sem != NULL", sem->sem != NULL);
|
---|
274 |
|
---|
275 | ret = xSemaphoreGive(sem->sem);
|
---|
276 | /* queue full is OK, this is a signal only... */
|
---|
277 | LWIP_ASSERT("sys_sem_signal: sane return value",
|
---|
278 | (ret == pdTRUE) || (ret == errQUEUE_FULL));
|
---|
279 | }
|
---|
280 |
|
---|
281 | u32_t
|
---|
282 | sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout_ms)
|
---|
283 | {
|
---|
284 | BaseType_t ret;
|
---|
285 | LWIP_ASSERT("sem != NULL", sem != NULL);
|
---|
286 | LWIP_ASSERT("sem->sem != NULL", sem->sem != NULL);
|
---|
287 |
|
---|
288 | if(!timeout_ms) {
|
---|
289 | /* wait infinite */
|
---|
290 | ret = xSemaphoreTake(sem->sem, portMAX_DELAY);
|
---|
291 | LWIP_ASSERT("taking semaphore failed", ret == pdTRUE);
|
---|
292 | } else {
|
---|
293 | TickType_t timeout_ticks = timeout_ms / portTICK_RATE_MS;
|
---|
294 | ret = xSemaphoreTake(sem->sem, timeout_ticks);
|
---|
295 | if (ret == errQUEUE_EMPTY) {
|
---|
296 | /* timed out */
|
---|
297 | return SYS_ARCH_TIMEOUT;
|
---|
298 | }
|
---|
299 | LWIP_ASSERT("taking semaphore failed", ret == pdTRUE);
|
---|
300 | }
|
---|
301 |
|
---|
302 | /* Old versions of lwIP required us to return the time waited.
|
---|
303 | This is not the case any more. Just returning != SYS_ARCH_TIMEOUT
|
---|
304 | here is enough. */
|
---|
305 | return 1;
|
---|
306 | }
|
---|
307 |
|
---|
308 | void
|
---|
309 | sys_sem_free(sys_sem_t *sem)
|
---|
310 | {
|
---|
311 | LWIP_ASSERT("sem != NULL", sem != NULL);
|
---|
312 | LWIP_ASSERT("sem->sem != NULL", sem->sem != NULL);
|
---|
313 |
|
---|
314 | SYS_STATS_DEC(sem.used);
|
---|
315 | vSemaphoreDelete(sem->sem);
|
---|
316 | sem->sem = NULL;
|
---|
317 | }
|
---|
318 |
|
---|
319 | err_t
|
---|
320 | sys_mbox_new(sys_mbox_t *mbox, int size)
|
---|
321 | {
|
---|
322 | LWIP_ASSERT("mbox != NULL", mbox != NULL);
|
---|
323 | LWIP_ASSERT("size > 0", size > 0);
|
---|
324 |
|
---|
325 | mbox->mbx = xQueueCreate((UBaseType_t)size, sizeof(void *));
|
---|
326 | if(mbox->mbx == NULL) {
|
---|
327 | SYS_STATS_INC(mbox.err);
|
---|
328 | return ERR_MEM;
|
---|
329 | }
|
---|
330 | SYS_STATS_INC_USED(mbox);
|
---|
331 | return ERR_OK;
|
---|
332 | }
|
---|
333 |
|
---|
334 | void
|
---|
335 | sys_mbox_post(sys_mbox_t *mbox, void *msg)
|
---|
336 | {
|
---|
337 | BaseType_t ret;
|
---|
338 | LWIP_ASSERT("mbox != NULL", mbox != NULL);
|
---|
339 | LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);
|
---|
340 |
|
---|
341 | ret = xQueueSendToBack(mbox->mbx, &msg, portMAX_DELAY);
|
---|
342 | LWIP_ASSERT("mbox post failed", ret == pdTRUE);
|
---|
343 | }
|
---|
344 |
|
---|
345 | err_t
|
---|
346 | sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
|
---|
347 | {
|
---|
348 | BaseType_t ret;
|
---|
349 | LWIP_ASSERT("mbox != NULL", mbox != NULL);
|
---|
350 | LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);
|
---|
351 |
|
---|
352 | ret = xQueueSendToBack(mbox->mbx, &msg, 0);
|
---|
353 | if (ret == pdTRUE) {
|
---|
354 | return ERR_OK;
|
---|
355 | } else {
|
---|
356 | LWIP_ASSERT("mbox trypost failed", ret == errQUEUE_FULL);
|
---|
357 | SYS_STATS_INC(mbox.err);
|
---|
358 | return ERR_MEM;
|
---|
359 | }
|
---|
360 | }
|
---|
361 |
|
---|
362 | err_t
|
---|
363 | sys_mbox_trypost_fromisr(sys_mbox_t *mbox, void *msg)
|
---|
364 | {
|
---|
365 | BaseType_t ret;
|
---|
366 | BaseType_t xHigherPriorityTaskWoken = pdFALSE;
|
---|
367 | LWIP_ASSERT("mbox != NULL", mbox != NULL);
|
---|
368 | LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);
|
---|
369 |
|
---|
370 | ret = xQueueSendToBackFromISR(mbox->mbx, &msg, &xHigherPriorityTaskWoken);
|
---|
371 | if (ret == pdTRUE) {
|
---|
372 | if (xHigherPriorityTaskWoken == pdTRUE) {
|
---|
373 | return ERR_NEED_SCHED;
|
---|
374 | }
|
---|
375 | return ERR_OK;
|
---|
376 | } else {
|
---|
377 | LWIP_ASSERT("mbox trypost failed", ret == errQUEUE_FULL);
|
---|
378 | SYS_STATS_INC(mbox.err);
|
---|
379 | return ERR_MEM;
|
---|
380 | }
|
---|
381 | }
|
---|
382 |
|
---|
383 | u32_t
|
---|
384 | sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout_ms)
|
---|
385 | {
|
---|
386 | BaseType_t ret;
|
---|
387 | void *msg_dummy;
|
---|
388 | LWIP_ASSERT("mbox != NULL", mbox != NULL);
|
---|
389 | LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);
|
---|
390 |
|
---|
391 | if (!msg) {
|
---|
392 | msg = &msg_dummy;
|
---|
393 | }
|
---|
394 |
|
---|
395 | if (!timeout_ms) {
|
---|
396 | /* wait infinite */
|
---|
397 | ret = xQueueReceive(mbox->mbx, &(*msg), portMAX_DELAY);
|
---|
398 | LWIP_ASSERT("mbox fetch failed", ret == pdTRUE);
|
---|
399 | } else {
|
---|
400 | TickType_t timeout_ticks = timeout_ms / portTICK_RATE_MS;
|
---|
401 | ret = xQueueReceive(mbox->mbx, &(*msg), timeout_ticks);
|
---|
402 | if (ret == errQUEUE_EMPTY) {
|
---|
403 | /* timed out */
|
---|
404 | *msg = NULL;
|
---|
405 | return SYS_ARCH_TIMEOUT;
|
---|
406 | }
|
---|
407 | LWIP_ASSERT("mbox fetch failed", ret == pdTRUE);
|
---|
408 | }
|
---|
409 |
|
---|
410 | /* Old versions of lwIP required us to return the time waited.
|
---|
411 | This is not the case any more. Just returning != SYS_ARCH_TIMEOUT
|
---|
412 | here is enough. */
|
---|
413 | return 1;
|
---|
414 | }
|
---|
415 |
|
---|
416 | u32_t
|
---|
417 | sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
|
---|
418 | {
|
---|
419 | BaseType_t ret;
|
---|
420 | void *msg_dummy;
|
---|
421 | LWIP_ASSERT("mbox != NULL", mbox != NULL);
|
---|
422 | LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);
|
---|
423 |
|
---|
424 | if (!msg) {
|
---|
425 | msg = &msg_dummy;
|
---|
426 | }
|
---|
427 |
|
---|
428 | ret = xQueueReceive(mbox->mbx, &(*msg), 0);
|
---|
429 | if (ret == errQUEUE_EMPTY) {
|
---|
430 | *msg = NULL;
|
---|
431 | return SYS_MBOX_EMPTY;
|
---|
432 | }
|
---|
433 | LWIP_ASSERT("mbox fetch failed", ret == pdTRUE);
|
---|
434 |
|
---|
435 | /* Old versions of lwIP required us to return the time waited.
|
---|
436 | This is not the case any more. Just returning != SYS_ARCH_TIMEOUT
|
---|
437 | here is enough. */
|
---|
438 | return 1;
|
---|
439 | }
|
---|
440 |
|
---|
441 | void
|
---|
442 | sys_mbox_free(sys_mbox_t *mbox)
|
---|
443 | {
|
---|
444 | LWIP_ASSERT("mbox != NULL", mbox != NULL);
|
---|
445 | LWIP_ASSERT("mbox->mbx != NULL", mbox->mbx != NULL);
|
---|
446 |
|
---|
447 | #if LWIP_FREERTOS_CHECK_QUEUE_EMPTY_ON_FREE
|
---|
448 | {
|
---|
449 | UBaseType_t msgs_waiting = uxQueueMessagesWaiting(mbox->mbx);
|
---|
450 | LWIP_ASSERT("mbox quence not empty", msgs_waiting == 0);
|
---|
451 |
|
---|
452 | if (msgs_waiting != 0) {
|
---|
453 | SYS_STATS_INC(mbox.err);
|
---|
454 | }
|
---|
455 | }
|
---|
456 | #endif
|
---|
457 |
|
---|
458 | vQueueDelete(mbox->mbx);
|
---|
459 |
|
---|
460 | SYS_STATS_DEC(mbox.used);
|
---|
461 | }
|
---|
462 |
|
---|
463 | sys_thread_t
|
---|
464 | sys_thread_new(const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio)
|
---|
465 | {
|
---|
466 | TaskHandle_t rtos_task;
|
---|
467 | BaseType_t ret;
|
---|
468 | sys_thread_t lwip_thread;
|
---|
469 | size_t rtos_stacksize;
|
---|
470 |
|
---|
471 | LWIP_ASSERT("invalid stacksize", stacksize > 0);
|
---|
472 | #if LWIP_FREERTOS_THREAD_STACKSIZE_IS_STACKWORDS
|
---|
473 | rtos_stacksize = (size_t)stacksize;
|
---|
474 | #else
|
---|
475 | rtos_stacksize = (size_t)stacksize / sizeof(StackType_t);
|
---|
476 | #endif
|
---|
477 |
|
---|
478 | /* lwIP's lwip_thread_fn matches FreeRTOS' TaskFunction_t, so we can pass the
|
---|
479 | thread function without adaption here. */
|
---|
480 | ret = xTaskCreate(thread, name, (configSTACK_DEPTH_TYPE)rtos_stacksize, arg, prio, &rtos_task);
|
---|
481 | LWIP_ASSERT("task creation failed", ret == pdTRUE);
|
---|
482 |
|
---|
483 | lwip_thread.thread_handle = rtos_task;
|
---|
484 | return lwip_thread;
|
---|
485 | }
|
---|
486 |
|
---|
487 | #if LWIP_NETCONN_SEM_PER_THREAD
|
---|
488 | #if configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0
|
---|
489 |
|
---|
490 | sys_sem_t *
|
---|
491 | sys_arch_netconn_sem_get(void)
|
---|
492 | {
|
---|
493 | void* ret;
|
---|
494 | TaskHandle_t task = xTaskGetCurrentTaskHandle();
|
---|
495 | LWIP_ASSERT("task != NULL", task != NULL);
|
---|
496 |
|
---|
497 | ret = pvTaskGetThreadLocalStoragePointer(task, 0);
|
---|
498 | return ret;
|
---|
499 | }
|
---|
500 |
|
---|
501 | void
|
---|
502 | sys_arch_netconn_sem_alloc(void)
|
---|
503 | {
|
---|
504 | void *ret;
|
---|
505 | TaskHandle_t task = xTaskGetCurrentTaskHandle();
|
---|
506 | LWIP_ASSERT("task != NULL", task != NULL);
|
---|
507 |
|
---|
508 | ret = pvTaskGetThreadLocalStoragePointer(task, 0);
|
---|
509 | if(ret == NULL) {
|
---|
510 | sys_sem_t *sem;
|
---|
511 | err_t err;
|
---|
512 | /* need to allocate the memory for this semaphore */
|
---|
513 | sem = mem_malloc(sizeof(sys_sem_t));
|
---|
514 | LWIP_ASSERT("sem != NULL", sem != NULL);
|
---|
515 | err = sys_sem_new(sem, 0);
|
---|
516 | LWIP_ASSERT("err == ERR_OK", err == ERR_OK);
|
---|
517 | LWIP_ASSERT("sem invalid", sys_sem_valid(sem));
|
---|
518 | vTaskSetThreadLocalStoragePointer(task, 0, sem);
|
---|
519 | }
|
---|
520 | }
|
---|
521 |
|
---|
522 | void sys_arch_netconn_sem_free(void)
|
---|
523 | {
|
---|
524 | void* ret;
|
---|
525 | TaskHandle_t task = xTaskGetCurrentTaskHandle();
|
---|
526 | LWIP_ASSERT("task != NULL", task != NULL);
|
---|
527 |
|
---|
528 | ret = pvTaskGetThreadLocalStoragePointer(task, 0);
|
---|
529 | if(ret != NULL) {
|
---|
530 | sys_sem_t *sem = ret;
|
---|
531 | sys_sem_free(sem);
|
---|
532 | mem_free(sem);
|
---|
533 | vTaskSetThreadLocalStoragePointer(task, 0, NULL);
|
---|
534 | }
|
---|
535 | }
|
---|
536 |
|
---|
537 | #else /* configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 */
|
---|
538 | #error LWIP_NETCONN_SEM_PER_THREAD needs configNUM_THREAD_LOCAL_STORAGE_POINTERS
|
---|
539 | #endif /* configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 */
|
---|
540 |
|
---|
541 | #endif /* LWIP_NETCONN_SEM_PER_THREAD */
|
---|
542 |
|
---|
543 | #if LWIP_FREERTOS_CHECK_CORE_LOCKING
|
---|
544 | #if LWIP_TCPIP_CORE_LOCKING
|
---|
545 |
|
---|
546 | /** Flag the core lock held. A counter for recursive locks. */
|
---|
547 | static u8_t lwip_core_lock_count;
|
---|
548 | static TaskHandle_t lwip_core_lock_holder_thread;
|
---|
549 |
|
---|
550 | void
|
---|
551 | sys_lock_tcpip_core(void)
|
---|
552 | {
|
---|
553 | sys_mutex_lock(&lock_tcpip_core);
|
---|
554 | if (lwip_core_lock_count == 0) {
|
---|
555 | lwip_core_lock_holder_thread = xTaskGetCurrentTaskHandle();
|
---|
556 | }
|
---|
557 | lwip_core_lock_count++;
|
---|
558 | }
|
---|
559 |
|
---|
560 | void
|
---|
561 | sys_unlock_tcpip_core(void)
|
---|
562 | {
|
---|
563 | lwip_core_lock_count--;
|
---|
564 | if (lwip_core_lock_count == 0) {
|
---|
565 | lwip_core_lock_holder_thread = 0;
|
---|
566 | }
|
---|
567 | sys_mutex_unlock(&lock_tcpip_core);
|
---|
568 | }
|
---|
569 |
|
---|
570 | #endif /* LWIP_TCPIP_CORE_LOCKING */
|
---|
571 |
|
---|
572 | #if !NO_SYS
|
---|
573 | static TaskHandle_t lwip_tcpip_thread;
|
---|
574 | #endif
|
---|
575 |
|
---|
576 | void
|
---|
577 | sys_mark_tcpip_thread(void)
|
---|
578 | {
|
---|
579 | #if !NO_SYS
|
---|
580 | lwip_tcpip_thread = xTaskGetCurrentTaskHandle();
|
---|
581 | #endif
|
---|
582 | }
|
---|
583 |
|
---|
584 | void
|
---|
585 | sys_check_core_locking(void)
|
---|
586 | {
|
---|
587 | /* Embedded systems should check we are NOT in an interrupt context here */
|
---|
588 | /* E.g. core Cortex-M3/M4 ports:
|
---|
589 | configASSERT( ( portNVIC_INT_CTRL_REG & portVECTACTIVE_MASK ) == 0 );
|
---|
590 |
|
---|
591 | Instead, we use more generic FreeRTOS functions here, which should fail from ISR: */
|
---|
592 | taskENTER_CRITICAL();
|
---|
593 | taskEXIT_CRITICAL();
|
---|
594 |
|
---|
595 | #if !NO_SYS
|
---|
596 | if (lwip_tcpip_thread != 0) {
|
---|
597 | TaskHandle_t current_thread = xTaskGetCurrentTaskHandle();
|
---|
598 |
|
---|
599 | #if LWIP_TCPIP_CORE_LOCKING
|
---|
600 | LWIP_ASSERT("Function called without core lock",
|
---|
601 | current_thread == lwip_core_lock_holder_thread && lwip_core_lock_count > 0);
|
---|
602 | #else /* LWIP_TCPIP_CORE_LOCKING */
|
---|
603 | LWIP_ASSERT("Function called from wrong thread", current_thread == lwip_tcpip_thread);
|
---|
604 | #endif /* LWIP_TCPIP_CORE_LOCKING */
|
---|
605 | }
|
---|
606 | #endif /* !NO_SYS */
|
---|
607 | }
|
---|
608 |
|
---|
609 | #endif /* LWIP_FREERTOS_CHECK_CORE_LOCKING*/
|
---|