HardwareCRC.h

Go to the documentation of this file.

 
#ifndef HARDWARECRC_H_
#define HARDWARECRC_H_
 
#ifndef SIMULATION
#include "wirish.h"
#else
#include "Simulation.h"
#endif
 
 
#define CRC_X0      (0x01UL)
#define CRC_X1      (0x01UL << 1U)
#define CRC_X2      (0x01UL << 2U)
#define CRC_X3      (0x01UL << 3U)
#define CRC_X4      (0x01UL << 4U)
#define CRC_X5      (0x01UL << 5U)
#define CRC_X6      (0x01UL << 6U)
#define CRC_X7      (0x01UL << 7U)
#define CRC_X8      (0x01UL << 8U)
#define CRC_X9      (0x01UL << 9U)
#define CRC_X10     (0x01UL << 10U)
#define CRC_X11     (0x01UL << 11U)
#define CRC_X12     (0x01UL << 12U)
#define CRC_X13     (0x01UL << 13U)
#define CRC_X14     (0x01UL << 14U)
#define CRC_X15     (0x01UL << 15U)
#define CRC_X16     (0x01UL << 16U)
#define CRC_X17     (0x01UL << 17U)
#define CRC_X18     (0x01UL << 18U)
#define CRC_X19     (0x01UL << 19U)
#define CRC_X20     (0x01UL << 20U)
#define CRC_X21     (0x01UL << 21U)
#define CRC_X22     (0x01UL << 22U)
#define CRC_X23     (0x01UL << 23U)
#define CRC_X24     (0x01UL << 24U)
#define CRC_X25     (0x01UL << 25U)
#define CRC_X26     (0x01UL << 26U)
#define CRC_X27     (0x01UL << 27U)
#define CRC_X28     (0x01UL << 28U)
#define CRC_X29     (0x01UL << 29U)
#define CRC_X30     (0x01UL << 30U)
#define CRC_X31     (0x01UL << 31U)
 
//Mostly used polynomials
#define CRC32_POLY          (0x04C11DB7UL)  /* X^32 + X^26 + X^23 + X^22 + X^16 + X^12 + X^11 + X^10 +X^8 + X^7 + X^5 + X^4 + X^2+ X +1 */
#define CRC16_POLY          (0x8005UL)  /* X^16 + X^15 + X^2 + 1 - IBM CRC polynomial*/
#define CRC8_POLY           (0x31UL)  /* X^8 + X^5 + X^4 + 1 - I2C CRC polynomial*/
#define CRC7_POLY           (0x09UL)  /* X^7 + X^3 + 1 */
 
#define DEFAULT_HCRC_INITVAL        (0xFFFFFFFFUL) //Default initial value
 
//Polynomial size CR register mask
#define HCRC_POLYSIZE_MASK  (0x18)  //B00011000
//Polynomial size values
#define HCRC_32BIT_POLYSIZE (0x00)
#define HCRC_16BIT_POLYSIZE (0x08)
#define HCRC_8BIT_POLYSIZE  (0x10)
#define HCRC_7BIT_POLYSIZE  (HCRC_POLYSIZE_MASK)
 
//Output reverse CR register mask
#define HCRC_OUT_REVERSE_MASK       (0x80)  //B10000000
//Output reverse values
#define HCRC_OUT_REVERSE_ENABLED    HCRC_OUT_REVERSE_MASK
#define HCRC_OUT_REVERSE_DISABLED   (0x0)
 
//Input reverse CR register mask
#define HCRC_IN_REVERSE_MASK                (0x60)  //B01100000
//Input reverse values
#define HCRC_IN_REVERSE_ENABLED_BYTE        (0x20)
#define HCRC_IN_REVERSE_ENABLED_HALFWORD    (0x40)
#define HCRC_IN_REVERSE_ENABLED_WORD        HCRC_IN_REVERSE_MASK
#define HCRC_IN_REVERSE_DISABLED            (0x0)
 
 
 
class HardwareCRC{
public:
 
    bool begin() {
        return true;
    }
 
    bool setPolynomial7(uint32_t polynomial = CRC7_POLY) {
        return true;
    }
 
    bool setPolynomial8(uint32_t polynomial = CRC8_POLY) {
        return true;
    }
 
    bool setPolynomial16(uint32_t polynomial = CRC16_POLY) {
        return true;
    }
 
    bool setPolynomial32(uint32_t polynomial = CRC32_POLY) {
        return true;
    }
 
    inline uint32_t getPolynomial(){
        return CRC32_POLY;
    }
 
    uint8_t getPolynomialLength() {
        return 32;
    }
 
    inline uint32_t getInitValue(){
        return 0xFFFFFFFFUL;
    }
 
    inline uint32_t getLastCRC(uint32_t finalXOR = 0x00){
        return 0;
    }
 
    void reset(uint32_t initValue = DEFAULT_HCRC_INITVAL) {
    }
 
