lwip/src/include/lwip/sys.h

   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
  38 extern "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 typedef u8_t sys_prot_t;
  48 struct sys_timeo {u8_t dummy;};
  49
  50 #define sys_init()
  51 #define sys_timeout(m,h,a)
  52 #define sys_untimeout(m,a)
  53 #define sys_sem_new(c) c
  54 #define sys_sem_signal(s)
  55 #define sys_sem_wait(s)
  56 #define sys_sem_wait_timeout(s,t)
  57 #define sys_arch_sem_wait(s,t)
  58 #define sys_sem_free(s)
  59 #define sys_mbox_new(s) 0
  60 #define sys_mbox_fetch(m,d)
  61 #define sys_mbox_tryfetch(m,d)
  62 #define sys_mbox_post(m,d)
  63 #define sys_mbox_trypost(m,d)
  64 #define sys_mbox_free(m)
  65
  66 #define sys_thread_new(n,t,a,s,p)
  67
  68 #else /* NO_SYS */
  69
  70 /** Return code for timeouts from sys_arch_mbox_fetch and sys_arch_sem_wait */
  71 #define SYS_ARCH_TIMEOUT 0xffffffffUL
  72
  73 /* sys_mbox_tryfetch returns SYS_MBOX_EMPTY if appropriate.
  74  * For now we use the same magic value, but we allow this to change in future.
  75  */
  76 #define SYS_MBOX_EMPTY SYS_ARCH_TIMEOUT
  77
  78 #include "lwip/err.h"
  79 #include "arch/sys_arch.h"
  80
  81 typedef void (* sys_timeout_handler)(void *arg);
  82
  83 struct sys_timeo {
  84   struct sys_timeo *next;
  85   u32_t time;
  86   sys_timeout_handler h;
  87   void *arg;
  88 };
  89
  90 struct sys_timeouts {
  91   struct sys_timeo *next;
  92 };
  93
  94 /* sys_init() must be called before anthing else. */
  95 void sys_init(void);
  96
  97 /*
  98  * sys_timeout():
  99  *
 100  * Schedule a timeout a specified amount of milliseconds in the
 101  * future. When the timeout occurs, the specified timeout handler will
 102  * be called. The handler will be passed the "arg" argument when
 103  * called.
 104  *
 105  */
 106 void sys_timeout(u32_t msecs, sys_timeout_handler h, void *arg);
 107 void sys_untimeout(sys_timeout_handler h, void *arg);
 108 struct sys_timeouts *sys_arch_timeouts(void);
 109
 110 /* Semaphore functions. */
 111 sys_sem_t sys_sem_new(u8_t count);
 112 void sys_sem_signal(sys_sem_t sem);
 113 u32_t sys_arch_sem_wait(sys_sem_t sem, u32_t timeout);
 114 void sys_sem_free(sys_sem_t sem);
 115 void sys_sem_wait(sys_sem_t sem);
 116 int sys_sem_wait_timeout(sys_sem_t sem, u32_t timeout);
 117
 118 /* Time functions. */
 119 #ifndef sys_msleep
 120 void sys_msleep(u32_t ms); /* only has a (close to) 1 jiffy resolution. */
 121 #endif
 122 #ifndef sys_jiffies
 123 u32_t sys_jiffies(void); /* since power up. */
 124 #endif
 125
 126 /* Mailbox functions. */
 127 sys_mbox_t sys_mbox_new(int size);
 128 void sys_mbox_post(sys_mbox_t mbox, void *msg);
 129 err_t sys_mbox_trypost(sys_mbox_t mbox, void *msg);
 130 u32_t sys_arch_mbox_fetch(sys_mbox_t mbox, void **msg, u32_t timeout);
 131 #ifndef sys_arch_mbox_tryfetch /* Allow port to override with a macro */
 132 u32_t sys_arch_mbox_tryfetch(sys_mbox_t mbox, void **msg);
 133 #endif
 134 /* For now, we map straight to sys_arch implementation. */
 135 #define sys_mbox_tryfetch(mbox, msg) sys_arch_mbox_tryfetch(mbox, msg)
 136 void sys_mbox_free(sys_mbox_t mbox);
 137 void sys_mbox_fetch(sys_mbox_t mbox, void **msg);
 138
 139 /* Thread functions. */
 140 sys_thread_t sys_thread_new(char *name, void (* thread)(void *arg), void *arg, int stacksize, int prio);
 141
 142 /* The following functions are used only in Unix code, and
 143    can be omitted when porting the stack. */
 144 /* Returns the current time in microseconds. */
 145 unsigned long sys_now(void);
 146
 147 #endif /* NO_SYS */
 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
 245
 246 #endif /* __LWIP_SYS_H__ */