timer.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_TIMER_H
#define BSP430_PERIPH_TIMER_H

/* !BSP430! periph=timer */
/* !BSP430! instance=@timers */

#include <bsp430/periph.h>
#include <bsp430/clock.h>

#define BSP430_MODULE_TIMER_A (defined(__MSP430_HAS_TA2__)      \
                               || defined(__MSP430_HAS_TA3__)   \
                               || defined(__MSP430_HAS_TA5__)   \
                               || defined(__MSP430_HAS_T0A3__)  \
                               || defined(__MSP430_HAS_T0A5__))

#define BSP430_MODULE_TIMER_B (defined(__MSP430_HAS_TB3__)      \
                               || defined(__MSP430_HAS_TB7__)   \
                               || defined(__MSP430_HAS_T0B3__)  \
                               || defined(__MSP430_HAS_T0B7__))


#define BSP430_MODULE_TIMER (BSP430_MODULE_TIMER_A || BSP430_MODULE_TIMER_B)

/* Surprisingly, not every MCU has a Timer_A.  Some have only a Basic
 * Timer (BT). */
#if defined(BSP430_DOXYGEN) || (BSP430_MODULE_TIMER - 0)

#ifndef configBSP430_TIMER_CCACLK
#define configBSP430_TIMER_CCACLK 0
#endif /* configBSP430_TIMER_CCACLK */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK include <bsp430/platform.h>
#endif /* BSP430_DOXYGEN */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_PERIPH_CPPID include "bsp430_config.h"
#endif /* BSP430_DOXYGEN */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_PERIPH_HANDLE derived platform or application specific
/* !BSP430! instance=@timers functional=timer_ccaclk subst=functional insert=periph_sethandle */
/* BEGIN AUTOMATICALLY GENERATED CODE---DO NOT MODIFY [periph_sethandle] */

#elif BSP430_TIMER_CCACLK_PERIPH_CPPID == BSP430_PERIPH_CPPID_TA0
#define BSP430_TIMER_CCACLK_PERIPH_HANDLE BSP430_PERIPH_TA0

#elif BSP430_TIMER_CCACLK_PERIPH_CPPID == BSP430_PERIPH_CPPID_TA1
#define BSP430_TIMER_CCACLK_PERIPH_HANDLE BSP430_PERIPH_TA1

#elif BSP430_TIMER_CCACLK_PERIPH_CPPID == BSP430_PERIPH_CPPID_TA2
#define BSP430_TIMER_CCACLK_PERIPH_HANDLE BSP430_PERIPH_TA2

#elif BSP430_TIMER_CCACLK_PERIPH_CPPID == BSP430_PERIPH_CPPID_TA3
#define BSP430_TIMER_CCACLK_PERIPH_HANDLE BSP430_PERIPH_TA3

#elif BSP430_TIMER_CCACLK_PERIPH_CPPID == BSP430_PERIPH_CPPID_TB0
#define BSP430_TIMER_CCACLK_PERIPH_HANDLE BSP430_PERIPH_TB0

#elif BSP430_TIMER_CCACLK_PERIPH_CPPID == BSP430_PERIPH_CPPID_TB1
#define BSP430_TIMER_CCACLK_PERIPH_HANDLE BSP430_PERIPH_TB1

#elif BSP430_TIMER_CCACLK_PERIPH_CPPID == BSP430_PERIPH_CPPID_TB2
#define BSP430_TIMER_CCACLK_PERIPH_HANDLE BSP430_PERIPH_TB2
/* END AUTOMATICALLY GENERATED CODE [periph_sethandle] */
/* !BSP430! end=periph_sethandle */
#endif /* BSP430_TIMER_CCACLK_PERIPH_CPPID */

#ifndef configBSP430_TIMER_CCACLK_HAL
#define configBSP430_TIMER_CCACLK_HAL indirectly defaulted
#endif /* configBSP430_TIMER_CCACLK_HAL */

#if defined(BSP430_DOXYGEN)
#define configBSP430_TIMER_CCACLK_HAL_ISR indirectly defaulted
#endif /* BSP430_DOXYGEN */

#if defined(BSP430_DOXYGEN)
#define configBSP430_TIMER_CCACLK_HAL_CC0_ISR indirectly defaulted
#endif /* BSP430_DOXYGEN */

#ifndef configBSP430_TIMER_CCACLK_CLK_PORT
#define configBSP430_TIMER_CCACLK_CLK_PORT indirectly defaulted
#endif /* configBSP430_TIMER_CCACLK_CLK_PORT */

#ifndef configBSP430_TIMER_CCACLK_CLK_PORT_HAL
#define configBSP430_TIMER_CCACLK_CLK_PORT_HAL indirectly defaulted 0
#endif /* configBSP430_TIMER_CCACLK_CLK_PORT_HAL */

#ifndef configBSP430_TIMER_CCACLK_CC0_PORT
#define configBSP430_TIMER_CCACLK_CC0_PORT indirectly defaulted
#endif /* configBSP430_TIMER_CCACLK_CC0_PORT */

#ifndef configBSP430_TIMER_CCACLK_CC0_PORT_HAL
#define configBSP430_TIMER_CCACLK_CC0_PORT_HAL indirectly defaulted 0
#endif /* configBSP430_TIMER_CCACLK_CC0_PORT_HAL */

#ifndef configBSP430_TIMER_CCACLK_CC1_PORT
#define configBSP430_TIMER_CCACLK_CC1_PORT indirectly defaulted
#endif /* configBSP430_TIMER_CCACLK_CC1_PORT */

#ifndef configBSP430_TIMER_CCACLK_CC1_PORT_HAL
#define configBSP430_TIMER_CCACLK_CC1_PORT_HAL indirectly defaulted 0
#endif /* configBSP430_TIMER_CCACLK_CC1_PORT_HAL */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_ACLK_CCIDX include <bsp430/platform.h>
#endif /* BSP430_DOXYGEN */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_ACLK_CCIS include <bsp430/platform.h>
#endif /* BSP430_DOXYGEN */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID platform or application specific
#endif /* BSP430_DOXYGEN */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_HANDLE derived platform or application specific
/* !BSP430! instance=@ports functional=timer_ccaclk_clk_port subst=functional insert=periph_sethandle */
/* BEGIN AUTOMATICALLY GENERATED CODE---DO NOT MODIFY [periph_sethandle] */

#elif BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT1
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT1

#elif BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT2
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT2

#elif BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT3
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT3

#elif BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT4
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT4

#elif BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT5
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT5

#elif BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT6
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT6

#elif BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT7
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT7

#elif BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT8
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT8

#elif BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT9
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT9

#elif BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT10
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT10

