kapi.h

实现快速傅立叶变换算法,provides test framwork for FFT testing

/* Interrupt controller access                                               */
void cyg_interrupt_mask(cyg_vector_t vector) __THROW;
void cyg_interrupt_mask_intunsafe(cyg_vector_t vector) __THROW;

void cyg_interrupt_unmask(cyg_vector_t vector) __THROW;
void cyg_interrupt_unmask_intunsafe(cyg_vector_t vector) __THROW;

void cyg_interrupt_acknowledge(cyg_vector_t vector) __THROW;

void cyg_interrupt_configure(
    cyg_vector_t        vector,         /* vector to configure               */
    cyg_bool_t          level,          /* level or edge triggered           */
    cyg_bool_t          up              /* rising/faling edge, high/low level*/
) __THROW;

void cyg_interrupt_set_cpu(
    cyg_vector_t        vector,         /* vector to control                 */
    cyg_cpu_t           cpu             /* CPU to set                        */
) __THROW;

cyg_cpu_t cyg_interrupt_get_cpu(
    cyg_vector_t        vector          /* vector to control                 */
) __THROW;
    
/*---------------------------------------------------------------------------*/
/* Counters, Clocks and Alarms                                               */

void cyg_counter_create(
    cyg_handle_t        *handle,        /* returned counter handle           */
    cyg_counter         *counter        /* put counter here                  */
) __THROW;

void cyg_counter_delete(cyg_handle_t counter) __THROW;

/* Return current value of counter                                           */
cyg_tick_count_t cyg_counter_current_value(cyg_handle_t counter) __THROW;

/* Set new current value                                                     */
void cyg_counter_set_value(
    cyg_handle_t        counter,
    cyg_tick_count_t new_value
) __THROW;

/* Advance counter by one tick                                               */
void cyg_counter_tick(cyg_handle_t counter) __THROW;

/* Advance counter by multiple ticks                                         */
void cyg_counter_multi_tick(cyg_handle_t counter, cyg_tick_count_t _ticks) __THROW;


#define CYG_RESOLUTION_T_MEMBERS  \
    cyg_uint32  dividend;         \
    cyg_uint32  divisor;

typedef struct 
{
    CYG_RESOLUTION_T_MEMBERS
} cyg_resolution_t;

/* Create a clock object                */
void cyg_clock_create(
    cyg_resolution_t    resolution,     /* Initial resolution                */
    cyg_handle_t        *handle,        /* Returned clock handle             */
    cyg_clock           *clock          /* put clock here                    */    
) __THROW;

void cyg_clock_delete(cyg_handle_t clock) __THROW;

/* convert a clock handle to a counter handle so we can use the              */
/* counter API on it.                                                        */
void cyg_clock_to_counter(
    cyg_handle_t        clock,
    cyg_handle_t        *counter
) __THROW;

void cyg_clock_set_resolution(
    cyg_handle_t        clock,
    cyg_resolution_t    resolution      /* New resolution                    */
) __THROW;

cyg_resolution_t cyg_clock_get_resolution(cyg_handle_t clock) __THROW;

/* handle of real time clock                                                 */
cyg_handle_t cyg_real_time_clock(void) __THROW;

/* returns value of real time clock's counter.
   This is the same as:
   (cyg_clock_to_counter(cyg_real_time_clock(), &h),
    cyg_counter_current_value(h))                                            */
cyg_tick_count_t cyg_current_time(void) __THROW;

/* Alarm handler function                                                    */
typedef void cyg_alarm_t(cyg_handle_t alarm, cyg_addrword_t data);

void cyg_alarm_create(
    cyg_handle_t        counter,        /* Attached to this counter          */
    cyg_alarm_t         *alarmfn,       /* Call-back function                */
    cyg_addrword_t      data,           /* Call-back data                    */
    cyg_handle_t        *handle,        /* Returned alarm object             */
    cyg_alarm           *alarm          /* put alarm here                    */    
) __THROW;

/* Disable alarm, detach from counter and invalidate handles                 */
void cyg_alarm_delete( cyg_handle_t alarm) __THROW;

void cyg_alarm_initialize(
    cyg_handle_t        alarm,
    cyg_tick_count_t    trigger,        /* Absolute trigger time             */
    cyg_tick_count_t    interval        /* Relative retrigger interval       */
) __THROW;

void cyg_alarm_get_times(
    cyg_handle_t        alarm,
    cyg_tick_count_t    *trigger,       /* Next trigger time                 */
    cyg_tick_count_t    *interval       /* Current interval                  */
) __THROW;

