takashi kadono / Mbed OS Nucleo446_SSD1331

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   ssd1331

mbed-os/features/lwipstack/lwip-sys/arch/lwip_sys_arch.c@0:8fdf9a60065b, 2018-10-10 (annotated)

Committer:
kadonotakashi
Date:
Wed Oct 10 00:33:53 2018 +0000
Revision:
0:8fdf9a60065b
how to make mbed librry

Who changed what in which revision?

UserRevisionLine numberNew contents of line
kadonotakashi 0:8fdf9a60065b 1 /* Copyright (C) 2012 mbed.org, MIT License
kadonotakashi 0:8fdf9a60065b 2 *
kadonotakashi 0:8fdf9a60065b 3 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
kadonotakashi 0:8fdf9a60065b 4 * and associated documentation files (the "Software"), to deal in the Software without restriction,
kadonotakashi 0:8fdf9a60065b 5 * including without limitation the rights to use, copy, modify, merge, publish, distribute,
kadonotakashi 0:8fdf9a60065b 6 * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
kadonotakashi 0:8fdf9a60065b 7 * furnished to do so, subject to the following conditions:
kadonotakashi 0:8fdf9a60065b 8 *
kadonotakashi 0:8fdf9a60065b 9 * The above copyright notice and this permission notice shall be included in all copies or
kadonotakashi 0:8fdf9a60065b 10 * substantial portions of the Software.
kadonotakashi 0:8fdf9a60065b 11 *
kadonotakashi 0:8fdf9a60065b 12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
kadonotakashi 0:8fdf9a60065b 13 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
kadonotakashi 0:8fdf9a60065b 14 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
kadonotakashi 0:8fdf9a60065b 15 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
kadonotakashi 0:8fdf9a60065b 16 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
kadonotakashi 0:8fdf9a60065b 17 */
kadonotakashi 0:8fdf9a60065b 18 #include <string.h>
kadonotakashi 0:8fdf9a60065b 19
kadonotakashi 0:8fdf9a60065b 20 /* mbed includes */
kadonotakashi 0:8fdf9a60065b 21 #include "mbed_error.h"
kadonotakashi 0:8fdf9a60065b 22 #include "mbed_interface.h"
kadonotakashi 0:8fdf9a60065b 23 #include "mbed_rtos_storage.h"
kadonotakashi 0:8fdf9a60065b 24
kadonotakashi 0:8fdf9a60065b 25 /* lwIP includes. */
kadonotakashi 0:8fdf9a60065b 26 #include "lwip/opt.h"
kadonotakashi 0:8fdf9a60065b 27 #include "lwip/debug.h"
kadonotakashi 0:8fdf9a60065b 28 #include "lwip/def.h"
kadonotakashi 0:8fdf9a60065b 29 #include "lwip/sys.h"
kadonotakashi 0:8fdf9a60065b 30 #include "lwip/mem.h"
kadonotakashi 0:8fdf9a60065b 31
kadonotakashi 0:8fdf9a60065b 32 /* Define the heap ourselves to give us section placement control */
kadonotakashi 0:8fdf9a60065b 33 #ifndef ETHMEM_SECTION
kadonotakashi 0:8fdf9a60065b 34 #if defined(TARGET_LPC4088) || defined(TARGET_LPC4088_DM)
kadonotakashi 0:8fdf9a60065b 35 # if defined (__ICCARM__)
kadonotakashi 0:8fdf9a60065b 36 # define ETHMEM_SECTION
kadonotakashi 0:8fdf9a60065b 37 # elif defined(TOOLCHAIN_GCC_CR)
kadonotakashi 0:8fdf9a60065b 38 # define ETHMEM_SECTION __attribute__((section(".data.$RamPeriph32")))
kadonotakashi 0:8fdf9a60065b 39 # else
kadonotakashi 0:8fdf9a60065b 40 # define ETHMEM_SECTION __attribute__((section("AHBSRAM1"),aligned))
kadonotakashi 0:8fdf9a60065b 41 # endif
kadonotakashi 0:8fdf9a60065b 42 #elif defined(TARGET_LPC1768)
kadonotakashi 0:8fdf9a60065b 43 # if defined (__ICCARM__)
kadonotakashi 0:8fdf9a60065b 44 # define ETHMEM_SECTION
kadonotakashi 0:8fdf9a60065b 45 # elif defined(TOOLCHAIN_GCC_CR)
kadonotakashi 0:8fdf9a60065b 46 # define ETHMEM_SECTION __attribute__((section(".data.$RamPeriph32")))
kadonotakashi 0:8fdf9a60065b 47 # else
kadonotakashi 0:8fdf9a60065b 48 # define ETHMEM_SECTION __attribute__((section("AHBSRAM0"),aligned))
kadonotakashi 0:8fdf9a60065b 49 # endif
kadonotakashi 0:8fdf9a60065b 50 #else
kadonotakashi 0:8fdf9a60065b 51 #define ETHMEM_SECTION
kadonotakashi 0:8fdf9a60065b 52 #endif
kadonotakashi 0:8fdf9a60065b 53 #endif
kadonotakashi 0:8fdf9a60065b 54
kadonotakashi 0:8fdf9a60065b 55 /* LWIP's mem.c doesn't give visibility of its overhead; memory area has to be big
kadonotakashi 0:8fdf9a60065b 56 * enough to hold "MEM_SIZE" (which we specify) plus mem.c's overhead. Have to work
kadonotakashi 0:8fdf9a60065b 57 * it all out here, copying code from mem.c */
kadonotakashi 0:8fdf9a60065b 58 struct mem {
kadonotakashi 0:8fdf9a60065b 59 /** index (-> ram[next]) of the next struct */
kadonotakashi 0:8fdf9a60065b 60 mem_size_t next;
kadonotakashi 0:8fdf9a60065b 61 /** index (-> ram[prev]) of the previous struct */
kadonotakashi 0:8fdf9a60065b 62 mem_size_t prev;
kadonotakashi 0:8fdf9a60065b 63 /** 1: this area is used; 0: this area is unused */
kadonotakashi 0:8fdf9a60065b 64 u8_t used;
kadonotakashi 0:8fdf9a60065b 65 };
kadonotakashi 0:8fdf9a60065b 66
kadonotakashi 0:8fdf9a60065b 67 #define SIZEOF_STRUCT_MEM LWIP_MEM_ALIGN_SIZE(sizeof(struct mem))
kadonotakashi 0:8fdf9a60065b 68 #define MEM_SIZE_ALIGNED LWIP_MEM_ALIGN_SIZE(MEM_SIZE)
kadonotakashi 0:8fdf9a60065b 69
kadonotakashi 0:8fdf9a60065b 70 #if defined (__ICCARM__)
kadonotakashi 0:8fdf9a60065b 71 #pragma location = ".ethusbram"
kadonotakashi 0:8fdf9a60065b 72 #endif
kadonotakashi 0:8fdf9a60065b 73 LWIP_DECLARE_MEMORY_ALIGNED(lwip_ram_heap, MEM_SIZE_ALIGNED + (2U*SIZEOF_STRUCT_MEM)) ETHMEM_SECTION;
kadonotakashi 0:8fdf9a60065b 74
kadonotakashi 0:8fdf9a60065b 75 #if NO_SYS==1
kadonotakashi 0:8fdf9a60065b 76 #include "cmsis.h"
kadonotakashi 0:8fdf9a60065b 77
kadonotakashi 0:8fdf9a60065b 78 /* Saved total time in ms since timer was enabled */
kadonotakashi 0:8fdf9a60065b 79 static volatile u32_t systick_timems;
kadonotakashi 0:8fdf9a60065b 80
kadonotakashi 0:8fdf9a60065b 81 /* Enable systick rate and interrupt */
kadonotakashi 0:8fdf9a60065b 82 void SysTick_Init(void) {
kadonotakashi 0:8fdf9a60065b 83 if (SysTick_Config(SystemCoreClock / 1000)) {
kadonotakashi 0:8fdf9a60065b 84 while (1); /* Capture error */
kadonotakashi 0:8fdf9a60065b 85 }
kadonotakashi 0:8fdf9a60065b 86 }
kadonotakashi 0:8fdf9a60065b 87
kadonotakashi 0:8fdf9a60065b 88 /** \brief SysTick IRQ handler and timebase management
kadonotakashi 0:8fdf9a60065b 89 *
kadonotakashi 0:8fdf9a60065b 90 * This function keeps a timebase for the sysTick that can be
kadonotakashi 0:8fdf9a60065b 91 * used for other functions. It also calls an external function
kadonotakashi 0:8fdf9a60065b 92 * (SysTick_User) that must be defined outside this handler.
kadonotakashi 0:8fdf9a60065b 93 */
kadonotakashi 0:8fdf9a60065b 94 void SysTick_Handler(void) {
kadonotakashi 0:8fdf9a60065b 95 systick_timems++;
kadonotakashi 0:8fdf9a60065b 96 }
kadonotakashi 0:8fdf9a60065b 97
kadonotakashi 0:8fdf9a60065b 98 /* Delay for the specified number of milliSeconds */
kadonotakashi 0:8fdf9a60065b 99 void osDelay(uint32_t ms) {
kadonotakashi 0:8fdf9a60065b 100 uint32_t to = ms + systick_timems;
kadonotakashi 0:8fdf9a60065b 101 while (to > systick_timems);
kadonotakashi 0:8fdf9a60065b 102 }
kadonotakashi 0:8fdf9a60065b 103
kadonotakashi 0:8fdf9a60065b 104 /* Returns the current time in mS. This is needed for the LWIP timers */
kadonotakashi 0:8fdf9a60065b 105 u32_t sys_now(void) {
kadonotakashi 0:8fdf9a60065b 106 return (u32_t) systick_timems;
kadonotakashi 0:8fdf9a60065b 107 }
kadonotakashi 0:8fdf9a60065b 108
kadonotakashi 0:8fdf9a60065b 109 #else
kadonotakashi 0:8fdf9a60065b 110 /* CMSIS-RTOS implementation of the lwip operating system abstraction */
kadonotakashi 0:8fdf9a60065b 111 #include "arch/sys_arch.h"
kadonotakashi 0:8fdf9a60065b 112
kadonotakashi 0:8fdf9a60065b 113 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 114 * Routine: sys_mbox_new
kadonotakashi 0:8fdf9a60065b 115 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 116 * Description:
kadonotakashi 0:8fdf9a60065b 117 * Creates a new mailbox
kadonotakashi 0:8fdf9a60065b 118 * Inputs:
kadonotakashi 0:8fdf9a60065b 119 * sys_mbox_t mbox -- Handle of mailbox
kadonotakashi 0:8fdf9a60065b 120 * int queue_sz -- Size of elements in the mailbox
kadonotakashi 0:8fdf9a60065b 121 * Outputs:
kadonotakashi 0:8fdf9a60065b 122 * err_t -- ERR_OK if message posted, else ERR_MEM
kadonotakashi 0:8fdf9a60065b 123 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 124 err_t sys_mbox_new(sys_mbox_t *mbox, int queue_sz) {
kadonotakashi 0:8fdf9a60065b 125 if (queue_sz > MB_SIZE)
kadonotakashi 0:8fdf9a60065b 126 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_INVALID_SIZE), "sys_mbox_new size error\n", queue_sz);
kadonotakashi 0:8fdf9a60065b 127
kadonotakashi 0:8fdf9a60065b 128 memset(mbox, 0, sizeof(*mbox));
kadonotakashi 0:8fdf9a60065b 129
kadonotakashi 0:8fdf9a60065b 130 mbox->attr.cb_mem = &mbox->data;
kadonotakashi 0:8fdf9a60065b 131 mbox->attr.cb_size = sizeof(mbox->data);
kadonotakashi 0:8fdf9a60065b 132 mbox->id = osEventFlagsNew(&mbox->attr);
kadonotakashi 0:8fdf9a60065b 133 if (mbox->id == NULL)
kadonotakashi 0:8fdf9a60065b 134 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_FAILED_OPERATION), "sys_mbox_new create error\n", (u32_t)mbox);
kadonotakashi 0:8fdf9a60065b 135
kadonotakashi 0:8fdf9a60065b 136 osEventFlagsSet(mbox->id, SYS_MBOX_POST_EVENT);
kadonotakashi 0:8fdf9a60065b 137
kadonotakashi 0:8fdf9a60065b 138 return ERR_OK;
kadonotakashi 0:8fdf9a60065b 139 }
kadonotakashi 0:8fdf9a60065b 140
kadonotakashi 0:8fdf9a60065b 141 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 142 * Routine: sys_mbox_free
kadonotakashi 0:8fdf9a60065b 143 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 144 * Description:
kadonotakashi 0:8fdf9a60065b 145 * Deallocates a mailbox. If there are messages still present in the
kadonotakashi 0:8fdf9a60065b 146 * mailbox when the mailbox is deallocated, it is an indication of a
kadonotakashi 0:8fdf9a60065b 147 * programming error in lwIP and the developer should be notified.
kadonotakashi 0:8fdf9a60065b 148 * Inputs:
kadonotakashi 0:8fdf9a60065b 149 * sys_mbox_t *mbox -- Handle of mailbox
kadonotakashi 0:8fdf9a60065b 150 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 151 void sys_mbox_free(sys_mbox_t *mbox) {
kadonotakashi 0:8fdf9a60065b 152 if (mbox->post_idx != mbox->fetch_idx)
kadonotakashi 0:8fdf9a60065b 153 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_INVALID_INDEX), "sys_mbox_free error\n", (u32_t)mbox->fetch_idx);
kadonotakashi 0:8fdf9a60065b 154 }
kadonotakashi 0:8fdf9a60065b 155
kadonotakashi 0:8fdf9a60065b 156 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 157 * Routine: sys_mbox_post
kadonotakashi 0:8fdf9a60065b 158 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 159 * Description:
kadonotakashi 0:8fdf9a60065b 160 * Post the "msg" to the mailbox.
kadonotakashi 0:8fdf9a60065b 161 * Inputs:
kadonotakashi 0:8fdf9a60065b 162 * sys_mbox_t mbox -- Handle of mailbox
kadonotakashi 0:8fdf9a60065b 163 * void *msg -- Pointer to data to post
kadonotakashi 0:8fdf9a60065b 164 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 165 void sys_mbox_post(sys_mbox_t *mbox, void *msg) {
kadonotakashi 0:8fdf9a60065b 166 osEventFlagsWait(mbox->id, SYS_MBOX_POST_EVENT,
kadonotakashi 0:8fdf9a60065b 167 osFlagsWaitAny | osFlagsNoClear, osWaitForever);
kadonotakashi 0:8fdf9a60065b 168
kadonotakashi 0:8fdf9a60065b 169 int state = osKernelLock();
kadonotakashi 0:8fdf9a60065b 170
kadonotakashi 0:8fdf9a60065b 171 mbox->queue[mbox->post_idx % MB_SIZE] = msg;
kadonotakashi 0:8fdf9a60065b 172 mbox->post_idx += 1;
kadonotakashi 0:8fdf9a60065b 173
kadonotakashi 0:8fdf9a60065b 174 osEventFlagsSet(mbox->id, SYS_MBOX_FETCH_EVENT);
kadonotakashi 0:8fdf9a60065b 175 if (mbox->post_idx - mbox->fetch_idx == MB_SIZE-1)
kadonotakashi 0:8fdf9a60065b 176 osEventFlagsClear(mbox->id, SYS_MBOX_POST_EVENT);
kadonotakashi 0:8fdf9a60065b 177
kadonotakashi 0:8fdf9a60065b 178 osKernelRestoreLock(state);
kadonotakashi 0:8fdf9a60065b 179 }
kadonotakashi 0:8fdf9a60065b 180
kadonotakashi 0:8fdf9a60065b 181 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 182 * Routine: sys_mbox_trypost
kadonotakashi 0:8fdf9a60065b 183 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 184 * Description:
kadonotakashi 0:8fdf9a60065b 185 * Try to post the "msg" to the mailbox. Returns immediately with
kadonotakashi 0:8fdf9a60065b 186 * error if cannot.
kadonotakashi 0:8fdf9a60065b 187 * Inputs:
kadonotakashi 0:8fdf9a60065b 188 * sys_mbox_t mbox -- Handle of mailbox
kadonotakashi 0:8fdf9a60065b 189 * void *msg -- Pointer to data to post
kadonotakashi 0:8fdf9a60065b 190 * Outputs:
kadonotakashi 0:8fdf9a60065b 191 * err_t -- ERR_OK if message posted, else ERR_MEM
kadonotakashi 0:8fdf9a60065b 192 * if not.
kadonotakashi 0:8fdf9a60065b 193 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 194 err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg) {
kadonotakashi 0:8fdf9a60065b 195 uint32_t flags = osEventFlagsWait(mbox->id, SYS_MBOX_POST_EVENT,
kadonotakashi 0:8fdf9a60065b 196 osFlagsWaitAny | osFlagsNoClear, 0);
kadonotakashi 0:8fdf9a60065b 197 if ((flags & osFlagsError) || !(flags & SYS_MBOX_POST_EVENT)) {
kadonotakashi 0:8fdf9a60065b 198 MBED_WARNING1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_FAILED_OPERATION), "sys_mbox_trypost error\n", flags);
kadonotakashi 0:8fdf9a60065b 199 return ERR_MEM;
kadonotakashi 0:8fdf9a60065b 200 }
kadonotakashi 0:8fdf9a60065b 201
kadonotakashi 0:8fdf9a60065b 202 int state = osKernelLock();
kadonotakashi 0:8fdf9a60065b 203
kadonotakashi 0:8fdf9a60065b 204 mbox->queue[mbox->post_idx % MB_SIZE] = msg;
kadonotakashi 0:8fdf9a60065b 205 mbox->post_idx += 1;
kadonotakashi 0:8fdf9a60065b 206
kadonotakashi 0:8fdf9a60065b 207 osEventFlagsSet(mbox->id, SYS_MBOX_FETCH_EVENT);
kadonotakashi 0:8fdf9a60065b 208 if (mbox->post_idx - mbox->fetch_idx == MB_SIZE-1)
kadonotakashi 0:8fdf9a60065b 209 osEventFlagsClear(mbox->id, SYS_MBOX_POST_EVENT);
kadonotakashi 0:8fdf9a60065b 210
kadonotakashi 0:8fdf9a60065b 211 osKernelRestoreLock(state);
kadonotakashi 0:8fdf9a60065b 212 return ERR_OK;
kadonotakashi 0:8fdf9a60065b 213 }
kadonotakashi 0:8fdf9a60065b 214
kadonotakashi 0:8fdf9a60065b 215 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 216 * Routine: sys_arch_mbox_fetch
kadonotakashi 0:8fdf9a60065b 217 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 218 * Description:
kadonotakashi 0:8fdf9a60065b 219 * Blocks the thread until a message arrives in the mailbox, but does
kadonotakashi 0:8fdf9a60065b 220 * not block the thread longer than "timeout" milliseconds (similar to
kadonotakashi 0:8fdf9a60065b 221 * the sys_arch_sem_wait() function). The "msg" argument is a result
kadonotakashi 0:8fdf9a60065b 222 * parameter that is set by the function (i.e., by doing "*msg =
kadonotakashi 0:8fdf9a60065b 223 * ptr"). The "msg" parameter maybe NULL to indicate that the message
kadonotakashi 0:8fdf9a60065b 224 * should be dropped.
kadonotakashi 0:8fdf9a60065b 225 *
kadonotakashi 0:8fdf9a60065b 226 * The return values are the same as for the sys_arch_sem_wait() function:
kadonotakashi 0:8fdf9a60065b 227 * Number of milliseconds spent waiting or SYS_ARCH_TIMEOUT if there was a
kadonotakashi 0:8fdf9a60065b 228 * timeout.
kadonotakashi 0:8fdf9a60065b 229 *
kadonotakashi 0:8fdf9a60065b 230 * Note that a function with a similar name, sys_mbox_fetch(), is
kadonotakashi 0:8fdf9a60065b 231 * implemented by lwIP.
kadonotakashi 0:8fdf9a60065b 232 * Inputs:
kadonotakashi 0:8fdf9a60065b 233 * sys_mbox_t mbox -- Handle of mailbox
kadonotakashi 0:8fdf9a60065b 234 * void **msg -- Pointer to pointer to msg received
kadonotakashi 0:8fdf9a60065b 235 * u32_t timeout -- Number of milliseconds until timeout
kadonotakashi 0:8fdf9a60065b 236 * Outputs:
kadonotakashi 0:8fdf9a60065b 237 * u32_t -- SYS_ARCH_TIMEOUT if timeout, else number
kadonotakashi 0:8fdf9a60065b 238 * of milliseconds until received.
kadonotakashi 0:8fdf9a60065b 239 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 240 u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout) {
kadonotakashi 0:8fdf9a60065b 241 uint32_t start = osKernelGetTickCount();
kadonotakashi 0:8fdf9a60065b 242 uint32_t flags = osEventFlagsWait(mbox->id, SYS_MBOX_FETCH_EVENT,
kadonotakashi 0:8fdf9a60065b 243 osFlagsWaitAny | osFlagsNoClear, (timeout ? timeout : osWaitForever));
kadonotakashi 0:8fdf9a60065b 244 if ((flags & osFlagsError) || !(flags & SYS_MBOX_FETCH_EVENT)) {
kadonotakashi 0:8fdf9a60065b 245 MBED_WARNING1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_TIME_OUT), "sys_arch_mbox_fetch time-out\n", flags);
kadonotakashi 0:8fdf9a60065b 246 return SYS_ARCH_TIMEOUT;
kadonotakashi 0:8fdf9a60065b 247 }
kadonotakashi 0:8fdf9a60065b 248
kadonotakashi 0:8fdf9a60065b 249 int state = osKernelLock();
kadonotakashi 0:8fdf9a60065b 250
kadonotakashi 0:8fdf9a60065b 251 if (msg)
kadonotakashi 0:8fdf9a60065b 252 *msg = mbox->queue[mbox->fetch_idx % MB_SIZE];
kadonotakashi 0:8fdf9a60065b 253 mbox->fetch_idx += 1;
kadonotakashi 0:8fdf9a60065b 254
kadonotakashi 0:8fdf9a60065b 255 osEventFlagsSet(mbox->id, SYS_MBOX_POST_EVENT);
kadonotakashi 0:8fdf9a60065b 256 if (mbox->post_idx == mbox->fetch_idx)
kadonotakashi 0:8fdf9a60065b 257 osEventFlagsClear(mbox->id, SYS_MBOX_FETCH_EVENT);
kadonotakashi 0:8fdf9a60065b 258
kadonotakashi 0:8fdf9a60065b 259 osKernelRestoreLock(state);
kadonotakashi 0:8fdf9a60065b 260 return osKernelGetTickCount() - start;
kadonotakashi 0:8fdf9a60065b 261 }
kadonotakashi 0:8fdf9a60065b 262
kadonotakashi 0:8fdf9a60065b 263 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 264 * Routine: sys_arch_mbox_tryfetch
kadonotakashi 0:8fdf9a60065b 265 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 266 * Description:
kadonotakashi 0:8fdf9a60065b 267 * Similar to sys_arch_mbox_fetch, but if message is not ready
kadonotakashi 0:8fdf9a60065b 268 * immediately, we'll return with SYS_MBOX_EMPTY. On success, 0 is
kadonotakashi 0:8fdf9a60065b 269 * returned.
kadonotakashi 0:8fdf9a60065b 270 * Inputs:
kadonotakashi 0:8fdf9a60065b 271 * sys_mbox_t mbox -- Handle of mailbox
kadonotakashi 0:8fdf9a60065b 272 * void **msg -- Pointer to pointer to msg received
kadonotakashi 0:8fdf9a60065b 273 * Outputs:
kadonotakashi 0:8fdf9a60065b 274 * u32_t -- SYS_MBOX_EMPTY if no messages. Otherwise,
kadonotakashi 0:8fdf9a60065b 275 * return ERR_OK.
kadonotakashi 0:8fdf9a60065b 276 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 277 u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg) {
kadonotakashi 0:8fdf9a60065b 278 uint32_t flags = osEventFlagsWait(mbox->id, SYS_MBOX_FETCH_EVENT,
kadonotakashi 0:8fdf9a60065b 279 osFlagsWaitAny | osFlagsNoClear, 0);
kadonotakashi 0:8fdf9a60065b 280 if ((flags & osFlagsError) || !(flags & SYS_MBOX_FETCH_EVENT)) {
kadonotakashi 0:8fdf9a60065b 281 MBED_WARNING1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_FAILED_OPERATION), "sys_arch_mbox_tryfetch empty\n", flags);
kadonotakashi 0:8fdf9a60065b 282 return SYS_MBOX_EMPTY;
kadonotakashi 0:8fdf9a60065b 283 }
kadonotakashi 0:8fdf9a60065b 284
kadonotakashi 0:8fdf9a60065b 285 int state = osKernelLock();
kadonotakashi 0:8fdf9a60065b 286
kadonotakashi 0:8fdf9a60065b 287 if (msg)
kadonotakashi 0:8fdf9a60065b 288 *msg = mbox->queue[mbox->fetch_idx % MB_SIZE];
kadonotakashi 0:8fdf9a60065b 289 mbox->fetch_idx += 1;
kadonotakashi 0:8fdf9a60065b 290
kadonotakashi 0:8fdf9a60065b 291 osEventFlagsSet(mbox->id, SYS_MBOX_POST_EVENT);
kadonotakashi 0:8fdf9a60065b 292 if (mbox->post_idx == mbox->fetch_idx)
kadonotakashi 0:8fdf9a60065b 293 osEventFlagsClear(mbox->id, SYS_MBOX_FETCH_EVENT);
kadonotakashi 0:8fdf9a60065b 294
kadonotakashi 0:8fdf9a60065b 295 osKernelRestoreLock(state);
kadonotakashi 0:8fdf9a60065b 296 return ERR_OK;
kadonotakashi 0:8fdf9a60065b 297 }
kadonotakashi 0:8fdf9a60065b 298
kadonotakashi 0:8fdf9a60065b 299 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 300 * Routine: sys_sem_new
kadonotakashi 0:8fdf9a60065b 301 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 302 * Description:
kadonotakashi 0:8fdf9a60065b 303 * Creates and returns a new semaphore. The "ucCount" argument specifies
kadonotakashi 0:8fdf9a60065b 304 * the initial state of the semaphore.
kadonotakashi 0:8fdf9a60065b 305 * NOTE: Currently this routine only creates counts of 1 or 0
kadonotakashi 0:8fdf9a60065b 306 * Inputs:
kadonotakashi 0:8fdf9a60065b 307 * sys_sem_t sem -- Handle of semaphore
kadonotakashi 0:8fdf9a60065b 308 * u8_t count -- Initial count of semaphore
kadonotakashi 0:8fdf9a60065b 309 * Outputs:
kadonotakashi 0:8fdf9a60065b 310 * err_t -- ERR_OK if semaphore created
kadonotakashi 0:8fdf9a60065b 311 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 312 err_t sys_sem_new(sys_sem_t *sem, u8_t count) {
kadonotakashi 0:8fdf9a60065b 313 memset(sem, 0, sizeof(*sem));
kadonotakashi 0:8fdf9a60065b 314 sem->attr.cb_mem = &sem->data;
kadonotakashi 0:8fdf9a60065b 315 sem->attr.cb_size = sizeof(sem->data);
kadonotakashi 0:8fdf9a60065b 316 sem->id = osSemaphoreNew(UINT16_MAX, count, &sem->attr);
kadonotakashi 0:8fdf9a60065b 317 if (sem->id == NULL)
kadonotakashi 0:8fdf9a60065b 318 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_FAILED_OPERATION), "sys_sem_new create error\n", (u32_t)sem);
kadonotakashi 0:8fdf9a60065b 319
kadonotakashi 0:8fdf9a60065b 320 return ERR_OK;
kadonotakashi 0:8fdf9a60065b 321 }
kadonotakashi 0:8fdf9a60065b 322
kadonotakashi 0:8fdf9a60065b 323 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 324 * Routine: sys_arch_sem_wait
kadonotakashi 0:8fdf9a60065b 325 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 326 * Description:
kadonotakashi 0:8fdf9a60065b 327 * Blocks the thread while waiting for the semaphore to be
kadonotakashi 0:8fdf9a60065b 328 * signaled. If the "timeout" argument is non-zero, the thread should
kadonotakashi 0:8fdf9a60065b 329 * only be blocked for the specified time (measured in
kadonotakashi 0:8fdf9a60065b 330 * milliseconds).
kadonotakashi 0:8fdf9a60065b 331 *
kadonotakashi 0:8fdf9a60065b 332 * If the timeout argument is non-zero, the return value is the number of
kadonotakashi 0:8fdf9a60065b 333 * milliseconds spent waiting for the semaphore to be signaled. If the
kadonotakashi 0:8fdf9a60065b 334 * semaphore wasn't signaled within the specified time, the return value is
kadonotakashi 0:8fdf9a60065b 335 * SYS_ARCH_TIMEOUT. If the thread didn't have to wait for the semaphore
kadonotakashi 0:8fdf9a60065b 336 * (i.e., it was already signaled), the function may return zero.
kadonotakashi 0:8fdf9a60065b 337 *
kadonotakashi 0:8fdf9a60065b 338 * Notice that lwIP implements a function with a similar name,
kadonotakashi 0:8fdf9a60065b 339 * sys_sem_wait(), that uses the sys_arch_sem_wait() function.
kadonotakashi 0:8fdf9a60065b 340 * Inputs:
kadonotakashi 0:8fdf9a60065b 341 * sys_sem_t sem -- Semaphore to wait on
kadonotakashi 0:8fdf9a60065b 342 * u32_t timeout -- Number of milliseconds until timeout
kadonotakashi 0:8fdf9a60065b 343 * Outputs:
kadonotakashi 0:8fdf9a60065b 344 * u32_t -- Time elapsed or SYS_ARCH_TIMEOUT.
kadonotakashi 0:8fdf9a60065b 345 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 346 u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout) {
kadonotakashi 0:8fdf9a60065b 347 u32_t start = osKernelGetTickCount();
kadonotakashi 0:8fdf9a60065b 348
kadonotakashi 0:8fdf9a60065b 349 if (osSemaphoreAcquire(sem->id, (timeout != 0)?(timeout):(osWaitForever)) != osOK) {
kadonotakashi 0:8fdf9a60065b 350 MBED_WARNING1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_TIME_OUT), "sys_arch_sem_wait time out\n", (u32_t)sem);
kadonotakashi 0:8fdf9a60065b 351 return SYS_ARCH_TIMEOUT;
kadonotakashi 0:8fdf9a60065b 352 }
kadonotakashi 0:8fdf9a60065b 353
kadonotakashi 0:8fdf9a60065b 354 return osKernelGetTickCount() - start;
kadonotakashi 0:8fdf9a60065b 355 }
kadonotakashi 0:8fdf9a60065b 356
kadonotakashi 0:8fdf9a60065b 357 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 358 * Routine: sys_sem_signal
kadonotakashi 0:8fdf9a60065b 359 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 360 * Description:
kadonotakashi 0:8fdf9a60065b 361 * Signals (releases) a semaphore
kadonotakashi 0:8fdf9a60065b 362 * Inputs:
kadonotakashi 0:8fdf9a60065b 363 * sys_sem_t sem -- Semaphore to signal
kadonotakashi 0:8fdf9a60065b 364 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 365 void sys_sem_signal(sys_sem_t *data) {
kadonotakashi 0:8fdf9a60065b 366 if (osSemaphoreRelease(data->id) != osOK)
kadonotakashi 0:8fdf9a60065b 367 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_SEMAPHORE_UNLOCK_FAILED), "sys_sem_signal error\n", (u32_t)data->id);
kadonotakashi 0:8fdf9a60065b 368 }
kadonotakashi 0:8fdf9a60065b 369
kadonotakashi 0:8fdf9a60065b 370 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 371 * Routine: sys_sem_free
kadonotakashi 0:8fdf9a60065b 372 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 373 * Description:
kadonotakashi 0:8fdf9a60065b 374 * Deallocates a semaphore
kadonotakashi 0:8fdf9a60065b 375 * Inputs:
kadonotakashi 0:8fdf9a60065b 376 * sys_sem_t sem -- Semaphore to free
kadonotakashi 0:8fdf9a60065b 377 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 378 void sys_sem_free(sys_sem_t *sem) {}
kadonotakashi 0:8fdf9a60065b 379
kadonotakashi 0:8fdf9a60065b 380 /** Create a new mutex
kadonotakashi 0:8fdf9a60065b 381 * @param mutex pointer to the mutex to create
kadonotakashi 0:8fdf9a60065b 382 * @return a new mutex */
kadonotakashi 0:8fdf9a60065b 383 err_t sys_mutex_new(sys_mutex_t *mutex) {
kadonotakashi 0:8fdf9a60065b 384 memset(mutex, 0, sizeof(*mutex));
kadonotakashi 0:8fdf9a60065b 385 mutex->attr.name = "lwip_mutex";
kadonotakashi 0:8fdf9a60065b 386 mutex->attr.cb_mem = &mutex->data;
kadonotakashi 0:8fdf9a60065b 387 mutex->attr.cb_size = sizeof(mutex->data);
kadonotakashi 0:8fdf9a60065b 388 mutex->id = osMutexNew(&mutex->attr);
kadonotakashi 0:8fdf9a60065b 389 if (mutex->id == NULL) {
kadonotakashi 0:8fdf9a60065b 390 MBED_WARNING1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_FAILED_OPERATION), "sys_mutex_new error\n", (u32_t)mutex);
kadonotakashi 0:8fdf9a60065b 391 return ERR_MEM;
kadonotakashi 0:8fdf9a60065b 392 }
kadonotakashi 0:8fdf9a60065b 393
kadonotakashi 0:8fdf9a60065b 394 return ERR_OK;
kadonotakashi 0:8fdf9a60065b 395 }
kadonotakashi 0:8fdf9a60065b 396
kadonotakashi 0:8fdf9a60065b 397 /** Lock a mutex
kadonotakashi 0:8fdf9a60065b 398 * @param mutex the mutex to lock */
kadonotakashi 0:8fdf9a60065b 399 void sys_mutex_lock(sys_mutex_t *mutex) {
kadonotakashi 0:8fdf9a60065b 400 if (osMutexAcquire(mutex->id, osWaitForever) != osOK)
kadonotakashi 0:8fdf9a60065b 401 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_mutex_lock error\n", (u32_t)mutex);
kadonotakashi 0:8fdf9a60065b 402 }
kadonotakashi 0:8fdf9a60065b 403
kadonotakashi 0:8fdf9a60065b 404 /** Unlock a mutex
kadonotakashi 0:8fdf9a60065b 405 * @param mutex the mutex to unlock */
kadonotakashi 0:8fdf9a60065b 406 void sys_mutex_unlock(sys_mutex_t *mutex) {
kadonotakashi 0:8fdf9a60065b 407 if (osMutexRelease(mutex->id) != osOK)
kadonotakashi 0:8fdf9a60065b 408 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_UNLOCK_FAILED), "sys_mutex_unlock error\n", (u32_t)mutex);
kadonotakashi 0:8fdf9a60065b 409 }
kadonotakashi 0:8fdf9a60065b 410
kadonotakashi 0:8fdf9a60065b 411 /** Delete a mutex
kadonotakashi 0:8fdf9a60065b 412 * @param mutex the mutex to delete */
kadonotakashi 0:8fdf9a60065b 413 void sys_mutex_free(sys_mutex_t *mutex) {}
kadonotakashi 0:8fdf9a60065b 414
kadonotakashi 0:8fdf9a60065b 415 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 416 * Routine: sys_init
kadonotakashi 0:8fdf9a60065b 417 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 418 * Description:
kadonotakashi 0:8fdf9a60065b 419 * Initialize sys arch
kadonotakashi 0:8fdf9a60065b 420 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 421 osMutexId_t lwip_sys_mutex;
kadonotakashi 0:8fdf9a60065b 422 osMutexAttr_t lwip_sys_mutex_attr;
kadonotakashi 0:8fdf9a60065b 423 mbed_rtos_storage_mutex_t lwip_sys_mutex_data;
kadonotakashi 0:8fdf9a60065b 424
kadonotakashi 0:8fdf9a60065b 425 void sys_init(void) {
kadonotakashi 0:8fdf9a60065b 426 lwip_sys_mutex_attr.name = "lwip_sys_mutex";
kadonotakashi 0:8fdf9a60065b 427 lwip_sys_mutex_attr.cb_mem = &lwip_sys_mutex_data;
kadonotakashi 0:8fdf9a60065b 428 lwip_sys_mutex_attr.cb_size = sizeof(lwip_sys_mutex_data);
kadonotakashi 0:8fdf9a60065b 429 lwip_sys_mutex = osMutexNew(&lwip_sys_mutex_attr);
kadonotakashi 0:8fdf9a60065b 430 if (lwip_sys_mutex == NULL)
kadonotakashi 0:8fdf9a60065b 431 MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_INITIALIZATION_FAILED), "sys_init error, mutex initialization failed\n");
kadonotakashi 0:8fdf9a60065b 432 }
kadonotakashi 0:8fdf9a60065b 433
kadonotakashi 0:8fdf9a60065b 434 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 435 * Routine: sys_jiffies
kadonotakashi 0:8fdf9a60065b 436 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 437 * Description:
kadonotakashi 0:8fdf9a60065b 438 * Used by PPP as a timestamp-ish value
kadonotakashi 0:8fdf9a60065b 439 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 440 u32_t sys_jiffies(void) {
kadonotakashi 0:8fdf9a60065b 441 return osKernelGetTickCount();
kadonotakashi 0:8fdf9a60065b 442 }
kadonotakashi 0:8fdf9a60065b 443
kadonotakashi 0:8fdf9a60065b 444 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 445 * Routine: sys_arch_protect
kadonotakashi 0:8fdf9a60065b 446 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 447 * Description:
kadonotakashi 0:8fdf9a60065b 448 * This optional function does a "fast" critical region protection and
kadonotakashi 0:8fdf9a60065b 449 * returns the previous protection level. This function is only called
kadonotakashi 0:8fdf9a60065b 450 * during very short critical regions. An embedded system which supports
kadonotakashi 0:8fdf9a60065b 451 * ISR-based drivers might want to implement this function by disabling
kadonotakashi 0:8fdf9a60065b 452 * interrupts. Task-based systems might want to implement this by using
kadonotakashi 0:8fdf9a60065b 453 * a mutex or disabling tasking. This function should support recursive
kadonotakashi 0:8fdf9a60065b 454 * calls from the same task or interrupt. In other words,
kadonotakashi 0:8fdf9a60065b 455 * sys_arch_protect() could be called while already protected. In
kadonotakashi 0:8fdf9a60065b 456 * that case the return value indicates that it is already protected.
kadonotakashi 0:8fdf9a60065b 457 *
kadonotakashi 0:8fdf9a60065b 458 * sys_arch_protect() is only required if your port is supporting an
kadonotakashi 0:8fdf9a60065b 459 * operating system.
kadonotakashi 0:8fdf9a60065b 460 * Outputs:
kadonotakashi 0:8fdf9a60065b 461 * sys_prot_t -- Previous protection level (not used here)
kadonotakashi 0:8fdf9a60065b 462 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 463 sys_prot_t sys_arch_protect(void) {
kadonotakashi 0:8fdf9a60065b 464 if (osMutexAcquire(lwip_sys_mutex, osWaitForever) != osOK)
kadonotakashi 0:8fdf9a60065b 465 MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_arch_protect error\n");
kadonotakashi 0:8fdf9a60065b 466 return (sys_prot_t) 1;
kadonotakashi 0:8fdf9a60065b 467 }
kadonotakashi 0:8fdf9a60065b 468
kadonotakashi 0:8fdf9a60065b 469 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 470 * Routine: sys_arch_unprotect
kadonotakashi 0:8fdf9a60065b 471 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 472 * Description:
kadonotakashi 0:8fdf9a60065b 473 * This optional function does a "fast" set of critical region
kadonotakashi 0:8fdf9a60065b 474 * protection to the value specified by pval. See the documentation for
kadonotakashi 0:8fdf9a60065b 475 * sys_arch_protect() for more information. This function is only
kadonotakashi 0:8fdf9a60065b 476 * required if your port is supporting an operating system.
kadonotakashi 0:8fdf9a60065b 477 * Inputs:
kadonotakashi 0:8fdf9a60065b 478 * sys_prot_t -- Previous protection level (not used here)
kadonotakashi 0:8fdf9a60065b 479 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 480 void sys_arch_unprotect(sys_prot_t p) {
kadonotakashi 0:8fdf9a60065b 481 if (osMutexRelease(lwip_sys_mutex) != osOK)
kadonotakashi 0:8fdf9a60065b 482 MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_UNLOCK_FAILED), "sys_arch_unprotect error\n");
kadonotakashi 0:8fdf9a60065b 483 }
kadonotakashi 0:8fdf9a60065b 484
kadonotakashi 0:8fdf9a60065b 485 u32_t sys_now(void) {
kadonotakashi 0:8fdf9a60065b 486 return osKernelGetTickCount();
kadonotakashi 0:8fdf9a60065b 487 }
kadonotakashi 0:8fdf9a60065b 488
kadonotakashi 0:8fdf9a60065b 489 void sys_msleep(u32_t ms) {
kadonotakashi 0:8fdf9a60065b 490 osDelay(ms);
kadonotakashi 0:8fdf9a60065b 491 }
kadonotakashi 0:8fdf9a60065b 492
kadonotakashi 0:8fdf9a60065b 493 osThreadId_t lwip_tcpip_thread_id = 0;
kadonotakashi 0:8fdf9a60065b 494
kadonotakashi 0:8fdf9a60065b 495 void sys_tcpip_thread_set(void)
kadonotakashi 0:8fdf9a60065b 496 {
kadonotakashi 0:8fdf9a60065b 497 lwip_tcpip_thread_id = osThreadGetId();
kadonotakashi 0:8fdf9a60065b 498 }
kadonotakashi 0:8fdf9a60065b 499
kadonotakashi 0:8fdf9a60065b 500 bool sys_tcpip_thread_check(void)
kadonotakashi 0:8fdf9a60065b 501 {
kadonotakashi 0:8fdf9a60065b 502 return osThreadGetId() == lwip_tcpip_thread_id;
kadonotakashi 0:8fdf9a60065b 503 }
kadonotakashi 0:8fdf9a60065b 504
kadonotakashi 0:8fdf9a60065b 505 // Keep a pool of thread structures
kadonotakashi 0:8fdf9a60065b 506 static int thread_pool_index = 0;
kadonotakashi 0:8fdf9a60065b 507 static sys_thread_data_t thread_pool[SYS_THREAD_POOL_N];
kadonotakashi 0:8fdf9a60065b 508
kadonotakashi 0:8fdf9a60065b 509 /*---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 510 * Routine: sys_thread_new
kadonotakashi 0:8fdf9a60065b 511 *---------------------------------------------------------------------------*
kadonotakashi 0:8fdf9a60065b 512 * Description:
kadonotakashi 0:8fdf9a60065b 513 * Starts a new thread with priority "prio" that will begin its
kadonotakashi 0:8fdf9a60065b 514 * execution in the function "thread()". The "arg" argument will be
kadonotakashi 0:8fdf9a60065b 515 * passed as an argument to the thread() function. The id of the new
kadonotakashi 0:8fdf9a60065b 516 * thread is returned. Both the id and the priority are system
kadonotakashi 0:8fdf9a60065b 517 * dependent.
kadonotakashi 0:8fdf9a60065b 518 * Inputs:
kadonotakashi 0:8fdf9a60065b 519 * char *name -- Name of thread
kadonotakashi 0:8fdf9a60065b 520 * void (*thread)(void *arg) -- Pointer to function to run.
kadonotakashi 0:8fdf9a60065b 521 * void *arg -- Argument passed into function
kadonotakashi 0:8fdf9a60065b 522 * int stacksize -- Required stack amount in bytes
kadonotakashi 0:8fdf9a60065b 523 * int priority -- Thread priority
kadonotakashi 0:8fdf9a60065b 524 * Outputs:
kadonotakashi 0:8fdf9a60065b 525 * sys_thread_t -- Pointer to thread handle.
kadonotakashi 0:8fdf9a60065b 526 *---------------------------------------------------------------------------*/
kadonotakashi 0:8fdf9a60065b 527 #ifndef MBED_TZ_DEFAULT_ACCESS
kadonotakashi 0:8fdf9a60065b 528 #define MBED_TZ_DEFAULT_ACCESS 0
kadonotakashi 0:8fdf9a60065b 529 #endif
kadonotakashi 0:8fdf9a60065b 530
kadonotakashi 0:8fdf9a60065b 531 sys_thread_t sys_thread_new(const char *pcName,
kadonotakashi 0:8fdf9a60065b 532 void (*thread)(void *arg),
kadonotakashi 0:8fdf9a60065b 533 void *arg, int stacksize, int priority) {
kadonotakashi 0:8fdf9a60065b 534 LWIP_DEBUGF(SYS_DEBUG, ("New Thread: %s\n", pcName));
kadonotakashi 0:8fdf9a60065b 535
kadonotakashi 0:8fdf9a60065b 536 if (thread_pool_index >= SYS_THREAD_POOL_N)
kadonotakashi 0:8fdf9a60065b 537 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_THREAD_CREATE_FAILED), "sys_thread_new number error\n", thread_pool_index);
kadonotakashi 0:8fdf9a60065b 538 sys_thread_t t = (sys_thread_t)&thread_pool[thread_pool_index];
kadonotakashi 0:8fdf9a60065b 539 thread_pool_index++;
kadonotakashi 0:8fdf9a60065b 540
kadonotakashi 0:8fdf9a60065b 541 memset(t, 0, sizeof(*t));
kadonotakashi 0:8fdf9a60065b 542 t->attr.name = pcName ? pcName : "lwip_unnamed_thread";
kadonotakashi 0:8fdf9a60065b 543 t->attr.priority = (osPriority_t)priority;
kadonotakashi 0:8fdf9a60065b 544 t->attr.cb_size = sizeof(t->data);
kadonotakashi 0:8fdf9a60065b 545 t->attr.cb_mem = &t->data;
kadonotakashi 0:8fdf9a60065b 546 t->attr.stack_size = stacksize;
kadonotakashi 0:8fdf9a60065b 547 t->attr.stack_mem = malloc(stacksize);
kadonotakashi 0:8fdf9a60065b 548 t->attr.tz_module = MBED_TZ_DEFAULT_ACCESS;
kadonotakashi 0:8fdf9a60065b 549 if (t->attr.stack_mem == NULL) {
kadonotakashi 0:8fdf9a60065b 550 MBED_ERROR1(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_OUT_OF_MEMORY), "unable to allocate thread stack\n", stacksize);
kadonotakashi 0:8fdf9a60065b 551 }
kadonotakashi 0:8fdf9a60065b 552 t->id = osThreadNew((osThreadFunc_t)thread, arg, &t->attr);
kadonotakashi 0:8fdf9a60065b 553 if (t->id == NULL)
kadonotakashi 0:8fdf9a60065b 554 MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_THREAD_CREATE_FAILED), "sys_thread_new create error\n");
kadonotakashi 0:8fdf9a60065b 555
kadonotakashi 0:8fdf9a60065b 556 return t;
kadonotakashi 0:8fdf9a60065b 557 }
kadonotakashi 0:8fdf9a60065b 558
kadonotakashi 0:8fdf9a60065b 559 #endif
kadonotakashi 0:8fdf9a60065b 560
kadonotakashi 0:8fdf9a60065b 561 #ifdef LWIP_DEBUG
kadonotakashi 0:8fdf9a60065b 562
kadonotakashi 0:8fdf9a60065b 563 #include <stdbool.h>
kadonotakashi 0:8fdf9a60065b 564
kadonotakashi 0:8fdf9a60065b 565 #if MBED_CONF_LWIP_USE_MBED_TRACE
kadonotakashi 0:8fdf9a60065b 566 #include "mbed-trace/mbed_trace.h"
kadonotakashi 0:8fdf9a60065b 567
kadonotakashi 0:8fdf9a60065b 568 void lwip_mbed_tracef_debug(const char *fmt, ...)
kadonotakashi 0:8fdf9a60065b 569 {
kadonotakashi 0:8fdf9a60065b 570 va_list ap;
kadonotakashi 0:8fdf9a60065b 571 va_start(ap, fmt);
kadonotakashi 0:8fdf9a60065b 572 mbed_vtracef(TRACE_LEVEL_DEBUG, "lwIP", fmt, ap);
kadonotakashi 0:8fdf9a60065b 573 va_end(ap);
kadonotakashi 0:8fdf9a60065b 574 }
kadonotakashi 0:8fdf9a60065b 575
kadonotakashi 0:8fdf9a60065b 576 void lwip_mbed_tracef_warn(const char *fmt, ...)
kadonotakashi 0:8fdf9a60065b 577 {
kadonotakashi 0:8fdf9a60065b 578 va_list ap;
kadonotakashi 0:8fdf9a60065b 579 va_start(ap, fmt);
kadonotakashi 0:8fdf9a60065b 580 mbed_vtracef(TRACE_LEVEL_WARN, "lwIP", fmt, ap);
kadonotakashi 0:8fdf9a60065b 581 va_end(ap);
kadonotakashi 0:8fdf9a60065b 582 }
kadonotakashi 0:8fdf9a60065b 583
kadonotakashi 0:8fdf9a60065b 584 void lwip_mbed_tracef_error(const char *fmt, ...)
kadonotakashi 0:8fdf9a60065b 585 {
kadonotakashi 0:8fdf9a60065b 586 va_list ap;
kadonotakashi 0:8fdf9a60065b 587 va_start(ap, fmt);
kadonotakashi 0:8fdf9a60065b 588 mbed_vtracef(TRACE_LEVEL_ERROR, "lwIP", fmt, ap);
kadonotakashi 0:8fdf9a60065b 589 va_end(ap);
kadonotakashi 0:8fdf9a60065b 590 }
kadonotakashi 0:8fdf9a60065b 591
kadonotakashi 0:8fdf9a60065b 592 void lwip_mbed_assert_fail(const char *msg, const char *func, const char *file, unsigned int line)
kadonotakashi 0:8fdf9a60065b 593 {
kadonotakashi 0:8fdf9a60065b 594 mbed_tracef(TRACE_LEVEL_ERROR, "lwIP", "Assertion failed: %s, function %s, file %s, line %u.", msg, func, file, line);
kadonotakashi 0:8fdf9a60065b 595 exit(EXIT_FAILURE); // XXX how about abort? mbed_assert uses exit, so follow suit
kadonotakashi 0:8fdf9a60065b 596 }
kadonotakashi 0:8fdf9a60065b 597 #else // MBED_CONF_LWIP_USE_MBED_TRACE
kadonotakashi 0:8fdf9a60065b 598
kadonotakashi 0:8fdf9a60065b 599 /** \brief Displays an error message on assertion
kadonotakashi 0:8fdf9a60065b 600
kadonotakashi 0:8fdf9a60065b 601 This function will display an error message on an assertion
kadonotakashi 0:8fdf9a60065b 602 to the debug output.
kadonotakashi 0:8fdf9a60065b 603
kadonotakashi 0:8fdf9a60065b 604 \param[in] msg Error message to display
kadonotakashi 0:8fdf9a60065b 605 \param[in] line Line number in file with error
kadonotakashi 0:8fdf9a60065b 606 \param[in] file Filename with error
kadonotakashi 0:8fdf9a60065b 607 */
kadonotakashi 0:8fdf9a60065b 608 void assert_printf(char *msg, int line, char *file) {
kadonotakashi 0:8fdf9a60065b 609 if (msg)
kadonotakashi 0:8fdf9a60065b 610 error("%s:%d in file %s\n", msg, line, file);
kadonotakashi 0:8fdf9a60065b 611 else
kadonotakashi 0:8fdf9a60065b 612 error("LWIP ASSERT\n");
kadonotakashi 0:8fdf9a60065b 613 }
kadonotakashi 0:8fdf9a60065b 614 #endif // MBED_CONF_LWIP_USE_MBED_TRACE
kadonotakashi 0:8fdf9a60065b 615
kadonotakashi 0:8fdf9a60065b 616 #if TRACE_TO_ASCII_HEX_DUMP
kadonotakashi 0:8fdf9a60065b 617 void trace_to_ascii_hex_dump(char *prefix, int len, char *data)
kadonotakashi 0:8fdf9a60065b 618 {
kadonotakashi 0:8fdf9a60065b 619 int line_len = 0;
kadonotakashi 0:8fdf9a60065b 620
kadonotakashi 0:8fdf9a60065b 621 for (int i = 0; i < len; i++) {
kadonotakashi 0:8fdf9a60065b 622 if ((line_len % 16) == 0) {
kadonotakashi 0:8fdf9a60065b 623 if (line_len != 0) {
kadonotakashi 0:8fdf9a60065b 624 LWIP_PLATFORM_DIAG(("\n"));
kadonotakashi 0:8fdf9a60065b 625 }
kadonotakashi 0:8fdf9a60065b 626 LWIP_PLATFORM_DIAG(("%s %06x", prefix, line_len));
kadonotakashi 0:8fdf9a60065b 627 }
kadonotakashi 0:8fdf9a60065b 628 line_len++;
kadonotakashi 0:8fdf9a60065b 629 LWIP_PLATFORM_DIAG((" %02x", data[i]));
kadonotakashi 0:8fdf9a60065b 630 }
kadonotakashi 0:8fdf9a60065b 631 LWIP_PLATFORM_DIAG(("\n"));
kadonotakashi 0:8fdf9a60065b 632 }
kadonotakashi 0:8fdf9a60065b 633 #endif
kadonotakashi 0:8fdf9a60065b 634
kadonotakashi 0:8fdf9a60065b 635 #endif /* LWIP_DEBUG */