pal.h

Go to the documentation of this file.

/*
 * Copyright (c) 2009, Atmel Corporation All rights reserved.
 *
 * Licensed under Atmel's Limited License Agreement --> EULA.txt
 */

/* Prevent double inclusion */
#ifndef PAL_H
#define PAL_H

/*
 * NOTE:- Include 'return_val.h' before this file, as return_val.h has the
 *        all return value enums.
 */

/* === Includes ============================================================ */

#include <stdbool.h>
#include <stdint.h>
#include "pal_types.h"
#include "pal_config.h"
#if (PAL_GENERIC_TYPE == MEGA_RF)
#include "pal_mcu_generic.h"
#endif
#include "app_config.h"

/* === Macros =============================================================== */

#define ADD_TIME(a, b)                  ((a) + (b))

#define SUB_TIME(a, b)                  ((a) - (b))

#if (PAL_GENERIC_TYPE == AVR32)
#define U16_TO_TARGET(x) ((((x) << 8) & 0xFF00) | (((x) >> 8) & 0x00FF))
#else
#define U16_TO_TARGET(x) (x)
#endif

/* === Types =============================================================== */

/* Please dont change this type. */
typedef enum pin_state_tag
{
    LOW,
    HIGH
} SHORTENUM pin_state_t;


#if defined (SIO_HUB) || defined(DOXYGEN)

typedef enum sio_serial_tag
{
    /* Serial unit used by user */
    SIO_0,
    SIO_1,
    SIO_2,
    SIO_3,
    SIO_4
} SHORTENUM sio_serial_t;
#endif


typedef enum
timeout_type_tag
{
    TIMEOUT_RELATIVE,
    TIMEOUT_ABSOLUTE
} SHORTENUM timeout_type_t;


typedef enum source_type_tag
{
    TMR_CLK_SRC_DURING_TRX_SLEEP,
    TMR_CLK_SRC_DURING_TRX_AWAKE
} SHORTENUM source_type_t;

typedef enum ps_id_tag
{
    PS_IEEE_ADDR,
    PS_XTAL_TRIM
} SHORTENUM ps_id_t;


typedef enum ps_type_tag
{
    INTERN_EEPROM,
    EXTERN_EEPROM
} SHORTENUM ps_type_t;


typedef enum led_action_tag
{
    LED_ON,
    LED_OFF,
    LED_TOGGLE
} SHORTENUM led_action_t;


typedef enum button_state_tag
{
    BUTTON_PRESSED,
    BUTTON_OFF
} SHORTENUM button_state_t;


typedef enum pwr_mode_tag
{
    SYSTEM_SLEEP
} pwr_mode_t;


typedef void (*irq_handler_t)(void);


#ifdef TEST_HARNESS
#if (DEBUG > 0)

typedef struct assert_tag
{
    uint8_t size            ALIGN8BIT;
    uint8_t assert_cmdcode  ALIGN8BIT;
    uint8_t data[1]         ALIGN8BIT;
} assert_t;
#endif  /* (DEBUG > 0) */
#endif  /* TEST_HARNESS */

/* === Externals ============================================================ */


/* === Prototypes =========================================================== */

