pal_board.c

Go to the documentation of this file.

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

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

#include <stdbool.h>
#include <stdlib.h>
#include "pal.h"
#include "pal_boardtypes.h"
#include "pal_config.h"

#if (BOARD_TYPE == RCB_6_3_PLAIN)

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

/* EEPROM command bytes */
#define AT25010_CMD_WREN  0x06  
#define AT25010_CMD_WRDI  0x04  
#define AT25010_CMD_RDSR  0x05  
#define AT25010_CMD_WRSR  0x01  
#define AT25010_CMD_READ  0x03  
#define AT25010_CMD_WRITE 0x02  
/* EEPROM status register bits */
#define AT25010_STATUS_NRDY 0x01 
#define AT25010_STATUS_WE   0x02 
#define AT25010_BP0         0x04 
#define AT25010_BP1         0x08 
/* Values for Feature Byte 1: RF frontend features */

#define CFG_FEATURE1_RFCONN             0x01

#define CFG_FEATURE1_ANTENNA            0x02

#define CFG_FEATURE1_EXDIV              0x04

#define CFG_FEATURE1_RESV3              0x08

#define CFG_FEATURE1_PA                 0x10

#define CFG_FEATURE1_LNA                0x20

#define CFG_FEATURE1_RESV6              0x40

#define CFG_FEATURE1_RESV7              0x80


#define CFG_NAMELEN             (32 - sizeof(uint16_t))

#define CFG_BINARYLEN           32

#if (EXTERN_EEPROM_AVAILABLE == 1)
#if defined(__GNUC__)
#include <util/crc16.h>
#define CRC_CCITT_UPDATE(crc, data) _crc_ccitt_update(crc, data)
#endif /* defined(__GNUC__) */

#if defined(__ICCAVR__)
#define CRC_CCITT_UPDATE(crc, data) crc_ccitt_update(crc, data)
/* Internal helper function for CRC_CCITT_UPDATE. */
uint16_t crc_ccitt_update(uint16_t crc, uint8_t data);
#endif /* __ICCAVR__ */
#endif /* EXTERN_EEPROM_AVAILABLE */


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

enum boardfamilycode
{
    CFG_BFAMILY_RADIO_EXTENDER, 
    CFG_BFAMILY_RCB             
} SHORTENUM;

struct cfg_eeprom_data
{
    union
    {
        uint8_t raw_binary[CFG_BINARYLEN];

        /* Structured access to binary configuration data. */
        struct
        {
            uint64_t mac_address;

            uint64_t serial_number;

            enum boardfamilycode board_family;

            uint8_t board_id[3];

            uint8_t feature1;

            uint8_t cal_16mhz;

            uint8_t cal_rc_36;

            uint8_t cal_rc_20;

            int8_t antenna_gain;

            /* 7 bytes reserved, leave as 0xFF */
        }
        struct_binary;
    }
    binary_data;

    char board_name[CFG_NAMELEN];

    uint16_t crc;
};

/* === Globals ============================================================= */


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

#if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN)
static uint8_t at25010_read_byte(uint8_t addr);
static void at25010_spi_setup(void);
static void at25010_spi_cleanup(void);
static void extern_eeprom_init(void);
#endif  /* #if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN) */

/* === Implementation ======================================================= */

bool pal_calibrate_rc_osc(void)
{
    /* Nothing to be done. */
    return true;
}



#if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN)

static void at25010_spi_setup(void)
{
    /* Ensure /SS, SCK and MOSI become outputs. */
    DDRB |= _BV(PB0) | _BV(PB1) | _BV(PB2);
    /*
     * Set SPI speed very low to allow proper EEPROM reading
     * even with large capacitors on pins (e.g. for debugging
     * on Breakout Board light.
     * Here the SPI speed is put to fosc/128 by setting
     * SPR1 and SPR0 bit.
     */
    SPCR = _BV(SPE) | _BV(MSTR) | _BV(SPR1) | _BV(SPR0);
}
#endif  /* #if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN) */



#if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN)

static void at25010_spi_cleanup(void)
{
    SPCR = 0;
    DDRB &= ~_BV(PB0);
}
#endif  /* #if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN) */



#if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN)

static uint8_t at25010_read_byte(uint8_t addr)
{
    uint8_t read_value;

    EXT_EE_CS_PORT &= ~EXT_EE_CS_PIN;

    PAL_WAIT_1_US();

    SPDR = AT25010_CMD_READ;
    while ((SPSR & _BV(SPIF)) == 0)
        /* wait */;
    SPDR = addr & 0x7F; // mask out Bit 7 for 128x8 EEPROM
    while ((SPSR & _BV(SPIF)) == 0)
        /* wait */;

    SPDR = 0;   // dummy value to start SPI transfer
    while ((SPSR & _BV(SPIF)) == 0)
        /* wait */;
    read_value = SPDR;

    EXT_EE_CS_PORT |= EXT_EE_CS_PIN;

    return read_value;
}
#endif  /* #if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN) */



#if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN)

