[mirror_ubuntu-bionic-kernel.git] / drivers / crypto / cavium / nitrox / nitrox_req.h

/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __NITROX_REQ_H
#define __NITROX_REQ_H

#include <linux/dma-mapping.h>
#include <crypto/aes.h>

#include "nitrox_dev.h"

/**
 * struct gphdr - General purpose Header
 * @param0: first parameter.
 * @param1: second parameter.
 * @param2: third parameter.
 * @param3: fourth parameter.
 *
 * Params tell the iv and enc/dec data offsets.
 */
struct gphdr {
	__be16 param0;
	__be16 param1;
	__be16 param2;
	__be16 param3;
};

/**
 * struct se_req_ctrl - SE request information.
 * @arg: Minor number of the opcode
 * @ctxc: Context control.
 * @unca: Uncertainity enabled.
 * @info: Additional information for SE cores.
 * @ctxl: Context length in bytes.
 * @uddl: User defined data length
 */
union se_req_ctrl {
	u64 value;
	struct {
		u64 raz	: 22;
		u64 arg	: 8;
		u64 ctxc : 2;
		u64 unca : 1;
		u64 info : 3;
		u64 unc : 8;
		u64 ctxl : 12;
		u64 uddl : 8;
	} s;
};

struct nitrox_sglist {
	u16 len;
	u16 raz0;
	u32 raz1;
	dma_addr_t dma;
};

#define MAX_IV_LEN 16

/**
 * struct se_crypto_request - SE crypto request structure.
 * @opcode: Request opcode (enc/dec)
 * @flags: flags from crypto subsystem
 * @ctx_handle: Crypto context handle.
 * @gph: GP Header
 * @ctrl: Request Information.
 * @in: Input sglist
 * @out: Output sglist
 */
struct se_crypto_request {
	u8 opcode;
	gfp_t gfp;
	u32 flags;
	u64 ctx_handle;

	struct gphdr gph;
	union se_req_ctrl ctrl;

	u8 iv[MAX_IV_LEN];
	u16 ivsize;

	struct scatterlist *src;
	struct scatterlist *dst;
};

/* Crypto opcodes */
#define FLEXI_CRYPTO_ENCRYPT_HMAC	0x33
#define ENCRYPT	0
#define DECRYPT 1

/* IV from context */
#define IV_FROM_CTX	0
/* IV from Input data */
#define IV_FROM_DPTR	1

/**
 * cipher opcodes for firmware
 */
enum flexi_cipher {
	CIPHER_NULL = 0,
	CIPHER_3DES_CBC,
	CIPHER_3DES_ECB,
	CIPHER_AES_CBC,
	CIPHER_AES_ECB,
	CIPHER_AES_CFB,
	CIPHER_AES_CTR,
	CIPHER_AES_GCM,
	CIPHER_AES_XTS,
	CIPHER_AES_CCM,
	CIPHER_AES_CBC_CTS,
	CIPHER_AES_ECB_CTS,
	CIPHER_INVALID
};

/**
 * struct crypto_keys - Crypto keys
 * @key: Encryption key or KEY1 for AES-XTS
 * @iv: Encryption IV or Tweak for AES-XTS
 */
struct crypto_keys {
	union {
		u8 key[AES_MAX_KEY_SIZE];
		u8 key1[AES_MAX_KEY_SIZE];
	} u;
	u8 iv[AES_BLOCK_SIZE];
};

/**
 * struct auth_keys - Authentication keys
 * @ipad: IPAD or KEY2 for AES-XTS
 * @opad: OPAD or AUTH KEY if auth_input_type = 1
 */
struct auth_keys {
	union {
		u8 ipad[64];
		u8 key2[64];
	} u;
	u8 opad[64];
};

/**
 * struct flexi_crypto_context - Crypto context
 * @cipher_type: Encryption cipher type
 * @aes_keylen: AES key length
 * @iv_source: Encryption IV source
 * @hash_type: Authentication type
 * @auth_input_type: Authentication input type
 *   1 - Authentication IV and KEY, microcode calculates OPAD/IPAD
 *   0 - Authentication OPAD/IPAD
 * @mac_len: mac length
 * @crypto: Crypto keys
 * @auth: Authentication keys
 */