    uint32_t append(const uint8_t data, uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    uint32_t append(const uint8_t* data, uint32_t dataLength, uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    uint32_t append(const int8_t* data, uint32_t dataLength, uint32_t finalXOR = 0x00){
        return append((const uint8_t*)data, dataLength, finalXOR);
    }
 
    uint32_t append(const uint16_t data, uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    uint32_t append(const uint16_t* data, uint32_t dataLength, uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    uint32_t append(const int16_t* data, uint32_t dataLength, uint32_t finalXOR = 0x00){
        return append((const uint16_t*)data, dataLength, finalXOR);
    }
 
    uint32_t append(const uint32_t data, uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    uint32_t append(const uint32_t* data, uint32_t dataLength, uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    uint32_t append (const int32_t* data, uint32_t dataLength, uint32_t finalXOR = 0x00){
        return append((const uint32_t*)data, dataLength, finalXOR);
    }
 
    uint32_t compute(const uint8_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    uint32_t compute(const int8_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00){
        return compute((const uint8_t*)data, dataLength, initValue, finalXOR);
    }
 
    uint32_t compute(const uint16_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    uint32_t compute(const int16_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00){
        return compute((const uint16_t*)data, dataLength, initValue, finalXOR);
    }
 
    uint32_t compute(const uint32_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    uint32_t compute(const int32_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00){
        return compute((const uint32_t*)data, dataLength, initValue, finalXOR);
    }
 
    uint32_t computeAndWriteToEnd(uint8_t*  data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    uint32_t computeAndWriteToEnd(int8_t*  data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00){
        return computeAndWriteToEnd((uint8_t*)data, dataLength, initValue, finalXOR);
    }
 
    uint32_t computeAndWriteToEnd(uint16_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    uint32_t computeAndWriteToEnd(int16_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00){
        return computeAndWriteToEnd((uint16_t*)data, dataLength, initValue, finalXOR);
    }
 
    uint32_t computeAndWriteToEnd(uint32_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    uint32_t computeAndWriteToEnd(int32_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00){
        return computeAndWriteToEnd((uint32_t*)data, dataLength, initValue, finalXOR);
    }
 
    bool check(const uint8_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00) {
        return true;
    }
 
    bool check(const int8_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00){
        return check((const uint8_t*)data, dataLength, initValue, finalXOR);
    }
 
    bool check(const uint16_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00) {
        return true;
    }
 
    bool check(const int16_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00){
        return check((const uint16_t*)data, dataLength, initValue, finalXOR);
    }
 
    bool check(const uint32_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00) {
        return true;
    }
 
    bool check(const int32_t* data, uint32_t dataLength, uint32_t initValue = DEFAULT_HCRC_INITVAL, uint32_t finalXOR = 0x00){
        return check((const uint32_t*)data, dataLength, initValue, finalXOR);
    }
 
    uint32_t getCheckValue(uint32_t initValue = DEFAULT_HCRC_INITVAL,uint32_t finalXOR = 0x00) {
        return 0;
    }
 
    bool setInputReverse(bool reverse) {
        return true;
    }
 
    bool setOutputReverse(bool reverse) {
        return true;
    }
 
    inline bool getInputReverse(){
#if CRC_IO_REV_SUPP == (0x1)
        return (inputReverse & HCRC_IN_REVERSE_MASK) != HCRC_IN_REVERSE_DISABLED;
#else
        return true; //Input is reversed by hardware
#endif
    }
 
    inline bool getOutputReverse(){
#if CRC_IO_REV_SUPP == (0x1)
        return (CRC->CR & HCRC_OUT_REVERSE_MASK) == HCRC_OUT_REVERSE_ENABLED;
#else
        return true; //Output is reversed by hardware
#endif
    }
 
    void end() {
    }
 
    /*CRCSettings exportSettings();
 
    void importSettings(CRCSettings settings);*/
 
    static const bool isCustomPolynomialSupported = 0;
 
    static const bool isIOReverseSupported = 0;
 
    static const bool isCustomInitValueSupported = 0;
 
protected:
 
    //Global values used to check, if setting has changed in getCheckValue() method.
    uint8_t lastCR = 0xFF;
#if CRC_CUST_POLY == (0x1)
    uint32_t lastPoly = 0;
#endif
#if CRC_CUST_INIT_VAL == (0x1)
    uint32_t lastInit = 0;
#endif
    uint32_t lastFXOR = 0;
    uint32_t lastCRCCheckValue = 0;
 
/*#if CRC_CUST_INIT_VAL == (0x1)
    uint32_t InitValue = 0xFFFFFFFF;
#endif*/
 
    void setInputReverseSize(uint32_t reverse) {
    }
 
    uint8_t inputReverse = HCRC_IN_REVERSE_DISABLED;
};
 
extern HardwareCRC crc;
 
#endif /* HARDWARECRC_H_ */