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
 *
 * 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
 
/* 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
 
enum crc_type {
 CRC4, 
 CRC4_TI, 
 CRC7_BE, 
 CRC8, 
 CRC8_CCITT, 
 CRC16, 
 CRC16_ANSI, 
 CRC16_CCITT, 
 CRC16_ITU_T, 
 CRC24_PGP, 
 CRC32_C, 
 CRC32_IEEE, 
};
 
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);
 
uint8_t crc8_ccitt(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);
 
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 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);
 default:
 break;
 }
 
 __ASSERT_NO_MSG(false);
 return -1;
}
 
#ifdef __cplusplus
}
#endif
 
#endif