retval_t extern_eeprom_get(uint8_t start_offset, uint8_t length, void *value)
{
    uint8_t i;
    struct cfg_eeprom_data cfg;
    uint8_t *up;
    uint16_t crc;

    // Read data from external EEPROM.
    at25010_spi_setup();
    for (i = 0, up = (uint8_t *)&cfg; i < sizeof(cfg); i++, up++)
    {
        *up = at25010_read_byte(i);
    }
    at25010_spi_cleanup();

    // Calcute CRC to validate data correctness
    for (i = 0, crc = 0, up = (uint8_t *)&cfg; i < sizeof(cfg); i++, up++)
    {
        crc = CRC_CCITT_UPDATE(crc, *up);
    }
    if (crc != 0)
    {
        return FAILURE;
    }

    /* Copy data from local cfg structure variable to target storage location */
    memcpy(value, ((uint8_t *)&cfg) + start_offset, length);

    return MAC_SUCCESS;
}
#endif  /* #if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN) */



#if defined(__ICCAVR__) || defined(DOXYGEN)
/* This function is available in WINAVR library */
#if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN)
uint16_t crc_ccitt_update(uint16_t crc, uint8_t data)
{
    data ^= crc & 0xFF;
    data ^= data << 4;

    return ((((uint16_t)data << 8) | ((crc & 0xFF00) >> 8)) ^ \
            (uint8_t)(data >> 4) ^ \
            ((uint16_t)data << 3));
}
#endif /* #if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN) */
#endif /* __ICCAVR__ || defined(DOXYGEN) */



void pal_led_init(void)
{
    LED_PORT |= (1 << LED_PIN_0);
    LED_PORT_DIR |= (1 << LED_PIN_0);
    LED_PORT |= (1 << LED_PIN_1);
    LED_PORT_DIR |= (1 << LED_PIN_1);
    LED_PORT |= (1 << LED_PIN_2);
    LED_PORT_DIR |= (1 << LED_PIN_2);
}



void pal_led(led_id_t led_no, led_action_t led_setting)
{
    switch (led_no)
    {
        default:
        case 0:
            switch (led_setting)
            {
                case LED_ON:
                    LED_PORT &= ~(1 << LED_PIN_0);
                    break;
                case LED_OFF:
                    LED_PORT |= (1 << LED_PIN_0);
                    break;
                case LED_TOGGLE:
                    LED_PORT ^= (1 << LED_PIN_0);
                    break;
            }
            break;

        case 1:
            switch (led_setting)
            {
                case LED_ON:
                    LED_PORT &= ~(1 << LED_PIN_1);
                    break;
                case LED_OFF:
                    LED_PORT |= (1 << LED_PIN_1);
                    break;
                case LED_TOGGLE:
                    LED_PORT ^= (1 << LED_PIN_1);
                    break;
            }
            break;

        case 2:
            switch (led_setting)
            {
                case LED_ON:
                    LED_PORT &= ~(1 << LED_PIN_2);
                    break;
                case LED_OFF:
                    LED_PORT |= (1 << LED_PIN_2);
                    break;
                case LED_TOGGLE:
                    LED_PORT ^= (1 << LED_PIN_2);
                    break;
            }
            break;
    }
}


void pal_button_init(void)
{
    BUTTON_PORT |= (1 << BUTTON_PIN_0);
    BUTTON_PORT_DIR &= ~(1 << BUTTON_PIN_0);
}



button_state_t pal_button_read(button_id_t button_no)
{
    /* Keep compiler happy. */
    button_no = button_no;

    if ((BUTTON_INPUT_PINS & (1 << BUTTON_PIN_0)) == 0x00)
    {
        return BUTTON_PRESSED;
    }
    else
    {
        return BUTTON_OFF;
    }
}


void gpio_init(void)
{
#if (EXTERN_EEPROM_AVAILABLE == 1)
    extern_eeprom_init();
#endif
}


#if (EXTERN_EEPROM_AVAILABLE == 1) || (defined DOXYGEN)

static void extern_eeprom_init(void)
{
    EXT_EE_CS_PORT |= EXT_EE_CS_PIN;
    EXT_EE_CS_DDR |= EXT_EE_CS_PIN;
}
#endif  /* #if (EXTERN_EEPROM_AVAILABLE == 1) || defined(DOXYGEN) */


void pal_sleep_mode(uint8_t sleep_mode)
{
    // Clear interrupt flag
    EIFR = (1 << INTF5);
    // Enable external interrupt
    EIMSK |= (1 << INT5);

#ifdef WATCHDOG
    /* Switch watchdog system reset off while being in sleep mode */
    WDT_DISABLE();
#endif

    /* Enter MCU sleep mode */
    SET_SLEEP_MODE(sleep_mode);
    SLEEP_MODE();

    /* Continue after wakeup */

#ifdef WATCHDOG
    /* Enable the Watchdog system reset mode */
#ifdef __ICCAVR__
    WDT_RESET();
    WDT_SYSTEM_RESET_MODE(WDT_TIMEOUT_PERIOD);
#endif /* __ICCAVR__ */
#ifdef __GNUC__
    wdt_disable();
    WDT_RESET();
    wdt_enable(WDT_TIMEOUT_PERIOD);
#endif /* __GNUC__ */
#endif
}


ISR(INT5_vect)
{
    /* MCU wakeup */
    // Disable external interrupt
    EIMSK &= ~(1 << INT5);
}


#endif /* RCB_6_3_PLAIN */

/* EOF */