[mirror_qemu.git] / include / sysemu / cryptodev.h

/*
 * QEMU Crypto Device Implementation
 *
 * Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
 *
 * Authors:
 *    Gonglei <arei.gonglei@huawei.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 *
 */
#ifndef CRYPTODEV_H
#define CRYPTODEV_H

#include "qom/object.h"
#include "qemu-common.h"

/**
 * CryptoDevBackend:
 *
 * The CryptoDevBackend object is an interface
 * for different cryptodev backends, which provides crypto
 * operation wrapper.
 *
 */

#define TYPE_CRYPTODEV_BACKEND "cryptodev-backend"

#define CRYPTODEV_BACKEND(obj) \
    OBJECT_CHECK(CryptoDevBackend, \
                 (obj), TYPE_CRYPTODEV_BACKEND)
#define CRYPTODEV_BACKEND_GET_CLASS(obj) \
    OBJECT_GET_CLASS(CryptoDevBackendClass, \
                 (obj), TYPE_CRYPTODEV_BACKEND)
#define CRYPTODEV_BACKEND_CLASS(klass) \
    OBJECT_CLASS_CHECK(CryptoDevBackendClass, \
                (klass), TYPE_CRYPTODEV_BACKEND)


#define MAX_CRYPTO_QUEUE_NUM  64

typedef struct CryptoDevBackendConf CryptoDevBackendConf;
typedef struct CryptoDevBackendPeers CryptoDevBackendPeers;
typedef struct CryptoDevBackendClient
                     CryptoDevBackendClient;
typedef struct CryptoDevBackend CryptoDevBackend;

enum CryptoDevBackendAlgType {
    CRYPTODEV_BACKEND_ALG_SYM,
    CRYPTODEV_BACKEND_ALG__MAX,
};

/**
 * CryptoDevBackendSymSessionInfo:
 *
 * @op_code: operation code (refer to virtio_crypto.h)
 * @cipher_alg: algorithm type of CIPHER
 * @key_len: byte length of cipher key
 * @hash_alg: algorithm type of HASH/MAC
 * @hash_result_len: byte length of HASH operation result
 * @auth_key_len: byte length of authenticated key
 * @add_len: byte length of additional authenticated data
 * @op_type: operation type (refer to virtio_crypto.h)
 * @direction: encryption or direction for CIPHER
 * @hash_mode: HASH mode for HASH operation (refer to virtio_crypto.h)
 * @alg_chain_order: order of algorithm chaining (CIPHER then HASH,
 *                   or HASH then CIPHER)
 * @cipher_key: point to a key of CIPHER
 * @auth_key: point to an authenticated key of MAC
 *
 */
typedef struct CryptoDevBackendSymSessionInfo {
    /* corresponding with virtio crypto spec */
    uint32_t op_code;
    uint32_t cipher_alg;
    uint32_t key_len;
    uint32_t hash_alg;
    uint32_t hash_result_len;
    uint32_t auth_key_len;
    uint32_t add_len;
    uint8_t op_type;
    uint8_t direction;
    uint8_t hash_mode;
    uint8_t alg_chain_order;
    uint8_t *cipher_key;
    uint8_t *auth_key;
} CryptoDevBackendSymSessionInfo;

/**
 * CryptoDevBackendSymOpInfo:
 *
 * @session_id: session index which was previously
 *              created by cryptodev_backend_sym_create_session()
 * @aad_len: byte length of additional authenticated data
 * @iv_len: byte length of initialization vector or counter
 * @src_len: byte length of source data
 * @dst_len: byte length of destination data
 * @digest_result_len: byte length of hash digest result
 * @hash_start_src_offset: Starting point for hash processing, specified
 *  as number of bytes from start of packet in source data, only used for
 *  algorithm chain
 * @cipher_start_src_offset: Starting point for cipher processing, specified
 *  as number of bytes from start of packet in source data, only used for
 *  algorithm chain
 * @len_to_hash: byte length of source data on which the hash
 *  operation will be computed, only used for algorithm chain
 * @len_to_cipher: byte length of source data on which the cipher
 *  operation will be computed, only used for algorithm chain
 * @op_type: operation type (refer to virtio_crypto.h)
 * @iv: point to the initialization vector or counter
 * @src: point to the source data
 * @dst: point to the destination data
 * @aad_data: point to the additional authenticated data
 * @digest_result: point to the digest result data
 * @data[0]: point to the extensional memory by one memory allocation
 *
 */
