crc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Workaround GmbH.
 * Copyright (c) 2017 Intel Corporation.
 * Copyright (c) 2017 Nordic Semiconductor ASA
 * Copyright (c) 2015 Runtime Inc
 * Copyright (c) 2018 Google LLC.
 * Copyright (c) 2022 Meta
 * Copyright (c) 2024 Intercreate, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_SYS_CRC_H_
#define ZEPHYR_INCLUDE_SYS_CRC_H_
 
#include <zephyr/types.h>
#include <stdbool.h>
#include <stddef.h>
 
#include <zephyr/sys/__assert.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Initial value expected to be used at the beginning of the crc8_ccitt
 * computation.
 */
#define CRC8_CCITT_INITIAL_VALUE 0xFF
#define CRC8_ROHC_INITIAL_VALUE  0xFF
 
/* Initial value expected to be used at the beginning of the OpenPGP CRC-24 computation. */
#define CRC24_PGP_INITIAL_VALUE 0x00B704CEU
/*
 * The CRC-24 value is stored on a 32-bit value, only the 3 least significant bytes
 * are meaningful. Use the following mask to only keep the CRC-24 value.
 */
#define CRC24_FINAL_VALUE_MASK 0x00FFFFFFU




#define CRC4_POLY 0x3

#define CRC4_REFLECT_POLY 0xC

#define CRC7_BE_POLY 0x09

#define CRC8_POLY 0x07

#define CRC8_REFLECT_POLY 0xE0

#define CRC16_POLY 0x8005

#define CRC16_REFLECT_POLY 0xA001

#define CRC16_CCITT_POLY 0x1021

#define CRC24_PGP_POLY 0x01864CFBU

#define CRC32_IEEE_POLY 0x04C11DB7U

#define CRC32C_POLY 0x1EDC6F41U

#define CRC32K_4_2_POLY 0x93A409EBU


enum crc_type {
        CRC4,        
        CRC4_TI,     
        CRC7_BE,     
        CRC8,        
        CRC8_CCITT,  
        CRC8_ROHC,   
        CRC16,       
        CRC16_ANSI,  
        CRC16_CCITT, 
        CRC16_ITU_T, 
        CRC24_PGP,   
        CRC32_C,     
        CRC32_IEEE,  
        CRC32_K_4_2, 
};

uint16_t crc16(uint16_t poly, uint16_t seed, const uint8_t *src, size_t len);

uint16_t crc16_reflect(uint16_t poly, uint16_t seed, const uint8_t *src, size_t len);
uint8_t crc8(const uint8_t *src, size_t len, uint8_t polynomial, uint8_t initial_value,
             bool reversed);

uint16_t crc16_ccitt(uint16_t seed, const uint8_t *src, size_t len);

uint16_t crc16_itu_t(uint16_t seed, const uint8_t *src, size_t len);

static inline uint16_t crc16_ansi(const uint8_t *src, size_t len)
{
        return crc16_reflect(0xA001, 0xffff, src, len);
}

uint32_t crc32_ieee(const uint8_t *data, size_t len);

uint32_t crc32_ieee_update(uint32_t crc, const uint8_t *data, size_t len);

uint32_t crc32_c(uint32_t crc, const uint8_t *data,
                 size_t len, bool first_pkt, bool last_pkt);

uint32_t crc32_k_4_2_update(uint32_t crc, const uint8_t *data, size_t len);

uint8_t crc8_ccitt(uint8_t initial_value, const void *buf, size_t len);

uint8_t crc8_rohc(uint8_t initial_value, const void *buf, size_t len);

uint8_t crc7_be(uint8_t seed, const uint8_t *src, size_t len);

uint8_t crc4_ti(uint8_t seed, const uint8_t *src, size_t len);

uint8_t crc4(const uint8_t *src, size_t len, uint8_t polynomial, uint8_t initial_value,
             bool reversed);

uint32_t crc24_pgp(const uint8_t *data, size_t len);

uint32_t crc24_pgp_update(uint32_t crc, const uint8_t *data, size_t len);

uint32_t crc24q_rtcm3(const uint8_t *data, size_t len);

static inline uint32_t crc_by_type(enum crc_type type, const uint8_t *src, size_t len,
                                   uint32_t seed, uint32_t poly, bool reflect, bool first,
                                   bool last)
{
        switch (type) {
        case CRC4:
                return crc4(src, len, poly, seed, reflect);
        case CRC4_TI:
                return crc4_ti(seed, src, len);
        case CRC7_BE:
                return crc7_be(seed, src, len);
        case CRC8:
                return crc8(src, len, poly, seed, reflect);
        case CRC8_CCITT:
                return crc8_ccitt(seed, src, len);
        case CRC8_ROHC:
                return crc8_rohc(seed, src, len);
        case CRC16:
                if (reflect) {
                        return crc16_reflect(poly, seed, src, len);
                } else {
                        return crc16(poly, seed, src, len);
                }
        case CRC16_ANSI:
                return crc16_ansi(src, len);
        case CRC16_CCITT:
                return crc16_ccitt(seed, src, len);
        case CRC16_ITU_T:
                return crc16_itu_t(seed, src, len);
        case CRC24_PGP: {
                uint32_t crc = crc24_pgp_update(seed, src, len);
 
                if (last) {
                        crc &= CRC24_FINAL_VALUE_MASK;
                }
                return crc;
        }
        case CRC32_C:
                return crc32_c(seed, src, len, first, last);
        case CRC32_IEEE:
                return crc32_ieee_update(seed, src, len);
        case CRC32_K_4_2:
                return crc32_k_4_2_update(seed, src, len);
        default:
                break;
        }
 
        __ASSERT_NO_MSG(false);
        return -1;
}

 
#ifdef __cplusplus
}
#endif
 
#endif