#elif BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT11
#define BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT11
/* END AUTOMATICALLY GENERATED CODE [periph_sethandle] */
/* !BSP430! end=periph_sethandle instance=@timers */
#endif /* BSP430_TIMER_CCACLK_CLK_PORT_PERIPH_CPPID */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_CLK_PORT_BIT include <bsp430/platform.h>
#endif /* BSP430_DOXYGEN */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID platform or application specific
#endif /* BSP430_DOXYGEN */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_HANDLE derived platform or application specific
/* !BSP430! instance=@ports functional=timer_ccaclk_cc0_port subst=functional insert=periph_sethandle */
/* BEGIN AUTOMATICALLY GENERATED CODE---DO NOT MODIFY [periph_sethandle] */

#elif BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT1
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT1

#elif BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT2
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT2

#elif BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT3
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT3

#elif BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT4
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT4

#elif BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT5
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT5

#elif BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT6
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT6

#elif BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT7
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT7

#elif BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT8
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT8

#elif BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT9
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT9

#elif BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT10
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT10

#elif BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT11
#define BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT11
/* END AUTOMATICALLY GENERATED CODE [periph_sethandle] */
/* !BSP430! end=periph_sethandle instance=@timers */
#endif /* BSP430_TIMER_CCACLK_CC0_PORT_PERIPH_CPPID */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_CC0_PORT_BIT include <bsp430/platform.h>
#endif /* BSP430_DOXYGEN */

#ifndef BSP430_TIMER_CCACLK_CC0_CCIS
#define BSP430_TIMER_CCACLK_CC0_CCIS CCIS_0
#endif /* BSP430_TIMER_CCACLK_CC0_CCIS */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID platform or application specific
#endif /* BSP430_DOXYGEN */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE derived platform or application specific
/* !BSP430! instance=@ports functional=timer_ccaclk_cc1_port subst=functional insert=periph_sethandle */
/* BEGIN AUTOMATICALLY GENERATED CODE---DO NOT MODIFY [periph_sethandle] */

#elif BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT1
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT1

#elif BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT2
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT2

#elif BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT3
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT3

#elif BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT4
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT4

#elif BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT5
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT5

#elif BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT6
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT6

#elif BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT7
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT7

#elif BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT8
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT8

#elif BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT9
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT9

#elif BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT10
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT10

#elif BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID == BSP430_PERIPH_CPPID_PORT11
#define BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_HANDLE BSP430_PERIPH_PORT11
/* END AUTOMATICALLY GENERATED CODE [periph_sethandle] */
/* !BSP430! end=periph_sethandle instance=@timers */
#endif /* BSP430_TIMER_CCACLK_CC1_PORT_PERIPH_CPPID */

#if defined(BSP430_DOXYGEN)
#define BSP430_TIMER_CCACLK_CC1_PORT_BIT include <bsp430/platform.h>
#endif /* BSP430_DOXYGEN */

#ifndef BSP430_TIMER_CCACLK_CC1_CCIS
#define BSP430_TIMER_CCACLK_CC1_CCIS CCIS_0
#endif /* BSP430_TIMER_CCACLK_CC1_CCIS */

#ifndef configBSP430_TIMER_VALID_COUNTER_READ
#define configBSP430_TIMER_VALID_COUNTER_READ 1
#endif /* configBSP430_TIMER_VALID_COUNTER_READ */

/* 20130312 TODO REMOVE 20130630 Detect legacy issues */
#ifdef configBSP430_TIMER_SAFE_COUNTER_READ
#warning configBSP430_TIMER_SAFE_COUNTER_READ has been superseded by configBSP430_TIMER_VALID_COUNTER_READ
#endif /* configBSP430_TIMER_SAFE_COUNTER_READ */

#if defined(BSP430_DOXYGEN) || (configBSP430_TIMER_VALID_COUNTER_READ - 0)
#ifndef BSP430_TIMER_VALID_COUNTER_READ_CCIDX
#define BSP430_TIMER_VALID_COUNTER_READ_CCIDX 2
#endif /* BSP430_TIMER_VALID_COUNTER_READ_CCIDX */
#endif /* configBSP430_TIMER_VALID_COUNTER_READ */

unsigned int uiBSP430timerCaptureDelta_ni (tBSP430periphHandle periph,
                                           int ccidx,
                                           unsigned int capture_mode,
                                           unsigned int ccis,
                                           unsigned int count);

typedef struct sBSP430hplTIMER {
  unsigned int ctl;             
  union {
    unsigned int cctl[7];       
    struct {
      unsigned int cctl0;       
      unsigned int cctl1;       
      unsigned int cctl2;       
      unsigned int cctl3;       
      unsigned int cctl4;       
      unsigned int cctl5;       
      unsigned int cctl6;       
    };
  };
  unsigned int r;               
  union {
    unsigned int ccr[7];        
    struct {
      unsigned int ccr0;        
      unsigned int ccr1;        
      unsigned int ccr2;        
      unsigned int ccr3;        
      unsigned int ccr4;        
      unsigned int ccr5;        
      unsigned int ccr6;        
    };
  };
} sBSP430hplTIMER;

#if defined(__MSP430_HAS_MSP430XV2_CPU__)
/* Find the relevant tests with the following command over the
 * upstream include files in the msp430mcu package::

  for i in TA T0A T1A T2A T3A TB T0B T1B T2B T3B ; do
     grep -h BASEADDRESS_${i} * \
       | sort \
       | uniq ;
  done

 * Use the alternative with the most CCs as the default.  If the MCU
 * doesn't support it but a user references the handle, the name will
 * be unresolved at compile time, which is a fair error message.
 */
#if defined(__MSP430_HAS_T0A3__)
#define BSP430_PERIPH_TA0_BASEADDRESS_ __MSP430_BASEADDRESS_T0A3__
#else /* TA0 */
#define BSP430_PERIPH_TA0_BASEADDRESS_ __MSP430_BASEADDRESS_T0A5__
#endif /* TA0 */

#if defined(__MSP430_HAS_T1A2__)
#define BSP430_PERIPH_TA1_BASEADDRESS_ __MSP430_BASEADDRESS_T1A2__
#else /* TA1 */
#define BSP430_PERIPH_TA1_BASEADDRESS_ __MSP430_BASEADDRESS_T1A3__
#endif /* TA1 */

#if defined(__MSP430_HAS_T2A2__)
#define BSP430_PERIPH_TA2_BASEADDRESS_ __MSP430_BASEADDRESS_T2A2__
#else /* TA2 */
#define BSP430_PERIPH_TA2_BASEADDRESS_ __MSP430_BASEADDRESS_T2A3__
#endif /* TA2 */

#if defined(__MSP430_HAS_T3A2__)
#define BSP430_PERIPH_TA3_BASEADDRESS_ __MSP430_BASEADDRESS_T3A2__
#else /* TA3 */
#define BSP430_PERIPH_TA3_BASEADDRESS_ __MSP430_BASEADDRESS_T3A3__
#endif /* TA3 */