typedef struct CryptoDevBackendSymOpInfo {
    uint64_t session_id;
    uint32_t aad_len;
    uint32_t iv_len;
    uint32_t src_len;
    uint32_t dst_len;
    uint32_t digest_result_len;
    uint32_t hash_start_src_offset;
    uint32_t cipher_start_src_offset;
    uint32_t len_to_hash;
    uint32_t len_to_cipher;
    uint8_t op_type;
    uint8_t *iv;
    uint8_t *src;
    uint8_t *dst;
    uint8_t *aad_data;
    uint8_t *digest_result;
    uint8_t data[0];
} CryptoDevBackendSymOpInfo;

typedef struct CryptoDevBackendClass {
    ObjectClass parent_class;

    void (*init)(CryptoDevBackend *backend, Error **errp);
    void (*cleanup)(CryptoDevBackend *backend, Error **errp);

    int64_t (*create_session)(CryptoDevBackend *backend,
                       CryptoDevBackendSymSessionInfo *sess_info,
                       uint32_t queue_index, Error **errp);
    int (*close_session)(CryptoDevBackend *backend,
                           uint64_t session_id,
                           uint32_t queue_index, Error **errp);
    int (*do_sym_op)(CryptoDevBackend *backend,
                     CryptoDevBackendSymOpInfo *op_info,
                     uint32_t queue_index, Error **errp);
} CryptoDevBackendClass;


struct CryptoDevBackendClient {
    char *model;
    char *name;
    char *info_str;
    unsigned int queue_index;
    QTAILQ_ENTRY(CryptoDevBackendClient) next;
};

struct CryptoDevBackendPeers {
    CryptoDevBackendClient *ccs[MAX_CRYPTO_QUEUE_NUM];
    uint32_t queues;
};

struct CryptoDevBackendConf {
    CryptoDevBackendPeers peers;

    /* Supported service mask */
    uint32_t crypto_services;

    /* Detailed algorithms mask */
    uint32_t cipher_algo_l;
    uint32_t cipher_algo_h;
    uint32_t hash_algo;
    uint32_t mac_algo_l;
    uint32_t mac_algo_h;
    uint32_t aead_algo;
    /* Maximum length of cipher key */
    uint32_t max_cipher_key_len;
    /* Maximum length of authenticated key */
    uint32_t max_auth_key_len;
    /* Maximum size of each crypto request's content */
    uint64_t max_size;
};

struct CryptoDevBackend {
    Object parent_obj;

    bool ready;
    /* Tag the cryptodev backend is used by virtio-crypto or not */
    bool is_used;
    CryptoDevBackendConf conf;
};

/**
 * cryptodev_backend_new_client:
 * @model: the cryptodev backend model
 * @name: the cryptodev backend name, can be NULL
 *
 * Creates a new cryptodev backend client object
 * with the @name in the model @model.
 *
 * The returned object must be released with
 * cryptodev_backend_free_client() when no
 * longer required
 *
 * Returns: a new cryptodev backend client object
 */
CryptoDevBackendClient *
cryptodev_backend_new_client(const char *model,
                                    const char *name);
/**
 * cryptodev_backend_free_client:
 * @cc: the cryptodev backend client object
 *
 * Release the memory associated with @cc that
 * was previously allocated by cryptodev_backend_new_client()
 */
void cryptodev_backend_free_client(
                  CryptoDevBackendClient *cc);

/**
 * cryptodev_backend_cleanup:
 * @backend: the cryptodev backend object
 * @errp: pointer to a NULL-initialized error object
 *
 * Clean the resouce associated with @backend that realizaed
 * by the specific backend's init() callback
 */
void cryptodev_backend_cleanup(
           CryptoDevBackend *backend,
           Error **errp);