#ifdef __cplusplus
extern "C" {
#endif

    retval_t pal_init(void);


    void pal_task(void);

#if (PAL_GENERIC_TYPE != MEGA_RF)

    void pal_trx_irq_init(FUNC_PTR trx_irq_cb);
#endif /* (PAL_GENERIC_TYPE != MEGA_RF) */

    void pal_trx_irq_init_tstamp(FUNC_PTR trx_irq_cb);

#if (PAL_GENERIC_TYPE == MEGA_RF)

    void pal_trx_irq_init_rx_end(FUNC_PTR trx_irq_cb);

    void pal_trx_irq_init_tx_end(FUNC_PTR trx_irq_cb);

    void pal_trx_irq_init_cca_ed(FUNC_PTR trx_irq_cb);

    void pal_trx_irq_init_awake(FUNC_PTR trx_irq_cb);

#ifdef ENABLE_ALL_TRX_IRQS

    void pal_trx_irq_init_ami(FUNC_PTR trx_irq_cb);

    void pal_trx_irq_init_batmon(FUNC_PTR trx_irq_cb);

    void pal_trx_irq_init_pll_lock(FUNC_PTR trx_irq_cb);

    void pal_trx_irq_init_pll_unlock(FUNC_PTR trx_irq_cb);

    void pal_trx_irq_init_aes_ready(FUNC_PTR trx_irq_cb);

#if PAL_TYPE == ATMEGA256RFR1 || PAL_TYPE == ATMEGA256RFR2

    void pal_trx_irq_init_tx_start(FUNC_PTR trx_irq_cb);

    void pal_trx_irq_init_maf_0_ami(FUNC_PTR trx_irq_cb);

    void pal_trx_irq_init_maf_1_ami(FUNC_PTR trx_irq_cb);

    void pal_trx_irq_init_maf_2_ami(FUNC_PTR trx_irq_cb);

    void pal_trx_irq_init_maf_3_ami(FUNC_PTR trx_irq_cb);
#endif  /* ATMEGA256RFR1 */

#endif  /* ENABLE_ALL_TRX_IRQS */

#ifdef PAL_XTD_IRQ_API

    FUNC_PTR pal_trx_irq_get_hdlr_rx_end(void);

    FUNC_PTR pal_trx_irq_get_hdlr_tx_end(void);
#endif  /* PAL_XTD_IRQ_API */
#endif  /* #if (PAL_GENERIC_TYPE == MEGA_RF) */

#if (PAL_GENERIC_TYPE != MEGA_RF)

#define pal_trx_irq_en()                ENABLE_TRX_IRQ()

#define pal_trx_irq_en_tstamp()         ENABLE_TRX_IRQ_TSTAMP()

#define pal_trx_irq_dis()               DISABLE_TRX_IRQ()

#define pal_trx_irq_dis_tstamp()        DISABLE_TRX_IRQ_TSTAMP()
#endif /* #if (PAL_GENERIC_TYPE != MEGA_RF) */

#define pal_trx_irq_flag_clr()          CLEAR_TRX_IRQ()

#define pal_trx_irq_flag_clr_tstamp()   CLEAR_TRX_IRQ_TSTAMP()

#if (PAL_GENERIC_TYPE == MEGA_RF)

#define pal_trx_irq_flag_clr_rx_end()   (CLEAR_TRX_IRQ_RX_END())

#define pal_trx_irq_flag_clr_tx_end()   (CLEAR_TRX_IRQ_TX_END())

#define pal_trx_irq_flag_clr_cca_ed()   (CLEAR_TRX_IRQ_CCA_ED())

#define pal_trx_irq_flag_clr_awake()    (CLEAR_TRX_IRQ_AWAKE())

#ifdef ENABLE_ALL_TRX_IRQS

#define pal_trx_irq_flag_clr_ami()      (CLEAR_TRX_IRQ_AMI())

#define pal_trx_irq_flag_clr_batmon()   (CLEAR_TRX_IRQ_BATMON())

#define pal_trx_irq_flag_clr_pll_lock() (CLEAR_TRX_IRQ_PLL_LOCK())

#define pal_trx_irq_flag_clr_pll_unlock()   (CLEAR_TRX_IRQ_PLL_UNLOCK())

#if PAL_TYPE == ATMEGA256RFR1

#define pal_trx_irq_flag_clr_tx_start()     (CLEAR_TRX_IRQ_TX_START())

#define pal_trx_irq_flag_clr_maf_0_ami()    (CLEAR_TRX_IRQ_MAF_0_AMI())

#define pal_trx_irq_flag_clr_maf_1_ami()    (CLEAR_TRX_IRQ_MAF_1_AMI())

#define pal_trx_irq_flag_clr_maf_2_ami()    (CLEAR_TRX_IRQ_MAF_2_AMI())

#define pal_trx_irq_flag_clr_maf_3_ami()    (CLEAR_TRX_IRQ_MAF_3_AMI())


#endif  /* ATMEGA256RFR1 */

#endif  /* ENABLE_ALL_TRX_IRQS */
#endif  /* #if (PAL_GENERIC_TYPE == MEGA_RF) */


    static inline void pal_global_irq_enable(void)
    {
        ENABLE_GLOBAL_IRQ();
    }


    static inline void pal_global_irq_disable(void)
    {
        DISABLE_GLOBAL_IRQ();
    }



#if defined(ENABLE_HIGH_PRIO_TMR) || defined(DOXYGEN)
    /*
     * Internal prototypes for pal_timer module
     */
    retval_t pal_start_high_priority_timer(uint8_t timer_id,
                                           uint16_t timer_count,
                                           FUNC_PTR timer_cb,
                                           void *param_cb);

    retval_t pal_stop_high_priority_timer(uint8_t timer_id);
#endif

    void pal_timer_delay(uint16_t delay);

    void pal_timer_source_select(source_type_t source);

#if (TOTAL_NUMBER_OF_TIMERS > 0) || defined(DOXYGEN)

    bool pal_is_timer_running(uint8_t timer_id);
#endif

#if (DEBUG > 0)
    bool pal_are_all_timers_stopped(void);
#endif  /* (DEBUG > 0) */

    static inline uint32_t pal_add_time_us(uint32_t a, uint32_t b)
    {
        return (ADD_TIME(a, b));
    }


    static inline uint32_t pal_sub_time_us(uint32_t a, uint32_t b)
    {
        return (SUB_TIME(a, b));
    }


    /*
     * Macros for TRX GPIO pins access.
     */
#define PAL_RST_HIGH()                  RST_HIGH()

#define PAL_RST_LOW()                   RST_LOW()

#define PAL_SLP_TR_HIGH()               SLP_TR_HIGH()

#define PAL_SLP_TR_LOW()                SLP_TR_LOW()

#define PAL_TRX_IRQ_HIGH()              IRQ_PINGET()

    void pal_trx_read_timestamp(uint32_t *timestamp);

#ifdef SNIFFER

    void pal_trx_write_timestamp(uint32_t *timestamp);
#endif  /* SNIFFER */

    /*
     * Prototypes for transceiver access.  Some PALs define these as
     * macros instead of implementing them as functions, so only declare
     * them here if they are not implemented as macros.
     */
#if defined(PAL_USE_SPI_TRX) || defined(DOXYGEN)

    void pal_trx_frame_read(uint8_t *data, uint8_t length);

    void pal_trx_frame_write(uint8_t *data, uint8_t length);

    uint8_t pal_trx_reg_read(uint8_t addr);

    void pal_trx_reg_write(uint8_t addr, uint8_t data);

    uint8_t pal_trx_bit_read(uint8_t addr, uint8_t mask, uint8_t pos);

    void pal_trx_bit_write(uint8_t reg_addr, uint8_t mask, uint8_t pos, uint8_t new_value);

#if defined(ENABLE_TRX_SRAM) || defined(ENABLE_TRX_SRAM_READ) || defined(DOXYGEN)

    void pal_trx_sram_read(uint8_t addr, uint8_t *data, uint8_t length);
#endif

#if defined(ENABLE_TRX_SRAM) || defined(DOXYGEN)

    void pal_trx_sram_write(uint8_t addr, uint8_t *data, uint8_t length);
#endif

#if defined(ENABLE_TRX_SRAM) || defined(DOXYGEN)

    void pal_trx_aes_wrrd(uint8_t addr, uint8_t *idata, uint8_t length);
#endif  /* #ifdef ENABLE_TRX_SRAM */

#endif  /* defined(PAL_USE_SPI_TRX) */


#if defined(SIO_HUB) || defined(DOXYGEN)
    /*
     * Prototypes for Stream I/O interface
     */
    retval_t pal_sio_init(uint8_t sio_unit);

    uint8_t pal_sio_tx(uint8_t sio_unit, uint8_t *data, uint8_t length);

    uint8_t pal_sio_rx(uint8_t sio_unit, uint8_t *data, uint8_t max_length);
#endif  /* SIO_HUB */


    bool pal_calibrate_rc_osc(void);


    /*
     * Prototypes for persistence storage
     */
    retval_t pal_ps_get(ps_type_t ps_type, uint16_t start_addr, uint16_t length, void *value);

    retval_t pal_ps_set(uint16_t start_addr, uint16_t length, void *value);


    void pal_alert(void);


#if (DEBUG > 0)
    void pal_assert(bool expression,
                    FLASH_STRING_T message,
                    int8_t *file,
                    uint16_t line);

    /* DEBUG only: Test for an assertion, similar to Std-C assert() */
#define ASSERT(expr)    pal_assert(expr, FLASH_STRING( #expr ), (int8_t*)__FILE__, __LINE__)
#else
#define ASSERT(expr)
#endif /* (DEBUG > 0) */

    /*
     * Public prototypes for pal_timer module
     */

#if (TOTAL_NUMBER_OF_TIMERS > 0) || defined(DOXYGEN)

    retval_t pal_timer_start(uint8_t timer_id,
                             uint32_t timer_count,
                             timeout_type_t timeout_type,
                             FUNC_PTR timer_cb,
                             void *param_cb);
#endif

#if (TOTAL_NUMBER_OF_TIMERS > 0) || defined(DOXYGEN)

    retval_t pal_timer_stop(uint8_t timer_id);
#endif

    void pal_get_current_time(uint32_t *current_time);


    void pal_led_init(void);

    void pal_led(led_id_t led_no, led_action_t led_setting);


    void pal_button_init(void);


    button_state_t pal_button_read(button_id_t button_no);


    void pal_sleep_mode(uint8_t sleep_mode);


#if defined(NON_BLOCKING_SPI) || defined(DOXYGEN)

    void pal_spi_done_cb_init(void *spi_done_cb);
#endif

#if defined(WATCHDOG) || defined(SLEEPING_TIMER) || defined(DOXYGEN)
#if (PAL_GENERIC_TYPE == XMEGA)

    void wdt_init(void);

    void wdt_parallel_timer_init(void);

    void sleeping_timer_without_wdt(void);

    void sleeping_timer_with_wdt(void);

    void sleeping_timer_init(void);

    void wdt_clear(void);

    void pal_wdt_enable( WDT_PER_t period );

    void RTC_Initialize( uint16_t period,
                         uint16_t count,
                         uint16_t compareValue,
                         RTC_PRESCALER_t prescaler );

    void RTC_SetIntLevels( RTC_OVFINTLVL_t ovfIntLevel,
                           RTC_COMPINTLVL_t compIntLevel );
#endif /* (PAL_GENERIC_TYPE == XMEGA) */
#endif /* (defined(WATCHDOG) || defined(SLEEPING_TIMER) || defined(DOXYGEN)) */

    uint16_t pal_generate_rand_seed(void);

#ifdef __cplusplus
} /* extern "C" */
#endif

#endif  /* PAL_H */
/* EOF */