ARM: 5660/1: bcmring: add csp timer block header and source files (7ba09020) · Commits · e / devices / android_kernel_xiaomi_markw

arch/arm/mach-bcmring/csp/tmr/Makefile

0 → 100644

+1 −0

Original line number	Diff line number	Diff line
		obj-y += tmrHw.o

arch/arm/mach-bcmring/csp/tmr/tmrHw.c

0 → 100644

+576 −0

Original line number	Diff line number	Diff line
		/*****************************************************************************
		* Copyright 2003 - 2008 Broadcom Corporation. All rights reserved.
		*
		* Unless you and Broadcom execute a separate written software license
		* agreement governing use of this software, this software is licensed to you
		* under the terms of the GNU General Public License version 2, available at
		* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
		*
		* Notwithstanding the above, under no circumstances may you combine this
		* software in any way with any other Broadcom software provided under a
		* license other than the GPL, without Broadcom's express prior written
		* consent.
		*****************************************************************************/

		/****************************************************************************/
		/**
		* @file tmrHw.c
		*
		* @brief Low level Timer driver routines
		*
		* @note
		*
		* These routines provide basic timer functionality only.
		*/
		/****************************************************************************/

		/* ---- Include Files ---------------------------------------------------- */

		#include <csp/errno.h>
		#include <csp/stdint.h>

		#include <csp/tmrHw.h>
		#include <mach/csp/tmrHw_reg.h>

		#define tmrHw_ASSERT(a) if (!(a)) (char )0 = 0
		#define tmrHw_MILLISEC_PER_SEC (1000)

		#define tmrHw_LOW_1_RESOLUTION_COUNT (tmrHw_LOW_RESOLUTION_CLOCK / tmrHw_MILLISEC_PER_SEC)
		#define tmrHw_LOW_1_MAX_MILLISEC (0xFFFFFFFF / tmrHw_LOW_1_RESOLUTION_COUNT)
		#define tmrHw_LOW_16_RESOLUTION_COUNT (tmrHw_LOW_1_RESOLUTION_COUNT / 16)
		#define tmrHw_LOW_16_MAX_MILLISEC (0xFFFFFFFF / tmrHw_LOW_16_RESOLUTION_COUNT)
		#define tmrHw_LOW_256_RESOLUTION_COUNT (tmrHw_LOW_1_RESOLUTION_COUNT / 256)
		#define tmrHw_LOW_256_MAX_MILLISEC (0xFFFFFFFF / tmrHw_LOW_256_RESOLUTION_COUNT)

		#define tmrHw_HIGH_1_RESOLUTION_COUNT (tmrHw_HIGH_RESOLUTION_CLOCK / tmrHw_MILLISEC_PER_SEC)
		#define tmrHw_HIGH_1_MAX_MILLISEC (0xFFFFFFFF / tmrHw_HIGH_1_RESOLUTION_COUNT)
		#define tmrHw_HIGH_16_RESOLUTION_COUNT (tmrHw_HIGH_1_RESOLUTION_COUNT / 16)
		#define tmrHw_HIGH_16_MAX_MILLISEC (0xFFFFFFFF / tmrHw_HIGH_16_RESOLUTION_COUNT)
		#define tmrHw_HIGH_256_RESOLUTION_COUNT (tmrHw_HIGH_1_RESOLUTION_COUNT / 256)
		#define tmrHw_HIGH_256_MAX_MILLISEC (0xFFFFFFFF / tmrHw_HIGH_256_RESOLUTION_COUNT)

		static void ResetTimer(tmrHw_ID_t timerId)
		__attribute__ ((section(".aramtext")));
		static int tmrHw_divide(int num, int denom)
		__attribute__ ((section(".aramtext")));

		/****************************************************************************/
		/**
		* @brief Get timer capability
		*
		* This function returns various capabilities/attributes of a timer
		*
		* @return Capability
		*
		*/
		/****************************************************************************/
		uint32_t tmrHw_getTimerCapability(tmrHw_ID_t timerId, /* [ IN ] Timer Id */
		tmrHw_CAPABILITY_e capability /* [ IN ] Timer capability */
		) {
		switch (capability) {
		case tmrHw_CAPABILITY_CLOCK:
		return (timerId <=
		1) ? tmrHw_LOW_RESOLUTION_CLOCK :
		tmrHw_HIGH_RESOLUTION_CLOCK;
		case tmrHw_CAPABILITY_RESOLUTION:
		return 32;
		default:
		return 0;
		}
		return 0;
		}

		/****************************************************************************/
		/**
		* @brief Resets a timer
		*
		* This function initializes timer
		*
		* @return void
		*
		*/
		/****************************************************************************/
		static void ResetTimer(tmrHw_ID_t timerId /* [ IN ] Timer Id */
		) {
		/* Reset timer */
		pTmrHw[timerId].LoadValue = 0;
		pTmrHw[timerId].CurrentValue = 0xFFFFFFFF;
		pTmrHw[timerId].Control = 0;
		pTmrHw[timerId].BackgroundLoad = 0;
		/* Always configure as a 32 bit timer */
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_32BIT;
		/* Clear interrupt only if raw status interrupt is set */
		if (pTmrHw[timerId].RawInterruptStatus) {
		pTmrHw[timerId].InterruptClear = 0xFFFFFFFF;
		}
		}

		/****************************************************************************/
		/**
		* @brief Sets counter value for an interval in ms
		*
		* @return On success: Effective counter value set
		* On failure: 0
		*
		*/
		/****************************************************************************/
		static tmrHw_INTERVAL_t SetTimerPeriod(tmrHw_ID_t timerId, /* [ IN ] Timer Id */
		tmrHw_INTERVAL_t msec /* [ IN ] Interval in milli-second */
		) {
		uint32_t scale = 0;
		uint32_t count = 0;

		if (timerId == 0 \|\| timerId == 1) {
		if (msec <= tmrHw_LOW_1_MAX_MILLISEC) {
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PRESCALE_1;
		scale = tmrHw_LOW_1_RESOLUTION_COUNT;
		} else if (msec <= tmrHw_LOW_16_MAX_MILLISEC) {
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PRESCALE_16;
		scale = tmrHw_LOW_16_RESOLUTION_COUNT;
		} else if (msec <= tmrHw_LOW_256_MAX_MILLISEC) {
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PRESCALE_256;
		scale = tmrHw_LOW_256_RESOLUTION_COUNT;
		} else {
		return 0;
		}

		count = msec * scale;
		/* Set counter value */
		pTmrHw[timerId].LoadValue = count;
		pTmrHw[timerId].BackgroundLoad = count;

		} else if (timerId == 2 \|\| timerId == 3) {
		if (msec <= tmrHw_HIGH_1_MAX_MILLISEC) {
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PRESCALE_1;
		scale = tmrHw_HIGH_1_RESOLUTION_COUNT;
		} else if (msec <= tmrHw_HIGH_16_MAX_MILLISEC) {
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PRESCALE_16;
		scale = tmrHw_HIGH_16_RESOLUTION_COUNT;
		} else if (msec <= tmrHw_HIGH_256_MAX_MILLISEC) {
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PRESCALE_256;
		scale = tmrHw_HIGH_256_RESOLUTION_COUNT;
		} else {
		return 0;
		}

		count = msec * scale;
		/* Set counter value */
		pTmrHw[timerId].LoadValue = count;
		pTmrHw[timerId].BackgroundLoad = count;
		}
		return count / scale;
		}

		/****************************************************************************/
		/**
		* @brief Configures a periodic timer in terms of timer interrupt rate
		*
		* This function initializes a periodic timer to generate specific number of
		* timer interrupt per second
		*
		* @return On success: Effective timer frequency
		* On failure: 0
		*
		*/
		/****************************************************************************/
		tmrHw_RATE_t tmrHw_setPeriodicTimerRate(tmrHw_ID_t timerId, /* [ IN ] Timer Id */
		tmrHw_RATE_t rate /* [ IN ] Number of timer interrupt per second */
		) {
		uint32_t resolution = 0;
		uint32_t count = 0;
		ResetTimer(timerId);

		/* Set timer mode periodic */
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PERIODIC;
		pTmrHw[timerId].Control &= ~tmrHw_CONTROL_ONESHOT;
		/* Set timer in highest resolution */
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PRESCALE_1;

		if (rate && (timerId == 0 \|\| timerId == 1)) {
		if (rate > tmrHw_LOW_RESOLUTION_CLOCK) {
		return 0;
		}
		resolution = tmrHw_LOW_RESOLUTION_CLOCK;
		} else if (rate && (timerId == 2 \|\| timerId == 3)) {
		if (rate > tmrHw_HIGH_RESOLUTION_CLOCK) {
		return 0;
		} else {
		resolution = tmrHw_HIGH_RESOLUTION_CLOCK;
		}
		} else {
		return 0;
		}
		/* Find the counter value */
		count = resolution / rate;
		/* Set counter value */
		pTmrHw[timerId].LoadValue = count;
		pTmrHw[timerId].BackgroundLoad = count;

		return resolution / count;
		}

		/****************************************************************************/
		/**
		* @brief Configures a periodic timer to generate timer interrupt after
		* certain time interval
		*
		* This function initializes a periodic timer to generate timer interrupt
		* after every time interval in millisecond
		*
		* @return On success: Effective interval set in milli-second
		* On failure: 0
		*
		*/
		/****************************************************************************/
		tmrHw_INTERVAL_t tmrHw_setPeriodicTimerInterval(tmrHw_ID_t timerId, /* [ IN ] Timer Id */
		tmrHw_INTERVAL_t msec /* [ IN ] Interval in milli-second */
		) {
		ResetTimer(timerId);

		/* Set timer mode periodic */
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PERIODIC;
		pTmrHw[timerId].Control &= ~tmrHw_CONTROL_ONESHOT;

		return SetTimerPeriod(timerId, msec);
		}

		/****************************************************************************/
		/**
		* @brief Configures a periodic timer to generate timer interrupt just once
		* after certain time interval
		*
		* This function initializes a periodic timer to generate a single ticks after
		* certain time interval in millisecond
		*
		* @return On success: Effective interval set in milli-second
		* On failure: 0
		*
		*/
		/****************************************************************************/
		tmrHw_INTERVAL_t tmrHw_setOneshotTimerInterval(tmrHw_ID_t timerId, /* [ IN ] Timer Id */
		tmrHw_INTERVAL_t msec /* [ IN ] Interval in milli-second */
		) {
		ResetTimer(timerId);

		/* Set timer mode oneshot */
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PERIODIC;
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_ONESHOT;

		return SetTimerPeriod(timerId, msec);
		}

		/****************************************************************************/
		/**
		* @brief Configures a timer to run as a free running timer
		*
		* This function initializes a timer to run as a free running timer
		*
		* @return Timer resolution (count / sec)
		*
		*/
		/****************************************************************************/
		tmrHw_RATE_t tmrHw_setFreeRunningTimer(tmrHw_ID_t timerId, /* [ IN ] Timer Id */
		uint32_t divider /* [ IN ] Dividing the clock frequency */
		) {
		uint32_t scale = 0;

		ResetTimer(timerId);
		/* Set timer as free running mode */
		pTmrHw[timerId].Control &= ~tmrHw_CONTROL_PERIODIC;
		pTmrHw[timerId].Control &= ~tmrHw_CONTROL_ONESHOT;

		if (divider >= 64) {
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PRESCALE_256;
		scale = 256;
		} else if (divider >= 8) {
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PRESCALE_16;
		scale = 16;
		} else {
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_PRESCALE_1;
		scale = 1;
		}

		if (timerId == 0 \|\| timerId == 1) {
		return tmrHw_divide(tmrHw_LOW_RESOLUTION_CLOCK, scale);
		} else if (timerId == 2 \|\| timerId == 3) {
		return tmrHw_divide(tmrHw_HIGH_RESOLUTION_CLOCK, scale);
		}

		return 0;
		}

		/****************************************************************************/
		/**
		* @brief Starts a timer
		*
		* This function starts a preconfigured timer
		*
		* @return -1 - On Failure
		* 0 - On Success
		*
		*/
		/****************************************************************************/
		int tmrHw_startTimer(tmrHw_ID_t timerId /* [ IN ] Timer id */
		) {
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_TIMER_ENABLE;
		return 0;
		}

		/****************************************************************************/
		/**
		* @brief Stops a timer
		*
		* This function stops a running timer
		*
		* @return -1 - On Failure
		* 0 - On Success
		*
		*/
		/****************************************************************************/
		int tmrHw_stopTimer(tmrHw_ID_t timerId /* [ IN ] Timer id */
		) {
		pTmrHw[timerId].Control &= ~tmrHw_CONTROL_TIMER_ENABLE;
		return 0;
		}

		/****************************************************************************/
		/**
		* @brief Gets current timer count
		*
		* This function returns the current timer value
		*
		* @return Current downcounting timer value
		*
		*/
		/****************************************************************************/
		uint32_t tmrHw_GetCurrentCount(tmrHw_ID_t timerId /* [ IN ] Timer id */
		) {
		/* return 32 bit timer value */
		switch (pTmrHw[timerId].Control & tmrHw_CONTROL_MODE_MASK) {
		case tmrHw_CONTROL_FREE_RUNNING:
		if (pTmrHw[timerId].CurrentValue) {
		return tmrHw_MAX_COUNT - pTmrHw[timerId].CurrentValue;
		}
		break;
		case tmrHw_CONTROL_PERIODIC:
		case tmrHw_CONTROL_ONESHOT:
		return pTmrHw[timerId].BackgroundLoad -
		pTmrHw[timerId].CurrentValue;
		}
		return 0;
		}

		/****************************************************************************/
		/**
		* @brief Gets timer count rate
		*
		* This function returns the number of counts per second
		*
		* @return Count rate
		*
		*/
		/****************************************************************************/
		tmrHw_RATE_t tmrHw_getCountRate(tmrHw_ID_t timerId /* [ IN ] Timer id */
		) {
		uint32_t divider = 0;

		switch (pTmrHw[timerId].Control & tmrHw_CONTROL_PRESCALE_MASK) {
		case tmrHw_CONTROL_PRESCALE_1:
		divider = 1;
		break;
		case tmrHw_CONTROL_PRESCALE_16:
		divider = 16;
		break;
		case tmrHw_CONTROL_PRESCALE_256:
		divider = 256;
		break;
		default:
		tmrHw_ASSERT(0);
		}

		if (timerId == 0 \|\| timerId == 1) {
		return tmrHw_divide(tmrHw_LOW_RESOLUTION_CLOCK, divider);
		} else {
		return tmrHw_divide(tmrHw_HIGH_RESOLUTION_CLOCK, divider);
		}
		return 0;
		}

		/****************************************************************************/
		/**
		* @brief Enables timer interrupt
		*
		* This function enables the timer interrupt
		*
		* @return N/A
		*
		*/
		/****************************************************************************/
		void tmrHw_enableInterrupt(tmrHw_ID_t timerId /* [ IN ] Timer id */
		) {
		pTmrHw[timerId].Control \|= tmrHw_CONTROL_INTERRUPT_ENABLE;
		}

		/****************************************************************************/
		/**
		* @brief Disables timer interrupt
		*
		* This function disable the timer interrupt
		*
		* @return N/A
		*
		*/
		/****************************************************************************/
		void tmrHw_disableInterrupt(tmrHw_ID_t timerId /* [ IN ] Timer id */
		) {
		pTmrHw[timerId].Control &= ~tmrHw_CONTROL_INTERRUPT_ENABLE;
		}

		/****************************************************************************/
		/**
		* @brief Clears the interrupt
		*
		* This function clears the timer interrupt
		*
		* @return N/A
		*
		* @note
		* Must be called under the context of ISR
		*/
		/****************************************************************************/
		void tmrHw_clearInterrupt(tmrHw_ID_t timerId /* [ IN ] Timer id */
		) {
		pTmrHw[timerId].InterruptClear = 0x1;
		}

		/****************************************************************************/
		/**
		* @brief Gets the interrupt status
		*
		* This function returns timer interrupt status
		*
		* @return Interrupt status
		*/
		/****************************************************************************/
		tmrHw_INTERRUPT_STATUS_e tmrHw_getInterruptStatus(tmrHw_ID_t timerId /* [ IN ] Timer id */
		) {
		if (pTmrHw[timerId].InterruptStatus) {
		return tmrHw_INTERRUPT_STATUS_SET;
		} else {
		return tmrHw_INTERRUPT_STATUS_UNSET;
		}
		}

		/****************************************************************************/
		/**
		* @brief Indentifies a timer causing interrupt
		*
		* This functions returns a timer causing interrupt
		*
		* @return 0xFFFFFFFF : No timer causing an interrupt
		* ! 0xFFFFFFFF : timer causing an interrupt
		* @note
		* tmrHw_clearIntrrupt() must be called with a valid timer id after calling this function
		*/
		/****************************************************************************/
		tmrHw_ID_t tmrHw_getInterruptSource(void /* void */
		) {
		int i;

		for (i = 0; i < tmrHw_TIMER_NUM_COUNT; i++) {
		if (pTmrHw[i].InterruptStatus) {
		return i;
		}
		}

		return 0xFFFFFFFF;
		}

		/****************************************************************************/
		/**
		* @brief Displays specific timer registers
		*
		*
		* @return void
		*
		*/
		/****************************************************************************/
		void tmrHw_printDebugInfo(tmrHw_ID_t timerId, /* [ IN ] Timer id */
		int (fpPrint) (const char , ...) /* [ IN ] Print callback function */
		) {
		(*fpPrint) ("Displaying register contents \n\n");
		(*fpPrint) ("Timer %d: Load value 0x%X\n", timerId,
		pTmrHw[timerId].LoadValue);
		(*fpPrint) ("Timer %d: Background load value 0x%X\n", timerId,
		pTmrHw[timerId].BackgroundLoad);
		(*fpPrint) ("Timer %d: Control 0x%X\n", timerId,
		pTmrHw[timerId].Control);
		(*fpPrint) ("Timer %d: Interrupt clear 0x%X\n", timerId,
		pTmrHw[timerId].InterruptClear);
		(*fpPrint) ("Timer %d: Interrupt raw interrupt 0x%X\n", timerId,
		pTmrHw[timerId].RawInterruptStatus);
		(*fpPrint) ("Timer %d: Interrupt status 0x%X\n", timerId,
		pTmrHw[timerId].InterruptStatus);
		}

		/****************************************************************************/
		/**
		* @brief Use a timer to perform a busy wait delay for a number of usecs.
		*
		* @return N/A
		*/
		/****************************************************************************/
		void tmrHw_udelay(tmrHw_ID_t timerId, /* [ IN ] Timer id */
		unsigned long usecs /* [ IN ] usec to delay */
		) {
		tmrHw_RATE_t usec_tick_rate;
		tmrHw_COUNT_t start_time;
		tmrHw_COUNT_t delta_time;

		start_time = tmrHw_GetCurrentCount(timerId);
		usec_tick_rate = tmrHw_divide(tmrHw_getCountRate(timerId), 1000000);
		delta_time = usecs * usec_tick_rate;

		/* Busy wait */
		while (delta_time > (tmrHw_GetCurrentCount(timerId) - start_time))
		;
		}

		/****************************************************************************/
		/**
		* @brief Local Divide function
		*
		* This function does the divide
		*
		* @return divide value
		*
		*/
		/****************************************************************************/
		static int tmrHw_divide(int num, int denom)
		{
		int r;
		int t = 1;

		/* Shift denom and t up to the largest value to optimize algorithm */
		/* t contains the units of each divide */
		while ((denom & 0x40000000) == 0) { /* fails if denom=0 */
		denom = denom << 1;
		t = t << 1;
		}

		/* Intialize the result */
		r = 0;

		do {
		/* Determine if there exists a positive remainder */
		if ((num - denom) >= 0) {
		/* Accumlate t to the result and calculate a new remainder */
		num = num - denom;
		r = r + t;
		}
		/* Continue to shift denom and shift t down to 0 */
		denom = denom >> 1;
		t = t >> 1;
		} while (t != 0);
		return r;
		}