#if defined(__MSP430_HAS_T0B3__)
#define BSP430_PERIPH_TB0_BASEADDRESS_ __MSP430_BASEADDRESS_T0B3__
#else /* TB0 */
#define BSP430_PERIPH_TB0_BASEADDRESS_ __MSP430_BASEADDRESS_T0B7__
#endif /* TB0 */

#define BSP430_PERIPH_TB1_BASEADDRESS_ __MSP430_BASEADDRESS_T1B3__
#define BSP430_PERIPH_TB2_BASEADDRESS_ __MSP430_BASEADDRESS_T2B3__

#else /* MSP430XV2 */

/* Non-5xx MCU headers don't provide peripheral base addresses.
 * Fortunately, all the variants are at the same address in these
 * families (in 5xx there are a couple chips with different addresses
 * for TA0). */
#define BSP430_PERIPH_TA0_BASEADDRESS_ 0x0160
/* In some chips (e.g., msp430g2553) there are two Timer_As, and the
 * second is located at the same address as Timer_B in other chips in
 * the family.  There are no MCUs of this type that have a Timer_B. */
#define BSP430_PERIPH_TA1_BASEADDRESS_ 0x0180
#define BSP430_PERIPH_TB0_BASEADDRESS_ 0x0180
#endif /* MSP430XV2 */

/* The other thing we're doing here is adapting old-style vector
 * macros for legacy MCUs with outdated headers. */
#if defined(TIMERA0_VECTOR) && ! defined(TIMER0_A0_VECTOR)
#define TIMER0_A0_VECTOR TIMERA0_VECTOR
#endif /* T0A CC0 */
#if defined(TIMERA1_VECTOR) && ! defined(TIMER0_A1_VECTOR)
#define TIMER0_A1_VECTOR TIMERA1_VECTOR
#endif /* T0A CC1-2 TA */
#if defined(TIMERB0_VECTOR) && ! defined(TIMER0_B0_VECTOR)
#define TIMER0_B0_VECTOR TIMERB0_VECTOR
#endif /* T0B CC0 */
#if defined(TIMERB1_VECTOR) && ! defined(TIMER0_B1_VECTOR)
#define TIMER0_B1_VECTOR TIMERB1_VECTOR
#endif /* T0B CC1-2 TB */
 /* DOXYGEN_INTERNAL */

#define BSP430_TIMER_HAL_HPL_VARIANT_TIMER 1

#define BSP430_TIMER_FLAG_MCLKSYNC 0x01

#define BSP430_TIMER_FLAG_SLOW 0x02

typedef struct sBSP430halTIMER {
  sBSP430hplHALStatePrefix hal_state;

  volatile sBSP430hplTIMER * const hpl;

  unsigned long overflow_count;

  const struct sBSP430halISRVoidChainNode * volatile overflow_cbchain_ni;

  const struct sBSP430halISRIndexedChainNode * volatile * const cc_cbchain_ni;
} sBSP430halTIMER;

typedef struct sBSP430halTIMER * hBSP430halTIMER;

void vBSP430timerInferHints_ni (hBSP430halTIMER timer);

eBSP430clockSource xBSP430timerClockSource (volatile sBSP430hplTIMER * hpl);

unsigned long ulBSP430timerFrequency_Hz_ni (tBSP430periphHandle periph);

unsigned long ulBSP430timerOverflowAdjusted_ni (hBSP430halTIMER timer,
                                                unsigned int ctr);

unsigned long ulBSP430timerCounter_ni (hBSP430halTIMER timer,
                                       unsigned int * overflowp);

static BSP430_CORE_INLINE
unsigned long
ulBSP430timerCounter (hBSP430halTIMER timer,
                      unsigned int * overflowp)
{
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  unsigned long rv;

  BSP430_CORE_DISABLE_INTERRUPT();
  rv = ulBSP430timerCounter_ni(timer, overflowp);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
  return rv;
}

static BSP430_CORE_INLINE
unsigned long long
ullBSP430timerCorrected (hBSP430halTIMER timer,
                         unsigned int ctr)
{
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  unsigned int overflow;
  unsigned int ui;
  unsigned long ul;
  unsigned long long ull;

  BSP430_CORE_DISABLE_INTERRUPT();
  do {
    ul = ulBSP430timerCounter_ni(timer, &overflow);
  } while (0);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
  ull = overflow;
  ull <<= 8 * sizeof(ul);
  ull += ul;
  ui = ul;
  ui -= ctr;
  ull -= (long)ui;
  return ull;
}

unsigned long ulBSP430timerCaptureCounter_ni (hBSP430halTIMER timer,
                                              unsigned int ccidx);

void vBSP430timerResetCounter_ni (hBSP430halTIMER timer);

void vBSP430timerSetCounter_ni (hBSP430halTIMER timer,
                                unsigned int overflow,
                                unsigned long counter);

/* Forward declaration */
struct sBSP430timerAlarm;

typedef const struct sBSP430timerAlarm * hBSP430timerAlarm;

typedef int (* iBSP430timerAlarmCallback_ni) (hBSP430timerAlarm alarm);

#define BSP430_TIMER_ALARM_FLAG_SET 0x01

#define BSP430_TIMER_ALARM_FLAG_ENABLED 0x02

typedef struct sBSP430timerAlarm {
  hBSP430halTIMER timer;

  unsigned char ccidx;

  unsigned char flags;

  unsigned long setting_tck;

  iBSP430timerAlarmCallback_ni callback_ni;

  sBSP430halISRVoidChainNode overflow_cb;

  sBSP430halISRIndexedChainNode cc_cb;
} sBSP430timerAlarm;

hBSP430timerAlarm hBSP430timerAlarmInitialize (sBSP430timerAlarm * alarm,
                                               tBSP430periphHandle periph,
                                               int ccidx,
                                               iBSP430timerAlarmCallback_ni callback);

int iBSP430timerAlarmSetEnabled_ni (hBSP430timerAlarm alarm,
                                    int enablep);

static BSP430_CORE_INLINE
int iBSP430timerAlarmEnable (hBSP430timerAlarm alarm)
{
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  int rv;

  BSP430_CORE_DISABLE_INTERRUPT();
  rv = iBSP430timerAlarmSetEnabled_ni(alarm, 1);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
  return rv;
}

static BSP430_CORE_INLINE
int iBSP430timerAlarmDisable (hBSP430timerAlarm alarm)
{
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  int rv;

  BSP430_CORE_DISABLE_INTERRUPT();
  rv = iBSP430timerAlarmSetEnabled_ni(alarm, 0);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
  return rv;
}