void cyg_alarm_enable( cyg_handle_t alarm ) __THROW;

void cyg_alarm_disable( cyg_handle_t alarm ) __THROW;

/*---------------------------------------------------------------------------*/
/* Mail boxes                                                                */
void cyg_mbox_create(
    cyg_handle_t        *handle,
    cyg_mbox            *mbox
) __THROW;

void cyg_mbox_delete(cyg_handle_t mbox) __THROW;

void *cyg_mbox_get(cyg_handle_t mbox) __THROW;

#ifdef CYGFUN_KERNEL_THREADS_TIMER
void *cyg_mbox_timed_get(
    cyg_handle_t mbox,
    cyg_tick_count_t abstime
    ) __THROW;
#endif

void *cyg_mbox_tryget(cyg_handle_t mbox) __THROW;

void *cyg_mbox_peek_item(cyg_handle_t mbox) __THROW;

#ifdef CYGMFN_KERNEL_SYNCH_MBOXT_PUT_CAN_WAIT
cyg_bool_t cyg_mbox_put(cyg_handle_t mbox, void *item) __THROW;
#ifdef CYGFUN_KERNEL_THREADS_TIMER
cyg_bool_t cyg_mbox_timed_put(
    cyg_handle_t mbox,
    void *item,
    cyg_tick_count_t abstime
    ) __THROW;
#endif
#endif

cyg_bool_t cyg_mbox_tryput(cyg_handle_t mbox, void *item) __THROW;

cyg_count32 cyg_mbox_peek(cyg_handle_t mbox) __THROW;

cyg_bool_t cyg_mbox_waiting_to_get(cyg_handle_t mbox) __THROW;

cyg_bool_t cyg_mbox_waiting_to_put(cyg_handle_t mbox) __THROW;


/*-----------------------------------------------------------------------*/
/* Memory pools                                                          */

/* These definitions are found in the "memalloc" package as this is      */
/* where the implementation lives.                                       */

#ifdef CYGPKG_MEMALLOC
# include <cyg/memalloc/kapi.h>
#endif

/*---------------------------------------------------------------------------*/
/* Semaphores                                                                */

void      cyg_semaphore_init(
    cyg_sem_t           *sem,            /* Semaphore to init                */
    cyg_count32         val              /* Initial semaphore value          */
) __THROW;

void cyg_semaphore_destroy( cyg_sem_t *sem ) __THROW;

cyg_bool_t cyg_semaphore_wait( cyg_sem_t *sem ) __THROW;

#ifdef CYGFUN_KERNEL_THREADS_TIMER
cyg_bool_t cyg_semaphore_timed_wait(
    cyg_sem_t          *sem,
    cyg_tick_count_t   abstime
    ) __THROW;
#endif

cyg_bool_t cyg_semaphore_trywait( cyg_sem_t *sem ) __THROW;

void cyg_semaphore_post( cyg_sem_t *sem ) __THROW;

void cyg_semaphore_peek( cyg_sem_t *sem, cyg_count32 *val ) __THROW;

/*---------------------------------------------------------------------------*/
/* Flags                                                                     */

typedef cyg_uint32 cyg_flag_value_t;
typedef cyg_uint8  cyg_flag_mode_t;
#define CYG_FLAG_WAITMODE_AND ((cyg_flag_mode_t)0) /* all bits must be set */
#define CYG_FLAG_WAITMODE_OR  ((cyg_flag_mode_t)2) /* any bit must be set  */
#define CYG_FLAG_WAITMODE_CLR ((cyg_flag_mode_t)1) /* clear when satisfied */

void cyg_flag_init(
    cyg_flag_t        *flag             /* Flag to init                      */
) __THROW;

void cyg_flag_destroy( cyg_flag_t *flag ) __THROW;

/* bitwise-or in the bits in value; awaken any waiting tasks whose
   condition is now satisfied */
void cyg_flag_setbits( cyg_flag_t *flag, cyg_flag_value_t value) __THROW;

/* bitwise-and with the the bits in value; this clears the bits which
   are not set in value.  No waiting task can be awoken. */
void cyg_flag_maskbits( cyg_flag_t *flag, cyg_flag_value_t value) __THROW;

/* wait for the flag value to match the pattern, according to the mode.
   If mode includes CLR, set the flag value to zero when
   our pattern is matched.  The return value is that which matched
   the request, or zero for an error/timeout return.
   Value must not itself be zero. */
