crypto_engine.c | Explore in Territory

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Handle async block request by crypto hardware engine.
 *
 * Copyright (C) 2016 Linaro, Inc.
 *
 * Author: Baolin Wang <[email protected]>
 */

#include <crypto/internal/aead.h>
#include <crypto/internal/akcipher.h>
#include <crypto/internal/engine.h>
#include <crypto/internal/hash.h>
#include <crypto/internal/kpp.h>
#include <crypto/internal/skcipher.h>
#include <linux/err.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <uapi/linux/sched/types.h>
#include "internal.h"

#define CRYPTO_ENGINE_MAX_QLEN …

/* Temporary algorithm flag used to indicate an updated driver. */
#define CRYPTO_ALG_ENGINE …

struct crypto_engine_alg { … };

/**
 * crypto_finalize_request - finalize one request if the request is done
 * @engine: the hardware engine
 * @req: the request need to be finalized
 * @err: error number
 */
static void crypto_finalize_request(struct crypto_engine *engine,
				    struct crypto_async_request *req, int err)
{ … }

/**
 * crypto_pump_requests - dequeue one request from engine queue to process
 * @engine: the hardware engine
 * @in_kthread: true if we are in the context of the request pump thread
 *
 * This function checks if there is any request in the engine queue that
 * needs processing and if so call out to the driver to initialize hardware
 * and handle each request.
 */
static void crypto_pump_requests(struct crypto_engine *engine,
				 bool in_kthread)
{ … }

static void crypto_pump_work(struct kthread_work *work)
{ … }

/**
 * crypto_transfer_request - transfer the new request into the engine queue
 * @engine: the hardware engine
 * @req: the request need to be listed into the engine queue
 * @need_pump: indicates whether queue the pump of request to kthread_work
 */
static int crypto_transfer_request(struct crypto_engine *engine,
				   struct crypto_async_request *req,
				   bool need_pump)
{ … }

/**
 * crypto_transfer_request_to_engine - transfer one request to list
 * into the engine queue
 * @engine: the hardware engine
 * @req: the request need to be listed into the engine queue
 */
static int crypto_transfer_request_to_engine(struct crypto_engine *engine,
					     struct crypto_async_request *req)
{ … }

/**
 * crypto_transfer_aead_request_to_engine - transfer one aead_request
 * to list into the engine queue
 * @engine: the hardware engine
 * @req: the request need to be listed into the engine queue
 */
int crypto_transfer_aead_request_to_engine(struct crypto_engine *engine,
					   struct aead_request *req)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_transfer_akcipher_request_to_engine - transfer one akcipher_request
 * to list into the engine queue
 * @engine: the hardware engine
 * @req: the request need to be listed into the engine queue
 */
int crypto_transfer_akcipher_request_to_engine(struct crypto_engine *engine,
					       struct akcipher_request *req)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_transfer_hash_request_to_engine - transfer one ahash_request
 * to list into the engine queue
 * @engine: the hardware engine
 * @req: the request need to be listed into the engine queue
 */
int crypto_transfer_hash_request_to_engine(struct crypto_engine *engine,
					   struct ahash_request *req)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_transfer_kpp_request_to_engine - transfer one kpp_request to list
 * into the engine queue
 * @engine: the hardware engine
 * @req: the request need to be listed into the engine queue
 */
int crypto_transfer_kpp_request_to_engine(struct crypto_engine *engine,
					  struct kpp_request *req)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_transfer_skcipher_request_to_engine - transfer one skcipher_request
 * to list into the engine queue
 * @engine: the hardware engine
 * @req: the request need to be listed into the engine queue
 */
int crypto_transfer_skcipher_request_to_engine(struct crypto_engine *engine,
					       struct skcipher_request *req)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_finalize_aead_request - finalize one aead_request if
 * the request is done
 * @engine: the hardware engine
 * @req: the request need to be finalized
 * @err: error number
 */
void crypto_finalize_aead_request(struct crypto_engine *engine,
				  struct aead_request *req, int err)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_finalize_akcipher_request - finalize one akcipher_request if
 * the request is done
 * @engine: the hardware engine
 * @req: the request need to be finalized
 * @err: error number
 */
void crypto_finalize_akcipher_request(struct crypto_engine *engine,
				      struct akcipher_request *req, int err)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_finalize_hash_request - finalize one ahash_request if
 * the request is done
 * @engine: the hardware engine
 * @req: the request need to be finalized
 * @err: error number
 */
