diff options
author | Jun Wako <wakojun@gmail.com> | 2015-04-24 16:26:14 +0900 |
---|---|---|
committer | Jun Wako <wakojun@gmail.com> | 2015-04-24 16:26:14 +0900 |
commit | 1fe4406f374291ab2e86e95a97341fd9c475fcb8 (patch) | |
tree | 1be0e16b4b07b5a31ea97ec50a9eb13a288c3d27 /tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys | |
parent | a20ef7052c6e937d2f7672dd59456e55a5c08296 (diff) |
Squashed 'tmk_core/' changes from 7967731..b9e0ea0
b9e0ea0 Merge commit '7fa9d8bdea3773d1195b04d98fcf27cf48ddd81d' as 'tool/mbed/mbed-sdk'
7fa9d8b Squashed 'tool/mbed/mbed-sdk/' content from commit 7c21ce5
git-subtree-dir: tmk_core
git-subtree-split: b9e0ea08cb940de20b3610ecdda18e9d8cd7c552
Diffstat (limited to 'tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys')
6 files changed, 925 insertions, 0 deletions
diff --git a/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/cc.h b/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/cc.h new file mode 100644 index 0000000000..00b6782d3b --- /dev/null +++ b/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/cc.h @@ -0,0 +1,119 @@ +/* + * 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 __CC_H__ +#define __CC_H__ + +#include <stdint.h> + +/* Types based on stdint.h */ +typedef uint8_t u8_t; +typedef int8_t s8_t; +typedef uint16_t u16_t; +typedef int16_t s16_t; +typedef uint32_t u32_t; +typedef int32_t s32_t; +typedef uintptr_t mem_ptr_t; + +/* Define (sn)printf formatters for these lwIP types */ +#define U16_F "hu" +#define S16_F "hd" +#define X16_F "hx" +#define U32_F "lu" +#define S32_F "ld" +#define X32_F "lx" +#define SZT_F "uz" + +/* ARM/LPC17xx is little endian only */ +#define BYTE_ORDER LITTLE_ENDIAN + +/* Use LWIP error codes */ +#define LWIP_PROVIDE_ERRNO + +#if defined(__arm__) && defined(__ARMCC_VERSION) + /* Keil uVision4 tools */ + #define PACK_STRUCT_BEGIN __packed + #define PACK_STRUCT_STRUCT + #define PACK_STRUCT_END + #define PACK_STRUCT_FIELD(fld) fld + #define ALIGNED(n) __align(n) +#elif defined (__IAR_SYSTEMS_ICC__) + /* IAR Embedded Workbench tools */ + #define PACK_STRUCT_BEGIN __packed + #define PACK_STRUCT_STRUCT + #define PACK_STRUCT_END + #define PACK_STRUCT_FIELD(fld) fld + #define IAR_STR(a) #a + #define ALIGNED(n) _Pragma(IAR_STR(data_alignment= ## n ##)) +#else + /* GCC tools (CodeSourcery) */ + #define PACK_STRUCT_BEGIN + #define PACK_STRUCT_STRUCT __attribute__ ((__packed__)) + #define PACK_STRUCT_END + #define PACK_STRUCT_FIELD(fld) fld + #define ALIGNED(n) __attribute__((aligned (n))) +#endif + +/* Provide Thumb-2 routines for GCC to improve performance */ +#if defined(TOOLCHAIN_GCC) && defined(__thumb2__) + #define MEMCPY(dst,src,len) thumb2_memcpy(dst,src,len) + #define LWIP_CHKSUM thumb2_checksum + /* Set algorithm to 0 so that unused lwip_standard_chksum function + doesn't generate compiler warning */ + #define LWIP_CHKSUM_ALGORITHM 0 + + void* thumb2_memcpy(void* pDest, const void* pSource, size_t length); + u16_t thumb2_checksum(void* pData, int length); +#else + /* Used with IP headers only */ + #define LWIP_CHKSUM_ALGORITHM 1 +#endif + + +#ifdef LWIP_DEBUG + +#include "stdio.h" + +void assert_printf(char *msg, int line, char *file); + +/* Plaform specific diagnostic output */ +#define LWIP_PLATFORM_DIAG(vars) printf vars +#define LWIP_PLATFORM_ASSERT(flag) { assert_printf((flag), __LINE__, __FILE__); } +#else +#define LWIP_PLATFORM_DIAG(msg) { ; } +#define LWIP_PLATFORM_ASSERT(flag) { ; } +#endif + +#include "cmsis.h" +#define LWIP_PLATFORM_HTONS(x) __REV16(x) +#define LWIP_PLATFORM_HTONL(x) __REV(x) + +#endif /* __CC_H__ */ diff --git a/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/checksum.c b/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/checksum.c new file mode 100644 index 0000000000..e97aef39d0 --- /dev/null +++ b/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/checksum.c @@ -0,0 +1,126 @@ +/* Copyright (C) 2013 - Adam Green (https://github.com/adamgreen) + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +#if defined(TOOLCHAIN_GCC) && defined(__thumb2__) + + +/* This is a hand written Thumb-2 assembly language version of the + algorithm 3 version of lwip_standard_chksum in lwIP's inet_chksum.c. It + performs the checksumming 32-bits at a time and even unrolls the loop to + perform two of these 32-bit adds per loop iteration. + + Returns: + 16-bit 1's complement summation (not inversed). + + NOTE: This function does return a uint16_t from the assembly language code + but is marked as void so that GCC doesn't issue warning because it + doesn't know about this low level return. +*/ +__attribute__((naked)) void /*uint16_t*/ thumb2_checksum(const void* pData, int length) +{ + __asm ( + ".syntax unified\n" + ".thumb\n" + + // Push non-volatile registers we use on stack. Push link register too to + // keep stack 8-byte aligned and allow single pop to restore and return. + " push {r4, lr}\n" + // Initialize sum, r2, to 0. + " movs r2, #0\n" + // Remember whether pData was at odd address in r3. This is used later to + // know if it needs to swap the result since the summation will be done at + // an offset of 1, rather than 0. + " ands r3, r0, #1\n" + // Need to 2-byte align? If not skip ahead. + " beq 1$\n" + // We can return if there are no bytes to sum. + " cbz r1, 9$\n" + + // 2-byte align. + // Place the first data byte in odd summation location since it needs to be + // swapped later. It's ok to overwrite r2 here as it only had a value of 0 + // up until now. Advance r0 pointer and decrement r1 length as we go. + " ldrb r2, [r0], #1\n" + " lsls r2, r2, #8\n" + " subs r1, r1, #1\n" + + // Need to 4-byte align? If not skip ahead. + "1$:\n" + " ands r4, r0, #3\n" + " beq 2$\n" + // Have more than 1 byte left to align? If not skip ahead to take care of + // trailing byte. + " cmp r1, #2\n" + " blt 7$\n" + + // 4-byte align. + " ldrh r4, [r0], #2\n" + " adds r2, r2, r4\n" + " subs r1, r1, #2\n" + + // Main summing loop which sums up data 2 words at a time. + // Make sure that we have more than 7 bytes left to sum. + "2$:\n" + " cmp r1, #8\n" + " blt 3$\n" + // Sum next two words. Applying previous upper 16-bit carry to + // lower 16-bits. + " ldr r4, [r0], #4\n" + " adds r2, r4\n" + " adc r2, r2, #0\n" + " ldr r4, [r0], #4\n" + " adds r2, r4\n" + " adc r2, r2, #0\n" + " subs r1, r1, #8\n" + " b 2$\n" + + // Sum up any remaining half-words. + "3$:\n" + // Make sure that we have more than 1 byte left to sum. + " cmp r1, #2\n" + " blt 7$\n" + // Sum up next half word, continue to apply carry. + " ldrh r4, [r0], #2\n" + " adds r2, r4\n" + " adc r2, r2, #0\n" + " subs r1, r1, #2\n" + " b 3$\n" + + // Handle trailing byte, if it exists + "7$:\n" + " cbz r1, 8$\n" + " ldrb r4, [r0]\n" + " adds r2, r4\n" + " adc r2, r2, #0\n" + + // Fold 32-bit checksum into 16-bit checksum. + "8$:\n" + " ubfx r4, r2, #16, #16\n" + " ubfx r2, r2, #0, #16\n" + " adds r2, r4\n" + " ubfx r4, r2, #16, #16\n" + " ubfx r2, r2, #0, #16\n" + " adds r2, r4\n" + + // Swap bytes if started at odd address + " cbz r3, 9$\n" + " rev16 r2, r2\n" + + // Return final sum. + "9$: mov r0, r2\n" + " pop {r4, pc}\n" + ); +} + +#endif diff --git a/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/memcpy.c b/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/memcpy.c new file mode 100644 index 0000000000..fefbcda3c2 --- /dev/null +++ b/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/memcpy.c @@ -0,0 +1,59 @@ +/* Copyright (C) 2013 - Adam Green (https://github.com/adamgreen) + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +*/ +#if defined(TOOLCHAIN_GCC) && defined(__thumb2__) + +#include <stdio.h> + + +/* This is a hand written Thumb-2 assembly language version of the + standard C memcpy() function that can be used by the lwIP networking + stack to improve its performance. It copies 4 bytes at a time and + unrolls the loop to perform 4 of these copies per loop iteration. +*/ +__attribute__((naked)) void thumb2_memcpy(void* pDest, const void* pSource, size_t length) +{ + __asm ( + ".syntax unified\n" + ".thumb\n" + + // Copy 16 bytes at a time first. + " lsrs r3, r2, #4\n" + " beq.n 2$\n" + "1$: ldr r12, [r1], #4\n" + " str r12, [r0], #4\n" + " ldr r12, [r1], #4\n" + " str r12, [r0], #4\n" + " ldr r12, [r1], #4\n" + " str r12, [r0], #4\n" + " ldr r12, [r1], #4\n" + " str r12, [r0], #4\n" + " subs r3, #1\n" + " bne 1$\n" + + // Copy byte by byte for what is left. + "2$:\n" + " ands r3, r2, #0xf\n" + " beq.n 4$\n" + "3$: ldrb r12, [r1], #1\n" + " strb r12, [r0], #1\n" + " subs r3, #1\n" + " bne 3$\n" + + // Return to caller. + "4$: bx lr\n" + ); +} + +#endif diff --git a/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/perf.h b/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/perf.h new file mode 100644 index 0000000000..334d42af8c --- /dev/null +++ b/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/perf.h @@ -0,0 +1,38 @@ +/* + * 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 __PERF_H__ +#define __PERF_H__ + +#define PERF_START /* null definition */ +#define PERF_STOP(x) /* null definition */ + +#endif /* __PERF_H__ */ diff --git a/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/sys_arch.c b/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/sys_arch.c new file mode 100644 index 0000000000..331b0a2257 --- /dev/null +++ b/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/sys_arch.c @@ -0,0 +1,463 @@ +/* Copyright (C) 2012 mbed.org, MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of this software + * and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or + * substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING + * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +#include <string.h> + +/* mbed includes */ +#include "mbed_error.h" +#include "mbed_interface.h" +#include "us_ticker_api.h" + +/* lwIP includes. */ +#include "lwip/opt.h" +#include "lwip/debug.h" +#include "lwip/def.h" +#include "lwip/sys.h" +#include "lwip/mem.h" + + #if NO_SYS==1 +#include "cmsis.h" + +/* Saved total time in ms since timer was enabled */ +static volatile u32_t systick_timems; + +/* Enable systick rate and interrupt */ +void SysTick_Init(void) { + if (SysTick_Config(SystemCoreClock / 1000)) { + while (1); /* Capture error */ + } +} + +/** \brief SysTick IRQ handler and timebase management + * + * This function keeps a timebase for the sysTick that can be + * used for other functions. It also calls an external function + * (SysTick_User) that must be defined outside this handler. + */ +void SysTick_Handler(void) { + systick_timems++; +} + +/* Delay for the specified number of milliSeconds */ +void osDelay(uint32_t ms) { + uint32_t to = ms + systick_timems; + while (to > systick_timems); +} + +/* Returns the current time in mS. This is needed for the LWIP timers */ +u32_t sys_now(void) { + return (u32_t) systick_timems; +} + +#else +/* CMSIS-RTOS implementation of the lwip operating system abstraction */ +#include "arch/sys_arch.h" + +/*---------------------------------------------------------------------------* + * Routine: sys_mbox_new + *---------------------------------------------------------------------------* + * Description: + * Creates a new mailbox + * Inputs: + * sys_mbox_t mbox -- Handle of mailbox + * int queue_sz -- Size of elements in the mailbox + * Outputs: + * err_t -- ERR_OK if message posted, else ERR_MEM + *---------------------------------------------------------------------------*/ +err_t sys_mbox_new(sys_mbox_t *mbox, int queue_sz) { + if (queue_sz > MB_SIZE) + error("sys_mbox_new size error\n"); + +#ifdef CMSIS_OS_RTX + memset(mbox->queue, 0, sizeof(mbox->queue)); + mbox->def.pool = mbox->queue; + mbox->def.queue_sz = queue_sz; +#endif + mbox->id = osMessageCreate(&mbox->def, NULL); + return (mbox->id == NULL) ? (ERR_MEM) : (ERR_OK); +} + +/*---------------------------------------------------------------------------* + * Routine: sys_mbox_free + *---------------------------------------------------------------------------* + * Description: + * Deallocates a mailbox. If there are messages still present in the + * mailbox when the mailbox is deallocated, it is an indication of a + * programming error in lwIP and the developer should be notified. + * Inputs: + * sys_mbox_t *mbox -- Handle of mailbox + *---------------------------------------------------------------------------*/ +void sys_mbox_free(sys_mbox_t *mbox) { + osEvent event = osMessageGet(mbox->id, 0); + if (event.status == osEventMessage) + error("sys_mbox_free error\n"); +} + +/*---------------------------------------------------------------------------* + * Routine: sys_mbox_post + *---------------------------------------------------------------------------* + * Description: + * Post the "msg" to the mailbox. + * Inputs: + * sys_mbox_t mbox -- Handle of mailbox + * void *msg -- Pointer to data to post + *---------------------------------------------------------------------------*/ +void sys_mbox_post(sys_mbox_t *mbox, void *msg) { + if (osMessagePut(mbox->id, (uint32_t)msg, osWaitForever) != osOK) + error("sys_mbox_post error\n"); +} + +/*---------------------------------------------------------------------------* + * Routine: sys_mbox_trypost + *---------------------------------------------------------------------------* + * Description: + * Try to post the "msg" to the mailbox. Returns immediately with + * error if cannot. + * Inputs: + * sys_mbox_t mbox -- Handle of mailbox + * void *msg -- Pointer to data to post + * Outputs: + * err_t -- ERR_OK if message posted, else ERR_MEM + * if not. + *---------------------------------------------------------------------------*/ +err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg) { + osStatus status = osMessagePut(mbox->id, (uint32_t)msg, 0); + return (status == osOK) ? (ERR_OK) : (ERR_MEM); +} + +/*---------------------------------------------------------------------------* + * Routine: sys_arch_mbox_fetch + *---------------------------------------------------------------------------* + * Description: + * Blocks the thread until a message arrives in the mailbox, but does + * not block the thread longer than "timeout" milliseconds (similar to + * the sys_arch_sem_wait() function). The "msg" argument is a result + * parameter that is set by the function (i.e., by doing "*msg = + * ptr"). The "msg" parameter maybe NULL to indicate that the message + * should be dropped. + * + * The return values are the same as for the sys_arch_sem_wait() function: + * Number of milliseconds spent waiting or SYS_ARCH_TIMEOUT if there was a + * timeout. + * + * Note that a function with a similar name, sys_mbox_fetch(), is + * implemented by lwIP. + * Inputs: + * sys_mbox_t mbox -- Handle of mailbox + * void **msg -- Pointer to pointer to msg received + * u32_t timeout -- Number of milliseconds until timeout + * Outputs: + * u32_t -- SYS_ARCH_TIMEOUT if timeout, else number + * of milliseconds until received. + *---------------------------------------------------------------------------*/ +u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout) { + u32_t start = us_ticker_read(); + + osEvent event = osMessageGet(mbox->id, (timeout != 0)?(timeout):(osWaitForever)); + if (event.status != osEventMessage) + return SYS_ARCH_TIMEOUT; + + *msg = (void *)event.value.v; + + return (us_ticker_read() - start) / 1000; +} + +/*---------------------------------------------------------------------------* + * Routine: sys_arch_mbox_tryfetch + *---------------------------------------------------------------------------* + * Description: + * Similar to sys_arch_mbox_fetch, but if message is not ready + * immediately, we'll return with SYS_MBOX_EMPTY. On success, 0 is + * returned. + * Inputs: + * sys_mbox_t mbox -- Handle of mailbox + * void **msg -- Pointer to pointer to msg received + * Outputs: + * u32_t -- SYS_MBOX_EMPTY if no messages. Otherwise, + * return ERR_OK. + *---------------------------------------------------------------------------*/ +u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg) { + osEvent event = osMessageGet(mbox->id, 0); + if (event.status != osEventMessage) + return SYS_MBOX_EMPTY; + + *msg = (void *)event.value.v; + + return ERR_OK; +} + +/*---------------------------------------------------------------------------* + * Routine: sys_sem_new + *---------------------------------------------------------------------------* + * Description: + * Creates and returns a new semaphore. The "ucCount" argument specifies + * the initial state of the semaphore. + * NOTE: Currently this routine only creates counts of 1 or 0 + * Inputs: + * sys_sem_t sem -- Handle of semaphore + * u8_t count -- Initial count of semaphore + * Outputs: + * err_t -- ERR_OK if semaphore created + *---------------------------------------------------------------------------*/ +err_t sys_sem_new(sys_sem_t *sem, u8_t count) { +#ifdef CMSIS_OS_RTX + memset(sem->data, 0, sizeof(uint32_t)*2); + sem->def.semaphore = sem->data; +#endif + sem->id = osSemaphoreCreate(&sem->def, count); + if (sem->id == NULL) + error("sys_sem_new create error\n"); + + return ERR_OK; +} + +/*---------------------------------------------------------------------------* + * Routine: sys_arch_sem_wait + *---------------------------------------------------------------------------* + * Description: + * Blocks the thread while waiting for the semaphore to be + * signaled. If the "timeout" argument is non-zero, the thread should + * only be blocked for the specified time (measured in + * milliseconds). + * + * If the timeout argument is non-zero, the return value is the number of + * milliseconds spent waiting for the semaphore to be signaled. If the + * semaphore wasn't signaled within the specified time, the return value is + * SYS_ARCH_TIMEOUT. If the thread didn't have to wait for the semaphore + * (i.e., it was already signaled), the function may return zero. + * + * Notice that lwIP implements a function with a similar name, + * sys_sem_wait(), that uses the sys_arch_sem_wait() function. + * Inputs: + * sys_sem_t sem -- Semaphore to wait on + * u32_t timeout -- Number of milliseconds until timeout + * Outputs: + * u32_t -- Time elapsed or SYS_ARCH_TIMEOUT. + *---------------------------------------------------------------------------*/ +u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout) { + u32_t start = us_ticker_read(); + + if (osSemaphoreWait(sem->id, (timeout != 0)?(timeout):(osWaitForever)) < 1) + return SYS_ARCH_TIMEOUT; + + return (us_ticker_read() - start) / 1000; +} + +/*---------------------------------------------------------------------------* + * Routine: sys_sem_signal + *---------------------------------------------------------------------------* + * Description: + * Signals (releases) a semaphore + * Inputs: + * sys_sem_t sem -- Semaphore to signal + *---------------------------------------------------------------------------*/ +void sys_sem_signal(sys_sem_t *data) { + if (osSemaphoreRelease(data->id) != osOK) + mbed_die(); /* Can be called by ISR do not use printf */ +} + +/*---------------------------------------------------------------------------* + * Routine: sys_sem_free + *---------------------------------------------------------------------------* + * Description: + * Deallocates a semaphore + * Inputs: + * sys_sem_t sem -- Semaphore to free + *---------------------------------------------------------------------------*/ +void sys_sem_free(sys_sem_t *sem) {} + +/** Create a new mutex + * @param mutex pointer to the mutex to create + * @return a new mutex */ +err_t sys_mutex_new(sys_mutex_t *mutex) { +#ifdef CMSIS_OS_RTX + memset(mutex->data, 0, sizeof(int32_t)*3); + mutex->def.mutex = mutex->data; +#endif + mutex->id = osMutexCreate(&mutex->def); + if (mutex->id == NULL) + return ERR_MEM; + + return ERR_OK; +} + +/** Lock a mutex + * @param mutex the mutex to lock */ +void sys_mutex_lock(sys_mutex_t *mutex) { + if (osMutexWait(mutex->id, osWaitForever) != osOK) + error("sys_mutex_lock error\n"); +} + +/** Unlock a mutex + * @param mutex the mutex to unlock */ +void sys_mutex_unlock(sys_mutex_t *mutex) { + if (osMutexRelease(mutex->id) != osOK) + error("sys_mutex_unlock error\n"); +} + +/** Delete a mutex + * @param mutex the mutex to delete */ +void sys_mutex_free(sys_mutex_t *mutex) {} + +/*---------------------------------------------------------------------------* + * Routine: sys_init + *---------------------------------------------------------------------------* + * Description: + * Initialize sys arch + *---------------------------------------------------------------------------*/ +osMutexId lwip_sys_mutex; +osMutexDef(lwip_sys_mutex); + +void sys_init(void) { + us_ticker_read(); // Init sys tick + lwip_sys_mutex = osMutexCreate(osMutex(lwip_sys_mutex)); + if (lwip_sys_mutex == NULL) + error("sys_init error\n"); +} + +/*---------------------------------------------------------------------------* + * Routine: sys_jiffies + *---------------------------------------------------------------------------* + * Description: + * Used by PPP as a timestamp-ish value + *---------------------------------------------------------------------------*/ +u32_t sys_jiffies(void) { + static u32_t jiffies = 0; + jiffies += 1 + (us_ticker_read()/10000); + return jiffies; +} + +/*---------------------------------------------------------------------------* + * Routine: sys_arch_protect + *---------------------------------------------------------------------------* + * Description: + * This optional function does a "fast" critical region protection and + * returns the previous protection level. This function is only called + * during very short critical regions. An embedded system which supports + * ISR-based drivers might want to implement this function by disabling + * interrupts. Task-based systems might want to implement this by using + * a mutex or disabling tasking. This function should support recursive + * calls from the same task or interrupt. In other words, + * sys_arch_protect() could be called while already protected. In + * that case the return value indicates that it is already protected. + * + * sys_arch_protect() is only required if your port is supporting an + * operating system. + * Outputs: + * sys_prot_t -- Previous protection level (not used here) + *---------------------------------------------------------------------------*/ +sys_prot_t sys_arch_protect(void) { + if (osMutexWait(lwip_sys_mutex, osWaitForever) != osOK) + error("sys_arch_protect error\n"); + return (sys_prot_t) 1; +} + +/*---------------------------------------------------------------------------* + * Routine: sys_arch_unprotect + *---------------------------------------------------------------------------* + * Description: + * This optional function does a "fast" set of critical region + * protection to the value specified by pval. See the documentation for + * sys_arch_protect() for more information. This function is only + * required if your port is supporting an operating system. + * Inputs: + * sys_prot_t -- Previous protection level (not used here) + *---------------------------------------------------------------------------*/ +void sys_arch_unprotect(sys_prot_t p) { + if (osMutexRelease(lwip_sys_mutex) != osOK) + error("sys_arch_unprotect error\n"); +} + +u32_t sys_now(void) { + return us_ticker_read() / 1000; +} + +void sys_msleep(u32_t ms) { + osDelay(ms); +} + +// Keep a pool of thread structures +static int thread_pool_index = 0; +static sys_thread_data_t thread_pool[SYS_THREAD_POOL_N]; + +/*---------------------------------------------------------------------------* + * Routine: sys_thread_new + *---------------------------------------------------------------------------* + * Description: + * Starts a new thread with priority "prio" that will begin its + * execution in the function "thread()". The "arg" argument will be + * passed as an argument to the thread() function. The id of the new + * thread is returned. Both the id and the priority are system + * dependent. + * Inputs: + * char *name -- Name of thread + * void (*thread)(void *arg) -- Pointer to function to run. + * void *arg -- Argument passed into function + * int stacksize -- Required stack amount in bytes + * int priority -- Thread priority + * Outputs: + * sys_thread_t -- Pointer to thread handle. + *---------------------------------------------------------------------------*/ +sys_thread_t sys_thread_new(const char *pcName, + void (*thread)(void *arg), + void *arg, int stacksize, int priority) { + LWIP_DEBUGF(SYS_DEBUG, ("New Thread: %s\n", pcName)); + + if (thread_pool_index >= SYS_THREAD_POOL_N) + error("sys_thread_new number error\n"); + sys_thread_t t = (sys_thread_t)&thread_pool[thread_pool_index]; + thread_pool_index++; + +#ifdef CMSIS_OS_RTX + t->def.pthread = (os_pthread)thread; + t->def.tpriority = (osPriority)priority; + t->def.stacksize = stacksize; +#ifndef __MBED_CMSIS_RTOS_CA9 + t->def.stack_pointer = (uint32_t*)malloc(stacksize); + if (t->def.stack_pointer == NULL) { + error("Error allocating the stack memory"); + } +#endif +#endif + t->id = osThreadCreate(&t->def, arg); + if (t->id == NULL) + error("sys_thread_new create error\n"); + + return t; +} + +#endif + +#ifdef LWIP_DEBUG + +/** \brief Displays an error message on assertion + + This function will display an error message on an assertion + to the debug output. + + \param[in] msg Error message to display + \param[in] line Line number in file with error + \param[in] file Filename with error + */ +void assert_printf(char *msg, int line, char *file) { + if (msg) + error("%s:%d in file %s\n", msg, line, file); + else + error("LWIP ASSERT\n"); +} + +#endif /* LWIP_DEBUG */ diff --git a/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/sys_arch.h b/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/sys_arch.h new file mode 100644 index 0000000000..909532eb2f --- /dev/null +++ b/tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/sys_arch.h @@ -0,0 +1,120 @@ +/* Copyright (C) 2012 mbed.org, MIT License + * + * Permission is hereby granted, free of charge, to any person obtaining a copy of this software + * and associated documentation files (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, publish, distribute, + * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all copies or + * substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING + * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ +#ifndef __ARCH_SYS_ARCH_H__ +#define __ARCH_SYS_ARCH_H__ + +#include "lwip/opt.h" + +#if NO_SYS == 0 +#include "cmsis_os.h" + +// === SEMAPHORE === +typedef struct { + osSemaphoreId id; + osSemaphoreDef_t def; +#ifdef CMSIS_OS_RTX + uint32_t data[2]; +#endif +} sys_sem_t; + +#define sys_sem_valid(x) (((*x).id == NULL) ? 0 : 1) +#define sys_sem_set_invalid(x) ( (*x).id = NULL) + +// === MUTEX === +typedef struct { + osMutexId id; + osMutexDef_t def; +#ifdef CMSIS_OS_RTX + int32_t data[3]; +#endif +} sys_mutex_t; + +// === MAIL BOX === +#define MB_SIZE 8 + +typedef struct { + osMessageQId id; + osMessageQDef_t def; +#ifdef CMSIS_OS_RTX + uint32_t queue[4+MB_SIZE]; /* The +4 is required for RTX OS_MCB overhead. */ +#endif +} sys_mbox_t; + +#define SYS_MBOX_NULL ((uint32_t) NULL) +#define sys_mbox_valid(x) (((*x).id == NULL) ? 0 : 1 ) +#define sys_mbox_set_invalid(x) ( (*x).id = NULL ) + +#if ((DEFAULT_RAW_RECVMBOX_SIZE) > (MB_SIZE)) || \ + ((DEFAULT_UDP_RECVMBOX_SIZE) > (MB_SIZE)) || \ + ((DEFAULT_TCP_RECVMBOX_SIZE) > (MB_SIZE)) || \ + ((DEFAULT_ACCEPTMBOX_SIZE) > (MB_SIZE)) || \ + ((TCPIP_MBOX_SIZE) > (MB_SIZE)) +# error Mailbox size not supported +#endif + +// === THREAD === +typedef struct { + osThreadId id; + osThreadDef_t def; +} sys_thread_data_t; +typedef sys_thread_data_t* sys_thread_t; + +#define SYS_THREAD_POOL_N 6 +#define SYS_DEFAULT_THREAD_STACK_DEPTH DEFAULT_STACK_SIZE + +// === PROTECTION === +typedef int sys_prot_t; + +#else +#ifdef __cplusplus +extern "C" { +#endif + +/** \brief Init systick to 1ms rate + * + * This init the systick to 1ms rate. This function is only used in standalone + * systems. + */ +void SysTick_Init(void); + + +/** \brief Get the current systick time in milliSeconds + * + * Returns the current systick time in milliSeconds. This function is only + * used in standalone systems. + * + * /returns current systick time in milliSeconds + */ +uint32_t SysTick_GetMS(void); + +/** \brief Delay for the specified number of milliSeconds + * + * For standalone systems. This function will block for the specified + * number of milliSconds. For RTOS based systems, this function will delay + * the task by the specified number of milliSeconds. + * + * \param[in] ms Time in milliSeconds to delay + */ +void osDelay(uint32_t ms); + +#ifdef __cplusplus +} +#endif +#endif + +#endif /* __ARCH_SYS_ARCH_H__ */ |