[linux-2.6-block.git] / drivers / crypto / virtio / virtio_crypto_common.h

/* SPDX-License-Identifier: GPL-2.0-or-later */
/* Common header for Virtio crypto device.
 *
 * Copyright 2016 HUAWEI TECHNOLOGIES CO., LTD.
 */

#ifndef _VIRTIO_CRYPTO_COMMON_H
#define _VIRTIO_CRYPTO_COMMON_H

#include <linux/virtio.h>
#include <linux/crypto.h>
#include <linux/spinlock.h>
#include <linux/interrupt.h>
#include <crypto/aead.h>
#include <crypto/aes.h>
#include <crypto/engine.h>
#include <uapi/linux/virtio_crypto.h>


/* Internal representation of a data virtqueue */
struct data_queue {
	/* Virtqueue associated with this send _queue */
	struct virtqueue *vq;

	/* To protect the vq operations for the dataq */
	spinlock_t lock;

	/* Name of the tx queue: dataq.$index */
	char name[32];

	struct crypto_engine *engine;
	struct tasklet_struct done_task;
};

struct virtio_crypto {
	struct virtio_device *vdev;
	struct virtqueue *ctrl_vq;
	struct data_queue *data_vq;

	/* Work struct for config space updates */
	struct work_struct config_work;

	/* To protect the vq operations for the controlq */
	spinlock_t ctrl_lock;

	/* Maximum of data queues supported by the device */
	u32 max_data_queues;

	/* Number of queue currently used by the driver */
	u32 curr_queue;

	/*
	 * Specifies the services mask which the device support,
	 * see VIRTIO_CRYPTO_SERVICE_*
	 */
	u32 crypto_services;

	/* Detailed algorithms mask */
	u32 cipher_algo_l;
	u32 cipher_algo_h;
	u32 hash_algo;
	u32 mac_algo_l;
	u32 mac_algo_h;
	u32 aead_algo;
	u32 akcipher_algo;

	/* Maximum length of cipher key */
	u32 max_cipher_key_len;
	/* Maximum length of authenticated key */
	u32 max_auth_key_len;
	/* Maximum size of per request */
	u64 max_size;

	unsigned long status;
	atomic_t ref_count;
	struct list_head list;
	struct module *owner;
	uint8_t dev_id;

	/* Does the affinity hint is set for virtqueues? */
	bool affinity_hint_set;
};

struct virtio_crypto_sym_session_info {
	/* Backend session id, which come from the host side */
	__u64 session_id;
};

/*
 * Note: there are padding fields in request, clear them to zero before
 *       sending to host to avoid to divulge any information.
 * Ex, virtio_crypto_ctrl_request::ctrl::u::destroy_session::padding[48]
 */
struct virtio_crypto_ctrl_request {
	struct virtio_crypto_op_ctrl_req ctrl;
	struct virtio_crypto_session_input input;
	struct virtio_crypto_inhdr ctrl_status;
	struct completion compl;
};

struct virtio_crypto_request;
typedef void (*virtio_crypto_data_callback)
		(struct virtio_crypto_request *vc_req, int len);

struct virtio_crypto_request {
	uint8_t status;
	struct virtio_crypto_op_data_req *req_data;
	struct scatterlist **sgs;
	struct data_queue *dataq;
	virtio_crypto_data_callback alg_cb;
};

int virtcrypto_devmgr_add_dev(struct virtio_crypto *vcrypto_dev);
struct list_head *virtcrypto_devmgr_get_head(void);
void virtcrypto_devmgr_rm_dev(struct virtio_crypto *vcrypto_dev);
struct virtio_crypto *virtcrypto_devmgr_get_first(void);
int virtcrypto_dev_in_use(struct virtio_crypto *vcrypto_dev);
int virtcrypto_dev_get(struct virtio_crypto *vcrypto_dev);
void virtcrypto_dev_put(struct virtio_crypto *vcrypto_dev);
int virtcrypto_dev_started(struct virtio_crypto *vcrypto_dev);
bool virtcrypto_algo_is_supported(struct virtio_crypto *vcrypto_dev,
				  uint32_t service,
				  uint32_t algo);
struct virtio_crypto *virtcrypto_get_dev_node(int node,
					      uint32_t service,
					      uint32_t algo);