#ifndef BSP430_TIMER_ALARM_FUTURE_LIMIT
#define BSP430_TIMER_ALARM_FUTURE_LIMIT 3UL
#endif /* BSP430_TIMER_ALARM_FUTURE_LIMIT */

#define BSP430_TIMER_ALARM_SET_NOW 1

#define BSP430_TIMER_ALARM_SET_PAST 2

#define BSP430_TIMER_ALARM_SET_ALREADY -2

int iBSP430timerAlarmSet_ni (hBSP430timerAlarm alarm,
                             unsigned long setting_tck);

int iBSP430timerAlarmSetForced_ni (hBSP430timerAlarm alarm,
                                   unsigned long setting_tck);

static BSP430_CORE_INLINE
int iBSP430timerAlarmSet (hBSP430timerAlarm alarm,
                          unsigned long setting_tck)
{
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  int rv;

  BSP430_CORE_DISABLE_INTERRUPT();
  rv = iBSP430timerAlarmSet_ni(alarm, setting_tck);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
  return rv;
}

int iBSP430timerAlarmCancel_ni (hBSP430timerAlarm alarm);

static BSP430_CORE_INLINE
int iBSP430timerAlarmCancel (hBSP430timerAlarm alarm)
{
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  int rv;

  BSP430_CORE_DISABLE_INTERRUPT();
  rv = iBSP430timerAlarmCancel_ni(alarm);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
  return rv;
}

/* Forward declaration */
struct sBSP430timerMuxAlarm;

/* Forward declaration */
struct sBSP430timerMuxSharedAlarm;

typedef int (* iBSP430timerMuxAlarmCallback_ni) (struct sBSP430timerMuxSharedAlarm * shared,
                                                 struct sBSP430timerMuxAlarm * alarm);

typedef struct sBSP430timerMuxSharedAlarm {
  sBSP430timerAlarm dedicated;

  struct sBSP430timerMuxAlarm * alarms;
} sBSP430timerMuxSharedAlarm;

typedef sBSP430timerMuxSharedAlarm * hBSP430timerMuxSharedAlarm;

typedef struct sBSP430timerMuxAlarm {
  unsigned long setting_tck;

  iBSP430timerMuxAlarmCallback_ni callback_ni;

  struct sBSP430timerMuxAlarm * next;
} sBSP430timerMuxAlarm;

typedef sBSP430timerMuxAlarm * hBSP430timerMuxAlarm;

hBSP430timerMuxSharedAlarm hBSP430timerMuxAlarmStartup (sBSP430timerMuxSharedAlarm * shared,
                                                        tBSP430periphHandle periph,
                                                        int ccidx);

int iBSP430timerMuxAlarmShutdown (sBSP430timerMuxSharedAlarm * shared);

static BSP430_CORE_INLINE
unsigned long ulBSP430timerMuxSharedAlarmCounter (sBSP430timerMuxSharedAlarm * shared)
{
  if (! shared->dedicated.timer) {
    return 0;
  }
  return ulBSP430timerCounter_ni(shared->dedicated.timer, NULL);
}

int iBSP430timerMuxAlarmAdd_ni (hBSP430timerMuxSharedAlarm shared,
                                hBSP430timerMuxAlarm alarm);

int iBSP430timerMuxAlarmRemove_ni (hBSP430timerMuxSharedAlarm shared,
                                   hBSP430timerMuxAlarm alarm);

#define BSP430_TIMER_PULSECAP_START_VALID 0x01

#define BSP430_TIMER_PULSECAP_END_VALID 0x02

#define BSP430_TIMER_PULSECAP_OVERFLOW 0x04

#define BSP430_TIMER_PULSECAP_ACTIVE_HIGH 0x08

#define BSP430_TIMER_PULSECAP_START_CALLBACK 0x100

#define BSP430_TIMER_PULSECAP_END_CALLBACK 0x200

#define BSP430_TIMER_PULSECAP_CALLBACK_ACTIVE 0x0400

#define BSP430_TIMER_PULSECAP_ENABLED 0x1000

#define BSP430_TIMER_PULSECAP_ACTIVE 0x2000

/* Forward declaration */
struct sBSP430timerPulseCapture;

typedef int (* iBSP430timerPulseCaptureCallback_ni) (struct sBSP430timerPulseCapture * state);

typedef struct sBSP430timerPulseCapture {
  sBSP430halISRIndexedChainNode cb;

  hBSP430halTIMER hal;

  int ccidx;

  unsigned int ccis;

  iBSP430timerPulseCaptureCallback_ni callback_ni;

  volatile unsigned int flags_ni;

  volatile unsigned long start_tt_ni;

  volatile unsigned long end_tt_ni;
} sBSP430timerPulseCapture;

typedef struct sBSP430timerPulseCapture * hBSP430timerPulseCapture;

hBSP430timerPulseCapture
hBSP430timerPulseCaptureInitialize (hBSP430timerPulseCapture pulsecap,
                                    tBSP430periphHandle periph,
                                    int ccidx,
                                    unsigned int ccis,
                                    unsigned int flags,
                                    iBSP430timerPulseCaptureCallback_ni callback);

int iBSP430timerPulseCaptureSetEnabled_ni (hBSP430timerPulseCapture pulsecap,
                                           int enablep);

int iBSP430timerPulseCaptureSetActive_ni (hBSP430timerPulseCapture pulsecap,
                                          int activep);

static BSP430_CORE_INLINE
void
vBSP430timerPulseCaptureClear_ni (hBSP430timerPulseCapture pulsecap)
{
  pulsecap->flags_ni &= ~(BSP430_TIMER_PULSECAP_START_VALID
                          | BSP430_TIMER_PULSECAP_END_VALID
                          | BSP430_TIMER_PULSECAP_OVERFLOW
                          | BSP430_TIMER_PULSECAP_ACTIVE_HIGH);
}

static BSP430_CORE_INLINE
int
iBSP430timerPulseCaptureDisable (hBSP430timerPulseCapture pulsecap)
{
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  int rv;

  BSP430_CORE_DISABLE_INTERRUPT();
  rv = iBSP430timerPulseCaptureSetEnabled_ni(pulsecap, 0);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
  return rv;
}

static BSP430_CORE_INLINE
int
iBSP430timerPulseCaptureEnable (hBSP430timerPulseCapture pulsecap)
{
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  int rv;

  BSP430_CORE_DISABLE_INTERRUPT();
  rv = iBSP430timerPulseCaptureSetEnabled_ni(pulsecap, 1);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
  return rv;
}

static BSP430_CORE_INLINE
int
iBSP430timerPulseCaptureActivate (hBSP430timerPulseCapture pulsecap)
{
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  int rv;

  BSP430_CORE_DISABLE_INTERRUPT();
  vBSP430timerPulseCaptureClear_ni(pulsecap);
  rv = iBSP430timerPulseCaptureSetActive_ni(pulsecap, 1);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
  return rv;
}

