dl_crcp.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023, 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_crcp.h
 *  @brief      Cyclic Redundancy Check with Configurable Polynomial (CRCP) Driver Library
 *  @defgroup   CRCP Cyclic Redundancy Check with Configurable Polynomial (CRCP)
 *
 *  @anchor ti_dl_dl_crcp_Overview
 *  # Overview
 *
 *  The CRCP DriverLib allows full configuration of the MSPM0 CRCP module.
 *  The cyclic redundancy check (CRC) accelerator generates signatures for a
 *  given data sequence based on a user-configured polynomial, allowing for
 *  support of any 16-bit or 32-bit polynomial including but not limited to:
 *      * CRC32-IS03309
 *      * CRC16-ITT
 *      * CRC-32C
 *      * CRC-32K
 *      * CRC-16-Profibus
 *
 *  <hr>
 ******************************************************************************
 */
#ifndef ti_dl_dl_crcp__include
#define ti_dl_dl_crcp__include

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

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

#ifdef __MSPM0_HAS_CRCP__

#ifdef __cplusplus
extern "C" {
#endif

/* clang-format off */

#define DL_CRC_POLYNOMIAL_SIZE_16                    DL_CRCP_POLYNOMIAL_SIZE_16

#define DL_CRC_POLYNOMIAL_SIZE_32                    DL_CRCP_POLYNOMIAL_SIZE_32

#define DL_CRC_BIT_REVERSED                                DL_CRCP_BIT_REVERSED

#define DL_CRC_BIT_NOT_REVERSED                        DL_CRCP_BIT_NOT_REVERSED

#define DL_CRC_INPUT_ENDIANESS_LITTLE_ENDIAN                                  \
                                           DL_CRCP_INPUT_ENDIANESS_LITTLE_ENDIAN

#define DL_CRC_INPUT_ENDIANESS_BIG_ENDIAN    DL_CRCP_INPUT_ENDIANESS_BIG_ENDIAN

#define DL_CRC_OUTPUT_BYTESWAP_ENABLED          DL_CRCP_OUTPUT_BYTESWAP_ENABLED

#define DL_CRC_OUTPUT_BYTESWAP_DISABLED        DL_CRCP_OUTPUT_BYTESWAP_DISABLED

#define DL_CRC_CRCPOLY_POLYNOMIAL_32_MPEG2  DL_CRCP_CRCPOLY_POLYNOMIAL_32_MPEG2

#define DL_CRC_CRCPOLY_POLYNOMIAL_32_Q          DL_CRCP_CRCPOLY_POLYNOMIAL_32_Q

#define DL_CRC_CRCPOLY_POLYNOMIAL_32_JAMCRC                                   \
                                            DL_CRCP_CRCPOLY_POLYNOMIAL_32_JAMCRC

#define DL_CRC_CRCPOLY_POLYNOMIAL_32_XFER                                     \
                                              DL_CRCP_CRCPOLY_POLYNOMIAL_32_XFER

#define DL_CRC_CRCPOLY_POLYNOMIAL_32_MPEG2  DL_CRCP_CRCPOLY_POLYNOMIAL_32_MPEG2

#define DL_CRC_CRCPOLY_POLYNOMIAL_16_CCIT_ZERO                                \
                                         DL_CRCP_CRCPOLY_POLYNOMIAL_16_CCIT_ZERO

#define DL_CRC_CRCPOLY_POLYNOMIAL_16_ARC                                      \
                                               DL_CRCP_CRCPOLY_POLYNOMIAL_16_ARC

#define DL_CRC_CRCPOLY_POLYNOMIAL_16_AUG_CCIT                                 \
                                          DL_CRCP_CRCPOLY_POLYNOMIAL_16_AUG_CCIT

#define DL_CRC_CRCPOLY_POLYNOMIAL_16_BUYPASS                                  \
                                           DL_CRCP_CRCPOLY_POLYNOMIAL_16_BUYPASS

#define DL_CRC_CRCPOLY_POLYNOMIAL_16_CCIT_FALSE                               \
                                        DL_CRCP_CRCPOLY_POLYNOMIAL_16_CCIT_FALSE

#define DL_CRC_CRCPOLY_POLYNOMIAL_16_CDMA2000                                 \
                                          DL_CRCP_CRCPOLY_POLYNOMIAL_16_CDMA2000

#define DL_CRC_CRCPOLY_POLYNOMIAL_16_MODBUS                                   \
                                            DL_CRCP_CRCPOLY_POLYNOMIAL_16_MODBUS

#define DL_CRC_CRCSEED_SEED_32_MPEG2              DL_CRCP_CRCSEED_SEED_32_MPEG2

#define DL_CRC_CRCSEED_SEED_32_Q                      DL_CRCP_CRCSEED_SEED_32_Q

#define DL_CRC_CRCSEED_SEED_32_JAMCRC            DL_CRCP_CRCSEED_SEED_32_JAMCRC

#define DL_CRC_CRCSEED_SEED_32_XFER                DL_CRCP_CRCSEED_SEED_32_XFER

#define DL_CRC_CRCSEED_SEED_32_MPEG2              DL_CRCP_CRCSEED_SEED_32_MPEG2

#define DL_CRC_CRCSEED_SEED_16_AUG_CCIT        DL_CRCP_CRCSEED_SEED_16_AUG_CCIT

#define DL_CRC_CRCSEED_SEED_16_BUYPASS          DL_CRCP_CRCSEED_SEED_16_BUYPASS

#define DL_CRC_CRCSEED_SEED_16_CCIT_FALSE    DL_CRCP_CRCSEED_SEED_16_CCIT_FALSE

#define DL_CRC_CRCSEED_SEED_16_CDMA2000        DL_CRCP_CRCSEED_SEED_16_CDMA2000

#define DL_CRC_CRCSEED_SEED_16_MODBUS            DL_CRCP_CRCSEED_SEED_16_MODBUS

#define DL_CRC_enablePower                                   DL_CRCP_enablePower

#define DL_CRC_isPowerEnabled                             DL_CRCP_isPowerEnabled

#define DL_CRC_reset                                               DL_CRCP_reset

#define DL_CRC_isReset                                           DL_CRCP_isReset

#define DL_CRC_init                                                 DL_CRCP_init

#define DL_CRC_setSeed16                                       DL_CRCP_setSeed16

#define DL_CRC_setSeed32                                       DL_CRCP_setSeed32

#define DL_CRC_feedData8                                       DL_CRCP_feedData8

#define DL_CRC_feedData16                                     DL_CRCP_feedData16

#define DL_CRC_feedData32                                     DL_CRCP_feedData32

#define DL_CRC_getResult16                                   DL_CRCP_getResult16

#define DL_CRC_getResult32                                   DL_CRCP_getResult32

#define DL_CRC_setPolynomial                               DL_CRCP_setPolynomial

#define DL_CRC_getPolynomial                               DL_CRCP_getPolynomial

#define DL_CRC_calculateBlock32                         DL_CRCP_calculateBlock32

#define DL_CRC_calculateMemoryRange32             DL_CRCP_calculateMemoryRange32

#define DL_CRC_calculateBlock16                         DL_CRCP_calculateBlock16

#define DL_CRC_calculateMemoryRange16             DL_CRCP_calculateMemoryRange16

#define DL_CRC_getCRCINAddr                                 DL_CRCP_getCRCINAddr

/* clang-format on */

typedef enum {
    DL_CRCP_POLYNOMIAL_SIZE_16 = CRCP_CRCCTRL_POLYSIZE_CRC16,
    DL_CRCP_POLYNOMIAL_SIZE_32 = CRCP_CRCCTRL_POLYSIZE_CRC32
} DL_CRCP_POLYNOMIAL_SIZE;

typedef enum {
    DL_CRCP_BIT_REVERSED = CRCP_CRCCTRL_BITREVERSE_REVERSED,
    DL_CRCP_BIT_NOT_REVERSED = CRCP_CRCCTRL_BITREVERSE_NOT_REVERSED
} DL_CRCP_BIT;

typedef enum {
    DL_CRCP_INPUT_ENDIANESS_LITTLE_ENDIAN =
        CRCP_CRCCTRL_INPUT_ENDIANNESS_LITTLE_ENDIAN,
    DL_CRCP_INPUT_ENDIANESS_BIG_ENDIAN =
        CRCP_CRCCTRL_INPUT_ENDIANNESS_BIG_ENDIAN
} DL_CRCP_INPUT_ENDIANESS;

typedef enum {
    DL_CRCP_OUTPUT_BYTESWAP_ENABLED = CRCP_CRCCTRL_OUTPUT_BYTESWAP_ENABLE,
    DL_CRCP_OUTPUT_BYTESWAP_DISABLED = CRCP_CRCCTRL_OUTPUT_BYTESWAP_DISABLE
} DL_CRCP_OUTPUT_BYTESWAP;

typedef enum {

    DL_CRCP_CRCPOLY_POLYNOMIAL_32_MPEG2 = 0x04C11DB7,
    DL_CRCP_CRCPOLY_POLYNOMIAL_32_Q = 0x814141AB,
    DL_CRCP_CRCPOLY_POLYNOMIAL_32_JAMCRC = 0x04C11DB7,
    DL_CRCP_CRCPOLY_POLYNOMIAL_32_XFER = 0x000000AF,
    DL_CRCP_CRCPOLY_POLYNOMIAL_16_CCIT_ZERO = 0x00001021,
    DL_CRCP_CRCPOLY_POLYNOMIAL_16_ARC = 0x00001DCF,
    DL_CRCP_CRCPOLY_POLYNOMIAL_16_AUG_CCIT = 0x00001021,
    DL_CRCP_CRCPOLY_POLYNOMIAL_16_BUYPASS = 0x00008005,
    DL_CRCP_CRCPOLY_POLYNOMIAL_16_CCIT_FALSE = 0x00001021,
    DL_CRCP_CRCPOLY_POLYNOMIAL_16_CDMA2000 = 0x0000C867,
    DL_CRCP_CRCPOLY_POLYNOMIAL_16_MODBUS = 0x00008005,

} DL_CRCP_CRCPOLY_POLYNOMIAL;

typedef enum {

    DL_CRCP_CRCSEED_SEED_32_MPEG2 = 0xFFFFFFFF,
    DL_CRCP_CRCSEED_SEED_32_Q = 0x00000000,
    DL_CRCP_CRCSEED_SEED_32_JAMCRC = 0xFFFFFFFF,
    DL_CRCP_CRCSEED_SEED_32_XFER = 0x00000000,
    DL_CRCP_CRCSEED_SEED_16_CCIT_ZERO = 0x0000,
    DL_CRCP_CRCSEED_SEED_16_ARC = 0x0000,
    DL_CRCP_CRCSEED_SEED_16_AUG_CCIT = 0x1D0F,
    DL_CRCP_CRCSEED_SEED_16_BUYPASS = 0x0000,
    DL_CRCP_CRCSEED_SEED_16_CCIT_FALSE = 0xFFFF,
    DL_CRCP_CRCSEED_SEED_16_CDMA2000 = 0xFFFF,
    DL_CRCP_CRCSEED_SEED_16_MODBUS = 0xFFFF,

} DL_CRCP_CRCSEED_SEED;

__STATIC_INLINE void DL_CRCP_enablePower(CRCP_Regs *crcp)
{
    crcp->GPRCM.PWREN = (CRCP_PWREN_KEY_UNLOCK_W | CRCP_PWREN_ENABLE_ENABLE);
}

__STATIC_INLINE void DL_CRCP_disablePower(CRCP_Regs *crcp)
{
    crcp->GPRCM.PWREN = (CRCP_PWREN_KEY_UNLOCK_W | CRCP_PWREN_ENABLE_DISABLE);
}

__STATIC_INLINE bool DL_CRCP_isPowerEnabled(const CRCP_Regs *crcp)
{
    return ((crcp->GPRCM.PWREN & CRCP_PWREN_ENABLE_MASK) ==
            CRCP_PWREN_ENABLE_ENABLE);
}

__STATIC_INLINE void DL_CRCP_reset(CRCP_Regs *crcp)
{
    crcp->GPRCM.RSTCTL =
        (CRCP_RSTCTL_KEY_UNLOCK_W | CRCP_RSTCTL_RESETSTKYCLR_CLR |
            CRCP_RSTCTL_RESETASSERT_ASSERT);
}

__STATIC_INLINE bool DL_CRCP_isReset(const CRCP_Regs *crcp)
{
    return ((crcp->GPRCM.STAT & CRCP_STAT_RESETSTKY_MASK) ==
            CRCP_STAT_RESETSTKY_RESET);
}

__STATIC_INLINE void DL_CRCP_init(CRCP_Regs *crcp,
    DL_CRCP_POLYNOMIAL_SIZE polySize, DL_CRCP_BIT bitOrd,
    DL_CRCP_INPUT_ENDIANESS inEndianness, DL_CRCP_OUTPUT_BYTESWAP outByteSwap)
{
    crcp->CRCCTRL = ((uint32_t) polySize | (uint32_t) bitOrd |
                     (uint32_t) inEndianness | (uint32_t) outByteSwap);
}

__STATIC_INLINE void DL_CRCP_setSeed16(CRCP_Regs *crcp, uint16_t seed)
{
    volatile uintptr_t addr;
    volatile uint16_t *pRef;

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

    *pRef = seed;
}

__STATIC_INLINE void DL_CRCP_setSeed32(CRCP_Regs *crcp, uint32_t seed)
{
    crcp->CRCSEED = seed;
}

__STATIC_INLINE void DL_CRCP_feedData8(CRCP_Regs *crcp, uint8_t dataIn)
{
    volatile uint8_t *pRef = (volatile uint8_t *) &crcp->CRCIN;
    *pRef                  = dataIn;
}

__STATIC_INLINE void DL_CRCP_feedData16(CRCP_Regs *crcp, uint16_t dataIn)
{
    volatile uintptr_t addr;
    volatile uint16_t *pRef;

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

    *pRef = dataIn;
}

__STATIC_INLINE void DL_CRCP_feedData32(CRCP_Regs *crcp, uint32_t dataIn)
{
    crcp->CRCIN = dataIn;
}

__STATIC_INLINE uint16_t DL_CRCP_getResult16(const CRCP_Regs *crcp)
{
    return ((uint16_t) crcp->CRCOUT);
}

__STATIC_INLINE uint32_t DL_CRCP_getResult32(const CRCP_Regs *crcp)
{
    return (crcp->CRCOUT);
}

__STATIC_INLINE void DL_CRCP_setPolynomial(CRCP_Regs *crcp, uint32_t poly)
{
    crcp->CRCPOLY = poly;
}

__STATIC_INLINE uint32_t DL_CRCP_getPolynomial(const CRCP_Regs *crcp)
{
    return (crcp->CRCPOLY);
}

extern uint32_t DL_CRCP_calculateBlock32(
    CRCP_Regs *crcp, uint32_t seed, const uint32_t *ptr, uint32_t size);

extern uint32_t DL_CRCP_calculateMemoryRange32(CRCP_Regs *crcp, uint32_t seed,
    uint32_t *ptrStart, const uint32_t *ptrEnd);

extern uint16_t DL_CRCP_calculateBlock16(
    CRCP_Regs *crcp, uint16_t seed, const uint16_t *ptr, uint16_t size);

extern uint16_t DL_CRCP_calculateMemoryRange16(CRCP_Regs *crcp, uint16_t seed,
    uint16_t *ptrStart, const uint16_t *ptrEnd);

__STATIC_INLINE uintptr_t DL_CRCP_getCRCINAddr(const CRCP_Regs *crcp)
{
    return ((uintptr_t) &crcp->CRCIN);
}
#ifdef __cplusplus
}
#endif

#endif /* __MSPM0_HAS_CRCP__ */

#endif /* ti_dl_DL_CRCP__include */