cyg_flag_value_t cyg_flag_wait( cyg_flag_t        *flag,
                                cyg_flag_value_t   pattern, 
                                cyg_flag_mode_t    mode ) __THROW;

#ifdef CYGFUN_KERNEL_THREADS_TIMER
cyg_flag_value_t cyg_flag_timed_wait( cyg_flag_t        *flag,
                                      cyg_flag_value_t   pattern, 
                                      cyg_flag_mode_t    mode,
                                      cyg_tick_count_t   abstime ) __THROW;

#endif

cyg_flag_value_t cyg_flag_poll( cyg_flag_t         *flag,
                                cyg_flag_value_t    pattern, 
                                cyg_flag_mode_t     mode ) __THROW;

cyg_flag_value_t cyg_flag_peek( cyg_flag_t *flag ) __THROW;

cyg_bool_t cyg_flag_waiting( cyg_flag_t *flag ) __THROW;

/*---------------------------------------------------------------------------*/
/* Mutex                                                                     */

#ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DYNAMIC
enum cyg_mutex_protocol
{
  CYG_MUTEX_NONE = 0,                   // no inversion protocol
  CYG_MUTEX_INHERIT,                    // priority inheritance protocol
  CYG_MUTEX_CEILING                     // priority ceiling protocol
};
#endif

void cyg_mutex_init(
    cyg_mutex_t        *mutex          /* Mutex to init                      */
) __THROW;

void cyg_mutex_destroy( cyg_mutex_t *mutex ) __THROW;

cyg_bool_t cyg_mutex_lock( cyg_mutex_t *mutex ) __THROW;

cyg_bool_t cyg_mutex_trylock( cyg_mutex_t *mutex ) __THROW;

void cyg_mutex_unlock( cyg_mutex_t *mutex ) __THROW;

void cyg_mutex_release( cyg_mutex_t *mutex ) __THROW;

#ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_CEILING
void cyg_mutex_set_ceiling( cyg_mutex_t *mutex, cyg_priority_t priority ) __THROW;
#endif

#ifdef CYGSEM_KERNEL_SYNCH_MUTEX_PRIORITY_INVERSION_PROTOCOL_DYNAMIC
void cyg_mutex_set_protocol ( cyg_mutex_t *mutex, enum cyg_mutex_protocol protocol ) __THROW;
#endif

/*---------------------------------------------------------------------------*/
/* Condition Variables                                                       */

void cyg_cond_init(
    cyg_cond_t          *cond,          /* condition variable to init        */
    cyg_mutex_t         *mutex          /* associated mutex                  */
) __THROW;

void cyg_cond_destroy( cyg_cond_t *cond ) __THROW;

cyg_bool_t cyg_cond_wait( cyg_cond_t *cond ) __THROW;

void cyg_cond_signal( cyg_cond_t *cond ) __THROW;

void cyg_cond_broadcast( cyg_cond_t *cond ) __THROW;

#ifdef CYGMFN_KERNEL_SYNCH_CONDVAR_TIMED_WAIT
cyg_bool_t cyg_cond_timed_wait(
    cyg_cond_t        *cond,
    cyg_tick_count_t  abstime
    ) __THROW;
#endif

/*---------------------------------------------------------------------------*/
/* Spinlocks                                                                 */

void cyg_spinlock_init(
    cyg_spinlock_t      *lock,          /* spinlock to initialize            */
    cyg_bool_t          locked          /* init locked or unlocked           */
) __THROW;

void cyg_spinlock_destroy( cyg_spinlock_t *lock ) __THROW;

void cyg_spinlock_spin( cyg_spinlock_t *lock ) __THROW;

void cyg_spinlock_clear( cyg_spinlock_t *lock ) __THROW;

cyg_bool_t cyg_spinlock_try( cyg_spinlock_t *lock ) __THROW;

cyg_bool_t cyg_spinlock_test( cyg_spinlock_t *lock ) __THROW;

void cyg_spinlock_spin_intsave( cyg_spinlock_t *lock,
                                cyg_addrword_t *istate ) __THROW;

void cyg_spinlock_clear_intsave( cyg_spinlock_t *lock,
                                 cyg_addrword_t istate ) __THROW;

/*---------------------------------------------------------------------------*/
#ifdef __cplusplus
}
#endif

/*---------------------------------------------------------------------------*/

#include <cyg/kernel/kapidata.h>

/*---------------------------------------------------------------------------*/
/* EOF kapi.h                                                                */
#endif /* CYGFUN_KERNEL_API_C   */
#endif /* CYGONCE_KERNEL_KAPI_H */