struct flexi_crypto_context {
	union {
		__be64 flags;
		struct {
#if defined(__BIG_ENDIAN_BITFIELD)
			u64 cipher_type	: 4;
			u64 reserved_59	: 1;
			u64 aes_keylen : 2;
			u64 iv_source : 1;
			u64 hash_type : 4;
			u64 reserved_49_51 : 3;
			u64 auth_input_type: 1;
			u64 mac_len : 8;
			u64 reserved_0_39 : 40;
#else
			u64 reserved_0_39 : 40;
			u64 mac_len : 8;
			u64 auth_input_type: 1;
			u64 reserved_49_51 : 3;
			u64 hash_type : 4;
			u64 iv_source : 1;
			u64 aes_keylen : 2;
			u64 reserved_59	: 1;
			u64 cipher_type	: 4;
#endif
		} w0;
	};

	struct crypto_keys crypto;
	struct auth_keys auth;
};

struct crypto_ctx_hdr {
	struct dma_pool *pool;
	dma_addr_t dma;
	void *vaddr;
};

struct nitrox_crypto_ctx {
	struct nitrox_device *ndev;
	union {
		u64 ctx_handle;
		struct flexi_crypto_context *fctx;
	} u;
	struct crypto_ctx_hdr *chdr;
};

struct nitrox_kcrypt_request {
	struct se_crypto_request creq;
	struct nitrox_crypto_ctx *nctx;
	struct skcipher_request *skreq;
};

/**
 * struct pkt_instr_hdr - Packet Instruction Header
 * @g: Gather used
 *   When [G] is set and [GSZ] != 0, the instruction is
 *   indirect gather instruction.
 *   When [G] is set and [GSZ] = 0, the instruction is
 *   direct gather instruction.
 * @gsz: Number of pointers in the indirect gather list
 * @ihi: When set hardware duplicates the 1st 8 bytes of pkt_instr_hdr
 *   and adds them to the packet after the pkt_instr_hdr but before any UDD
 * @ssz: Not used by the input hardware. But can become slc_store_int[SSZ]
 *   when [IHI] is set.
 * @fsz: The number of front data bytes directly included in the
 *   PCIe instruction.
 * @tlen: The length of the input packet in bytes, include:
 *   - 16B pkt_hdr
 *   - Inline context bytes if any,
 *   - UDD if any,
 *   - packet payload bytes
 */
union pkt_instr_hdr {
	u64 value;
	struct {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 raz_48_63 : 16;
		u64 g : 1;
		u64 gsz	: 7;
		u64 ihi	: 1;
		u64 ssz	: 7;
		u64 raz_30_31 : 2;
		u64 fsz	: 6;
		u64 raz_16_23 : 8;
		u64 tlen : 16;
#else
		u64 tlen : 16;
		u64 raz_16_23 : 8;
		u64 fsz	: 6;
		u64 raz_30_31 : 2;
		u64 ssz	: 7;
		u64 ihi	: 1;
		u64 gsz	: 7;
		u64 g : 1;
		u64 raz_48_63 : 16;
#endif
	} s;
};

/**
 * struct pkt_hdr - Packet Input Header
 * @opcode: Request opcode (Major)
 * @arg: Request opcode (Minor)
 * @ctxc: Context control.
 * @unca: When set [UNC] is the uncertainty count for an input packet.
 *        The hardware uses uncertainty counts to predict
 *        output buffer use and avoid deadlock.
 * @info: Not used by input hardware. Available for use
 *        during SE processing.
 * @destport: The expected destination port/ring/channel for the packet.
 * @unc: Uncertainty count for an input packet.
 * @grp: SE group that will process the input packet.
 * @ctxl: Context Length in 64-bit words.
 * @uddl: User-defined data (UDD) length in bytes.
 * @ctxp: Context pointer. CTXP<63,2:0> must be zero in all cases.
 */