int virtcrypto_dev_start(struct virtio_crypto *vcrypto);
void virtcrypto_dev_stop(struct virtio_crypto *vcrypto);
int virtio_crypto_skcipher_crypt_req(
	struct crypto_engine *engine, void *vreq);

void
virtcrypto_clear_request(struct virtio_crypto_request *vc_req);

static inline int virtio_crypto_get_current_node(void)
{
	int cpu, node;

	cpu = get_cpu();
	node = topology_physical_package_id(cpu);
	put_cpu();

	return node;
}

int virtio_crypto_skcipher_algs_register(struct virtio_crypto *vcrypto);
void virtio_crypto_skcipher_algs_unregister(struct virtio_crypto *vcrypto);
int virtio_crypto_akcipher_algs_register(struct virtio_crypto *vcrypto);
void virtio_crypto_akcipher_algs_unregister(struct virtio_crypto *vcrypto);
int virtio_crypto_ctrl_vq_request(struct virtio_crypto *vcrypto, struct scatterlist *sgs[],
				  unsigned int out_sgs, unsigned int in_sgs,
				  struct virtio_crypto_ctrl_request *vc_ctrl_req);

#endif /* _VIRTIO_CRYPTO_COMMON_H */
Commit	Line	Data
1ccea77e	1	/* SPDX-License-Identifier: GPL-2.0-or-later */
dbaf0624 G	2	/* Common header for Virtio crypto device.
	3	*
	4	* Copyright 2016 HUAWEI TECHNOLOGIES CO., LTD.
dbaf0624 G	5	*/
	6
	7	#ifndef _VIRTIO_CRYPTO_COMMON_H
	8	#define _VIRTIO_CRYPTO_COMMON_H
	9
	10	#include <linux/virtio.h>
	11	#include <linux/crypto.h>
	12	#include <linux/spinlock.h>
fed93fb6	13	#include <linux/interrupt.h>
dbaf0624 G	14	#include <crypto/aead.h>
dbaf0624 G	15	#include <crypto/aes.h>
d79b5d0b	16	#include <crypto/engine.h>
0756ad15	17	#include <uapi/linux/virtio_crypto.h>
dbaf0624 G	18
	19
	20	/* Internal representation of a data virtqueue */
	21	struct data_queue {
	22	/* Virtqueue associated with this send _queue */
	23	struct virtqueue *vq;
	24
	25	/* To protect the vq operations for the dataq */
	26	spinlock_t lock;
	27
	28	/* Name of the tx queue: dataq.$index */
	29	char name[32];
d79b5d0b GA	30
d79b5d0b GA	31	struct crypto_engine *engine;
fed93fb6	32	struct tasklet_struct done_task;
dbaf0624 G	33	};
	34
	35	struct virtio_crypto {
	36	struct virtio_device *vdev;
	37	struct virtqueue *ctrl_vq;
	38	struct data_queue *data_vq;
	39
fa2e6947	40	/* Work struct for config space updates */
	41	struct work_struct config_work;
	42
dbaf0624 G	43	/* To protect the vq operations for the controlq */
	44	spinlock_t ctrl_lock;
	45
	46	/* Maximum of data queues supported by the device */
	47	u32 max_data_queues;
	48
	49	/* Number of queue currently used by the driver */
	50	u32 curr_queue;
	51
b551bac1 FA	52	/*
	53	* Specifies the services mask which the device support,
	54	* see VIRTIO_CRYPTO_SERVICE_*
	55	*/
	56	u32 crypto_services;
	57
	58	/* Detailed algorithms mask */
	59	u32 cipher_algo_l;
	60	u32 cipher_algo_h;
	61	u32 hash_algo;
	62	u32 mac_algo_l;
	63	u32 mac_algo_h;
	64	u32 aead_algo;
59ca6c93	65	u32 akcipher_algo;
b551bac1	66
dbaf0624 G	67	/* Maximum length of cipher key */
	68	u32 max_cipher_key_len;
	69	/* Maximum length of authenticated key */
	70	u32 max_auth_key_len;
	71	/* Maximum size of per request */
	72	u64 max_size;
	73
dbaf0624 G	74	unsigned long status;
	75	atomic_t ref_count;
	76	struct list_head list;
	77	struct module *owner;
	78	uint8_t dev_id;
	79
	80	/* Does the affinity hint is set for virtqueues? */
	81	bool affinity_hint_set;
	82	};
	83
	84	struct virtio_crypto_sym_session_info {
	85	/* Backend session id, which come from the host side */
	86	__u64 session_id;
	87	};
	88
