From 1fe4406f374291ab2e86e95a97341fd9c475fcb8 Mon Sep 17 00:00:00 2001 From: Jun Wako Date: Fri, 24 Apr 2015 16:26:14 +0900 Subject: 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 --- tool/mbed/mbed-sdk/libraries/doc/net/doc.txt | 35 ++++ tool/mbed/mbed-sdk/libraries/doc/net/layers.dia | Bin 0 -> 1428 bytes tool/mbed/mbed-sdk/libraries/doc/net/source.txt | 32 ++++ tool/mbed/mbed-sdk/libraries/doc/net/sys_arch.txt | 216 ++++++++++++++++++++++ tool/mbed/mbed-sdk/libraries/doc/net/tcp.dia | Bin 0 -> 2806 bytes tool/mbed/mbed-sdk/libraries/doc/net/udp.dia | Bin 0 -> 2228 bytes 6 files changed, 283 insertions(+) create mode 100644 tool/mbed/mbed-sdk/libraries/doc/net/doc.txt create mode 100644 tool/mbed/mbed-sdk/libraries/doc/net/layers.dia create mode 100644 tool/mbed/mbed-sdk/libraries/doc/net/source.txt create mode 100644 tool/mbed/mbed-sdk/libraries/doc/net/sys_arch.txt create mode 100644 tool/mbed/mbed-sdk/libraries/doc/net/tcp.dia create mode 100644 tool/mbed/mbed-sdk/libraries/doc/net/udp.dia (limited to 'tool/mbed/mbed-sdk/libraries/doc/net') diff --git a/tool/mbed/mbed-sdk/libraries/doc/net/doc.txt b/tool/mbed/mbed-sdk/libraries/doc/net/doc.txt new file mode 100644 index 0000000000..270c64c06e --- /dev/null +++ b/tool/mbed/mbed-sdk/libraries/doc/net/doc.txt @@ -0,0 +1,35 @@ +lwip/api/tcpip.c: tcpip_init -> tcpip_thread + +lwip/core/netif.c: netif_add +lwip/arch/lpc17_emac.c: lpc_enetif_init -> packet_rx, packet_tx + +=== tcpip_thread === + while (true): + sys_timeouts_mbox_fetch(&mbox, (void **)&msg) + ... + +Feeding the tcpip_thread mbox: + tcpip_input + tcpip_callback_with_block + tcpip_timeout + tcpip_untimeout + tcpip_apimsg + tcpip_netifapi + + +=== packet_rx === + while (true): + sys_arch_sem_wait(&lpc_enetif->RxSem, osWaitForever) + ... + +Feeding the RX semaphore: + ENET_IRQHandler + + +=== packet_tx === + while (true): + sys_arch_sem_wait(&lpc_enetif->TxCleanSem, osWaitForever) + ... + +Feeding the TX semaphore: + ENET_IRQHandler diff --git a/tool/mbed/mbed-sdk/libraries/doc/net/layers.dia b/tool/mbed/mbed-sdk/libraries/doc/net/layers.dia new file mode 100644 index 0000000000..ff427c8185 Binary files /dev/null and b/tool/mbed/mbed-sdk/libraries/doc/net/layers.dia differ diff --git a/tool/mbed/mbed-sdk/libraries/doc/net/source.txt b/tool/mbed/mbed-sdk/libraries/doc/net/source.txt new file mode 100644 index 0000000000..9300ad3a62 --- /dev/null +++ b/tool/mbed/mbed-sdk/libraries/doc/net/source.txt @@ -0,0 +1,32 @@ +lwip-1.4.0: + http://download.savannah.gnu.org/releases/lwip/lwip-1.4.0.zip + +NXP lwIP port: + http://sw.lpcware.com/index.php?p=lwip_lpc.git&a=snapshot&h=7b84446afe97af955acad1d720696a0de73ab7cf&fmt=zip + +NXP Driver Library (needed for Ethernet defines) + http://ics.nxp.com/support/documents/microcontrollers/zip/lpc17xx.cmsis.driver.library.zip + +# lwip library + lwip-1.4.0\src + api + core + include + netif + +# lwip-eth library + lwip_lpc\nxpcommon\ + examples/lpc177x_8x/ea1788/ea1788_tcpecho_freertos/source/configs/flash/lpc_emac_config.h + lpc_phy_dp83848.c + lpc_phy.h + arch\lpc177x_8x\lpc17_emac.c + arch\lpc177x_8x\lpc17_emac.h + lpc17xx.cmsis.driver.library\Drivers\include + lpc17xx_emac.h + +# lwip-sys library + lwip_lpc\nxpcommon\arch + cc.h + perf.h + touch sys_arch.c + touch sys_arch.h diff --git a/tool/mbed/mbed-sdk/libraries/doc/net/sys_arch.txt b/tool/mbed/mbed-sdk/libraries/doc/net/sys_arch.txt new file mode 100644 index 0000000000..38377b6655 --- /dev/null +++ b/tool/mbed/mbed-sdk/libraries/doc/net/sys_arch.txt @@ -0,0 +1,216 @@ +sys_arch interface for lwIP 0.6++ + +Author: Adam Dunkels + +The operating system emulation layer provides a common interface +between the lwIP code and the underlying operating system kernel. The +general idea is that porting lwIP to new architectures requires only +small changes to a few header files and a new sys_arch +implementation. It is also possible to do a sys_arch implementation +that does not rely on any underlying operating system. + +The sys_arch provides semaphores and mailboxes to lwIP. For the full +lwIP functionality, multiple threads support can be implemented in the +sys_arch, but this is not required for the basic lwIP +functionality. Previous versions of lwIP required the sys_arch to +implement timer scheduling as well but as of lwIP 0.5 this is +implemented in a higher layer. + +In addition to the source file providing the functionality of sys_arch, +the OS emulation layer must provide several header files defining +macros used throughout lwip. The files required and the macros they +must define are listed below the sys_arch description. + +Semaphores can be either counting or binary - lwIP works with both +kinds. Mailboxes are used for message passing and can be implemented +either as a queue which allows multiple messages to be posted to a +mailbox, or as a rendez-vous point where only one message can be +posted at a time. lwIP works with both kinds, but the former type will +be more efficient. A message in a mailbox is just a pointer, nothing +more. + +Semaphores are represented by the type "sys_sem_t" which is typedef'd +in the sys_arch.h file. Mailboxes are equivalently represented by the +type "sys_mbox_t". lwIP does not place any restrictions on how +sys_sem_t or sys_mbox_t are represented internally. + +The following functions must be implemented by the sys_arch: + +- void sys_init(void) + + Is called to initialize the sys_arch layer. + +- sys_sem_t sys_sem_new(u8_t count) + + Creates and returns a new semaphore. The "count" argument specifies + the initial state of the semaphore. + +- void sys_sem_free(sys_sem_t sem) + + Deallocates a semaphore. + +- void sys_sem_signal(sys_sem_t sem) + + Signals a semaphore. + +- u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout) + + 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 zero, the thread should be + blocked until the semaphore is signalled. + + 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. + +- sys_mbox_t sys_mbox_new(int size) + + Creates an empty mailbox for maximum "size" elements. Elements stored + in mailboxes are pointers. You have to define macros "_MBOX_SIZE" + in your lwipopts.h, or ignore this parameter in your implementation + and use a default size. + +- void sys_mbox_free(sys_mbox_t mbox) + + 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. + +- void sys_mbox_post(sys_mbox_t mbox, void *msg) + + Posts the "msg" to the mailbox. This function have to block until + the "msg" is really posted. + +- err_t sys_mbox_trypost(sys_mbox_t mbox, void *msg) + + Try to post the "msg" to the mailbox. Returns ERR_MEM if this one + is full, else, ERR_OK if the "msg" is posted. + +- u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout) + + 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). If "timeout" is 0, the thread should + be blocked until a message arrives. 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. + +- u32_t sys_arch_mbox_tryfetch(sys_mbox_t mbox, void **msg) + + This is similar to sys_arch_mbox_fetch, however if a message is not + present in the mailbox, it immediately returns with the code + SYS_MBOX_EMPTY. On success 0 is returned. + + To allow for efficient implementations, this can be defined as a + function-like macro in sys_arch.h instead of a normal function. For + example, a naive implementation could be: + #define sys_arch_mbox_tryfetch(mbox,msg) \ + sys_arch_mbox_fetch(mbox,msg,1) + although this would introduce unnecessary delays. + +If threads are supported by the underlying operating system and if +such functionality is needed in lwIP, the following function will have +to be implemented as well: + +- sys_thread_t sys_thread_new(char *name, void (* thread)(void *arg), void *arg, int stacksize, int prio) + + Starts a new thread named "name" 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 stack size to used for this thread is + the "stacksize" parameter. The id of the new thread is returned. Both the id + and the priority are system dependent. + +- sys_prot_t sys_arch_protect(void) + + 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. + +- void sys_arch_unprotect(sys_prot_t pval) + + 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. + +Note: + +Be carefull with using mem_malloc() in sys_arch. When malloc() refers to +mem_malloc() you can run into a circular function call problem. In mem.c +mem_init() tries to allcate a semaphore using mem_malloc, which of course +can't be performed when sys_arch uses mem_malloc. + +------------------------------------------------------------------------------- +Additional files required for the "OS support" emulation layer: +------------------------------------------------------------------------------- + +cc.h - Architecture environment, some compiler specific, some + environment specific (probably should move env stuff + to sys_arch.h.) + + Typedefs for the types used by lwip - + u8_t, s8_t, u16_t, s16_t, u32_t, s32_t, mem_ptr_t + + Compiler hints for packing lwip's structures - + PACK_STRUCT_FIELD(x) + PACK_STRUCT_STRUCT + PACK_STRUCT_BEGIN + PACK_STRUCT_END + + Platform specific diagnostic output - + LWIP_PLATFORM_DIAG(x) - non-fatal, print a message. + LWIP_PLATFORM_ASSERT(x) - fatal, print message and abandon execution. + Portability defines for printf formatters: + U16_F, S16_F, X16_F, U32_F, S32_F, X32_F, SZT_F + + "lightweight" synchronization mechanisms - + SYS_ARCH_DECL_PROTECT(x) - declare a protection state variable. + SYS_ARCH_PROTECT(x) - enter protection mode. + SYS_ARCH_UNPROTECT(x) - leave protection mode. + + If the compiler does not provide memset() this file must include a + definition of it, or include a file which defines it. + + This file must either include a system-local which defines + the standard *nix error codes, or it should #define LWIP_PROVIDE_ERRNO + to make lwip/arch.h define the codes which are used throughout. + + +perf.h - Architecture specific performance measurement. + Measurement calls made throughout lwip, these can be defined to nothing. + PERF_START - start measuring something. + PERF_STOP(x) - stop measuring something, and record the result. + +sys_arch.h - Tied to sys_arch.c + + Arch dependent types for the following objects: + sys_sem_t, sys_mbox_t, sys_thread_t, + And, optionally: + sys_prot_t + + Defines to set vars of sys_mbox_t and sys_sem_t to NULL. + SYS_MBOX_NULL NULL + SYS_SEM_NULL NULL diff --git a/tool/mbed/mbed-sdk/libraries/doc/net/tcp.dia b/tool/mbed/mbed-sdk/libraries/doc/net/tcp.dia new file mode 100644 index 0000000000..7c79fabff1 Binary files /dev/null and b/tool/mbed/mbed-sdk/libraries/doc/net/tcp.dia differ diff --git a/tool/mbed/mbed-sdk/libraries/doc/net/udp.dia b/tool/mbed/mbed-sdk/libraries/doc/net/udp.dia new file mode 100644 index 0000000000..cbffd7c93c Binary files /dev/null and b/tool/mbed/mbed-sdk/libraries/doc/net/udp.dia differ -- cgit v1.2.3