include/u-boot/crc.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  * (C) Copyright 2009
   4  * Marvell Semiconductor <www.marvell.com>
   5  * Written-by: Prafulla Wadaskar <prafulla@marvell.com>
   6  */
   7
   8 #ifndef _UBOOT_CRC_H
   9 #define _UBOOT_CRC_H
  10
  11 #include <compiler.h> /* 'uint*' definitions */
  12
  13 /**
  14  * crc8() - Calculate and return CRC-8 of the data
  15  *
  16  * This uses an x^8 + x^2 + x + 1 polynomial.  A table-based algorithm would
  17  * be faster, but for only a few bytes it isn't worth the code size
  18  *
  19  * lib/crc8.c
  20  *
  21  * @crc_start: CRC8 start value
  22  * @vptr: Buffer to checksum
  23  * @len: Length of buffer in bytes
  24  * Return: CRC8 checksum
  25  */
  26 unsigned int crc8(unsigned int crc_start, const unsigned char *vptr, int len);
  27
  28 /* lib/crc16.c - 16 bit CRC with polynomial x^16 + x^15 + x^2 + 1 */
  29 uint16_t crc16(uint16_t crc, const unsigned char *buffer, size_t len);
  30
  31 /* lib/crc16-ccitt.c - 16 bit CRC with polynomial x^16+x^12+x^5+1 (CRC-CCITT) */
  32 uint16_t crc16_ccitt(uint16_t crc_start, const unsigned char *s, int len);
  33 /**
  34  * crc16_ccitt_wd_buf - Perform CRC16-CCIT on an input buffer and return the
  35  *                      16-bit result (network byte-order) in an output buffer
  36  *
  37  * @in: input buffer
  38  * @len: input buffer length
  39  * @out: output buffer (at least 2 bytes)
  40  * @chunk_sz: ignored
  41  */
  42 void crc16_ccitt_wd_buf(const uint8_t *in, uint len,
  43                         uint8_t *out, uint chunk_sz);
  44
  45 /* lib/crc32.c */
  46
  47 /**
  48  * crc32 - Calculate the CRC32 for a block of data
  49  *
  50  * @crc: Input crc to chain from a previous calculution (use 0 to start a new
  51  *      calculation)
  52  * @buf: Bytes to checksum
  53  * @len: Number of bytes to checksum
  54  * Return: checksum value
  55  */
  56 uint32_t crc32(uint32_t crc, const unsigned char *buf, uint len);
  57
  58 /**
  59  * crc32_wd - Calculate the CRC32 for a block of data (watchdog version)
  60  *
  61  * This checksums the data @chunk_sz bytes at a time, calling WATCHDOG_RESET()
  62  * after each chunk, to prevent the watchdog from firing.
  63  *
  64  * @crc: Input crc to chain from a previous calculution (use 0 to start a new
  65  *      calculation)
  66  * @buf: Bytes to checksum
  67  * @len: Number of bytes to checksum
  68  * @chunk_sz: Chunk size to use between watchdog resets
  69  * Return: checksum
  70  */
  71 uint32_t crc32_wd(uint32_t crc, const unsigned char *buf, uint len,
  72                   uint chunk_sz);
  73
  74 /**
  75  * crc32_no_comp - Calculate the CRC32 for a block of data (no one's compliment)
  76  *
  77  * This version uses a different algorithm which doesn't use one's compliment.
  78  * JFFS2 (and other things?) use this.
  79  *
  80  * @crc: Input crc to chain from a previous calculution (use 0 to start a new
  81  *      calculation)
  82  * @buf: Bytes to checksum
  83  * @len: Number of bytes to checksum
  84  * Return: checksum value
  85  */
  86 uint32_t crc32_no_comp(uint32_t crc, const unsigned char *buf, uint len);
  87
  88 /**
  89  * crc32_wd_buf - Perform CRC32 on a buffer and return result in buffer
  90  *
  91  * @input:      Input buffer
  92  * @ilen:       Input buffer length
  93  * @output:     Place to put checksum result (4 bytes)
  94  * @chunk_sz:   Trigger watchdog after processing this many bytes
  95  */
  96 void crc32_wd_buf(const uint8_t *input, uint ilen, uint8_t *output,
  97                   uint chunk_sz);
  98
  99 /* lib/crc32c.c */
 100
 101 /**
 102  * crc32c_init() - Set up a the CRC32 table
 103  *
 104  * This sets up 256-item table to aid in CRC32 calculation
 105  *
 106  * @crc32c_table: Place to put table
 107  * @pol: polynomial to use
 108  */
 109 void crc32c_init(uint32_t *crc32c_table, uint32_t pol);
 110
 111 /**
 112  * crc32c_cal() - Perform CRC32 on a buffer given a table
 113  *
 114  * This algorithm uses the table (set up by crc32c_init() to speed up
 115  * processing.
 116  *
 117  * @crc: Previous crc (use 0 at start)
 118  * @data: Data bytes to checksum
 119  * @length: Number of bytes to process
 120  * @crc32c_table:: CRC table
 121  * Return: checksum value
 122  */
 123 uint32_t crc32c_cal(uint32_t crc, const char *data, int length,
 124                     uint32_t *crc32c_table);
 125
 126 #endif /* _UBOOT_CRC_H */