0756ad15	89	/*
	90	* Note: there are padding fields in request, clear them to zero before
	91	* sending to host to avoid to divulge any information.
	92	* Ex, virtio_crypto_ctrl_request::ctrl::u::destroy_session::padding[48]
	93	*/
	94	struct virtio_crypto_ctrl_request {
	95	struct virtio_crypto_op_ctrl_req ctrl;
	96	struct virtio_crypto_session_input input;
	97	struct virtio_crypto_inhdr ctrl_status;
977231e8	98	struct completion compl;
0756ad15	99	};
0756ad15	100
d31e7123 ZX	101	struct virtio_crypto_request;
	102	typedef void (*virtio_crypto_data_callback)
	103	(struct virtio_crypto_request *vc_req, int len);
dbaf0624 G	104
dbaf0624 G	105	struct virtio_crypto_request {
dbaf0624	106	uint8_t status;
dbaf0624 G	107	struct virtio_crypto_op_data_req *req_data;
dbaf0624 G	108	struct scatterlist **sgs;
d79b5d0b	109	struct data_queue *dataq;
d31e7123	110	virtio_crypto_data_callback alg_cb;
dbaf0624 G	111	};
	112
	113	int virtcrypto_devmgr_add_dev(struct virtio_crypto *vcrypto_dev);
	114	struct list_head *virtcrypto_devmgr_get_head(void);
	115	void virtcrypto_devmgr_rm_dev(struct virtio_crypto *vcrypto_dev);
	116	struct virtio_crypto *virtcrypto_devmgr_get_first(void);
	117	int virtcrypto_dev_in_use(struct virtio_crypto *vcrypto_dev);
	118	int virtcrypto_dev_get(struct virtio_crypto *vcrypto_dev);
	119	void virtcrypto_dev_put(struct virtio_crypto *vcrypto_dev);
	120	int virtcrypto_dev_started(struct virtio_crypto *vcrypto_dev);
d0d859bb FA	121	bool virtcrypto_algo_is_supported(struct virtio_crypto *vcrypto_dev,
	122	uint32_t service,
	123	uint32_t algo);
	124	struct virtio_crypto *virtcrypto_get_dev_node(int node,
	125	uint32_t service,
	126	uint32_t algo);
dbaf0624 G	127	int virtcrypto_dev_start(struct virtio_crypto *vcrypto);
dbaf0624 G	128	void virtcrypto_dev_stop(struct virtio_crypto *vcrypto);
eee1d6fc	129	int virtio_crypto_skcipher_crypt_req(
67189375	130	struct crypto_engine engine, void vreq);
d79b5d0b GA	131
	132	void
	133	virtcrypto_clear_request(struct virtio_crypto_request *vc_req);
dbaf0624 G	134
	135	static inline int virtio_crypto_get_current_node(void)
	136	{
	137	int cpu, node;
	138
	139	cpu = get_cpu();
	140	node = topology_physical_package_id(cpu);
	141	put_cpu();
	142
	143	return node;
	144	}
	145
ea993de1	146	int virtio_crypto_skcipher_algs_register(struct virtio_crypto *vcrypto);
ea993de1	147	void virtio_crypto_skcipher_algs_unregister(struct virtio_crypto *vcrypto);
59ca6c93	148	int virtio_crypto_akcipher_algs_register(struct virtio_crypto *vcrypto);
59ca6c93	149	void virtio_crypto_akcipher_algs_unregister(struct virtio_crypto *vcrypto);
977231e8	150	int virtio_crypto_ctrl_vq_request(struct virtio_crypto vcrypto, struct scatterlist sgs[],
	151	unsigned int out_sgs, unsigned int in_sgs,
	152	struct virtio_crypto_ctrl_request *vc_ctrl_req);
dbaf0624 G	153
dbaf0624 G	154	#endif /* _VIRTIO_CRYPTO_COMMON_H */