union pkt_hdr {
	u64 value[2];
	struct {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 opcode : 8;
		u64 arg	: 8;
		u64 ctxc : 2;
		u64 unca : 1;
		u64 raz_44 : 1;
		u64 info : 3;
		u64 destport : 9;
		u64 unc	: 8;
		u64 raz_19_23 : 5;
		u64 grp	: 3;
		u64 raz_15 : 1;
		u64 ctxl : 7;
		u64 uddl : 8;
#else
		u64 uddl : 8;
		u64 ctxl : 7;
		u64 raz_15 : 1;
		u64 grp	: 3;
		u64 raz_19_23 : 5;
		u64 unc	: 8;
		u64 destport : 9;
		u64 info : 3;
		u64 raz_44 : 1;
		u64 unca : 1;
		u64 ctxc : 2;
		u64 arg	: 8;
		u64 opcode : 8;
#endif
		__be64 ctxp;
	} s;
};

/**
 * struct slc_store_info - Solicited Paceket Output Store Information.
 * @ssz: The number of scatterlist pointers for the solicited output port
 *       packet.
 * @rptr: The result pointer for the solicited output port packet.
 *        If [SSZ]=0, [RPTR] must point directly to a buffer on the remote
 *        host that is large enough to hold the entire output packet.
 *        If [SSZ]!=0, [RPTR] must point to an array of ([SSZ]+3)/4
 *        sglist components at [RPTR] on the remote host.
 */
union slc_store_info {
	u64 value[2];
	struct {
#if defined(__BIG_ENDIAN_BITFIELD)
		u64 raz_39_63 : 25;
		u64 ssz	: 7;
		u64 raz_0_31 : 32;
#else
		u64 raz_0_31 : 32;
		u64 ssz	: 7;
		u64 raz_39_63 : 25;
#endif
		__be64 rptr;
	} s;
};

/**
 * struct nps_pkt_instr - NPS Packet Instruction of SE cores.
 * @dptr0 : Input pointer points to buffer in remote host.
 * @ih: Packet Instruction Header (8 bytes)
 * @irh: Packet Input Header (16 bytes)
 * @slc: Solicited Packet Output Store Information (16 bytes)
 * @fdata: Front data
 *
 * 64-Byte Instruction Format
 */
struct nps_pkt_instr {
	__be64 dptr0;
	union pkt_instr_hdr ih;
	union pkt_hdr irh;
	union slc_store_info slc;
	u64 fdata[2];
};

/**
 * struct ctx_hdr - Book keeping data about the crypto context
 * @pool: Pool used to allocate crypto context
 * @dma: Base DMA address of the cypto context
 * @ctx_dma: Actual usable crypto context for NITROX
 */
struct ctx_hdr {
	struct dma_pool *pool;
	dma_addr_t dma;
	dma_addr_t ctx_dma;
};

/*
 * struct sglist_component - SG list component format
 * @len0: The number of bytes at [PTR0] on the remote host.
 * @len1: The number of bytes at [PTR1] on the remote host.
 * @len2: The number of bytes at [PTR2] on the remote host.
 * @len3: The number of bytes at [PTR3] on the remote host.
 * @dma0: First pointer point to buffer in remote host.
 * @dma1: Second pointer point to buffer in remote host.
 * @dma2: Third pointer point to buffer in remote host.
 * @dma3: Fourth pointer point to buffer in remote host.
 */
struct nitrox_sgcomp {
	__be16 len[4];
	__be64 dma[4];
};

/*
 * strutct nitrox_sgtable - SG list information
 * @map_cnt: Number of buffers mapped
 * @nr_comp: Number of sglist components
 * @total_bytes: Total bytes in sglist.
 * @len: Total sglist components length.
 * @dma: DMA address of sglist component.
 * @dir: DMA direction.
 * @buf: crypto request buffer.
 * @sglist: SG list of input/output buffers.
 * @sgcomp: sglist component for NITROX.
 */
struct nitrox_sgtable {
	u8 map_bufs_cnt;
	u8 nr_sgcomp;
	u16 total_bytes;
	u32 len;
	dma_addr_t dma;
	enum dma_data_direction dir;

	struct scatterlist *buf;
	struct nitrox_sglist *sglist;
	struct nitrox_sgcomp *sgcomp;
};

/* Response Header Length */
#define ORH_HLEN	8
/* Completion bytes Length */
#define COMP_HLEN	8

