drashna/qmk_firmware
1
0
Fork 0
Code Activity Actions

Squashed 'tmk_core/' changes from 7967731..b9e0ea0

Browse source 
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
This commit is contained in:
Jun Wako 2015-04-24 16:26:14 +09:00
parent a20ef7052c
commit 1fe4406f37
4198 changed files with 2016457 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

119
tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/cc.h Normal file
View file

@ -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__ */

126
tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/checksum.c Normal file
View file

@ -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

59
tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/memcpy.c Normal file
View file

@ -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

38
tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/perf.h Normal file
View file

@ -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__ */

463
tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/sys_arch.c Normal file
View file

@ -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 */

120
tool/mbed/mbed-sdk/libraries/net/lwip/lwip-sys/arch/sys_arch.h Normal file
View file

@ -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__ */