static BSP430_CORE_INLINE
int
iBSP430timerPulseCaptureDeactivate (hBSP430timerPulseCapture pulsecap)
{
  BSP430_CORE_SAVED_INTERRUPT_STATE(istate);
  int rv;

  BSP430_CORE_DISABLE_INTERRUPT();
  rv = iBSP430timerPulseCaptureSetActive_ni(pulsecap, 0);
  BSP430_CORE_RESTORE_INTERRUPT_STATE(istate);
  return rv;
}

static BSP430_CORE_INLINE
void vBSP430timerPulseCaptureInvertSense_ni (hBSP430timerPulseCapture pulsecap)
{
  unsigned int flags = pulsecap->flags_ni;
  flags ^= BSP430_TIMER_PULSECAP_ACTIVE_HIGH;
  if (BSP430_TIMER_PULSECAP_END_VALID & flags) {
    flags &= ~BSP430_TIMER_PULSECAP_END_VALID;
    flags |= BSP430_TIMER_PULSECAP_START_VALID;
    pulsecap->start_tt_ni = pulsecap->end_tt_ni;
  } else {
    flags &= ~BSP430_TIMER_PULSECAP_START_VALID;
  }
  pulsecap->flags_ni = flags;
}

/* !BSP430! insert=hal_decl */
/* BEGIN AUTOMATICALLY GENERATED CODE---DO NOT MODIFY [hal_decl] */
#ifndef configBSP430_HAL_TA0
#define configBSP430_HAL_TA0 0
#endif /* configBSP430_HAL_TA0 */

#if (configBSP430_HAL_TA0 - 0)
/* You do not need to know about this */
extern sBSP430halTIMER xBSP430hal_TA0_;
#endif /* configBSP430_HAL_TA0 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HAL_TA0 - 0)
#define BSP430_HAL_TA0 (&xBSP430hal_TA0_)
#endif /* configBSP430_HAL_TA0 */

#ifndef configBSP430_HAL_TA1
#define configBSP430_HAL_TA1 0
#endif /* configBSP430_HAL_TA1 */

#if (configBSP430_HAL_TA1 - 0)
/* You do not need to know about this */
extern sBSP430halTIMER xBSP430hal_TA1_;
#endif /* configBSP430_HAL_TA1 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HAL_TA1 - 0)
#define BSP430_HAL_TA1 (&xBSP430hal_TA1_)
#endif /* configBSP430_HAL_TA1 */

#ifndef configBSP430_HAL_TA2
#define configBSP430_HAL_TA2 0
#endif /* configBSP430_HAL_TA2 */

#if (configBSP430_HAL_TA2 - 0)
/* You do not need to know about this */
extern sBSP430halTIMER xBSP430hal_TA2_;
#endif /* configBSP430_HAL_TA2 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HAL_TA2 - 0)
#define BSP430_HAL_TA2 (&xBSP430hal_TA2_)
#endif /* configBSP430_HAL_TA2 */

#ifndef configBSP430_HAL_TA3
#define configBSP430_HAL_TA3 0
#endif /* configBSP430_HAL_TA3 */

#if (configBSP430_HAL_TA3 - 0)
/* You do not need to know about this */
extern sBSP430halTIMER xBSP430hal_TA3_;
#endif /* configBSP430_HAL_TA3 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HAL_TA3 - 0)
#define BSP430_HAL_TA3 (&xBSP430hal_TA3_)
#endif /* configBSP430_HAL_TA3 */

#ifndef configBSP430_HAL_TB0
#define configBSP430_HAL_TB0 0
#endif /* configBSP430_HAL_TB0 */

#if (configBSP430_HAL_TB0 - 0)
/* You do not need to know about this */
extern sBSP430halTIMER xBSP430hal_TB0_;
#endif /* configBSP430_HAL_TB0 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HAL_TB0 - 0)
#define BSP430_HAL_TB0 (&xBSP430hal_TB0_)
#endif /* configBSP430_HAL_TB0 */

#ifndef configBSP430_HAL_TB1
#define configBSP430_HAL_TB1 0
#endif /* configBSP430_HAL_TB1 */

#if (configBSP430_HAL_TB1 - 0)
/* You do not need to know about this */
extern sBSP430halTIMER xBSP430hal_TB1_;
#endif /* configBSP430_HAL_TB1 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HAL_TB1 - 0)
#define BSP430_HAL_TB1 (&xBSP430hal_TB1_)
#endif /* configBSP430_HAL_TB1 */

#ifndef configBSP430_HAL_TB2
#define configBSP430_HAL_TB2 0
#endif /* configBSP430_HAL_TB2 */

#if (configBSP430_HAL_TB2 - 0)
/* You do not need to know about this */
extern sBSP430halTIMER xBSP430hal_TB2_;
#endif /* configBSP430_HAL_TB2 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HAL_TB2 - 0)
#define BSP430_HAL_TB2 (&xBSP430hal_TB2_)
#endif /* configBSP430_HAL_TB2 */

/* END AUTOMATICALLY GENERATED CODE [hal_decl] */
/* !BSP430! end=hal_decl */

/* !BSP430! insert=periph_decl */
/* BEGIN AUTOMATICALLY GENERATED CODE---DO NOT MODIFY [periph_decl] */
#ifndef configBSP430_HPL_TA0
#define configBSP430_HPL_TA0 (configBSP430_HAL_TA0 - 0)
#endif /* configBSP430_HPL_TA0 */

#if (configBSP430_HAL_TA0 - 0) && ! (configBSP430_HPL_TA0 - 0)
#warning configBSP430_HAL_TA0 requested without configBSP430_HPL_TA0
#endif /* HAL and not HPL */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TA0 - 0)
#define BSP430_PERIPH_TA0 ((tBSP430periphHandle)(BSP430_PERIPH_TA0_BASEADDRESS_))
#endif /* configBSP430_HPL_TA0 */

#ifndef configBSP430_HPL_TA1
#define configBSP430_HPL_TA1 (configBSP430_HAL_TA1 - 0)
#endif /* configBSP430_HPL_TA1 */

#if (configBSP430_HAL_TA1 - 0) && ! (configBSP430_HPL_TA1 - 0)
#warning configBSP430_HAL_TA1 requested without configBSP430_HPL_TA1
#endif /* HAL and not HPL */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TA1 - 0)
#define BSP430_PERIPH_TA1 ((tBSP430periphHandle)(BSP430_PERIPH_TA1_BASEADDRESS_))
#endif /* configBSP430_HPL_TA1 */

#ifndef configBSP430_HPL_TA2
#define configBSP430_HPL_TA2 (configBSP430_HAL_TA2 - 0)
#endif /* configBSP430_HPL_TA2 */

