crc.h

Go to the documentation of this file.

/*
 * Copyright (c) 2024 Brill Power Ltd.
 * Copyright (c) 2025 Renesas Electronics Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

 
#ifndef ZEPHYR_INCLUDE_DRIVERS_CRC_H
#define ZEPHYR_INCLUDE_DRIVERS_CRC_H
 
#include <zephyr/device.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/crc.h>
 
#ifdef __cplusplus
extern "C" {
#endif



#define CRC_FLAG_REVERSE_INPUT BIT(0)

#define CRC_FLAG_REVERSE_OUTPUT BIT(1)



#define CRC4_INIT_VAL 0x0

#define CRC4_TI_INIT_VAL 0x0

#define CRC7_BE_INIT_VAL 0x0

#define CRC8_INIT_VAL 0x0

#define CRC8_CCITT_INIT_VAL 0xFF

#define CRC8_ROHC_INIT_VAL 0xFF

#define CRC16_INIT_VAL 0x0

#define CRC16_ANSI_INIT_VAL 0x0

#define CRC16_CCITT_INIT_VAL 0x0000

#define CRC16_ITU_T_INIT_VAL 0x0000

#define CRC24_PGP_INIT_VALUE 0x00B704CEU

#define CRC32_C_INIT_VAL 0xFFFFFFFFU

#define CRC32_IEEE_INIT_VAL 0xFFFFFFFFU

#define CRC32_K_4_2_INIT_VAL 0xFFFFFFFFU


 
enum crc_state {
        CRC_STATE_IDLE = 0,
        CRC_STATE_IN_PROGRESS
};

typedef uint32_t crc_init_val_t;

typedef uint32_t crc_poly_t;

typedef uint32_t crc_result_t;

 
struct crc_ctx {
        enum crc_type type;
        enum crc_state state;
        uint32_t reversed;
        crc_poly_t polynomial;
        crc_init_val_t seed;
        crc_result_t result;
};

typedef int (*crc_api_begin)(const struct device *dev, struct crc_ctx *ctx);

typedef int (*crc_api_update)(const struct device *dev, struct crc_ctx *ctx, const void *buffer,
                              size_t bufsize);

typedef int (*crc_api_finish)(const struct device *dev, struct crc_ctx *ctx);
 
__subsystem struct crc_driver_api {
        crc_api_begin begin;
        crc_api_update update;
        crc_api_finish finish;
};

__syscall int crc_begin(const struct device *dev, struct crc_ctx *ctx);
 
static inline int z_impl_crc_begin(const struct device *dev, struct crc_ctx *ctx)
{
        const struct crc_driver_api *api = (const struct crc_driver_api *)dev->api;
 
        if (api->begin == NULL) {
                return -ENOSYS;
        }
 
        return api->begin(dev, ctx);
}

__syscall int crc_update(const struct device *dev, struct crc_ctx *ctx, const void *buffer,
                         size_t bufsize);
 
static inline int z_impl_crc_update(const struct device *dev, struct crc_ctx *ctx,
                                    const void *buffer, size_t bufsize)
{
        const struct crc_driver_api *api = (const struct crc_driver_api *)dev->api;
 
        if (api->update == NULL) {
                return -ENOSYS;
        }
 
        return api->update(dev, ctx, buffer, bufsize);
}

__syscall int crc_finish(const struct device *dev, struct crc_ctx *ctx);
 
static inline int z_impl_crc_finish(const struct device *dev, struct crc_ctx *ctx)
{
        const struct crc_driver_api *api = (const struct crc_driver_api *)dev->api;
 
        if (api->finish == NULL) {
                return -ENOSYS;
        }
 
        return api->finish(dev, ctx);
}

static inline int crc_verify(struct crc_ctx *ctx, crc_result_t expected)
{
        if (ctx == NULL) {
                return -EINVAL;
        }
 
        if (ctx->state == CRC_STATE_IN_PROGRESS) {
                return -EBUSY;
        }
 
        if (expected != ctx->result) {
                return -EPERM;
        }
 
        return 0;
}

 
#ifdef __cplusplus
}
#endif
 
#include <zephyr/syscalls/crc.h>
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_CRC_H */