struct resp_hdr {
	u64 orh;
	dma_addr_t orh_dma;
	u64 completion;
	dma_addr_t completion_dma;
};

typedef void (*completion_t)(struct skcipher_request *skreq, int err);

/**
 * struct nitrox_softreq - Represents the NIROX Request.
 * @response: response list entry
 * @backlog: Backlog list entry
 * @ndev: Device used to submit the request
 * @cmdq: Command queue for submission
 * @resp: Response headers
 * @instr: 64B instruction
 * @in: SG table for input
 * @out SG table for output
 * @tstamp: Request submitted time in jiffies
 * @callback: callback after request completion/timeout
 * @cb_arg: callback argument
 */
struct nitrox_softreq {
	struct list_head response;
	struct list_head backlog;

	u32 flags;
	gfp_t gfp;
	atomic_t status;
	bool inplace;

	struct nitrox_device *ndev;
	struct nitrox_cmdq *cmdq;

	struct nps_pkt_instr instr;
	struct resp_hdr resp;
	struct nitrox_sgtable in;
	struct nitrox_sgtable out;

	unsigned long tstamp;

	completion_t callback;
	struct skcipher_request *skreq;
};

#endif /* __NITROX_REQ_H */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
14fa93cd SJ	2	#ifndef __NITROX_REQ_H
	3	#define __NITROX_REQ_H
	4
	5	#include <linux/dma-mapping.h>
	6	#include <crypto/aes.h>
	7
	8	#include "nitrox_dev.h"
	9
	10	/**
	11	* struct gphdr - General purpose Header
	12	* @param0: first parameter.
	13	* @param1: second parameter.
	14	* @param2: third parameter.
	15	* @param3: fourth parameter.
	16	*
	17	* Params tell the iv and enc/dec data offsets.
	18	*/
	19	struct gphdr {
	20	__be16 param0;
	21	__be16 param1;
	22	__be16 param2;
	23	__be16 param3;
	24	};
	25
	26	/**
	27	* struct se_req_ctrl - SE request information.
	28	* @arg: Minor number of the opcode
	29	* @ctxc: Context control.
	30	* @unca: Uncertainity enabled.
	31	* @info: Additional information for SE cores.
	32	* @ctxl: Context length in bytes.
	33	* @uddl: User defined data length
	34	*/
	35	union se_req_ctrl {
	36	u64 value;
	37	struct {
	38	u64 raz : 22;
	39	u64 arg : 8;
	40	u64 ctxc : 2;
	41	u64 unca : 1;
	42	u64 info : 3;
	43	u64 unc : 8;
	44	u64 ctxl : 12;
	45	u64 uddl : 8;
	46	} s;
	47	};
	48
	49	struct nitrox_sglist {
	50	u16 len;
	51	u16 raz0;
	52	u32 raz1;
	53	dma_addr_t dma;
	54	};
	55
	56	#define MAX_IV_LEN 16
	57
	58	/**
	59	* struct se_crypto_request - SE crypto request structure.
	60	* @opcode: Request opcode (enc/dec)
	61	* @flags: flags from crypto subsystem
	62	* @ctx_handle: Crypto context handle.
	63	* @gph: GP Header
	64	* @ctrl: Request Information.
	65	* @in: Input sglist
66	* @out: Output sglist
67	*/
68	struct se_crypto_request {
69	u8 opcode;
70	gfp_t gfp;
71	u32 flags;
72	u64 ctx_handle;
73
74	struct gphdr gph;
75	union se_req_ctrl ctrl;
76
77	u8 iv[MAX_IV_LEN];
78	u16 ivsize;
79
80	struct scatterlist *src;
81	struct scatterlist *dst;
82	};
83
84	/* Crypto opcodes */
85	#define FLEXI_CRYPTO_ENCRYPT_HMAC 0x33
86	#define ENCRYPT 0
87	#define DECRYPT 1
88
89	/* IV from context */
90	#define IV_FROM_CTX 0
91	/* IV from Input data */
92	#define IV_FROM_DPTR 1
93
94	/**
95	* cipher opcodes for firmware
96	*/
97	enum flexi_cipher {
98	CIPHER_NULL = 0,
99	CIPHER_3DES_CBC,
100	CIPHER_3DES_ECB,
101	CIPHER_AES_CBC,
102	CIPHER_AES_ECB,
103	CIPHER_AES_CFB,
104	CIPHER_AES_CTR,
105	CIPHER_AES_GCM,
106	CIPHER_AES_XTS,
107	CIPHER_AES_CCM,
108	CIPHER_AES_CBC_CTS,
109	CIPHER_AES_ECB_CTS,
110	CIPHER_INVALID
111	};
112
113	/**
114	* struct crypto_keys - Crypto keys
115	* @key: Encryption key or KEY1 for AES-XTS
116	* @iv: Encryption IV or Tweak for AES-XTS
117	*/
118	struct crypto_keys {
119	union {
120	u8 key[AES_MAX_KEY_SIZE];
121	u8 key1[AES_MAX_KEY_SIZE];
122	} u;
123	u8 iv[AES_BLOCK_SIZE];
124	};
125
126	/**
127	* struct auth_keys - Authentication keys
128	* @ipad: IPAD or KEY2 for AES-XTS
129	* @opad: OPAD or AUTH KEY if auth_input_type = 1
130	*/
131	struct auth_keys {
132	union {
133	u8 ipad[64];
134	u8 key2[64];
135	} u;
136	u8 opad[64];
137	};
138
139	/**
140	* struct flexi_crypto_context - Crypto context
141	* @cipher_type: Encryption cipher type
142	* @aes_keylen: AES key length
143	* @iv_source: Encryption IV source
144	* @hash_type: Authentication type
145	* @auth_input_type: Authentication input type
146	* 1 - Authentication IV and KEY, microcode calculates OPAD/IPAD
147	* 0 - Authentication OPAD/IPAD
148	* @mac_len: mac length
149	* @crypto: Crypto keys
150	* @auth: Authentication keys
151	*/
152	struct flexi_crypto_context {
153	union {
154	__be64 flags;
155	struct {
156	#if defined(__BIG_ENDIAN_BITFIELD)
157	u64 cipher_type : 4;
158	u64 reserved_59 : 1;
159	u64 aes_keylen : 2;
160	u64 iv_source : 1;
161	u64 hash_type : 4;
162	u64 reserved_49_51 : 3;
163	u64 auth_input_type: 1;
164	u64 mac_len : 8;
165	u64 reserved_0_39 : 40;
166	#else
167	u64 reserved_0_39 : 40;
168	u64 mac_len : 8;
169	u64 auth_input_type: 1;
170	u64 reserved_49_51 : 3;
171	u64 hash_type : 4;
172	u64 iv_source : 1;
173	u64 aes_keylen : 2;
174	u64 reserved_59 : 1;
175	u64 cipher_type : 4;
176	#endif
177	} w0;
178	};
179
180	struct crypto_keys crypto;
181	struct auth_keys auth;
182	};
183
6111327e WW	184	struct crypto_ctx_hdr {
	185	struct dma_pool *pool;
	186	dma_addr_t dma;
	187	void *vaddr;
	188	};
	189