/**
 * cryptodev_backend_sym_create_session:
 * @backend: the cryptodev backend object
 * @sess_info: parameters needed by session creating
 * @queue_index: queue index of cryptodev backend client
 * @errp: pointer to a NULL-initialized error object
 *
 * Create a session for symmetric algorithms
 *
 * Returns: session id on success, or -1 on error
 */
int64_t cryptodev_backend_sym_create_session(
           CryptoDevBackend *backend,
           CryptoDevBackendSymSessionInfo *sess_info,
           uint32_t queue_index, Error **errp);

/**
 * cryptodev_backend_sym_close_session:
 * @backend: the cryptodev backend object
 * @session_id: the session id
 * @queue_index: queue index of cryptodev backend client
 * @errp: pointer to a NULL-initialized error object
 *
 * Close a session for symmetric algorithms which was previously
 * created by cryptodev_backend_sym_create_session()
 *
 * Returns: 0 on success, or Negative on error
 */
int cryptodev_backend_sym_close_session(
           CryptoDevBackend *backend,
           uint64_t session_id,
           uint32_t queue_index, Error **errp);

/**
 * cryptodev_backend_crypto_operation:
 * @backend: the cryptodev backend object
 * @opaque: pointer to a VirtIOCryptoReq object
 * @queue_index: queue index of cryptodev backend client
 * @errp: pointer to a NULL-initialized error object
 *
 * Do crypto operation, such as encryption and
 * decryption
 *
 * Returns: VIRTIO_CRYPTO_OK on success,
 *         or -VIRTIO_CRYPTO_* on error
 */
int cryptodev_backend_crypto_operation(
                 CryptoDevBackend *backend,
                 void *opaque,
                 uint32_t queue_index, Error **errp);

/**
 * cryptodev_backend_set_used:
 * @backend: the cryptodev backend object
 * @used: ture or false
 *
 * Set the cryptodev backend is used by virtio-crypto or not
 */
void cryptodev_backend_set_used(CryptoDevBackend *backend, bool used);

/**
 * cryptodev_backend_is_used:
 * @backend: the cryptodev backend object
 *
 * Return the status that the cryptodev backend is used
 * by virtio-crypto or not
 *
 * Returns: true on used, or false on not used
 */
bool cryptodev_backend_is_used(CryptoDevBackend *backend);

/**
 * cryptodev_backend_set_ready:
 * @backend: the cryptodev backend object
 * @ready: ture or false
 *
 * Set the cryptodev backend is ready or not, which is called
 * by the children of the cryptodev banckend interface.
 */
void cryptodev_backend_set_ready(CryptoDevBackend *backend, bool ready);

/**
 * cryptodev_backend_is_ready:
 * @backend: the cryptodev backend object
 *
 * Return the status that the cryptodev backend is ready or not
 *
 * Returns: true on ready, or false on not ready
 */
bool cryptodev_backend_is_ready(CryptoDevBackend *backend);

#endif /* CRYPTODEV_H */
Commit	Line	Data
d0ee7a13 GA	1	/*
	2	* QEMU Crypto Device Implementation
	3	*
	4	* Copyright (c) 2016 HUAWEI TECHNOLOGIES CO., LTD.
	5	*
	6	* Authors:
	7	* Gonglei <arei.gonglei@huawei.com>
	8	*
	9	* This library is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU Lesser General Public
	11	* License as published by the Free Software Foundation; either
	12	* version 2 of the License, or (at your option) any later version.
	13	*
	14	* This library is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* Lesser General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU Lesser General Public
	20	* License along with this library; if not, see <http://www.gnu.org/licenses/>.
	21	*
	22	*/
	23	#ifndef CRYPTODEV_H
	24	#define CRYPTODEV_H
	25
	26	#include "qom/object.h"
	27	#include "qemu-common.h"
	28
	29	/**
	30	* CryptoDevBackend:
	31	*
	32	* The CryptoDevBackend object is an interface
	33	* for different cryptodev backends, which provides crypto
	34	* operation wrapper.
	35	*
	36	*/
	37
	38	#define TYPE_CRYPTODEV_BACKEND "cryptodev-backend"
	39
	40	#define CRYPTODEV_BACKEND(obj) \
	41	OBJECT_CHECK(CryptoDevBackend, \
	42	(obj), TYPE_CRYPTODEV_BACKEND)
	43	#define CRYPTODEV_BACKEND_GET_CLASS(obj) \
	44	OBJECT_GET_CLASS(CryptoDevBackendClass, \
	45	(obj), TYPE_CRYPTODEV_BACKEND)
	46	#define CRYPTODEV_BACKEND_CLASS(klass) \
	47	OBJECT_CLASS_CHECK(CryptoDevBackendClass, \
	48	(klass), TYPE_CRYPTODEV_BACKEND)
	49
	50
	51	#define MAX_CRYPTO_QUEUE_NUM 64
	52
	53	typedef struct CryptoDevBackendConf CryptoDevBackendConf;
	54	typedef struct CryptoDevBackendPeers CryptoDevBackendPeers;
	55	typedef struct CryptoDevBackendClient
	56	CryptoDevBackendClient;
	57	typedef struct CryptoDevBackend CryptoDevBackend;
	58
