1/* 2 * Copyright (c) 2001-2004 Swedish Institute of Computer Science. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without modification, 6 * are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright notice, 11 * this list of conditions and the following disclaimer in the documentation 12 * and/or other materials provided with the distribution. 13 * 3. The name of the author may not be used to endorse or promote products 14 * derived from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 19 * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 20 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 21 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 24 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 25 * OF SUCH DAMAGE. 26 * 27 * This file is part of the lwIP TCP/IP stack. 28 * 29 * Author: Adam Dunkels <adam@sics.se> 30 * 31 */ 32#ifndef __LWIP_SYS_H__ 33#define __LWIP_SYS_H__ 34 35#include "lwip/opt.h" 36 37#ifdef __cplusplus 38extern "C" { 39#endif 40 41#if NO_SYS 42 43/* For a totally minimal and standalone system, we provide null 44 definitions of the sys_ functions. */ 45 typedef u8_t sys_sem_t; 46 typedef u8_t sys_mbox_t; 47 struct sys_timeo { 48 u8_t dummy; 49 }; 50 51#define sys_init() 52#define sys_timeout(m,h,a) 53#define sys_untimeout(m,a) 54#define sys_sem_new(c) c 55#define sys_sem_signal(s) 56#define sys_sem_wait(s) 57#define sys_sem_wait_timeout(s,t) 58#define sys_arch_sem_wait(s,t) 59#define sys_sem_free(s) 60#define sys_mbox_new(s) 0 61#define sys_mbox_fetch(m,d) 62#define sys_mbox_tryfetch(m,d) 63#define sys_mbox_post(m,d) 64#define sys_mbox_trypost(m,d) 65#define sys_mbox_free(m) 66 67#define sys_thread_new(n,t,a,s,p) 68 69#else /* NO_SYS */ 70 71/** Return code for timeouts from sys_arch_mbox_fetch and sys_arch_sem_wait */ 72#define SYS_ARCH_TIMEOUT 0xffffffffUL 73 74/* sys_mbox_tryfetch returns SYS_MBOX_EMPTY if appropriate. 75 * For now we use the same magic value, but we allow this to change in future. 76 */ 77#define SYS_MBOX_EMPTY SYS_ARCH_TIMEOUT 78 79#include "lwip/err.h" 80#include "arch/sys_arch.h" 81 82 typedef void (*sys_timeout_handler) (void *arg); 83 84 struct sys_timeo { 85 struct sys_timeo *next; 86 u32_t time; 87 sys_timeout_handler h; 88 void *arg; 89 }; 90 91 struct sys_timeouts { 92 struct sys_timeo *next; 93 }; 94 95/* sys_init() must be called before anthing else. */ 96 void sys_init(void); 97 98/* 99 * sys_timeout(): 100 * 101 * Schedule a timeout a specified amount of milliseconds in the 102 * future. When the timeout occurs, the specified timeout handler will 103 * be called. The handler will be passed the "arg" argument when 104 * called. 105 * 106 */ 107 void sys_timeout(u32_t msecs, sys_timeout_handler h, void *arg); 108 void sys_untimeout(sys_timeout_handler h, void *arg); 109 struct sys_timeouts *sys_arch_timeouts(void); 110 111/* Semaphore functions. */ 112 sys_sem_t sys_sem_new(u8_t count); 113 void sys_sem_signal(sys_sem_t sem); 114 u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout); 115 void sys_sem_free(sys_sem_t sem); 116 void sys_sem_wait(sys_sem_t sem); 117 int sys_sem_wait_timeout(sys_sem_t sem, u32_t timeout); 118 119/* Time functions. */ 120#ifndef sys_msleep 121 void sys_msleep(u32_t ms); /* only has a (close to) 1 jiffy resolution. */ 122#endif 123#ifndef sys_jiffies 124 u32_t sys_jiffies(void); /* since power up. */ 125#endif 126 127/* Mailbox functions. */ 128 sys_mbox_t sys_mbox_new(int size); 129 void sys_mbox_post(sys_mbox_t mbox, void *msg); 130 err_t sys_mbox_trypost(sys_mbox_t mbox, void *msg); 131 u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout); 132#ifndef sys_arch_mbox_tryfetch /* Allow port to override with a macro */ 133 u32_t sys_arch_mbox_tryfetch(sys_mbox_t mbox, void **msg); 134#endif 135/* For now, we map straight to sys_arch implementation. */ 136#define sys_mbox_tryfetch(mbox, msg) sys_arch_mbox_tryfetch(mbox, msg) 137 void sys_mbox_free(sys_mbox_t mbox); 138 void sys_mbox_fetch(sys_mbox_t mbox, void **msg); 139 140/* Thread functions. */ 141 sys_thread_t sys_thread_new(char *name, void (*thread) (void *arg), 142 void *arg, int stacksize, int prio); 143 144#endif /* NO_SYS */ 145 146/** Returns the current time in milliseconds. */ 147 u32_t sys_now(void); 148 149/* Critical Region Protection */ 150/* These functions must be implemented in the sys_arch.c file. 151 In some implementations they can provide a more light-weight protection 152 mechanism than using semaphores. Otherwise semaphores can be used for 153 implementation */ 154#ifndef SYS_ARCH_PROTECT 155/** SYS_LIGHTWEIGHT_PROT 156 * define SYS_LIGHTWEIGHT_PROT in lwipopts.h if you want inter-task protection 157 * for certain critical regions during buffer allocation, deallocation and memory 158 * allocation and deallocation. 159 */ 160#if SYS_LIGHTWEIGHT_PROT 161 162/** SYS_ARCH_DECL_PROTECT 163 * declare a protection variable. This macro will default to defining a variable of 164 * type sys_prot_t. If a particular port needs a different implementation, then 165 * this macro may be defined in sys_arch.h. 166 */ 167#define SYS_ARCH_DECL_PROTECT(lev) sys_prot_t lev 168/** SYS_ARCH_PROTECT 169 * Perform a "fast" protect. This could be implemented by 170 * disabling interrupts for an embedded system or by using a semaphore or 171 * mutex. The implementation should allow calling SYS_ARCH_PROTECT when 172 * already protected. The old protection level is returned in the variable 173 * "lev". This macro will default to calling the sys_arch_protect() function 174 * which should be implemented in sys_arch.c. If a particular port needs a 175 * different implementation, then this macro may be defined in sys_arch.h 176 */ 177#define SYS_ARCH_PROTECT(lev) lev = sys_arch_protect() 178/** SYS_ARCH_UNPROTECT 179 * Perform a "fast" set of the protection level to "lev". This could be 180 * implemented by setting the interrupt level to "lev" within the MACRO or by 181 * using a semaphore or mutex. This macro will default to calling the 182 * sys_arch_unprotect() function which should be implemented in 183 * sys_arch.c. If a particular port needs a different implementation, then 184 * this macro may be defined in sys_arch.h 185 */ 186#define SYS_ARCH_UNPROTECT(lev) sys_arch_unprotect(lev) 187 sys_prot_t sys_arch_protect(void); 188 void sys_arch_unprotect(sys_prot_t pval); 189 190#else 191 192#define SYS_ARCH_DECL_PROTECT(lev) 193#define SYS_ARCH_PROTECT(lev) 194#define SYS_ARCH_UNPROTECT(lev) 195 196#endif /* SYS_LIGHTWEIGHT_PROT */ 197 198#endif /* SYS_ARCH_PROTECT */ 199 200/* 201 * Macros to set/get and increase/decrease variables in a thread-safe way. 202 * Use these for accessing variable that are used from more than one thread. 203 */ 204 205#ifndef SYS_ARCH_INC 206#define SYS_ARCH_INC(var, val) do { \ 207 SYS_ARCH_DECL_PROTECT(old_level); \ 208 SYS_ARCH_PROTECT(old_level); \ 209 var += val; \ 210 SYS_ARCH_UNPROTECT(old_level); \ 211 } while(0) 212#endif /* SYS_ARCH_INC */ 213 214#ifndef SYS_ARCH_DEC 215#define SYS_ARCH_DEC(var, val) do { \ 216 SYS_ARCH_DECL_PROTECT(old_level); \ 217 SYS_ARCH_PROTECT(old_level); \ 218 var -= val; \ 219 SYS_ARCH_UNPROTECT(old_level); \ 220 } while(0) 221#endif /* SYS_ARCH_DEC */ 222 223#ifndef SYS_ARCH_GET 224#define SYS_ARCH_GET(var, ret) do { \ 225 SYS_ARCH_DECL_PROTECT(old_level); \ 226 SYS_ARCH_PROTECT(old_level); \ 227 ret = var; \ 228 SYS_ARCH_UNPROTECT(old_level); \ 229 } while(0) 230#endif /* SYS_ARCH_GET */ 231 232#ifndef SYS_ARCH_SET 233#define SYS_ARCH_SET(var, val) do { \ 234 SYS_ARCH_DECL_PROTECT(old_level); \ 235 SYS_ARCH_PROTECT(old_level); \ 236 var = val; \ 237 SYS_ARCH_UNPROTECT(old_level); \ 238 } while(0) 239#endif /* SYS_ARCH_SET */ 240 241 242#ifdef __cplusplus 243} 244#endif 245extern struct thread_mutex *lwip_mutex; 246 247void lwip_mutex_lock(void); 248void lwip_mutex_unlock(void); 249 250#endif /* __LWIP_SYS_H__ */ 251