14fa93cd SJ	190	struct nitrox_crypto_ctx {
	191	struct nitrox_device *ndev;
	192	union {
	193	u64 ctx_handle;
	194	struct flexi_crypto_context *fctx;
	195	} u;
6111327e	196	struct crypto_ctx_hdr *chdr;
14fa93cd SJ	197	};
	198
	199	struct nitrox_kcrypt_request {
	200	struct se_crypto_request creq;
	201	struct nitrox_crypto_ctx *nctx;
	202	struct skcipher_request *skreq;
	203	};
	204
	205	/**
	206	* struct pkt_instr_hdr - Packet Instruction Header
	207	* @g: Gather used
	208	* When [G] is set and [GSZ] != 0, the instruction is
	209	* indirect gather instruction.
	210	* When [G] is set and [GSZ] = 0, the instruction is
	211	* direct gather instruction.
	212	* @gsz: Number of pointers in the indirect gather list
	213	* @ihi: When set hardware duplicates the 1st 8 bytes of pkt_instr_hdr
	214	* and adds them to the packet after the pkt_instr_hdr but before any UDD
	215	* @ssz: Not used by the input hardware. But can become slc_store_int[SSZ]
	216	* when [IHI] is set.
	217	* @fsz: The number of front data bytes directly included in the
	218	* PCIe instruction.
	219	* @tlen: The length of the input packet in bytes, include:
	220	* - 16B pkt_hdr
	221	* - Inline context bytes if any,
	222	* - UDD if any,
	223	* - packet payload bytes
	224	*/
	225	union pkt_instr_hdr {
	226	u64 value;
	227	struct {
	228	#if defined(__BIG_ENDIAN_BITFIELD)
	229	u64 raz_48_63 : 16;
	230	u64 g : 1;
	231	u64 gsz : 7;
	232	u64 ihi : 1;
	233	u64 ssz : 7;
	234	u64 raz_30_31 : 2;
	235	u64 fsz : 6;
	236	u64 raz_16_23 : 8;
	237	u64 tlen : 16;
	238	#else
	239	u64 tlen : 16;
	240	u64 raz_16_23 : 8;
	241	u64 fsz : 6;
	242	u64 raz_30_31 : 2;
	243	u64 ssz : 7;
	244	u64 ihi : 1;
	245	u64 gsz : 7;
	246	u64 g : 1;
	247	u64 raz_48_63 : 16;
	248	#endif
	249	} s;
	250	};
	251
	252	/**
	253	* struct pkt_hdr - Packet Input Header
	254	* @opcode: Request opcode (Major)
	255	* @arg: Request opcode (Minor)
	256	* @ctxc: Context control.
	257	* @unca: When set [UNC] is the uncertainty count for an input packet.
	258	* The hardware uses uncertainty counts to predict
	259	* output buffer use and avoid deadlock.
	260	* @info: Not used by input hardware. Available for use
261	* during SE processing.
262	* @destport: The expected destination port/ring/channel for the packet.
263	* @unc: Uncertainty count for an input packet.
264	* @grp: SE group that will process the input packet.
265	* @ctxl: Context Length in 64-bit words.
266	* @uddl: User-defined data (UDD) length in bytes.
267	* @ctxp: Context pointer. CTXP<63,2:0> must be zero in all cases.
268	*/
269	union pkt_hdr {
270	u64 value[2];
271	struct {
272	#if defined(__BIG_ENDIAN_BITFIELD)
273	u64 opcode : 8;
274	u64 arg : 8;
275	u64 ctxc : 2;
276	u64 unca : 1;
277	u64 raz_44 : 1;
278	u64 info : 3;
279	u64 destport : 9;
280	u64 unc : 8;
281	u64 raz_19_23 : 5;
282	u64 grp : 3;
283	u64 raz_15 : 1;
284	u64 ctxl : 7;
285	u64 uddl : 8;
286	#else
287	u64 uddl : 8;
288	u64 ctxl : 7;
289	u64 raz_15 : 1;
290	u64 grp : 3;
291	u64 raz_19_23 : 5;
292	u64 unc : 8;
293	u64 destport : 9;
294	u64 info : 3;
295	u64 raz_44 : 1;
296	u64 unca : 1;
297	u64 ctxc : 2;
298	u64 arg : 8;
299	u64 opcode : 8;
300	#endif
301	__be64 ctxp;
302	} s;
303	};
304
305	/**
306	* struct slc_store_info - Solicited Paceket Output Store Information.
307	* @ssz: The number of scatterlist pointers for the solicited output port
308	* packet.
309	* @rptr: The result pointer for the solicited output port packet.
310	* If [SSZ]=0, [RPTR] must point directly to a buffer on the remote
311	* host that is large enough to hold the entire output packet.
312	* If [SSZ]!=0, [RPTR] must point to an array of ([SSZ]+3)/4
313	* sglist components at [RPTR] on the remote host.
314	*/
315	union slc_store_info {
316	u64 value[2];
317	struct {
318	#if defined(__BIG_ENDIAN_BITFIELD)
319	u64 raz_39_63 : 25;
320	u64 ssz : 7;
321	u64 raz_0_31 : 32;
322	#else
323	u64 raz_0_31 : 32;
324	u64 ssz : 7;
325	u64 raz_39_63 : 25;
326	#endif
327	__be64 rptr;
328	} s;
329	};
330
331	/**
332	* struct nps_pkt_instr - NPS Packet Instruction of SE cores.
333	* @dptr0 : Input pointer points to buffer in remote host.
334	* @ih: Packet Instruction Header (8 bytes)
335	* @irh: Packet Input Header (16 bytes)
336	* @slc: Solicited Packet Output Store Information (16 bytes)
337	* @fdata: Front data
338	*
339	* 64-Byte Instruction Format
340	*/
341	struct nps_pkt_instr {
342	__be64 dptr0;
343	union pkt_instr_hdr ih;
344	union pkt_hdr irh;
345	union slc_store_info slc;
346	u64 fdata[2];
347	};
348
349	/**
350	* struct ctx_hdr - Book keeping data about the crypto context
351	* @pool: Pool used to allocate crypto context
352	* @dma: Base DMA address of the cypto context
353	* @ctx_dma: Actual usable crypto context for NITROX
354	*/
355	struct ctx_hdr {
356	struct dma_pool *pool;
357	dma_addr_t dma;
358	dma_addr_t ctx_dma;
359	};
360
361	/*
362	* struct sglist_component - SG list component format
363	* @len0: The number of bytes at [PTR0] on the remote host.
364	* @len1: The number of bytes at [PTR1] on the remote host.
365	* @len2: The number of bytes at [PTR2] on the remote host.
366	* @len3: The number of bytes at [PTR3] on the remote host.
367	* @dma0: First pointer point to buffer in remote host.
368	* @dma1: Second pointer point to buffer in remote host.
369	* @dma2: Third pointer point to buffer in remote host.
370	* @dma3: Fourth pointer point to buffer in remote host.
371	*/
372	struct nitrox_sgcomp {
373	__be16 len[4];
374	__be64 dma[4];
375	};
376
377	/*
378	* strutct nitrox_sgtable - SG list information
379	* @map_cnt: Number of buffers mapped
380	* @nr_comp: Number of sglist components
381	* @total_bytes: Total bytes in sglist.
382	* @len: Total sglist components length.
383	* @dma: DMA address of sglist component.
384	* @dir: DMA direction.
385	* @buf: crypto request buffer.
386	* @sglist: SG list of input/output buffers.
387	* @sgcomp: sglist component for NITROX.
388	*/
389	struct nitrox_sgtable {
390	u8 map_bufs_cnt;
391	u8 nr_sgcomp;
392	u16 total_bytes;
393	u32 len;
394	dma_addr_t dma;
395	enum dma_data_direction dir;
396
397	struct scatterlist *buf;
398	struct nitrox_sglist *sglist;
399	struct nitrox_sgcomp *sgcomp;
400	};
401
402	/* Response Header Length */
403	#define ORH_HLEN 8
404	/* Completion bytes Length */
405	#define COMP_HLEN 8
406
407	struct resp_hdr {
408	u64 orh;
409	dma_addr_t orh_dma;
410	u64 completion;
411	dma_addr_t completion_dma;
412	};
413
414	typedef void (completion_t)(struct skcipher_request skreq, int err);
415
416	/**
417	* struct nitrox_softreq - Represents the NIROX Request.
418	* @response: response list entry
419	* @backlog: Backlog list entry
420	* @ndev: Device used to submit the request
421	* @cmdq: Command queue for submission
422	* @resp: Response headers
423	* @instr: 64B instruction
424	* @in: SG table for input
425	* @out SG table for output
426	* @tstamp: Request submitted time in jiffies
427	* @callback: callback after request completion/timeout
428	* @cb_arg: callback argument
429	*/
430	struct nitrox_softreq {
431	struct list_head response;
432	struct list_head backlog;
433
434	u32 flags;
435	gfp_t gfp;
436	atomic_t status;
437	bool inplace;
438
439	struct nitrox_device *ndev;
440	struct nitrox_cmdq *cmdq;
441
442	struct nps_pkt_instr instr;
443	struct resp_hdr resp;
444	struct nitrox_sgtable in;
445	struct nitrox_sgtable out;
446
447	unsigned long tstamp;
448
449	completion_t callback;
450	struct skcipher_request *skreq;
451	};
452
453	#endif /* __NITROX_REQ_H */