Loading...
Searching...
No Matches
sys.h File Reference
`#include "lwip/opt.h"`
`#include "lwip/err.h"`
`#include "arch/sys_arch.h"`

## Macros

#define | SYS_ARCH_TIMEOUT 0xffffffffUL
#define | SYS_ARCH_INTR 0xfffffffeUL
#define | SYS_MBOX_EMPTY SYS_ARCH_TIMEOUT
#define | LWIP_COMPAT_MUTEX 0
#define | sys_sem_wait_interruptible(sem)
#define | sys_sem_valid_val(sem)
#define | sys_sem_set_invalid_val(sem)
#define | sys_mbox_tryfetch(mbox, msg)
#define | sys_mbox_valid_val(mbox)
#define | sys_mbox_set_invalid_val(mbox)
#define | LWIP_MARK_TCPIP_THREAD()
#define | SYS_ARCH_DECL_PROTECT(lev)
#define | SYS_ARCH_PROTECT(lev)
#define | SYS_ARCH_UNPROTECT(lev)

## Typedefs

typedef void(* | lwip_thread_fn) (void *arg)

## Functions

err_t | sys_mutex_new (sys_mutex_t *mutex)
void | sys_mutex_lock (sys_mutex_t *mutex)
void | sys_mutex_unlock (sys_mutex_t *mutex)
void | sys_mutex_free (sys_mutex_t *mutex)
int | sys_mutex_valid (sys_mutex_t *mutex)
void | sys_mutex_set_invalid (sys_mutex_t *mutex)
err_t | sys_sem_new (sys_sem_t *sem, u8_t count)
void | sys_sem_signal (sys_sem_t *sem)
u32_t | sys_arch_sem_wait_interruptible (sys_sem_t *sem, u32_t timeout)
u32_t | sys_arch_sem_wait (sys_sem_t *sem, u32_t timeout)
void | sys_sem_free (sys_sem_t *sem)
int | sys_sem_valid (sys_sem_t *sem)
void | sys_sem_set_invalid (sys_sem_t *sem)
void | sys_msleep (u32_t ms)
err_t | sys_mbox_new (sys_mbox_t *mbox, int size)
void | sys_mbox_post (sys_mbox_t *mbox, void *msg)
err_t | sys_mbox_trypost (sys_mbox_t *mbox, void *msg)
err_t | sys_mbox_trypost_fromisr (sys_mbox_t *mbox, void *msg)
u32_t | sys_arch_mbox_fetch (sys_mbox_t *mbox, void **msg, u32_t timeout)
u32_t | sys_arch_mbox_tryfetch (sys_mbox_t *mbox, void **msg)
void | sys_mbox_free (sys_mbox_t *mbox)
int | sys_mbox_valid (sys_mbox_t *mbox)
void | sys_mbox_set_invalid (sys_mbox_t *mbox)
sys_thread_t | sys_thread_new (const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio)
void | sys_init (void)
u32_t | sys_jiffies (void)
u32_t | sys_now (void)

## Detailed Description

OS abstraction layer

## Macro Definition Documentation

## LWIP_COMPAT_MUTEX

#define LWIP_COMPAT_MUTEX 0

Define LWIP_COMPAT_MUTEX if the port has no mutexes and binary semaphores should be used instead

## SYS_ARCH_INTR

#define SYS_ARCH_INTR 0xfffffffeUL

Return code for an interruptions from sys_arch_sem_wait_interruptible

## SYS_ARCH_TIMEOUT

#define SYS_ARCH_TIMEOUT 0xffffffffUL

Return code for timeouts from sys_arch_mbox_fetch and sys_arch_sem_wait

## SYS_MBOX_EMPTY

#define SYS_MBOX_EMPTY SYS_ARCH_TIMEOUT

sys_mbox_tryfetch() returns SYS_MBOX_EMPTY if appropriate. For now we use the same magic value, but we allow this to change in future.

## sys_mbox_set_invalid_val

#define sys_mbox_set_invalid_val | ( |  | mbox | ) |

Value:
sys_mbox_set_invalid(&(mbox))
sys_mbox_set_invalid
void sys_mbox_set_invalid(sys_mbox_t *mbox)

Same as sys_mbox_set_invalid() but taking a value, not a pointer

## sys_mbox_tryfetch

#define sys_mbox_tryfetch | ( |  | mbox,
|  |  | msg )

Value:
sys_arch_mbox_tryfetch(mbox, msg)
sys_arch_mbox_tryfetch
u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)

For now, we map straight to sys_arch implementation.

## sys_mbox_valid_val

#define sys_mbox_valid_val | ( |  | mbox | ) |

Value:
sys_mbox_valid(&(mbox))
sys_mbox_valid
int sys_mbox_valid(sys_mbox_t *mbox)

Same as sys_mbox_valid() but taking a value, not a pointer

## sys_sem_set_invalid_val

#define sys_sem_set_invalid_val | ( |  | sem | ) |

Value:
sys_sem_set_invalid(&(sem))
sys_sem_set_invalid
void sys_sem_set_invalid(sys_sem_t *sem)

Same as sys_sem_set_invalid() but taking a value, not a pointer

## sys_sem_valid_val

#define sys_sem_valid_val | ( |  | sem | ) |

Value:
sys_sem_valid(&(sem))
sys_sem_valid
int sys_sem_valid(sys_sem_t *sem)

Same as sys_sem_valid() but taking a value, not a pointer

## sys_sem_wait_interruptible

#define sys_sem_wait_interruptible | ( |  | sem | ) |

Value:
sys_arch_sem_wait_interruptible(sem, 0)
sys_arch_sem_wait_interruptible
u32_t sys_arch_sem_wait_interruptible(sys_sem_t *sem, u32_t timeout)

Wait for a semaphore - forever/no timeout

## Typedef Documentation

## lwip_thread_fn

typedef void(* lwip_thread_fn) (void *arg)

Function prototype for thread functions

## Function Documentation

## sys_jiffies()

u32_t sys_jiffies | ( | void |  | ) |

Ticks/jiffies since power up.