#if (configBSP430_HAL_TA2 - 0) && ! (configBSP430_HPL_TA2 - 0)
#warning configBSP430_HAL_TA2 requested without configBSP430_HPL_TA2
#endif /* HAL and not HPL */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TA2 - 0)
#define BSP430_PERIPH_TA2 ((tBSP430periphHandle)(BSP430_PERIPH_TA2_BASEADDRESS_))
#endif /* configBSP430_HPL_TA2 */

#ifndef configBSP430_HPL_TA3
#define configBSP430_HPL_TA3 (configBSP430_HAL_TA3 - 0)
#endif /* configBSP430_HPL_TA3 */

#if (configBSP430_HAL_TA3 - 0) && ! (configBSP430_HPL_TA3 - 0)
#warning configBSP430_HAL_TA3 requested without configBSP430_HPL_TA3
#endif /* HAL and not HPL */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TA3 - 0)
#define BSP430_PERIPH_TA3 ((tBSP430periphHandle)(BSP430_PERIPH_TA3_BASEADDRESS_))
#endif /* configBSP430_HPL_TA3 */

#ifndef configBSP430_HPL_TB0
#define configBSP430_HPL_TB0 (configBSP430_HAL_TB0 - 0)
#endif /* configBSP430_HPL_TB0 */

#if (configBSP430_HAL_TB0 - 0) && ! (configBSP430_HPL_TB0 - 0)
#warning configBSP430_HAL_TB0 requested without configBSP430_HPL_TB0
#endif /* HAL and not HPL */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TB0 - 0)
#define BSP430_PERIPH_TB0 ((tBSP430periphHandle)(BSP430_PERIPH_TB0_BASEADDRESS_))
#endif /* configBSP430_HPL_TB0 */

#ifndef configBSP430_HPL_TB1
#define configBSP430_HPL_TB1 (configBSP430_HAL_TB1 - 0)
#endif /* configBSP430_HPL_TB1 */

#if (configBSP430_HAL_TB1 - 0) && ! (configBSP430_HPL_TB1 - 0)
#warning configBSP430_HAL_TB1 requested without configBSP430_HPL_TB1
#endif /* HAL and not HPL */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TB1 - 0)
#define BSP430_PERIPH_TB1 ((tBSP430periphHandle)(BSP430_PERIPH_TB1_BASEADDRESS_))
#endif /* configBSP430_HPL_TB1 */

#ifndef configBSP430_HPL_TB2
#define configBSP430_HPL_TB2 (configBSP430_HAL_TB2 - 0)
#endif /* configBSP430_HPL_TB2 */

#if (configBSP430_HAL_TB2 - 0) && ! (configBSP430_HPL_TB2 - 0)
#warning configBSP430_HAL_TB2 requested without configBSP430_HPL_TB2
#endif /* HAL and not HPL */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TB2 - 0)
#define BSP430_PERIPH_TB2 ((tBSP430periphHandle)(BSP430_PERIPH_TB2_BASEADDRESS_))
#endif /* configBSP430_HPL_TB2 */

/* END AUTOMATICALLY GENERATED CODE [periph_decl] */
/* !BSP430! end=periph_decl */

/* !BSP430! insert=hpl_decl */
/* BEGIN AUTOMATICALLY GENERATED CODE---DO NOT MODIFY [hpl_decl] */
#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TA0 - 0)
#define BSP430_HPL_TA0 ((volatile sBSP430hplTIMER *)BSP430_PERIPH_TA0)
#endif /* configBSP430_HPL_TA0 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TA1 - 0)
#define BSP430_HPL_TA1 ((volatile sBSP430hplTIMER *)BSP430_PERIPH_TA1)
#endif /* configBSP430_HPL_TA1 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TA2 - 0)
#define BSP430_HPL_TA2 ((volatile sBSP430hplTIMER *)BSP430_PERIPH_TA2)
#endif /* configBSP430_HPL_TA2 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TA3 - 0)
#define BSP430_HPL_TA3 ((volatile sBSP430hplTIMER *)BSP430_PERIPH_TA3)
#endif /* configBSP430_HPL_TA3 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TB0 - 0)
#define BSP430_HPL_TB0 ((volatile sBSP430hplTIMER *)BSP430_PERIPH_TB0)
#endif /* configBSP430_HPL_TB0 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TB1 - 0)
#define BSP430_HPL_TB1 ((volatile sBSP430hplTIMER *)BSP430_PERIPH_TB1)
#endif /* configBSP430_HPL_TB1 */

#if defined(BSP430_DOXYGEN) || (configBSP430_HPL_TB2 - 0)
#define BSP430_HPL_TB2 ((volatile sBSP430hplTIMER *)BSP430_PERIPH_TB2)
#endif /* configBSP430_HPL_TB2 */

/* END AUTOMATICALLY GENERATED CODE [hpl_decl] */
/* !BSP430! end=hpl_decl */

/* !BSP430! insert=hal_timer_isr_decl */
/* BEGIN AUTOMATICALLY GENERATED CODE---DO NOT MODIFY [hal_timer_isr_decl] */
#if defined(BSP430_DOXYGEN)
#define configBSP430_HAL_TA0_CC0_ISR 0
#endif /* BSP430_DOXYGEN */

#if (configBSP430_HAL_TA0_CC0_ISR - 0) && ! (configBSP430_HAL_TA0 - 0)
#warning configBSP430_HAL_TA0_CC0_ISR requested without configBSP430_HAL_TA0
#endif /* HAL_CC0_ISR and not HAL */

#ifndef configBSP430_HAL_TA0_ISR
#define configBSP430_HAL_TA0_ISR (configBSP430_HAL_TA0 - 0)
#endif /* configBSP430_HAL_TA0_ISR */

#if (configBSP430_HAL_TA0_ISR - 0) && ! (configBSP430_HAL_TA0 - 0)
#warning configBSP430_HAL_TA0_ISR requested without configBSP430_HAL_TA0
#endif /* HAL_ISR and not HAL */

#if defined(BSP430_DOXYGEN)
#define configBSP430_HAL_TA1_CC0_ISR 0
#endif /* BSP430_DOXYGEN */

#if (configBSP430_HAL_TA1_CC0_ISR - 0) && ! (configBSP430_HAL_TA1 - 0)
#warning configBSP430_HAL_TA1_CC0_ISR requested without configBSP430_HAL_TA1
#endif /* HAL_CC0_ISR and not HAL */

#ifndef configBSP430_HAL_TA1_ISR
#define configBSP430_HAL_TA1_ISR (configBSP430_HAL_TA1 - 0)
#endif /* configBSP430_HAL_TA1_ISR */

