periph.h

Go to the documentation of this file.

/* Copyright 2012-2014, Peter A. Bigot
 *
 * 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 the software 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 HOLDER 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.
 */

#ifndef BSP430_PERIPH_H
#define BSP430_PERIPH_H

#include <bsp430/core.h>
#include <msp430.h>

typedef int tBSP430periphHandle;

#define BSP430_PERIPH_NONE ((tBSP430periphHandle)0)

#define BSP430_PERIPH_LFXT1 ((tBSP430periphHandle)0x4001)

#ifndef configBSP430_PERIPH_XT2
#define configBSP430_PERIPH_XT2 0
#endif /* configBSP430_PERIPH_XT2 */

#if defined(BSP430_DOXYGEN) || (configBSP430_PERIPH_XT2 - 0)
#define BSP430_PERIPH_XT2 ((tBSP430periphHandle)0x4003)
#endif /* configBSP430_PERIPH_XT2 */

#ifndef configBSP430_PERIPH_EXPOSED_CLOCKS
#define configBSP430_PERIPH_EXPOSED_CLOCKS 0
#endif /* configBSP430_PERIPH_EXPOSED_CLOCKS */

#if defined(BSP430_DOXYGEN) || (configBSP430_PERIPH_EXPOSED_CLOCKS - 0)
#define BSP430_PERIPH_EXPOSED_CLOCKS ((tBSP430periphHandle)0x4005)
#endif /* configBSP430_PERIPH_EXPOSED_CLOCKS */

#define BSP430_PERIPH_BUTTON0 ((tBSP430periphHandle)0x4101)

#define BSP430_PERIPH_BUTTON1 ((tBSP430periphHandle)0x4103)

#define BSP430_PERIPH_BUTTON2 ((tBSP430periphHandle)0x4105)

#define BSP430_PERIPH_BUTTON3 ((tBSP430periphHandle)0x4107)

#define BSP430_PERIPHCFG_DEFAULT 0

#define BSP430_PERIPHCFG_SERIAL_UART 1

#define BSP430_PERIPHCFG_SERIAL_I2C 2

#define BSP430_PERIPHCFG_SERIAL_SPI3 3

#define BSP430_PERIPHCFG_SERIAL_SPI4 4

#define BSP430_PERIPH_HAL_STATE_CFLAGS_VARIANT_UNKNOWN 0

#define BSP430_PERIPH_HAL_STATE_CFLAGS_VARIANT_MASK_ 0x0F

#define BSP430_PERIPH_HAL_STATE_CFLAGS_VARIANT(_p) (BSP430_PERIPH_HAL_STATE_CFLAGS_VARIANT_MASK_ & (_p)->hal_state.cflags)

#define BSP430_PERIPH_HAL_STATE_CFLAGS_ISR 0x80

#define BSP430_PERIPH_HAL_STATE_CFLAGS_ISR2 0x40

typedef struct sBSP430hplHALStatePrefix {
  const unsigned char cflags;

  volatile unsigned char flags;
} sBSP430hplHALStatePrefix;

static BSP430_CORE_INLINE
tBSP430periphHandle
xBSP430periphFromHPL (volatile void * hpl)
{
  return (tBSP430periphHandle)(uintptr_t)hpl;
}

/* Forward declarations */
struct sBSP430halISRVoidChainNode;
struct sBSP430halISRIndexedChainNode;

/* BSP430_HAL_ISR bits must not use 0x00F8 which are SCG1, SCG0,
 * OSCOFF, CPUOFF, and GIE.
 *
 * 0x0001 -- SR C, used for #BSP430_HAL_ISR_CALLBACK_BREAK_CHAIN
 * 0x0002 -- SR Z, used for #BSP430_HAL_ISR_CALLBACK_EXIT_LPM
 * 0x0004 -- SR N, available
 * 0x00F8 -- SR bits used for their SR purpose
 * 0x0100 -- SR V, available
 * 0x0E00 -- Reserved, available
 * 0x1000 -- Reserved, used for #BSP430_HAL_ISR_CALLBACK_YIELD
 * 0x2000 -- Reserved, used for #BSP430_HAL_ISR_CALLBACK_DISABLE_INTERRUPT
 * 0x4000 -- Reserved, available
 * 0x8000 -- Reserved, available (use this last)
 */

