mirror of
https://github.com/thelsing/knx.git
synced 2025-10-12 11:15:54 +02:00
e51b65f8c2
git-subtree-dir: examples/knx-cc1310/coresdk_cc13xx_cc26xx git-subtree-split: 0d78d3280357416a5c0388148cda13717c9ffaa5
290 lines
11 KiB
C
290 lines
11 KiB
C
/*
|
|
* Copyright (c) 2015-2017 Texas Instruments Incorporated - http://www.ti.com
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* * 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.
|
|
*
|
|
* * Neither the name of Texas Instruments Incorporated nor the names of
|
|
* its contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR
|
|
* CONTRIBUTORS 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.
|
|
*/
|
|
|
|
/*
|
|
* ======== pthread.h ========
|
|
*/
|
|
|
|
#ifndef ti_posix_iar_pthread__include
|
|
#define ti_posix_iar_pthread__include
|
|
|
|
/* compiler vendor check */
|
|
#ifndef __IAR_SYSTEMS_ICC__
|
|
#error Incompatible compiler: use this include path (.../ti/posix/iar) only with an IAR compiler. You appear to be using a different compiler.
|
|
#endif
|
|
|
|
#include <stdint.h>
|
|
|
|
#include "sys/types.h"
|
|
#include "time.h"
|
|
#include "sched.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#define PTHREAD_BARRIER_SERIAL_THREAD -1
|
|
|
|
#define PTHREAD_CREATE_JOINABLE 0
|
|
#define PTHREAD_CREATE_DETACHED 1
|
|
|
|
/* PThread cancellation */
|
|
#define PTHREAD_CANCEL_ENABLE 0
|
|
#define PTHREAD_CANCEL_DISABLE 1
|
|
#define PTHREAD_CANCELED ((void *) -1)
|
|
|
|
/*
|
|
* Mutex attributes - type
|
|
*
|
|
* PTHREAD_MUTEX_NORMAL: Owner of mutex cannot relock it. Attempting
|
|
* to relock will cause deadlock.
|
|
* PTHREAD_MUTEX_RECURSIVE: Owner can relock the mutex.
|
|
* PTHREAD_MUTEX_ERRORCHECK: If owner attempts to relock the mutex, an
|
|
* error is returned.
|
|
*
|
|
*/
|
|
#define PTHREAD_MUTEX_NORMAL 0
|
|
#define PTHREAD_MUTEX_RECURSIVE 1
|
|
#define PTHREAD_MUTEX_ERRORCHECK 2
|
|
#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
|
|
|
|
/* Passed to pthread_once() */
|
|
#define PTHREAD_ONCE_INIT 0
|
|
|
|
/*
|
|
* Mutex attributes - protocol
|
|
*
|
|
* PTHREAD_PRIO_NONE: Ownership of mutex does not affect priority.
|
|
* PTHREAD_PRIO_INHERIT: Owner's priority is boosted to the priority of
|
|
* highest priority thread blocked on the mutex.
|
|
* PTHREAD_PRIO_PROTECT: Mutex has a priority ceiling. The owner's
|
|
* priority is boosted to the highest priority ceiling of all mutexes
|
|
* owned (regardless of whether or not other threads are blocked on
|
|
* any of these mutexes).
|
|
*/
|
|
#define PTHREAD_PRIO_NONE 0
|
|
#define PTHREAD_PRIO_INHERIT 1
|
|
#define PTHREAD_PRIO_PROTECT 2
|
|
|
|
#define PTHREAD_PROCESS_PRIVATE 0
|
|
|
|
/*
|
|
*************************************************************************
|
|
* pthread_attr
|
|
*************************************************************************
|
|
*/
|
|
extern int pthread_attr_destroy(pthread_attr_t *attr);
|
|
|
|
extern int pthread_attr_getdetachstate(const pthread_attr_t *attr,
|
|
int *detachstate);
|
|
extern int pthread_attr_getguardsize(const pthread_attr_t *attr,
|
|
size_t *guardsize);
|
|
|
|
extern int pthread_attr_getschedparam(const pthread_attr_t *attr,
|
|
struct sched_param *schedparam);
|
|
|
|
extern int pthread_attr_getstack(const pthread_attr_t *attr,
|
|
void **stackaddr, size_t *stacksize);
|
|
extern int pthread_attr_getstacksize(const pthread_attr_t *attr,
|
|
size_t *stacksize);
|
|
|
|
extern int pthread_attr_init(pthread_attr_t *attr);
|
|
|
|
extern int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachedstate);
|
|
extern int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize);
|
|
|
|
extern int pthread_attr_setschedparam(pthread_attr_t *attr,
|
|
const struct sched_param *schedparam);
|
|
|
|
extern int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr,
|
|
size_t stacksize);
|
|
extern int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
|
|
|
|
/*
|
|
*************************************************************************
|
|
* pthread
|
|
*************************************************************************
|
|
*/
|
|
extern int pthread_cancel(pthread_t pthread);
|
|
extern void _pthread_cleanup_pop(struct _pthread_cleanup_context *context,
|
|
int execute);
|
|
extern void _pthread_cleanup_push(struct _pthread_cleanup_context *context,
|
|
void (*fxn)(void *), void *arg);
|
|
|
|
#define pthread_cleanup_push(fxn, arg) \
|
|
do { \
|
|
struct _pthread_cleanup_context _pthread_clup_ctx; \
|
|
_pthread_cleanup_push(&_pthread_clup_ctx, (fxn), (arg))
|
|
|
|
#define pthread_cleanup_pop(execute) \
|
|
_pthread_cleanup_pop(&_pthread_clup_ctx, (execute)); \
|
|
} while (0)
|
|
|
|
extern int pthread_create(pthread_t *newthread, const pthread_attr_t *attr,
|
|
void *(*startroutine)(void *), void *arg);
|
|
extern int pthread_detach(pthread_t pthread);
|
|
extern int pthread_equal(pthread_t pt1, pthread_t pt2);
|
|
extern void pthread_exit(void *ptr);
|
|
extern int pthread_getschedparam(pthread_t thread, int *policy,
|
|
struct sched_param *param);
|
|
extern int pthread_join(pthread_t th, void **thread_return);
|
|
extern int pthread_once(pthread_once_t *once, void (*initFxn)(void));
|
|
extern pthread_t pthread_self(void);
|
|
extern int pthread_setcancelstate(int state, int *oldstate);
|
|
extern int pthread_setschedparam(pthread_t pthread, int policy,
|
|
const struct sched_param *param);
|
|
|
|
/*
|
|
*************************************************************************
|
|
* pthread_barrierattr
|
|
*************************************************************************
|
|
*/
|
|
extern int pthread_barrierattr_destroy(pthread_barrierattr_t *attr);
|
|
extern int pthread_barrierattr_init(pthread_barrierattr_t *attr);
|
|
|
|
/*
|
|
*************************************************************************
|
|
* pthread_barrier
|
|
*************************************************************************
|
|
*/
|
|
extern int pthread_barrier_destroy(pthread_barrier_t *barrier);
|
|
extern int pthread_barrier_init(pthread_barrier_t *barrier,
|
|
const pthread_barrierattr_t *attr, unsigned count);
|
|
extern int pthread_barrier_wait(pthread_barrier_t *barrier);
|
|
|
|
/*
|
|
*************************************************************************
|
|
* pthread_condattr
|
|
*************************************************************************
|
|
*/
|
|
extern int pthread_condattr_destroy(pthread_condattr_t *attr);
|
|
extern int pthread_condattr_getclock(const pthread_condattr_t *attr,
|
|
clockid_t *clock_id);
|
|
extern int pthread_condattr_init(pthread_condattr_t * attr);
|
|
extern int pthread_condattr_setclock(pthread_condattr_t *attr,
|
|
clockid_t clock_id);
|
|
|
|
/*
|
|
*************************************************************************
|
|
* pthread_cond
|
|
*************************************************************************
|
|
*/
|
|
extern int pthread_cond_broadcast(pthread_cond_t *cond);
|
|
extern int pthread_cond_destroy(pthread_cond_t *cond);
|
|
extern int pthread_cond_init(pthread_cond_t *cond,
|
|
const pthread_condattr_t *attr);
|
|
extern int pthread_cond_signal(pthread_cond_t *cond);
|
|
extern int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
|
|
const struct timespec *abstime);
|
|
extern int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
|
|
|
|
/*
|
|
*************************************************************************
|
|
* pthread_key
|
|
*************************************************************************
|
|
*/
|
|
extern int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));
|
|
extern int pthread_key_delete(pthread_key_t key);
|
|
extern void *pthread_getspecific(pthread_key_t key);
|
|
extern int pthread_setspecific(pthread_key_t key, const void *value);
|
|
|
|
/*
|
|
*************************************************************************
|
|
* pthread_mutexattr
|
|
*************************************************************************
|
|
*/
|
|
extern int pthread_mutexattr_destroy(pthread_mutexattr_t *attr);
|
|
extern int pthread_mutexattr_gettype(const pthread_mutexattr_t *attr,
|
|
int *type);
|
|
extern int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *attr,
|
|
int *prioceiling);
|
|
extern int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *attr,
|
|
int *protocol);
|
|
extern int pthread_mutexattr_init(pthread_mutexattr_t *attr);
|
|
extern int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *attr,
|
|
int prioceiling);
|
|
extern int pthread_mutexattr_setprotocol(pthread_mutexattr_t *attr,
|
|
int protocol);
|
|
extern int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);
|
|
|
|
/*
|
|
*************************************************************************
|
|
* pthread_mutex
|
|
*************************************************************************
|
|
*/
|
|
extern int pthread_mutex_destroy(pthread_mutex_t *mutex);
|
|
extern int pthread_mutex_getprioceiling(const pthread_mutex_t *mutex,
|
|
int *prioceiling);
|
|
extern int pthread_mutex_init(pthread_mutex_t *mutex,
|
|
const pthread_mutexattr_t *attr);
|
|
extern int pthread_mutex_lock(pthread_mutex_t *mutex);
|
|
extern int pthread_mutex_setprioceiling(pthread_mutex_t *mutex,
|
|
int prioceiling, int *oldceiling);
|
|
extern int pthread_mutex_timedlock(pthread_mutex_t *mutex,
|
|
const struct timespec *abstime);
|
|
extern int pthread_mutex_trylock(pthread_mutex_t *mutex);
|
|
|
|
extern int pthread_mutex_unlock(pthread_mutex_t *mutex);
|
|
|
|
/*
|
|
*************************************************************************
|
|
* pthread_rwlockattr
|
|
*************************************************************************
|
|
*/
|
|
extern int pthread_rwlockattr_destroy(pthread_rwlockattr_t *attr);
|
|
extern int pthread_rwlockattr_init(pthread_rwlockattr_t * attr);
|
|
|
|
/*
|
|
*************************************************************************
|
|
* pthread_rwlock
|
|
*************************************************************************
|
|
*/
|
|
extern int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
|
|
extern int pthread_rwlock_init(pthread_rwlock_t *rwlock,
|
|
const pthread_rwlockattr_t *attr);
|
|
|
|
extern int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
|
|
extern int pthread_rwlock_timedrdlock(pthread_rwlock_t *rwlock,
|
|
const struct timespec *abstime);
|
|
extern int pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock,
|
|
const struct timespec *abstime);
|
|
extern int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
|
|
extern int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
|
|
extern int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
|
|
extern int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* ti_posix_iar_pthread__include */
|