void crypto_finalize_hash_request(struct crypto_engine *engine,
				  struct ahash_request *req, int err)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_finalize_kpp_request - finalize one kpp_request if the request is done
 * @engine: the hardware engine
 * @req: the request need to be finalized
 * @err: error number
 */
void crypto_finalize_kpp_request(struct crypto_engine *engine,
				 struct kpp_request *req, int err)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_finalize_skcipher_request - finalize one skcipher_request if
 * the request is done
 * @engine: the hardware engine
 * @req: the request need to be finalized
 * @err: error number
 */
void crypto_finalize_skcipher_request(struct crypto_engine *engine,
				      struct skcipher_request *req, int err)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_engine_start - start the hardware engine
 * @engine: the hardware engine need to be started
 *
 * Return 0 on success, else on fail.
 */
int crypto_engine_start(struct crypto_engine *engine)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_engine_stop - stop the hardware engine
 * @engine: the hardware engine need to be stopped
 *
 * Return 0 on success, else on fail.
 */
int crypto_engine_stop(struct crypto_engine *engine)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_engine_alloc_init_and_set - allocate crypto hardware engine structure
 * and initialize it by setting the maximum number of entries in the software
 * crypto-engine queue.
 * @dev: the device attached with one hardware engine
 * @retry_support: whether hardware has support for retry mechanism
 * @cbk_do_batch: pointer to a callback function to be invoked when executing
 *                a batch of requests.
 *                This has the form:
 *                callback(struct crypto_engine *engine)
 *                where:
 *                engine: the crypto engine structure.
 * @rt: whether this queue is set to run as a realtime task
 * @qlen: maximum size of the crypto-engine queue
 *
 * This must be called from context that can sleep.
 * Return: the crypto engine structure on success, else NULL.
 */
struct crypto_engine *crypto_engine_alloc_init_and_set(struct device *dev,
						       bool retry_support,
						       int (*cbk_do_batch)(struct crypto_engine *engine),
						       bool rt, int qlen)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_engine_alloc_init - allocate crypto hardware engine structure and
 * initialize it.
 * @dev: the device attached with one hardware engine
 * @rt: whether this queue is set to run as a realtime task
 *
 * This must be called from context that can sleep.
 * Return: the crypto engine structure on success, else NULL.
 */
struct crypto_engine *crypto_engine_alloc_init(struct device *dev, bool rt)
{ … }
EXPORT_SYMBOL_GPL(…);

/**
 * crypto_engine_exit - free the resources of hardware engine when exit
 * @engine: the hardware engine need to be freed
 */
void crypto_engine_exit(struct crypto_engine *engine)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_engine_register_aead(struct aead_engine_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

void crypto_engine_unregister_aead(struct aead_engine_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_engine_register_aeads(struct aead_engine_alg *algs, int count)
{ … }
EXPORT_SYMBOL_GPL(…);

void crypto_engine_unregister_aeads(struct aead_engine_alg *algs, int count)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_engine_register_ahash(struct ahash_engine_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

void crypto_engine_unregister_ahash(struct ahash_engine_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_engine_register_ahashes(struct ahash_engine_alg *algs, int count)
{ … }
EXPORT_SYMBOL_GPL(…);

void crypto_engine_unregister_ahashes(struct ahash_engine_alg *algs,
				      int count)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_engine_register_akcipher(struct akcipher_engine_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

void crypto_engine_unregister_akcipher(struct akcipher_engine_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_engine_register_kpp(struct kpp_engine_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

void crypto_engine_unregister_kpp(struct kpp_engine_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_engine_register_skcipher(struct skcipher_engine_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

void crypto_engine_unregister_skcipher(struct skcipher_engine_alg *alg)
{ … }
EXPORT_SYMBOL_GPL(…);

int crypto_engine_register_skciphers(struct skcipher_engine_alg *algs,
				     int count)
{ … }
EXPORT_SYMBOL_GPL(…);

void crypto_engine_unregister_skciphers(struct skcipher_engine_alg *algs,
					int count)
{ … }
EXPORT_SYMBOL_GPL(…);

MODULE_LICENSE(…) …;
MODULE_DESCRIPTION(…) …;
linux/crypto/crypto_engine.c