9e4f86a8 GA	59	enum CryptoDevBackendAlgType {
	60	CRYPTODEV_BACKEND_ALG_SYM,
	61	CRYPTODEV_BACKEND_ALG__MAX,
	62	};
	63
	64	/**
	65	* CryptoDevBackendSymSessionInfo:
	66	*
	67	* @op_code: operation code (refer to virtio_crypto.h)
	68	* @cipher_alg: algorithm type of CIPHER
	69	* @key_len: byte length of cipher key
	70	* @hash_alg: algorithm type of HASH/MAC
	71	* @hash_result_len: byte length of HASH operation result
	72	* @auth_key_len: byte length of authenticated key
	73	* @add_len: byte length of additional authenticated data
	74	* @op_type: operation type (refer to virtio_crypto.h)
	75	* @direction: encryption or direction for CIPHER
	76	* @hash_mode: HASH mode for HASH operation (refer to virtio_crypto.h)
	77	* @alg_chain_order: order of algorithm chaining (CIPHER then HASH,
	78	* or HASH then CIPHER)
	79	* @cipher_key: point to a key of CIPHER
	80	* @auth_key: point to an authenticated key of MAC
	81	*
	82	*/
	83	typedef struct CryptoDevBackendSymSessionInfo {
	84	/* corresponding with virtio crypto spec */
	85	uint32_t op_code;
	86	uint32_t cipher_alg;
	87	uint32_t key_len;
	88	uint32_t hash_alg;
	89	uint32_t hash_result_len;
	90	uint32_t auth_key_len;
	91	uint32_t add_len;
	92	uint8_t op_type;
	93	uint8_t direction;
	94	uint8_t hash_mode;
	95	uint8_t alg_chain_order;
	96	uint8_t *cipher_key;
	97	uint8_t *auth_key;
	98	} CryptoDevBackendSymSessionInfo;
	99
	100	/**
	101	* CryptoDevBackendSymOpInfo:
	102	*
	103	* @session_id: session index which was previously
	104	* created by cryptodev_backend_sym_create_session()
	105	* @aad_len: byte length of additional authenticated data
	106	* @iv_len: byte length of initialization vector or counter
	107	* @src_len: byte length of source data
	108	* @dst_len: byte length of destination data
	109	* @digest_result_len: byte length of hash digest result
	110	* @hash_start_src_offset: Starting point for hash processing, specified
	111	* as number of bytes from start of packet in source data, only used for
	112	* algorithm chain
	113	* @cipher_start_src_offset: Starting point for cipher processing, specified
	114	* as number of bytes from start of packet in source data, only used for
	115	* algorithm chain
	116	* @len_to_hash: byte length of source data on which the hash
	117	* operation will be computed, only used for algorithm chain
	118	* @len_to_cipher: byte length of source data on which the cipher
	119	* operation will be computed, only used for algorithm chain
	120	* @op_type: operation type (refer to virtio_crypto.h)
	121	* @iv: point to the initialization vector or counter
	122	* @src: point to the source data
123	* @dst: point to the destination data
124	* @aad_data: point to the additional authenticated data
125	* @digest_result: point to the digest result data
126	* @data[0]: point to the extensional memory by one memory allocation
127	*
128	*/
129	typedef struct CryptoDevBackendSymOpInfo {
130	uint64_t session_id;
131	uint32_t aad_len;
132	uint32_t iv_len;
133	uint32_t src_len;
134	uint32_t dst_len;
135	uint32_t digest_result_len;
136	uint32_t hash_start_src_offset;
137	uint32_t cipher_start_src_offset;
138	uint32_t len_to_hash;
139	uint32_t len_to_cipher;
140	uint8_t op_type;
141	uint8_t *iv;
142	uint8_t *src;
143	uint8_t *dst;
144	uint8_t *aad_data;
145	uint8_t *digest_result;
146	uint8_t data[0];
147	} CryptoDevBackendSymOpInfo;
d0ee7a13 GA	148
	149	typedef struct CryptoDevBackendClass {
	150	ObjectClass parent_class;
	151
	152	void (init)(CryptoDevBackend backend, Error **errp);
	153	void (cleanup)(CryptoDevBackend backend, Error **errp);
9e4f86a8 GA	154
	155	int64_t (create_session)(CryptoDevBackend backend,
	156	CryptoDevBackendSymSessionInfo *sess_info,
	157	uint32_t queue_index, Error **errp);
	158	int (close_session)(CryptoDevBackend backend,
	159	uint64_t session_id,
	160	uint32_t queue_index, Error **errp);
	161	int (do_sym_op)(CryptoDevBackend backend,
	162	CryptoDevBackendSymOpInfo *op_info,
	163	uint32_t queue_index, Error **errp);
d0ee7a13 GA	164	} CryptoDevBackendClass;
	165
	166
	167	struct CryptoDevBackendClient {
	168	char *model;
	169	char *name;
	170	char *info_str;
	171	unsigned int queue_index;
	172	QTAILQ_ENTRY(CryptoDevBackendClient) next;
	173	};
	174
	175	struct CryptoDevBackendPeers {
	176	CryptoDevBackendClient *ccs[MAX_CRYPTO_QUEUE_NUM];
	177	uint32_t queues;
	178	};
	179
	180	struct CryptoDevBackendConf {
	181	CryptoDevBackendPeers peers;
	182
	183	/* Supported service mask */
	184	uint32_t crypto_services;
	185
	186	/* Detailed algorithms mask */
	187	uint32_t cipher_algo_l;
	188	uint32_t cipher_algo_h;
	189	uint32_t hash_algo;
	190	uint32_t mac_algo_l;
	191	uint32_t mac_algo_h;
	192	uint32_t aead_algo;
	193	/* Maximum length of cipher key */
	194	uint32_t max_cipher_key_len;
	195	/* Maximum length of authenticated key */
	196	uint32_t max_auth_key_len;
	197	/* Maximum size of each crypto request's content */
	198	uint64_t max_size;
	199	};
	200
	201	struct CryptoDevBackend {
	202	Object parent_obj;
	203
	204	bool ready;
46fd1705 GA	205	/* Tag the cryptodev backend is used by virtio-crypto or not */
46fd1705 GA	206	bool is_used;
d0ee7a13 GA	207	CryptoDevBackendConf conf;
	208	};
	209
	210	/**
	211	* cryptodev_backend_new_client:
	212	* @model: the cryptodev backend model
	213	* @name: the cryptodev backend name, can be NULL
	214	*
	215	* Creates a new cryptodev backend client object
	216	* with the @name in the model @model.
	217	*
	218	* The returned object must be released with
	219	* cryptodev_backend_free_client() when no
	220	* longer required
	221	*
	222	* Returns: a new cryptodev backend client object
	223	*/
	224	CryptoDevBackendClient *
	225	cryptodev_backend_new_client(const char *model,
	226	const char *name);
	227	/**
	228	* cryptodev_backend_free_client:
	229	* @cc: the cryptodev backend client object
	230	*
	231	* Release the memory associated with @cc that
	232	* was previously allocated by cryptodev_backend_new_client()
	233	*/
	234	void cryptodev_backend_free_client(
	235	CryptoDevBackendClient *cc);
	236
	237	/**
	238	* cryptodev_backend_cleanup:
	239	* @backend: the cryptodev backend object
	240	* @errp: pointer to a NULL-initialized error object
	241	*
	242	* Clean the resouce associated with @backend that realizaed
	243	* by the specific backend's init() callback
	244	*/
	245	void cryptodev_backend_cleanup(
	246	CryptoDevBackend *backend,
	247	Error **errp);
	248