arch/arm/mach-bcmring/include/csp/tmrHw.h

0 → 100644

+263 −0

File added.

Preview size limit exceeded, changes collapsed.

arch/arm/mach-bcmring/include/mach/csp/tmrHw_reg.h

0 → 100644

+82 −0

Original line number	Diff line number	Diff line
		/*****************************************************************************
		* Copyright 2004 - 2008 Broadcom Corporation. All rights reserved.
		*
		* Unless you and Broadcom execute a separate written software license
		* agreement governing use of this software, this software is licensed to you
		* under the terms of the GNU General Public License version 2, available at
		* http://www.broadcom.com/licenses/GPLv2.php (the "GPL").
		*
		* Notwithstanding the above, under no circumstances may you combine this
		* software in any way with any other Broadcom software provided under a
		* license other than the GPL, without Broadcom's express prior written
		* consent.
		*****************************************************************************/

		/****************************************************************************/
		/**
		* @file tmrHw_reg.h
		*
		* @brief Definitions for low level Timer registers
		*
		*/
		/****************************************************************************/
		#ifndef _TMRHW_REG_H
		#define _TMRHW_REG_H

		#include <mach/csp/mm_io.h>
		#include <mach/csp/hw_cfg.h>
		/* Base address */
		#define tmrHw_MODULE_BASE_ADDR MM_IO_BASE_TMR

		/*
		This platform has four different timers running at different clock speed

		Timer one (Timer ID 0) runs at 25 MHz
		Timer two (Timer ID 1) runs at 25 MHz
		Timer three (Timer ID 2) runs at 150 MHz
		Timer four (Timer ID 3) runs at 150 MHz
		*/
		#define tmrHw_LOW_FREQUENCY_MHZ 25 /* Always 25MHz from XTAL */
		#define tmrHw_LOW_FREQUENCY_HZ 25000000

		#if defined(CFG_GLOBAL_CHIP) && (CFG_GLOBAL_CHIP == FPGA11107)
		#define tmrHw_HIGH_FREQUENCY_MHZ 150 /* Always 150MHz for FPGA */
		#define tmrHw_HIGH_FREQUENCY_HZ 150000000
		#else
		#define tmrHw_HIGH_FREQUENCY_HZ HW_CFG_BUS_CLK_HZ
		#define tmrHw_HIGH_FREQUENCY_MHZ (HW_CFG_BUS_CLK_HZ / 1000000)
		#endif

		#define tmrHw_LOW_RESOLUTION_CLOCK tmrHw_LOW_FREQUENCY_HZ
		#define tmrHw_HIGH_RESOLUTION_CLOCK tmrHw_HIGH_FREQUENCY_HZ
		#define tmrHw_MAX_COUNT (0xFFFFFFFF) /* maximum number of count a timer can count */
		#define tmrHw_TIMER_NUM_COUNT (4) /* Number of timer module supported */

		typedef struct {
		uint32_t LoadValue; /* Load value for timer */
		uint32_t CurrentValue; /* Current value for timer */
		uint32_t Control; /* Control register */
		uint32_t InterruptClear; /* Interrupt clear register */
		uint32_t RawInterruptStatus; /* Raw interrupt status */
		uint32_t InterruptStatus; /* Masked interrupt status */
		uint32_t BackgroundLoad; /* Background load value */
		uint32_t padding; /* Padding register */
		} tmrHw_REG_t;

		/* Control bot masks */
		#define tmrHw_CONTROL_TIMER_ENABLE 0x00000080
		#define tmrHw_CONTROL_PERIODIC 0x00000040
		#define tmrHw_CONTROL_INTERRUPT_ENABLE 0x00000020
		#define tmrHw_CONTROL_PRESCALE_MASK 0x0000000C
		#define tmrHw_CONTROL_PRESCALE_1 0x00000000
		#define tmrHw_CONTROL_PRESCALE_16 0x00000004
		#define tmrHw_CONTROL_PRESCALE_256 0x00000008
		#define tmrHw_CONTROL_32BIT 0x00000002
		#define tmrHw_CONTROL_ONESHOT 0x00000001
		#define tmrHw_CONTROL_FREE_RUNNING 0x00000000

		#define tmrHw_CONTROL_MODE_MASK (tmrHw_CONTROL_PERIODIC \| tmrHw_CONTROL_ONESHOT)

		#define pTmrHw ((volatile tmrHw_REG_t *)tmrHw_MODULE_BASE_ADDR)

		#endif /* _TMRHW_REG_H */