/* * 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 * */ /* FreeRTOS port by Alexander Drozd . */ /* lwIP includes. */ #include "lwip/debug.h" #include "lwip/def.h" #include "lwip/sys.h" #include "lwip/mem.h" #define portTICKS_BETWEEN(StartTicks, EndTicks) \ ((portTickType)(((StartTicks) <= (EndTicks))?((EndTicks) - (StartTicks)):((portMAX_DELAY - (StartTicks)) + (EndTicks)))) struct thread_timeouts { struct sys_timeouts timeouts; xTaskHandle pid; }; /* This is the number of threads that can simultaneously use lwIP timeouts */ #define SYS_TIMEOUTS_MAX 10 static struct thread_timeouts timeoutlist[SYS_TIMEOUTS_MAX]; struct sys_thread_wrapper_arg { void (* thread)(void *arg); void *arg; }; /*-----------------------------------------------------------------------------------*/ // Creates an empty mailbox. sys_mbox_t sys_mbox_new(int size) { return (xQueueCreate(size, sizeof(void*))); } /*-----------------------------------------------------------------------------------*/ /* 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_free(sys_mbox_t mbox) { if( uxQueueMessagesWaiting( mbox ) ) { /* Line for breakpoint. Should never break here! */ asm( "NOP" ); } vQueueDelete( mbox ); } /*-----------------------------------------------------------------------------------*/ // Posts the "msg" to the mailbox. /* - 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. */ void sys_mbox_post(sys_mbox_t mbox, void *msg) { while (pdPASS != xQueueSend( mbox, &msg, ( portTickType ) 10000 )) {;}; } /* - 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. */ err_t sys_mbox_trypost(sys_mbox_t mbox, void *msg) { if (pdPASS != xQueueSend( mbox, &msg, ( portTickType ) 0 )) return(ERR_MEM); return(ERR_OK); } /*-----------------------------------------------------------------------------------*/ /* 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. */ u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout) { void *dummyptr; portTickType StartTicks, EndTicks; u32_t Elapsed; StartTicks = xTaskGetTickCount(); if( msg == NULL ) { msg = &dummyptr; } if(timeout != 0) { if(pdTRUE == xQueueReceive( mbox, &(*msg), timeout )) { EndTicks = xTaskGetTickCount(); Elapsed = portTICKS_BETWEEN(StartTicks, EndTicks); if(Elapsed == 0){Elapsed = 1;} return ( Elapsed ); } else { *msg = NULL; return SYS_ARCH_TIMEOUT; } } else { while( pdTRUE != xQueueReceive(mbox, &(*msg), 10000 )){;} EndTicks = xTaskGetTickCount(); Elapsed = portTICKS_BETWEEN(StartTicks, EndTicks); if( Elapsed == 0 ){Elapsed = 1;} return ( Elapsed ); } } /*-----------------------------------------------------------------------------------*/ // Creates and returns a new semaphore. The "count" argument specifies // the initial state of the semaphore. TBD finish and test sys_sem_t sys_sem_new(u8_t count) { xSemaphoreHandle xSemaphore; vSemaphoreCreateBinary(xSemaphore); if( xSemaphore == NULL ) { return NULL; } else { if(count == 0) // Means it can't be taken { xSemaphoreTake(xSemaphore,1); } return xSemaphore; } } /*-----------------------------------------------------------------------------------*/ /* 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. */ u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout) { portTickType StartTicks, EndTicks; u32_t Elapsed; StartTicks = xTaskGetTickCount(); if(timeout != 0) { if(xSemaphoreTake(sem, timeout) == pdTRUE) { EndTicks = xTaskGetTickCount(); Elapsed = portTICKS_BETWEEN(StartTicks, EndTicks); if(Elapsed == 0){Elapsed = 1;} return (Elapsed); } else { return SYS_ARCH_TIMEOUT; } } else { while( xSemaphoreTake( sem, 10000 ) != pdTRUE ){;} EndTicks = xTaskGetTickCount(); Elapsed = portTICKS_BETWEEN(StartTicks, EndTicks); if( Elapsed == 0 ) {Elapsed = 1;} return ( Elapsed ); // return time blocked } } /*-----------------------------------------------------------------------------------*/ // Signals a semaphore void sys_sem_signal(sys_sem_t sem) { xSemaphoreGive( sem ); } /*-----------------------------------------------------------------------------------*/ // Deallocates a semaphore void sys_sem_free(sys_sem_t sem) { vQueueDelete( sem ); } /*-----------------------------------------------------------------------------------*/ // Initialize sys arch void sys_init(void) { int i; // Initialize the the per-thread sys_timeouts structures // make sure there are no valid pids in the list for(i = 0; i < SYS_TIMEOUTS_MAX; i++) { timeoutlist[i].pid = 0; } } /*-----------------------------------------------------------------------------------*/ /* Returns a pointer to the per-thread sys_timeouts structure. In lwIP, each thread has a list of timeouts which is represented as a linked list of sys_timeout structures. The sys_timeouts structure holds a pointer to a linked list of timeouts. This function is called by the lwIP timeout scheduler and must not return a NULL value. In a single threaded sys_arch implementation, this function will simply return a pointer to a global sys_timeouts variable stored in the sys_arch module. */ struct sys_timeouts * sys_arch_timeouts(void) { int i; xTaskHandle pid; struct thread_timeouts *tt; pid = xTaskGetCurrentTaskHandle( ); for(i = 0; i < SYS_TIMEOUTS_MAX; i++) { tt = &timeoutlist[i]; if(tt->pid == pid) { return &(tt->timeouts); } } vTaskSuspendAll(); for(i = 0; i < SYS_TIMEOUTS_MAX; i++) { tt = &timeoutlist[i]; if(tt->pid == 0) { tt->timeouts.next = NULL; tt->pid = xTaskGetCurrentTaskHandle(); xTaskResumeAll(); return &(tt->timeouts); } } xTaskResumeAll(); // Error return NULL; } static void sys_thread_timeouts_mark_empty(void) { int i; xTaskHandle pid; struct thread_timeouts *tt; pid = xTaskGetCurrentTaskHandle( ); for(i = 0; i < SYS_TIMEOUTS_MAX; i++) { tt = &timeoutlist[i]; if(tt->pid == pid) { tt->pid = 0; break; } } } /* Wrapper for lwIP thread. It is necessary to call sys_thread_timeouts_mark_empty() and vTaskDelete() at lwIP thread (for example pppMain()) end. */ static void sys_thread_wrapper(void * arg) { void (* thread)(void *arg); void *thread_arg; thread = ((struct sys_thread_wrapper_arg*)arg)->thread; thread_arg = ((struct sys_thread_wrapper_arg*)arg)->arg; vPortFree(arg); thread(thread_arg); sys_thread_timeouts_mark_empty(); vTaskDelete(0); } /* 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. */ sys_thread_t sys_thread_new(char *name, void (* thread)(void *arg), void *arg, int stacksize, int prio) { xTaskHandle CreatedTask = NULL; struct sys_thread_wrapper_arg * pwrapper_arg; pwrapper_arg = pvPortMalloc(sizeof(*pwrapper_arg)); if (pwrapper_arg) { pwrapper_arg->thread = thread; pwrapper_arg->arg = arg; if(xTaskCreate( sys_thread_wrapper, ( signed portCHAR * ) name, stacksize, pwrapper_arg, prio, &CreatedTask ) != pdPASS) { vPortFree(pwrapper_arg); } } return(CreatedTask); } /* 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. */ sys_prot_t sys_arch_protect(void) { vPortEnterCritical(); return 1; } /* 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. */ void sys_arch_unprotect(sys_prot_t pval) { (void)pval; vPortExitCritical(); }