#if (configBSP430_HAL_TA1_ISR - 0) && ! (configBSP430_HAL_TA1 - 0)
#warning configBSP430_HAL_TA1_ISR requested without configBSP430_HAL_TA1
#endif /* HAL_ISR and not HAL */

#if defined(BSP430_DOXYGEN)
#define configBSP430_HAL_TA2_CC0_ISR 0
#endif /* BSP430_DOXYGEN */

#if (configBSP430_HAL_TA2_CC0_ISR - 0) && ! (configBSP430_HAL_TA2 - 0)
#warning configBSP430_HAL_TA2_CC0_ISR requested without configBSP430_HAL_TA2
#endif /* HAL_CC0_ISR and not HAL */

#ifndef configBSP430_HAL_TA2_ISR
#define configBSP430_HAL_TA2_ISR (configBSP430_HAL_TA2 - 0)
#endif /* configBSP430_HAL_TA2_ISR */

#if (configBSP430_HAL_TA2_ISR - 0) && ! (configBSP430_HAL_TA2 - 0)
#warning configBSP430_HAL_TA2_ISR requested without configBSP430_HAL_TA2
#endif /* HAL_ISR and not HAL */

#if defined(BSP430_DOXYGEN)
#define configBSP430_HAL_TA3_CC0_ISR 0
#endif /* BSP430_DOXYGEN */

#if (configBSP430_HAL_TA3_CC0_ISR - 0) && ! (configBSP430_HAL_TA3 - 0)
#warning configBSP430_HAL_TA3_CC0_ISR requested without configBSP430_HAL_TA3
#endif /* HAL_CC0_ISR and not HAL */

#ifndef configBSP430_HAL_TA3_ISR
#define configBSP430_HAL_TA3_ISR (configBSP430_HAL_TA3 - 0)
#endif /* configBSP430_HAL_TA3_ISR */

#if (configBSP430_HAL_TA3_ISR - 0) && ! (configBSP430_HAL_TA3 - 0)
#warning configBSP430_HAL_TA3_ISR requested without configBSP430_HAL_TA3
#endif /* HAL_ISR and not HAL */

#if defined(BSP430_DOXYGEN)
#define configBSP430_HAL_TB0_CC0_ISR 0
#endif /* BSP430_DOXYGEN */

#if (configBSP430_HAL_TB0_CC0_ISR - 0) && ! (configBSP430_HAL_TB0 - 0)
#warning configBSP430_HAL_TB0_CC0_ISR requested without configBSP430_HAL_TB0
#endif /* HAL_CC0_ISR and not HAL */

#ifndef configBSP430_HAL_TB0_ISR
#define configBSP430_HAL_TB0_ISR (configBSP430_HAL_TB0 - 0)
#endif /* configBSP430_HAL_TB0_ISR */

#if (configBSP430_HAL_TB0_ISR - 0) && ! (configBSP430_HAL_TB0 - 0)
#warning configBSP430_HAL_TB0_ISR requested without configBSP430_HAL_TB0
#endif /* HAL_ISR and not HAL */

#if defined(BSP430_DOXYGEN)
#define configBSP430_HAL_TB1_CC0_ISR 0
#endif /* BSP430_DOXYGEN */

#if (configBSP430_HAL_TB1_CC0_ISR - 0) && ! (configBSP430_HAL_TB1 - 0)
#warning configBSP430_HAL_TB1_CC0_ISR requested without configBSP430_HAL_TB1
#endif /* HAL_CC0_ISR and not HAL */

#ifndef configBSP430_HAL_TB1_ISR
#define configBSP430_HAL_TB1_ISR (configBSP430_HAL_TB1 - 0)
#endif /* configBSP430_HAL_TB1_ISR */

#if (configBSP430_HAL_TB1_ISR - 0) && ! (configBSP430_HAL_TB1 - 0)
#warning configBSP430_HAL_TB1_ISR requested without configBSP430_HAL_TB1
#endif /* HAL_ISR and not HAL */

#if defined(BSP430_DOXYGEN)
#define configBSP430_HAL_TB2_CC0_ISR 0
#endif /* BSP430_DOXYGEN */

#if (configBSP430_HAL_TB2_CC0_ISR - 0) && ! (configBSP430_HAL_TB2 - 0)
#warning configBSP430_HAL_TB2_CC0_ISR requested without configBSP430_HAL_TB2
#endif /* HAL_CC0_ISR and not HAL */

#ifndef configBSP430_HAL_TB2_ISR
#define configBSP430_HAL_TB2_ISR (configBSP430_HAL_TB2 - 0)
#endif /* configBSP430_HAL_TB2_ISR */

#if (configBSP430_HAL_TB2_ISR - 0) && ! (configBSP430_HAL_TB2 - 0)
#warning configBSP430_HAL_TB2_ISR requested without configBSP430_HAL_TB2
#endif /* HAL_ISR and not HAL */

/* END AUTOMATICALLY GENERATED CODE [hal_timer_isr_decl] */
/* !BSP430! end=hal_timer_isr_decl */

static BSP430_CORE_INLINE
volatile sBSP430hplTIMER * xBSP430hplLookupTIMER (tBSP430periphHandle periph)
{
  /* !BSP430! insert=periph_hpl_demux */
  /* BEGIN AUTOMATICALLY GENERATED CODE---DO NOT MODIFY [periph_hpl_demux] */
#if (configBSP430_HPL_TA0 - 0)
  if (BSP430_PERIPH_TA0 == periph) {
    return BSP430_HPL_TA0;
  }
#endif /* configBSP430_HPL_TA0 */

#if (configBSP430_HPL_TA1 - 0)
  if (BSP430_PERIPH_TA1 == periph) {
    return BSP430_HPL_TA1;
  }
#endif /* configBSP430_HPL_TA1 */

#if (configBSP430_HPL_TA2 - 0)
  if (BSP430_PERIPH_TA2 == periph) {
    return BSP430_HPL_TA2;
  }
#endif /* configBSP430_HPL_TA2 */

#if (configBSP430_HPL_TA3 - 0)
  if (BSP430_PERIPH_TA3 == periph) {
    return BSP430_HPL_TA3;
  }
#endif /* configBSP430_HPL_TA3 */

#if (configBSP430_HPL_TB0 - 0)
  if (BSP430_PERIPH_TB0 == periph) {
    return BSP430_HPL_TB0;
  }
#endif /* configBSP430_HPL_TB0 */

#if (configBSP430_HPL_TB1 - 0)
  if (BSP430_PERIPH_TB1 == periph) {
    return BSP430_HPL_TB1;
  }
#endif /* configBSP430_HPL_TB1 */

#if (configBSP430_HPL_TB2 - 0)
  if (BSP430_PERIPH_TB2 == periph) {
    return BSP430_HPL_TB2;
  }
#endif /* configBSP430_HPL_TB2 */

  /* END AUTOMATICALLY GENERATED CODE [periph_hpl_demux] */
  /* !BSP430! end=periph_hpl_demux */
  return NULL;
}

