dl_crc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020, 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.
 */
/*!****************************************************************************
 *  @file       dl_crc.h
 *  @brief      Cyclic Redundancy Check (CRC) Driver Library
 *  @defgroup   CRC Cyclic Redundancy Check (CRC)
 *
 *  @anchor ti_dl_dl_crc_Overview
 *  # Overview
 *
 *  The CRC DriverLib allows full configuration of the MSPM0 CRC module.
 *  The cyclic redundancy check (CRC) accelerator generates signatures for a
 *  given data sequence based on the CRC16-CCITT polynomial or the
 *  CRC32-ISO3309 polynomial.
 *
 *  <hr>
 ******************************************************************************
 */
#ifndef ti_dl_dl_crc__include
#define ti_dl_dl_crc__include

#include <stdbool.h>
#include <stdint.h>

#include <ti/devices/msp/msp.h>
#include <ti/driverlib/dl_common.h>

#ifdef __MSPM0_HAS_CRC__

#ifdef __cplusplus
extern "C" {
#endif

#if (CRC_SYS_CRC32_ENABLE == 1)

#define DEVICE_HAS_CRC_32_BIT_POLYNOMIAL
#endif

typedef enum {
    DL_CRC_16_POLYNOMIAL = CRC_CRCCTRL_POLYSIZE_CRC16,
#ifdef DEVICE_HAS_CRC_32_BIT_POLYNOMIAL

    DL_CRC_32_POLYNOMIAL = CRC_CRCCTRL_POLYSIZE_CRC32
#endif /* DEVICE_HAS_CRC_32_BIT_POLYNOMIAL */
} DL_CRC_POLYNOMIAL;

typedef enum {
    DL_CRC_BIT_REVERSED = CRC_CRCCTRL_BITREVERSE_REVERSED,
    DL_CRC_BIT_NOT_REVERSED = CRC_CRCCTRL_BITREVERSE_NOT_REVERSED
} DL_CRC_BIT;

typedef enum {
    DL_CRC_INPUT_ENDIANESS_LITTLE_ENDIAN =
        CRC_CRCCTRL_INPUT_ENDIANNESS_LITTLE_ENDIAN,
    DL_CRC_INPUT_ENDIANESS_BIG_ENDIAN = CRC_CRCCTRL_INPUT_ENDIANNESS_BIG_ENDIAN
} DL_CRC_INPUT_ENDIANESS;

typedef enum {
    DL_CRC_OUTPUT_BYTESWAP_ENABLED = CRC_CRCCTRL_OUTPUT_BYTESWAP_ENABLE,
    DL_CRC_OUTPUT_BYTESWAP_DISABLED = CRC_CRCCTRL_OUTPUT_BYTESWAP_DISABLE
} DL_CRC_OUTPUT_BYTESWAP;

__STATIC_INLINE void DL_CRC_enablePower(CRC_Regs *crc)
{
    crc->GPRCM.PWREN = (CRC_PWREN_KEY_UNLOCK_W | CRC_PWREN_ENABLE_ENABLE);
}

__STATIC_INLINE void DL_CRC_disablePower(CRC_Regs *crc)
{
    crc->GPRCM.PWREN = (CRC_PWREN_KEY_UNLOCK_W | CRC_PWREN_ENABLE_DISABLE);
}

__STATIC_INLINE bool DL_CRC_isPowerEnabled(const CRC_Regs *crc)
{
    return (
        (crc->GPRCM.PWREN & CRC_PWREN_ENABLE_MASK) == CRC_PWREN_ENABLE_ENABLE);
}

__STATIC_INLINE void DL_CRC_reset(CRC_Regs *crc)
{
    crc->GPRCM.RSTCTL =
        (CRC_RSTCTL_KEY_UNLOCK_W | CRC_RSTCTL_RESETSTKYCLR_CLR |
            CRC_RSTCTL_RESETASSERT_ASSERT);
}

__STATIC_INLINE bool DL_CRC_isReset(const CRC_Regs *crc)
{
    return ((crc->GPRCM.STAT & CRC_STAT_RESETSTKY_MASK) ==
            CRC_STAT_RESETSTKY_RESET);
}

__STATIC_INLINE void DL_CRC_init(CRC_Regs *crc, DL_CRC_POLYNOMIAL poly,
    DL_CRC_BIT bitOrd, DL_CRC_INPUT_ENDIANESS inEndianness,
    DL_CRC_OUTPUT_BYTESWAP outByteSwap)
{
    crc->CRCCTRL = ((uint32_t) poly | (uint32_t) bitOrd |
                    (uint32_t) inEndianness | (uint32_t) outByteSwap);
}

__STATIC_INLINE void DL_CRC_setSeed16(CRC_Regs *crc, uint16_t seed)
{
    volatile uintptr_t addr;
    volatile uint16_t *pRef;

    addr = (uintptr_t)((volatile uintptr_t *) &crc->CRCSEED);
    pRef = (volatile uint16_t *) addr;

    *pRef = seed;
}

__STATIC_INLINE void DL_CRC_setSeed32(CRC_Regs *crc, uint32_t seed)
{
    crc->CRCSEED = seed;
}

__STATIC_INLINE void DL_CRC_feedData8(CRC_Regs *crc, uint8_t dataIn)
{
    volatile uint8_t *pRef = (volatile uint8_t *) &crc->CRCIN;
    *pRef                  = dataIn;
}

__STATIC_INLINE void DL_CRC_feedData16(CRC_Regs *crc, uint16_t dataIn)
{
    volatile uintptr_t addr;
    volatile uint16_t *pRef;

    addr = (uintptr_t)((volatile uintptr_t *) &crc->CRCIN);
    pRef = (volatile uint16_t *) addr;

    *pRef = dataIn;
}

__STATIC_INLINE void DL_CRC_feedData32(CRC_Regs *crc, uint32_t dataIn)
{
    crc->CRCIN = dataIn;
}

__STATIC_INLINE uint16_t DL_CRC_getResult16(const CRC_Regs *crc)
{
    return ((uint16_t) crc->CRCOUT);
}

__STATIC_INLINE uint32_t DL_CRC_getResult32(const CRC_Regs *crc)
{
    return (crc->CRCOUT);
}

extern uint32_t DL_CRC_calculateBlock32(
    CRC_Regs *crc, uint32_t seed, const uint32_t *ptr, uint32_t size);

extern uint32_t DL_CRC_calculateMemoryRange32(
    CRC_Regs *crc, uint32_t seed, uint32_t *ptrStart, const uint32_t *ptrEnd);

extern uint16_t DL_CRC_calculateBlock16(
    CRC_Regs *crc, uint16_t seed, const uint16_t *ptr, uint16_t size);

extern uint16_t DL_CRC_calculateMemoryRange16(
    CRC_Regs *crc, uint16_t seed, uint16_t *ptrStart, const uint16_t *ptrEnd);

__STATIC_INLINE uintptr_t DL_CRC_getCRCINAddr(const CRC_Regs *crc)
{
    return ((uintptr_t) &crc->CRCIN);
}
#ifdef __cplusplus
}
#endif

#endif /* __MSPM0_HAS_CRC__ */

#endif /* ti_dl_dl_crc__include */