Clock.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020, 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.
 *
 */
/*
 * ======== Clock.h ========
 */

#ifndef Clock__include
#define Clock__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/Swi.h>

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

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

/*
 * Error and Assert Ids
 */

#define Clock_A_clockDisabled "Cannot create a clock instance when BIOS.clockEnabled is false."

#define Clock_A_badThreadType "Cannot create/delete a Clock from a Hwi or Swi thread."

#define Clock_A_badTimeout    "Bad timeout value."

typedef struct Clock_Module_State Clock_Module_State;
typedef struct Clock_Params Clock_Params;
typedef struct Clock_Struct Clock_Struct;
typedef struct Clock_Struct Clock_Object;
typedef Clock_Object* Clock_Handle;
typedef Clock_Object* Clock_Instance;

enum Clock_TickSource {
    Clock_TickSource_TIMER,
    Clock_TickSource_USER,
    Clock_TickSource_NULL
};
typedef enum Clock_TickSource Clock_TickSource;

enum Clock_TickMode {
    Clock_TickMode_PERIODIC,
    Clock_TickMode_DYNAMIC
};
typedef enum Clock_TickMode Clock_TickMode;

typedef void (*Clock_FuncPtr)(uintptr_t arg1);

/* Params */
struct Clock_Params {
    bool startFlag;
    uint32_t period;
    uintptr_t arg;
};

/* Module_State */
struct Clock_Module_State {
    Queue_Object clockQ;
    volatile uint32_t ticks;
    unsigned int swiCount;
    Swi_Struct swiStruct;
    Swi_Handle swi;
    volatile unsigned int numTickSkip;
    uint32_t nextScheduledTick;
    uint32_t maxSkippable;
    bool inWorkFunc;
    volatile bool startDuringWorkFunc;
    bool ticking;
    Clock_TickMode tickMode;
    uint32_t tickPeriod;
    Clock_TickSource tickSource;
    bool initDone;
};

/* Struct */
struct Clock_Struct {
    Queue_Elem objElem;
    uint32_t timeout;
    uint32_t currTimeout;
    uint32_t period;
    volatile bool active;
    Clock_FuncPtr fxn;
    uintptr_t arg;
    uint32_t timeoutTicks;
};

extern const uint32_t Clock_serviceMargin;
extern const Clock_TickSource Clock_tickSource;

extern const Clock_TickMode Clock_tickMode;

extern const unsigned int Clock_timerId;

extern const uint32_t Clock_tickPeriod;

extern const Clock_Handle Clock_triggerClock;

extern void Clock_init(void);

extern void Clock_Instance_init(Clock_Object *obj, Clock_FuncPtr clockFxn, unsigned int timeout, const Clock_Params *prms);

extern void Clock_Instance_finalize(Clock_Object *obj);
extern Clock_Handle Clock_create(Clock_FuncPtr clockFxn, unsigned int timeout, const Clock_Params *prms, Error_Block *eb);

extern Clock_Handle Clock_construct(Clock_Struct *obj, Clock_FuncPtr clockFxn, unsigned int timeout, const Clock_Params *prms);

extern void Clock_delete(Clock_Handle *clock);

extern void Clock_destruct(Clock_Struct *obj);

extern void Clock_Params_init(Clock_Params *prms);

extern Clock_Handle Clock_Object_first(void);

extern Clock_Handle Clock_Object_next(Clock_Handle clock);

extern uint32_t Clock_getTicks(void);

extern void * Clock_getTimerHandle(void);
extern void Clock_setTicks(uint32_t ticks);
extern void Clock_tickStop(void);

extern bool Clock_tickReconfig(void);

extern void Clock_tickStart(void);

extern void Clock_tick(void);

extern void Clock_workFunc(uintptr_t arg0, uintptr_t arg1);
extern void Clock_workFuncDynamic(uintptr_t arg0, uintptr_t arg1);
extern void Clock_logTick(void);
extern uint32_t Clock_getCompletedTicks(void);
extern uint32_t Clock_getTickPeriod(void);
extern uint32_t Clock_getTicksUntilInterrupt(void);
extern uint32_t Clock_getTicksUntilTimeout(void);
extern uint32_t Clock_walkQueueDynamic(bool service, uint32_t tick);
extern uint32_t Clock_walkQueuePeriodic(void);
extern void Clock_scheduleNextTick(uint32_t deltaTicks, uint32_t absTick);
extern void Clock_addI(Clock_Handle clock, Clock_FuncPtr clockFxn, uint32_t timeout, uintptr_t arg);
extern void Clock_initI(Clock_Handle clock, Clock_FuncPtr clockFxn, uint32_t timeout, uintptr_t arg);
extern void Clock_enqueueI(Clock_Handle clock);
extern void Clock_removeI(Clock_Handle clock);
extern void Clock_start(Clock_Handle clock);

extern void Clock_startI(Clock_Handle clock);
extern void Clock_stop(Clock_Handle clock);

extern void Clock_setPeriod(Clock_Handle clock, uint32_t period);

extern void Clock_setTimeout(Clock_Handle clock, uint32_t timeout);

extern void Clock_setFunc(Clock_Handle clock, Clock_FuncPtr fxn, uintptr_t arg);

extern uint32_t Clock_getPeriod(Clock_Handle clock);

extern uint32_t Clock_getTimeout(Clock_Handle clock);

extern bool Clock_isActive(Clock_Handle clock);

/* @cond NODOC */
extern void Clock_doTick(uintptr_t arg);

extern void Clock_triggerFunc(uintptr_t arg);

extern Clock_Module_State Clock_Module_state;

#define Clock_module ((Clock_Module_State *) &(Clock_Module_state))

static inline Clock_Handle Clock_handle(Clock_Struct *str)
{  
    return ((Clock_Handle)str);
}

static inline Clock_Struct * Clock_struct(Clock_Handle h)
{
    return ((Clock_Struct *)h);
}

/* CC32XX DPL calls this internal function, map it for now */
#define ti_sysbios_knl_Clock_doTick(a) Clock_tick()
/* @endcond */

#ifdef __cplusplus
}
#endif
#endif /* Clock__include */

/* @cond NODOC */
#undef ti_sysbios_knl_Clock_long_names
#include "Clock_defs.h"