Semaphore.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020, Texas Instruments Incorporated - https://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.
 *
 */
/*
 * ======== Semaphore.h ========
 */

#ifndef ti_sysbios_knl_Semaphore__include
#define ti_sysbios_knl_Semaphore__include

/* BIOS 6.x compatibility, use -Dxdc_std__include to disable */
#include <xdc/std.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

#include <ti/sysbios/knl/Queue.h>
#include <ti/sysbios/knl/Task.h>
#include <ti/sysbios/knl/Clock.h>
#include <ti/sysbios/knl/Event.h>

#include <ti/sysbios/runtime/Error.h>

/* @cond NODOC */
#define ti_sysbios_knl_Semaphore_long_names
#include "Semaphore_defs.h"
#ifdef __cplusplus
extern "C" {
#endif

/*
 * Error and Assert Ids
 */

#define Semaphore_A_badContext       "bad calling context - must be called from a Task"

#define Semaphore_A_noEvents         "the Semaphore.supportsEvents flag is disabled"

#define Semaphore_A_overflow         "count has exceeded 65535 and rolled over"

#define Semaphore_A_pendTaskDisabled "cannot call Semaphore_pend() while the Task or Swi scheduler is disabled"

typedef struct Semaphore_PendElem Semaphore_PendElem;
typedef struct Semaphore_Params Semaphore_Params;
typedef struct Semaphore_Struct Semaphore_Object;
typedef struct Semaphore_Struct Semaphore_Struct;
typedef Semaphore_Struct* Semaphore_Handle;
typedef Semaphore_Struct* Semaphore_Instance;

enum Semaphore_Mode {
    Semaphore_Mode_COUNTING = 0x0,
    Semaphore_Mode_BINARY = 0x1,
    Semaphore_Mode_COUNTING_PRIORITY = 0x2,
    Semaphore_Mode_BINARY_PRIORITY = 0x3
};

typedef enum Semaphore_Mode Semaphore_Mode;

enum Semaphore_PendState {
    Semaphore_PendState_TIMEOUT = 0,
    Semaphore_PendState_POSTED = 1,
    Semaphore_PendState_CLOCK_WAIT = 2,
    Semaphore_PendState_WAIT_FOREVER = 3
};
typedef enum Semaphore_PendState Semaphore_PendState;

struct Semaphore_PendElem {
    Task_PendElem tpElem;
    Semaphore_PendState pendState;
};
struct Semaphore_Params {
    Semaphore_Mode mode;
    Event_Handle event;
    unsigned int eventId;
};

struct Semaphore_Struct {
    Queue_Elem objElem;
    Event_Handle event;
    unsigned int eventId;
    Semaphore_Mode mode;
    volatile uint16_t count;
    Queue_Elem pendQ;
};

typedef struct {
    Queue_Struct objQ;
} Semaphore_Module_State;
extern const bool Semaphore_supportsEvents;

extern const bool Semaphore_supportsPriority;

typedef void (*Semaphore_EventPost)(Event_Handle arg1, unsigned int arg2);
extern const Semaphore_EventPost Semaphore_eventPost;

typedef void (*Semaphore_EventSync)(Event_Handle arg1, unsigned int arg2, unsigned int arg3);
extern const Semaphore_EventSync Semaphore_eventSync;

extern void Semaphore_Instance_init(Semaphore_Object *obj, int count, const Semaphore_Params *prms);

extern void Semaphore_Instance_finalize(Semaphore_Object *obj);
extern Semaphore_Handle Semaphore_create(int count, const Semaphore_Params *prms, Error_Block *eb);

extern Semaphore_Handle Semaphore_construct(Semaphore_Struct *obj, int count, const Semaphore_Params *prms);

extern void Semaphore_delete(Semaphore_Handle *semaphore);

extern void Semaphore_destruct(Semaphore_Struct *obj);

extern void Semaphore_Params_init(Semaphore_Params *prms);

extern Semaphore_Handle Semaphore_Object_first(void);

extern Semaphore_Handle Semaphore_Object_next(Semaphore_Handle semaphore);

extern int Semaphore_getCount(Semaphore_Handle semaphore);

extern bool Semaphore_pend(Semaphore_Handle semaphore, uint32_t timeout);

extern void Semaphore_post(Semaphore_Handle semaphore);

extern void Semaphore_registerEvent(Semaphore_Handle semaphore, Event_Handle event, unsigned int eventId);

extern void Semaphore_reset(Semaphore_Handle semaphore, int count);

extern void Semaphore_pendTimeout(uintptr_t arg);

static inline Semaphore_Handle Semaphore_handle(Semaphore_Struct *str)
{  
    return ((Semaphore_Handle)str);
}

static inline Semaphore_Struct * Semaphore_struct(Semaphore_Handle handle)
{  
    return ((Semaphore_Struct *)handle);
}

#ifdef __cplusplus
}
#endif
#endif /* ti_sysbios_knl_Semaphore__include */

/* @cond NODOC */
#undef ti_sysbios_knl_Semaphore_long_names
#include "Semaphore_defs.h"