9e4f86a8 GA	249	/**
	250	* cryptodev_backend_sym_create_session:
	251	* @backend: the cryptodev backend object
	252	* @sess_info: parameters needed by session creating
	253	* @queue_index: queue index of cryptodev backend client
	254	* @errp: pointer to a NULL-initialized error object
	255	*
	256	* Create a session for symmetric algorithms
	257	*
	258	* Returns: session id on success, or -1 on error
	259	*/
	260	int64_t cryptodev_backend_sym_create_session(
	261	CryptoDevBackend *backend,
	262	CryptoDevBackendSymSessionInfo *sess_info,
	263	uint32_t queue_index, Error **errp);
	264
	265	/**
	266	* cryptodev_backend_sym_close_session:
	267	* @backend: the cryptodev backend object
	268	* @session_id: the session id
	269	* @queue_index: queue index of cryptodev backend client
	270	* @errp: pointer to a NULL-initialized error object
	271	*
	272	* Close a session for symmetric algorithms which was previously
	273	* created by cryptodev_backend_sym_create_session()
	274	*
	275	* Returns: 0 on success, or Negative on error
	276	*/
	277	int cryptodev_backend_sym_close_session(
	278	CryptoDevBackend *backend,
	279	uint64_t session_id,
	280	uint32_t queue_index, Error **errp);
	281
	282	/**
d6634ac0	283	* cryptodev_backend_crypto_operation:
9e4f86a8	284	* @backend: the cryptodev backend object
d6634ac0	285	* @opaque: pointer to a VirtIOCryptoReq object
9e4f86a8 GA	286	* @queue_index: queue index of cryptodev backend client
	287	* @errp: pointer to a NULL-initialized error object
	288	*
d6634ac0	289	* Do crypto operation, such as encryption and
9e4f86a8 GA	290	* decryption
9e4f86a8 GA	291	*
d6634ac0 GA	292	* Returns: VIRTIO_CRYPTO_OK on success,
d6634ac0 GA	293	* or -VIRTIO_CRYPTO_* on error
9e4f86a8	294	*/
d6634ac0	295	int cryptodev_backend_crypto_operation(
9e4f86a8	296	CryptoDevBackend *backend,
d6634ac0	297	void *opaque,
9e4f86a8 GA	298	uint32_t queue_index, Error **errp);
9e4f86a8 GA	299
46fd1705 GA	300	/**
	301	* cryptodev_backend_set_used:
	302	* @backend: the cryptodev backend object
	303	* @used: ture or false
	304	*
	305	* Set the cryptodev backend is used by virtio-crypto or not
	306	*/
	307	void cryptodev_backend_set_used(CryptoDevBackend *backend, bool used);
	308
	309	/**
	310	* cryptodev_backend_is_used:
	311	* @backend: the cryptodev backend object
	312	*
	313	* Return the status that the cryptodev backend is used
	314	* by virtio-crypto or not
	315	*
	316	* Returns: true on used, or false on not used
	317	*/
	318	bool cryptodev_backend_is_used(CryptoDevBackend *backend);
	319
6138dbda GA	320	/**
	321	* cryptodev_backend_set_ready:
	322	* @backend: the cryptodev backend object
	323	* @ready: ture or false
	324	*
	325	* Set the cryptodev backend is ready or not, which is called
	326	* by the children of the cryptodev banckend interface.
	327	*/
	328	void cryptodev_backend_set_ready(CryptoDevBackend *backend, bool ready);
	329
	330	/**
	331	* cryptodev_backend_is_ready:
	332	* @backend: the cryptodev backend object
	333	*
	334	* Return the status that the cryptodev backend is ready or not
	335	*
	336	* Returns: true on ready, or false on not ready
	337	*/
	338	bool cryptodev_backend_is_ready(CryptoDevBackend *backend);
46fd1705	339
d0ee7a13	340	#endif /* CRYPTODEV_H */