static BSP430_CORE_INLINE
hBSP430halTIMER hBSP430timerLookup (tBSP430periphHandle periph)
{
  /* !BSP430! insert=periph_hal_demux */
  /* BEGIN AUTOMATICALLY GENERATED CODE---DO NOT MODIFY [periph_hal_demux] */
#if (configBSP430_HAL_TA0 - 0)
  if (BSP430_PERIPH_TA0 == periph) {
    return BSP430_HAL_TA0;
  }
#endif /* configBSP430_HAL_TA0 */

#if (configBSP430_HAL_TA1 - 0)
  if (BSP430_PERIPH_TA1 == periph) {
    return BSP430_HAL_TA1;
  }
#endif /* configBSP430_HAL_TA1 */

#if (configBSP430_HAL_TA2 - 0)
  if (BSP430_PERIPH_TA2 == periph) {
    return BSP430_HAL_TA2;
  }
#endif /* configBSP430_HAL_TA2 */

#if (configBSP430_HAL_TA3 - 0)
  if (BSP430_PERIPH_TA3 == periph) {
    return BSP430_HAL_TA3;
  }
#endif /* configBSP430_HAL_TA3 */

#if (configBSP430_HAL_TB0 - 0)
  if (BSP430_PERIPH_TB0 == periph) {
    return BSP430_HAL_TB0;
  }
#endif /* configBSP430_HAL_TB0 */

#if (configBSP430_HAL_TB1 - 0)
  if (BSP430_PERIPH_TB1 == periph) {
    return BSP430_HAL_TB1;
  }
#endif /* configBSP430_HAL_TB1 */

#if (configBSP430_HAL_TB2 - 0)
  if (BSP430_PERIPH_TB2 == periph) {
    return BSP430_HAL_TB2;
  }
#endif /* configBSP430_HAL_TB2 */

  /* END AUTOMATICALLY GENERATED CODE [periph_hal_demux] */
  /* !BSP430! end=periph_hal_demux */
  return NULL;
}

const char * xBSP430timerName (tBSP430periphHandle periph);

int iBSP430timerSupportedCCs (tBSP430periphHandle periph);

static BSP430_CORE_INLINE_FORCED
unsigned int
uiBSP430timerSyncCounterRead_ni (volatile sBSP430hplTIMER * const hpl)
{
  return hpl->r;
}

static BSP430_CORE_INLINE_FORCED
unsigned int
uiBSP430timerAsyncCounterRead_ni (volatile sBSP430hplTIMER * const hpl)
{
  unsigned int v1;
  unsigned int v2;
  do {
    v1 = uiBSP430timerSyncCounterRead_ni(hpl);
    v2 = uiBSP430timerSyncCounterRead_ni(hpl);
  } while (v1 != v2);
  return v1;
}

static BSP430_CORE_INLINE_FORCED
void
vBSP430timerLatchedCounterInitialize_ni (volatile sBSP430hplTIMER * const hpl,
                                         int ccidx)
{
  /* Configure for capture, alternating between GND and VCC as
   * sources, triggering on both edges, asynchronously. */
  hpl->cctl[ccidx] = CAP | CCIS1 | CM_3;
}

static BSP430_CORE_INLINE_FORCED
unsigned int
uiBSP430timerLatchedCounterRead_ni (volatile sBSP430hplTIMER * const hpl,
                                    int ccidx)
{
  /* Latch the current counter into a capture register and return it. */
  hpl->cctl[ccidx] ^= CCIS0;
  return hpl->ccr[ccidx];
}

static BSP430_CORE_INLINE
void
vBSP430timerSafeCounterInitialize_ni (volatile sBSP430hplTIMER * const hpl)
{
#if (configBSP430_TIMER_VALID_COUNTER_READ - 0)
#if ! (BSP430_CORE_NDEBUG - 0)
  tBSP430periphHandle periph = xBSP430periphFromHPL(hpl);
  while ((NULL == hpl)
         || (BSP430_TIMER_VALID_COUNTER_READ_CCIDX >= iBSP430timerSupportedCCs(periph))) {
    /* Spin to detect misconfiguration */
  }
#endif /* BSP430_CORE_NDEBUG */
  vBSP430timerLatchedCounterInitialize_ni(hpl, BSP430_TIMER_VALID_COUNTER_READ_CCIDX);
#endif /* configBSP430_TIMER_VALID_COUNTER_READ */
}

static BSP430_CORE_INLINE_FORCED
unsigned int
uiBSP430timerSafeCounterRead_ni (volatile sBSP430hplTIMER * const hpl)
{
  unsigned int rv;
#if (configBSP430_TIMER_VALID_COUNTER_READ - 0)
#if ! (BSP430_CORE_NDEBUG - 0)
  /* Clear the flag; used only to prevent the following sanity check
   * from falsely failing. */
  hpl->cctl[BSP430_TIMER_VALID_COUNTER_READ_CCIDX] &= ~CCIFG;
#endif /* BSP430_CORE_NDEBUG */
  rv = uiBSP430timerLatchedCounterRead_ni(hpl, BSP430_TIMER_VALID_COUNTER_READ_CCIDX);
#if ! (BSP430_CORE_NDEBUG - 0)
  /* If the capture/compare register is not configured properly to
   * have done a capture, spin in place so this problem can be
   * detected during development. */
  while ((CCIS1 | CCIFG) != (hpl->cctl[BSP430_TIMER_VALID_COUNTER_READ_CCIDX] & (CCIS1 | CCIFG))) {
    /* Spin to detect misconfiguration */
  }
#endif /* NDEBUG */
#else /* configBSP430_TIMER_VALID_COUNTER_READ */
  /* Async could hang if the clock rates were too close, so just read
   * once and hope for the best. */
  rv = uiBSP430timerSyncCounterRead_ni(hpl);
#endif /* configBSP430_TIMER_VALID_COUNTER_READ */
  return rv;
}

static BSP430_CORE_INLINE_FORCED
unsigned int
uiBSP430timerBestCounterRead_ni (volatile sBSP430hplTIMER * const hpl,
                                 int flags)
{
  if (flags & BSP430_TIMER_FLAG_MCLKSYNC) {
    return uiBSP430timerSyncCounterRead_ni(hpl);
  }
  if (flags & BSP430_TIMER_FLAG_SLOW) {
    return uiBSP430timerAsyncCounterRead_ni(hpl);
  }
  return uiBSP430timerSafeCounterRead_ni(hpl);
}

#endif /* BSP430_MODULE_TIMER */

#endif /* BSP430_PERIPH_TIMER_H */