mirror of
https://github.com/FreeRTOS/FreeRTOS-Kernel.git
synced 2026-01-21 01:00:35 -05:00
Start of an MSP430FR5969 IAR project - currently running Blinky only.
This commit is contained in:
Richard Barry
parent
d39c0d5926
commit
91b249d24b
72 changed files with 43164 additions and 0 deletions
|
|
@ -0,0 +1,445 @@
|
|||
/* --COPYRIGHT--,BSD
|
||||
* Copyright (c) 2014, Texas Instruments Incorporated
|
||||
* 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 Texas Instruments Incorporated 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 OWNER 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.
|
||||
* --/COPYRIGHT--*/
|
||||
//*****************************************************************************
|
||||
//
|
||||
// mpy32.h - Driver for the MPY32 Module.
|
||||
//
|
||||
//*****************************************************************************
|
||||
|
||||
#ifndef __MSP430WARE_MPY32_H__
|
||||
#define __MSP430WARE_MPY32_H__
|
||||
|
||||
#include "inc/hw_memmap.h"
|
||||
|
||||
#ifdef __MSP430_HAS_MPY32__
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
// If building with a C++ compiler, make all of the definitions in this header
|
||||
// have a C binding.
|
||||
//
|
||||
//*****************************************************************************
|
||||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
{
|
||||
#endif
|
||||
|
||||
#include "inc/hw_regaccess.h"
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
// The following are values that can be passed to the writeDelaySelect
|
||||
// parameter for functions: MPY32_setWriteDelay().
|
||||
//
|
||||
//*****************************************************************************
|
||||
#define MPY32_WRITEDELAY_OFF (!(MPYDLY32 + MPYDLYWRTEN))
|
||||
#define MPY32_WRITEDELAY_32BIT (MPYDLYWRTEN)
|
||||
#define MPY32_WRITEDELAY_64BIT (MPYDLY32 + MPYDLYWRTEN)
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
// The following are values that can be passed to the multiplicationType
|
||||
// parameter for functions: MPY32_setOperandOne8Bit(),
|
||||
// MPY32_setOperandOne16Bit(), MPY32_setOperandOne24Bit(), and
|
||||
// MPY32_setOperandOne32Bit().
|
||||
//
|
||||
//*****************************************************************************
|
||||
#define MPY32_MULTIPLY_UNSIGNED (0x00)
|
||||
#define MPY32_MULTIPLY_SIGNED (0x02)
|
||||
#define MPY32_MULTIPLYACCUMULATE_UNSIGNED (0x04)
|
||||
#define MPY32_MULTIPLYACCUMULATE_SIGNED (0x06)
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
// The following are values that can be passed toThe following are values that
|
||||
// can be returned by the MPY32_getSaturationMode() function.
|
||||
//
|
||||
//*****************************************************************************
|
||||
#define MPY32_SATURATION_MODE_DISABLED 0x00
|
||||
#define MPY32_SATURATION_MODE_ENABLED MPYSAT
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
// The following are values that can be passed toThe following are values that
|
||||
// can be returned by the MPY32_getFractionalMode() function.
|
||||
//
|
||||
//*****************************************************************************
|
||||
#define MPY32_FRACTIONAL_MODE_DISABLED 0x00
|
||||
#define MPY32_FRACTIONAL_MODE_ENABLED MPYFRAC
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
// Prototypes for the APIs.
|
||||
//
|
||||
//*****************************************************************************
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Sets the write delay setting for the MPY32 module.
|
||||
//!
|
||||
//! This function sets up a write delay to the MPY module's registers, which
|
||||
//! holds any writes to the registers until all calculations are complete.
|
||||
//! There are two different settings, one which waits for 32-bit results to be
|
||||
//! ready, and one which waits for 64-bit results to be ready. This prevents
|
||||
//! unpredicatble results if registers are changed before the results are
|
||||
//! ready.
|
||||
//!
|
||||
//! \param writeDelaySelect delays the write to any MPY32 register until the
|
||||
//! selected bit size of result has been written.
|
||||
//! Valid values are:
|
||||
//! - \b MPY32_WRITEDELAY_OFF [Default] - writes are not delayed
|
||||
//! - \b MPY32_WRITEDELAY_32BIT - writes are delayed until a 32-bit
|
||||
//! result is available in the result registers
|
||||
//! - \b MPY32_WRITEDELAY_64BIT - writes are delayed until a 64-bit
|
||||
//! result is available in the result registers
|
||||
//! \n Modified bits are \b MPYDLY32 and \b MPYDLYWRTEN of \b MPY32CTL0
|
||||
//! register.
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_setWriteDelay(uint16_t writeDelaySelect);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Enables Saturation Mode.
|
||||
//!
|
||||
//! This function enables saturation mode. When this is enabled, the result
|
||||
//! read out from the MPY result registers is converted to the most-positive
|
||||
//! number in the case of an overflow, or the most-negative number in the case
|
||||
//! of an underflow. Please note, that the raw value in the registers does not
|
||||
//! reflect the result returned, and if the saturation mode is disabled, then
|
||||
//! the raw value of the registers will be returned instead.
|
||||
//!
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_enableSaturationMode(void);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Disables Saturation Mode.
|
||||
//!
|
||||
//! This function disables saturation mode, which allows the raw result of the
|
||||
//! MPY result registers to be returned.
|
||||
//!
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_disableSaturationMode(void);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Gets the Saturation Mode.
|
||||
//!
|
||||
//! This function gets the current saturation mode.
|
||||
//!
|
||||
//!
|
||||
//! \return Gets the Saturation Mode
|
||||
//! Return one of the following:
|
||||
//! - \b MPY32_SATURATION_MODE_DISABLED
|
||||
//! - \b MPY32_SATURATION_MODE_ENABLED
|
||||
//! \n Gets the Saturation Mode
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern uint8_t MPY32_getSaturationMode(void);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Enables Fraction Mode.
|
||||
//!
|
||||
//! This function enables fraction mode.
|
||||
//!
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_enableFractionalMode(void);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Disables Fraction Mode.
|
||||
//!
|
||||
//! This function disables fraction mode.
|
||||
//!
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_disableFractionalMode(void);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Gets the Fractional Mode.
|
||||
//!
|
||||
//! This function gets the current fractional mode.
|
||||
//!
|
||||
//!
|
||||
//! \return Gets the fractional mode
|
||||
//! Return one of the following:
|
||||
//! - \b MPY32_FRACTIONAL_MODE_DISABLED
|
||||
//! - \b MPY32_FRACTIONAL_MODE_ENABLED
|
||||
//! \n Gets the Fractional Mode
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern uint8_t MPY32_getFractionalMode(void);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Sets an 8-bit value into operand 1.
|
||||
//!
|
||||
//! This function sets the first operand for multiplication and determines what
|
||||
//! type of operation should be performed. Once the second operand is set, then
|
||||
//! the operation will begin.
|
||||
//!
|
||||
//! \param multiplicationType is the type of multiplication to perform once the
|
||||
//! second operand is set.
|
||||
//! Valid values are:
|
||||
//! - \b MPY32_MULTIPLY_UNSIGNED
|
||||
//! - \b MPY32_MULTIPLY_SIGNED
|
||||
//! - \b MPY32_MULTIPLYACCUMULATE_UNSIGNED
|
||||
//! - \b MPY32_MULTIPLYACCUMULATE_SIGNED
|
||||
//! \param operand is the 8-bit value to load into the 1st operand.
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_setOperandOne8Bit(uint8_t multiplicationType,
|
||||
uint8_t operand);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Sets an 16-bit value into operand 1.
|
||||
//!
|
||||
//! This function sets the first operand for multiplication and determines what
|
||||
//! type of operation should be performed. Once the second operand is set, then
|
||||
//! the operation will begin.
|
||||
//!
|
||||
//! \param multiplicationType is the type of multiplication to perform once the
|
||||
//! second operand is set.
|
||||
//! Valid values are:
|
||||
//! - \b MPY32_MULTIPLY_UNSIGNED
|
||||
//! - \b MPY32_MULTIPLY_SIGNED
|
||||
//! - \b MPY32_MULTIPLYACCUMULATE_UNSIGNED
|
||||
//! - \b MPY32_MULTIPLYACCUMULATE_SIGNED
|
||||
//! \param operand is the 16-bit value to load into the 1st operand.
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_setOperandOne16Bit(uint8_t multiplicationType,
|
||||
uint16_t operand);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Sets an 24-bit value into operand 1.
|
||||
//!
|
||||
//! This function sets the first operand for multiplication and determines what
|
||||
//! type of operation should be performed. Once the second operand is set, then
|
||||
//! the operation will begin.
|
||||
//!
|
||||
//! \param multiplicationType is the type of multiplication to perform once the
|
||||
//! second operand is set.
|
||||
//! Valid values are:
|
||||
//! - \b MPY32_MULTIPLY_UNSIGNED
|
||||
//! - \b MPY32_MULTIPLY_SIGNED
|
||||
//! - \b MPY32_MULTIPLYACCUMULATE_UNSIGNED
|
||||
//! - \b MPY32_MULTIPLYACCUMULATE_SIGNED
|
||||
//! \param operand is the 24-bit value to load into the 1st operand.
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_setOperandOne24Bit(uint8_t multiplicationType,
|
||||
uint32_t operand);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Sets an 32-bit value into operand 1.
|
||||
//!
|
||||
//! This function sets the first operand for multiplication and determines what
|
||||
//! type of operation should be performed. Once the second operand is set, then
|
||||
//! the operation will begin.
|
||||
//!
|
||||
//! \param multiplicationType is the type of multiplication to perform once the
|
||||
//! second operand is set.
|
||||
//! Valid values are:
|
||||
//! - \b MPY32_MULTIPLY_UNSIGNED
|
||||
//! - \b MPY32_MULTIPLY_SIGNED
|
||||
//! - \b MPY32_MULTIPLYACCUMULATE_UNSIGNED
|
||||
//! - \b MPY32_MULTIPLYACCUMULATE_SIGNED
|
||||
//! \param operand is the 32-bit value to load into the 1st operand.
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_setOperandOne32Bit(uint8_t multiplicationType,
|
||||
uint32_t operand);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Sets an 8-bit value into operand 2, which starts the multiplication.
|
||||
//!
|
||||
//! This function sets the second operand of the multiplication operation and
|
||||
//! starts the operation.
|
||||
//!
|
||||
//! \param operand is the 8-bit value to load into the 2nd operand.
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_setOperandTwo8Bit(uint8_t operand);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Sets an 16-bit value into operand 2, which starts the
|
||||
//! multiplication.
|
||||
//!
|
||||
//! This function sets the second operand of the multiplication operation and
|
||||
//! starts the operation.
|
||||
//!
|
||||
//! \param operand is the 16-bit value to load into the 2nd operand.
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_setOperandTwo16Bit(uint16_t operand);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Sets an 24-bit value into operand 2, which starts the
|
||||
//! multiplication.
|
||||
//!
|
||||
//! This function sets the second operand of the multiplication operation and
|
||||
//! starts the operation.
|
||||
//!
|
||||
//! \param operand is the 24-bit value to load into the 2nd operand.
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_setOperandTwo24Bit(uint32_t operand);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Sets an 32-bit value into operand 2, which starts the
|
||||
//! multiplication.
|
||||
//!
|
||||
//! This function sets the second operand of the multiplication operation and
|
||||
//! starts the operation.
|
||||
//!
|
||||
//! \param operand is the 32-bit value to load into the 2nd operand.
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_setOperandTwo32Bit(uint32_t operand);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Returns an 64-bit result of the last multiplication operation.
|
||||
//!
|
||||
//! This function returns all 64 bits of the result registers
|
||||
//!
|
||||
//!
|
||||
//! \return The 64-bit result is returned as a uint64_t type
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern uint64_t MPY32_getResult(void);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Returns the Sum Extension of the last multiplication operation.
|
||||
//!
|
||||
//! This function returns the Sum Extension of the MPY module, which either
|
||||
//! gives the sign after a signed operation or shows a carry after a multiply-
|
||||
//! and-accumulate operation. The Sum Extension acts as a check for overflows
|
||||
//! or underflows.
|
||||
//!
|
||||
//!
|
||||
//! \return The value of the MPY32 module Sum Extension.
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern uint16_t MPY32_getSumExtension(void);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Returns the Carry Bit of the last multiplication operation.
|
||||
//!
|
||||
//! This function returns the Carry Bit of the MPY module, which either gives
|
||||
//! the sign after a signed operation or shows a carry after a multiply- and-
|
||||
//! accumulate operation.
|
||||
//!
|
||||
//!
|
||||
//! \return The value of the MPY32 module Carry Bit 0x0 or 0x1.
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern uint16_t MPY32_getCarryBitValue(void);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Clears the Carry Bit of the last multiplication operation.
|
||||
//!
|
||||
//! This function clears the Carry Bit of the MPY module
|
||||
//!
|
||||
//!
|
||||
//! \return The value of the MPY32 module Carry Bit 0x0 or 0x1.
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_clearCarryBitValue(void);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
//! \brief Preloads the result register
|
||||
//!
|
||||
//! This function Preloads the result register
|
||||
//!
|
||||
//! \param result value to preload the result register to
|
||||
//!
|
||||
//! \return None
|
||||
//
|
||||
//*****************************************************************************
|
||||
extern void MPY32_preloadResult(uint64_t result);
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
// Mark the end of the C bindings section for C++ compilers.
|
||||
//
|
||||
//*****************************************************************************
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif // __MSP430WARE_MPY32_H__
|
||||
Loading…
Add table
Add a link
Reference in a new issue