#define BSP430_HAL_ISR_CALLBACK_BREAK_CHAIN 0x0001

#define BSP430_HAL_ISR_CALLBACK_EXIT_LPM 0x0002

#define BSP430_HAL_ISR_CALLBACK_YIELD 0x1000

#define BSP430_HAL_ISR_CALLBACK_DISABLE_INTERRUPT 0x2000

typedef int (* iBSP430halISRCallbackVoid_ni) (const struct sBSP430halISRVoidChainNode * cb,
                                              void * context);

typedef int (* iBSP430halISRCallbackIndexed_ni) (const struct sBSP430halISRIndexedChainNode * cb,
                                                 void * context,
                                                 int idx);

typedef struct sBSP430halISRVoidChainNode {
  const struct sBSP430halISRVoidChainNode * volatile next_ni;

  iBSP430halISRCallbackVoid_ni callback_ni;
} sBSP430halISRVoidChainNode;

typedef struct sBSP430halISRIndexedChainNode {
  const struct sBSP430halISRIndexedChainNode * volatile next_ni;

  iBSP430halISRCallbackIndexed_ni callback_ni;
} sBSP430halISRIndexedChainNode;

static BSP430_CORE_INLINE
int
iBSP430callbackInvokeISRVoid_ni (const struct sBSP430halISRVoidChainNode * volatile const * cbpp,
                                 void * context,
                                 int basis)
{
  while (*cbpp && ! (basis & BSP430_HAL_ISR_CALLBACK_BREAK_CHAIN)) {
    basis |= (*cbpp)->callback_ni(*cbpp, context);
    cbpp = &(*cbpp)->next_ni;
  }
  return basis;
}

static BSP430_CORE_INLINE
int
iBSP430callbackInvokeISRIndexed_ni (const struct sBSP430halISRIndexedChainNode * volatile const * cbpp,
                                    void * context,
                                    int idx,
                                    int basis)
{
  while (*cbpp && ! (basis & BSP430_HAL_ISR_CALLBACK_BREAK_CHAIN)) {
    basis |= (*cbpp)->callback_ni(*cbpp, context, idx);
    cbpp = &(*cbpp)->next_ni;
  }
  return basis;
}

#define BSP430_HAL_ISR_CALLBACK_TAIL_NI(return_flags_) do {             \
    unsigned int rf = (return_flags_);                                  \
    if (rf & BSP430_HAL_ISR_CALLBACK_EXIT_LPM) {                        \
      rf |= BSP430_CORE_LPM_EXIT_MASK;                                  \
    }                                                                   \
    BSP430_CORE_LPM_EXIT_FROM_ISR(rf);                                  \
    if (rf & BSP430_HAL_ISR_CALLBACK_YIELD) {                           \
      BSP430_RTOS_YIELD_FROM_ISR();                                     \
    }                                                                   \
  } while (0)

#define BSP430_HAL_ISR_CALLBACK_LINK_NI(type_,root_,node_,next_) do {   \
    (node_).next_ = root_;                                              \
    root_ = &(node_);                                                   \
  } while (0)

#define BSP430_HAL_ISR_CALLBACK_UNLINK_NI(type_,root_,node_,next_) do { \
    typedef type_ tNode_;                                               \
    const tNode_ * volatile * curp_ = &(root_);                         \
    while ((NULL != *curp_) && (&(node_) != *curp_)) {                  \
      curp_ = &(((tNode_*)*curp_)->next_);                              \
    }                                                                   \
    if (&(node_) == *curp_) {                                           \
      *curp_ = (node_).next_;                                           \
      (node_).next_ = NULL;                                             \
    }                                                                   \
  } while (0)

#endif /* BSP430_PERIPH_H */