xref: /linux/drivers/infiniband/hw/ionic/ionic_fw.h (revision cb8fef4b07f71da01843457b66e579ad248a625e)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /* Copyright (C) 2018-2025, Advanced Micro Devices, Inc. */
3 
4 #ifndef _IONIC_FW_H_
5 #define _IONIC_FW_H_
6 
7 #include <linux/kernel.h>
8 #include <rdma/ib_verbs.h>
9 
10 /* common for ib spec */
11 
12 #define IONIC_EXP_DBELL_SZ		8
13 
14 enum ionic_mrid_bits {
15 	IONIC_MRID_INDEX_SHIFT		= 8,
16 };
17 
18 static inline u32 ionic_mrid(u32 index, u8 key)
19 {
20 	return (index << IONIC_MRID_INDEX_SHIFT) | key;
21 }
22 
23 static inline u32 ionic_mrid_index(u32 lrkey)
24 {
25 	return lrkey >> IONIC_MRID_INDEX_SHIFT;
26 }
27 
28 /* common to all versions */
29 
30 /* wqe scatter gather element */
31 struct ionic_sge {
32 	__be64				va;
33 	__be32				len;
34 	__be32				lkey;
35 };
36 
37 /* admin queue mr type */
38 enum ionic_mr_flags {
39 	/* bits that determine mr access */
40 	IONIC_MRF_LOCAL_WRITE		= BIT(0),
41 	IONIC_MRF_REMOTE_WRITE		= BIT(1),
42 	IONIC_MRF_REMOTE_READ		= BIT(2),
43 	IONIC_MRF_REMOTE_ATOMIC		= BIT(3),
44 	IONIC_MRF_MW_BIND		= BIT(4),
45 	IONIC_MRF_ZERO_BASED		= BIT(5),
46 	IONIC_MRF_ON_DEMAND		= BIT(6),
47 	IONIC_MRF_PB			= BIT(7),
48 	IONIC_MRF_ACCESS_MASK		= BIT(12) - 1,
49 
50 	/* bits that determine mr type */
51 	IONIC_MRF_UKEY_EN		= BIT(13),
52 	IONIC_MRF_IS_MW			= BIT(14),
53 	IONIC_MRF_INV_EN		= BIT(15),
54 
55 	/* base flags combinations for mr types */
56 	IONIC_MRF_USER_MR		= 0,
57 	IONIC_MRF_PHYS_MR		= (IONIC_MRF_UKEY_EN |
58 					   IONIC_MRF_INV_EN),
59 	IONIC_MRF_MW_1			= (IONIC_MRF_UKEY_EN |
60 					   IONIC_MRF_IS_MW),
61 	IONIC_MRF_MW_2			= (IONIC_MRF_UKEY_EN |
62 					   IONIC_MRF_IS_MW |
63 					   IONIC_MRF_INV_EN),
64 };
65 
66 static inline int to_ionic_mr_flags(int access)
67 {
68 	int flags = 0;
69 
70 	if (access & IB_ACCESS_LOCAL_WRITE)
71 		flags |= IONIC_MRF_LOCAL_WRITE;
72 
73 	if (access & IB_ACCESS_REMOTE_READ)
74 		flags |= IONIC_MRF_REMOTE_READ;
75 
76 	if (access & IB_ACCESS_REMOTE_WRITE)
77 		flags |= IONIC_MRF_REMOTE_WRITE;
78 
79 	if (access & IB_ACCESS_REMOTE_ATOMIC)
80 		flags |= IONIC_MRF_REMOTE_ATOMIC;
81 
82 	if (access & IB_ACCESS_MW_BIND)
83 		flags |= IONIC_MRF_MW_BIND;
84 
85 	if (access & IB_ZERO_BASED)
86 		flags |= IONIC_MRF_ZERO_BASED;
87 
88 	return flags;
89 }
90 
91 enum ionic_srq_flags {
92 	IONIC_SRQF_CMB			= BIT(0),
93 };
94 
95 enum ionic_qp_flags {
96 	/* bits that determine qp access */
97 	IONIC_QPF_REMOTE_WRITE		= BIT(0),
98 	IONIC_QPF_REMOTE_READ		= BIT(1),
99 	IONIC_QPF_REMOTE_ATOMIC		= BIT(2),
100 
101 	/* bits that determine other qp behavior */
102 	IONIC_QPF_SQ_PB			= BIT(6),
103 	IONIC_QPF_RQ_PB			= BIT(7),
104 	IONIC_QPF_SQ_SPEC		= BIT(8),
105 	IONIC_QPF_RQ_SPEC		= BIT(9),
106 	IONIC_QPF_REMOTE_PRIVILEGED	= BIT(10),
107 	IONIC_QPF_SQ_DRAINING		= BIT(11),
108 	IONIC_QPF_SQD_NOTIFY		= BIT(12),
109 	IONIC_QPF_SQ_CMB		= BIT(13),
110 	IONIC_QPF_RQ_CMB		= BIT(14),
111 	IONIC_QPF_PRIVILEGED		= BIT(15),
112 
113 	IONIC_QP_USER_FLAGS_MASK	= GENMASK(31, 16),
114 };
115 
116 static inline int from_ionic_qp_flags(int flags)
117 {
118 	int access_flags = 0;
119 
120 	if (flags & IONIC_QPF_REMOTE_WRITE)
121 		access_flags |= IB_ACCESS_REMOTE_WRITE;
122 
123 	if (flags & IONIC_QPF_REMOTE_READ)
124 		access_flags |= IB_ACCESS_REMOTE_READ;
125 
126 	if (flags & IONIC_QPF_REMOTE_ATOMIC)
127 		access_flags |= IB_ACCESS_REMOTE_ATOMIC;
128 
129 	return access_flags;
130 }
131 
132 static inline int to_ionic_qp_flags(int access, bool sqd_notify,
133 				    bool sq_is_cmb, bool rq_is_cmb,
134 				    bool sq_spec, bool rq_spec,
135 				    bool privileged, bool remote_privileged)
136 {
137 	int flags = 0;
138 
139 	if (access & IB_ACCESS_REMOTE_WRITE)
140 		flags |= IONIC_QPF_REMOTE_WRITE;
141 
142 	if (access & IB_ACCESS_REMOTE_READ)
143 		flags |= IONIC_QPF_REMOTE_READ;
144 
145 	if (access & IB_ACCESS_REMOTE_ATOMIC)
146 		flags |= IONIC_QPF_REMOTE_ATOMIC;
147 
148 	if (sqd_notify)
149 		flags |= IONIC_QPF_SQD_NOTIFY;
150 
151 	if (sq_is_cmb)
152 		flags |= IONIC_QPF_SQ_CMB;
153 
154 	if (rq_is_cmb)
155 		flags |= IONIC_QPF_RQ_CMB;
156 
157 	if (sq_spec)
158 		flags |= IONIC_QPF_SQ_SPEC;
159 
160 	if (rq_spec)
161 		flags |= IONIC_QPF_RQ_SPEC;
162 
163 	if (privileged)
164 		flags |= IONIC_QPF_PRIVILEGED;
165 
166 	if (remote_privileged)
167 		flags |= IONIC_QPF_REMOTE_PRIVILEGED;
168 
169 	return flags;
170 }
171 
172 /* cqe non-admin status indicated in status_length field when err bit is set */
173 enum ionic_status {
174 	IONIC_STS_OK,
175 	IONIC_STS_LOCAL_LEN_ERR,
176 	IONIC_STS_LOCAL_QP_OPER_ERR,
177 	IONIC_STS_LOCAL_PROT_ERR,
178 	IONIC_STS_WQE_FLUSHED_ERR,
179 	IONIC_STS_MEM_MGMT_OPER_ERR,
180 	IONIC_STS_BAD_RESP_ERR,
181 	IONIC_STS_LOCAL_ACC_ERR,
182 	IONIC_STS_REMOTE_INV_REQ_ERR,
183 	IONIC_STS_REMOTE_ACC_ERR,
184 	IONIC_STS_REMOTE_OPER_ERR,
185 	IONIC_STS_RETRY_EXCEEDED,
186 	IONIC_STS_RNR_RETRY_EXCEEDED,
187 	IONIC_STS_XRC_VIO_ERR,
188 	IONIC_STS_LOCAL_SGL_INV_ERR,
189 };
190 
191 static inline int ionic_to_ib_status(int sts)
192 {
193 	switch (sts) {
194 	case IONIC_STS_OK:
195 		return IB_WC_SUCCESS;
196 	case IONIC_STS_LOCAL_LEN_ERR:
197 		return IB_WC_LOC_LEN_ERR;
198 	case IONIC_STS_LOCAL_QP_OPER_ERR:
199 	case IONIC_STS_LOCAL_SGL_INV_ERR:
200 		return IB_WC_LOC_QP_OP_ERR;
201 	case IONIC_STS_LOCAL_PROT_ERR:
202 		return IB_WC_LOC_PROT_ERR;
203 	case IONIC_STS_WQE_FLUSHED_ERR:
204 		return IB_WC_WR_FLUSH_ERR;
205 	case IONIC_STS_MEM_MGMT_OPER_ERR:
206 		return IB_WC_MW_BIND_ERR;
207 	case IONIC_STS_BAD_RESP_ERR:
208 		return IB_WC_BAD_RESP_ERR;
209 	case IONIC_STS_LOCAL_ACC_ERR:
210 		return IB_WC_LOC_ACCESS_ERR;
211 	case IONIC_STS_REMOTE_INV_REQ_ERR:
212 		return IB_WC_REM_INV_REQ_ERR;
213 	case IONIC_STS_REMOTE_ACC_ERR:
214 		return IB_WC_REM_ACCESS_ERR;
215 	case IONIC_STS_REMOTE_OPER_ERR:
216 		return IB_WC_REM_OP_ERR;
217 	case IONIC_STS_RETRY_EXCEEDED:
218 		return IB_WC_RETRY_EXC_ERR;
219 	case IONIC_STS_RNR_RETRY_EXCEEDED:
220 		return IB_WC_RNR_RETRY_EXC_ERR;
221 	case IONIC_STS_XRC_VIO_ERR:
222 	default:
223 		return IB_WC_GENERAL_ERR;
224 	}
225 }
226 
227 /* admin queue qp type */
228 enum ionic_qp_type {
229 	IONIC_QPT_RC,
230 	IONIC_QPT_UC,
231 	IONIC_QPT_RD,
232 	IONIC_QPT_UD,
233 	IONIC_QPT_SRQ,
234 	IONIC_QPT_XRC_INI,
235 	IONIC_QPT_XRC_TGT,
236 	IONIC_QPT_XRC_SRQ,
237 };
238 
239 static inline int to_ionic_qp_type(enum ib_qp_type type)
240 {
241 	switch (type) {
242 	case IB_QPT_GSI:
243 	case IB_QPT_UD:
244 		return IONIC_QPT_UD;
245 	case IB_QPT_RC:
246 		return IONIC_QPT_RC;
247 	case IB_QPT_UC:
248 		return IONIC_QPT_UC;
249 	case IB_QPT_XRC_INI:
250 		return IONIC_QPT_XRC_INI;
251 	case IB_QPT_XRC_TGT:
252 		return IONIC_QPT_XRC_TGT;
253 	default:
254 		return -EINVAL;
255 	}
256 }
257 
258 /* admin queue qp state */
259 enum ionic_qp_state {
260 	IONIC_QPS_RESET,
261 	IONIC_QPS_INIT,
262 	IONIC_QPS_RTR,
263 	IONIC_QPS_RTS,
264 	IONIC_QPS_SQD,
265 	IONIC_QPS_SQE,
266 	IONIC_QPS_ERR,
267 };
268 
269 static inline int from_ionic_qp_state(enum ionic_qp_state state)
270 {
271 	switch (state) {
272 	case IONIC_QPS_RESET:
273 		return IB_QPS_RESET;
274 	case IONIC_QPS_INIT:
275 		return IB_QPS_INIT;
276 	case IONIC_QPS_RTR:
277 		return IB_QPS_RTR;
278 	case IONIC_QPS_RTS:
279 		return IB_QPS_RTS;
280 	case IONIC_QPS_SQD:
281 		return IB_QPS_SQD;
282 	case IONIC_QPS_SQE:
283 		return IB_QPS_SQE;
284 	case IONIC_QPS_ERR:
285 		return IB_QPS_ERR;
286 	default:
287 		return -EINVAL;
288 	}
289 }
290 
291 static inline int to_ionic_qp_state(enum ib_qp_state state)
292 {
293 	switch (state) {
294 	case IB_QPS_RESET:
295 		return IONIC_QPS_RESET;
296 	case IB_QPS_INIT:
297 		return IONIC_QPS_INIT;
298 	case IB_QPS_RTR:
299 		return IONIC_QPS_RTR;
300 	case IB_QPS_RTS:
301 		return IONIC_QPS_RTS;
302 	case IB_QPS_SQD:
303 		return IONIC_QPS_SQD;
304 	case IB_QPS_SQE:
305 		return IONIC_QPS_SQE;
306 	case IB_QPS_ERR:
307 		return IONIC_QPS_ERR;
308 	default:
309 		return 0;
310 	}
311 }
312 
313 static inline int to_ionic_qp_modify_state(enum ib_qp_state to_state,
314 					   enum ib_qp_state from_state)
315 {
316 	return to_ionic_qp_state(to_state) |
317 		(to_ionic_qp_state(from_state) << 4);
318 }
319 
320 /* fw abi v1 */
321 
322 /* data payload part of v1 wqe */
323 union ionic_v1_pld {
324 	struct ionic_sge	sgl[2];
325 	__be32			spec32[8];
326 	__be16			spec16[16];
327 	__u8			data[32];
328 };
329 
330 /* completion queue v1 cqe */
331 struct ionic_v1_cqe {
332 	union {
333 		struct {
334 			__be16		cmd_idx;
335 			__u8		cmd_op;
336 			__u8		rsvd[17];
337 			__le16		old_sq_cindex;
338 			__le16		old_rq_cq_cindex;
339 		} admin;
340 		struct {
341 			__le64		wqe_idx_timestamp;
342 			__be32		src_qpn_op;
343 			__u8		src_mac[6];
344 			__be16		vlan_tag;
345 			__be32		imm_data_rkey;
346 		} recv;
347 		struct {
348 			__u8		rsvd[4];
349 			__be32		msg_msn;
350 			__u8		rsvd2[8];
351 			__le64		npg_wqe_idx_timestamp;
352 		} send;
353 	};
354 	__be32				status_length;
355 	__be32				qid_type_flags;
356 };
357 
358 /* bits for cqe wqe_idx and timestamp */
359 enum ionic_v1_cqe_wqe_idx_timestamp_bits {
360 	IONIC_V1_CQE_WQE_IDX_MASK	= 0xffff,
361 	IONIC_V1_CQE_TIMESTAMP_SHIFT	= 16,
362 };
363 
364 /* bits for cqe recv */
365 enum ionic_v1_cqe_src_qpn_bits {
366 	IONIC_V1_CQE_RECV_QPN_MASK	= 0xffffff,
367 	IONIC_V1_CQE_RECV_OP_SHIFT	= 24,
368 
369 	/* MASK could be 0x3, but need 0x1f for makeshift values:
370 	 * OP_TYPE_RDMA_OPER_WITH_IMM, OP_TYPE_SEND_RCVD
371 	 */
372 	IONIC_V1_CQE_RECV_OP_MASK	= 0x1f,
373 	IONIC_V1_CQE_RECV_OP_SEND	= 0,
374 	IONIC_V1_CQE_RECV_OP_SEND_INV	= 1,
375 	IONIC_V1_CQE_RECV_OP_SEND_IMM	= 2,
376 	IONIC_V1_CQE_RECV_OP_RDMA_IMM	= 3,
377 
378 	IONIC_V1_CQE_RECV_IS_IPV4	= BIT(7 + IONIC_V1_CQE_RECV_OP_SHIFT),
379 	IONIC_V1_CQE_RECV_IS_VLAN	= BIT(6 + IONIC_V1_CQE_RECV_OP_SHIFT),
380 };
381 
382 /* bits for cqe qid_type_flags */
383 enum ionic_v1_cqe_qtf_bits {
384 	IONIC_V1_CQE_COLOR		= BIT(0),
385 	IONIC_V1_CQE_ERROR		= BIT(1),
386 	IONIC_V1_CQE_TYPE_SHIFT		= 5,
387 	IONIC_V1_CQE_TYPE_MASK		= 0x7,
388 	IONIC_V1_CQE_QID_SHIFT		= 8,
389 
390 	IONIC_V1_CQE_TYPE_ADMIN		= 0,
391 	IONIC_V1_CQE_TYPE_RECV		= 1,
392 	IONIC_V1_CQE_TYPE_SEND_MSN	= 2,
393 	IONIC_V1_CQE_TYPE_SEND_NPG	= 3,
394 };
395 
396 static inline bool ionic_v1_cqe_color(struct ionic_v1_cqe *cqe)
397 {
398 	return cqe->qid_type_flags & cpu_to_be32(IONIC_V1_CQE_COLOR);
399 }
400 
401 static inline bool ionic_v1_cqe_error(struct ionic_v1_cqe *cqe)
402 {
403 	return cqe->qid_type_flags & cpu_to_be32(IONIC_V1_CQE_ERROR);
404 }
405 
406 static inline bool ionic_v1_cqe_recv_is_ipv4(struct ionic_v1_cqe *cqe)
407 {
408 	return cqe->recv.src_qpn_op & cpu_to_be32(IONIC_V1_CQE_RECV_IS_IPV4);
409 }
410 
411 static inline bool ionic_v1_cqe_recv_is_vlan(struct ionic_v1_cqe *cqe)
412 {
413 	return cqe->recv.src_qpn_op & cpu_to_be32(IONIC_V1_CQE_RECV_IS_VLAN);
414 }
415 
416 static inline void ionic_v1_cqe_clean(struct ionic_v1_cqe *cqe)
417 {
418 	cqe->qid_type_flags |= cpu_to_be32(~0u << IONIC_V1_CQE_QID_SHIFT);
419 }
420 
421 static inline u32 ionic_v1_cqe_qtf(struct ionic_v1_cqe *cqe)
422 {
423 	return be32_to_cpu(cqe->qid_type_flags);
424 }
425 
426 static inline u8 ionic_v1_cqe_qtf_type(u32 qtf)
427 {
428 	return (qtf >> IONIC_V1_CQE_TYPE_SHIFT) & IONIC_V1_CQE_TYPE_MASK;
429 }
430 
431 static inline u32 ionic_v1_cqe_qtf_qid(u32 qtf)
432 {
433 	return qtf >> IONIC_V1_CQE_QID_SHIFT;
434 }
435 
436 /* v1 base wqe header */
437 struct ionic_v1_base_hdr {
438 	__le64				wqe_idx;
439 	__u8				op;
440 	__u8				num_sge_key;
441 	__be16				flags;
442 	__be32				imm_data_key;
443 };
444 
445 /* v1 receive wqe body */
446 struct ionic_v1_recv_bdy {
447 	__u8				rsvd[16];
448 	union ionic_v1_pld		pld;
449 };
450 
451 /* v1 send/rdma wqe body (common, has sgl) */
452 struct ionic_v1_common_bdy {
453 	union {
454 		struct {
455 			__be32		ah_id;
456 			__be32		dest_qpn;
457 			__be32		dest_qkey;
458 		} send;
459 		struct {
460 			__be32		remote_va_high;
461 			__be32		remote_va_low;
462 			__be32		remote_rkey;
463 		} rdma;
464 	};
465 	__be32				length;
466 	union ionic_v1_pld		pld;
467 };
468 
469 /* v1 atomic wqe body */
470 struct ionic_v1_atomic_bdy {
471 	__be32				remote_va_high;
472 	__be32				remote_va_low;
473 	__be32				remote_rkey;
474 	__be32				swap_add_high;
475 	__be32				swap_add_low;
476 	__be32				compare_high;
477 	__be32				compare_low;
478 	__u8				rsvd[4];
479 	struct ionic_sge		sge;
480 };
481 
482 /* v1 reg mr wqe body */
483 struct ionic_v1_reg_mr_bdy {
484 	__be64				va;
485 	__be64				length;
486 	__be64				offset;
487 	__be64				dma_addr;
488 	__be32				map_count;
489 	__be16				flags;
490 	__u8				dir_size_log2;
491 	__u8				page_size_log2;
492 	__u8				rsvd[8];
493 };
494 
495 /* v1 bind mw wqe body */
496 struct ionic_v1_bind_mw_bdy {
497 	__be64				va;
498 	__be64				length;
499 	__be32				lkey;
500 	__be16				flags;
501 	__u8				rsvd[26];
502 };
503 
504 /* v1 send/recv wqe */
505 struct ionic_v1_wqe {
506 	struct ionic_v1_base_hdr	base;
507 	union {
508 		struct ionic_v1_recv_bdy	recv;
509 		struct ionic_v1_common_bdy	common;
510 		struct ionic_v1_atomic_bdy	atomic;
511 		struct ionic_v1_reg_mr_bdy	reg_mr;
512 		struct ionic_v1_bind_mw_bdy	bind_mw;
513 	};
514 };
515 
516 /* queue pair v1 send opcodes */
517 enum ionic_v1_op {
518 	IONIC_V1_OP_SEND,
519 	IONIC_V1_OP_SEND_INV,
520 	IONIC_V1_OP_SEND_IMM,
521 	IONIC_V1_OP_RDMA_READ,
522 	IONIC_V1_OP_RDMA_WRITE,
523 	IONIC_V1_OP_RDMA_WRITE_IMM,
524 	IONIC_V1_OP_ATOMIC_CS,
525 	IONIC_V1_OP_ATOMIC_FA,
526 	IONIC_V1_OP_REG_MR,
527 	IONIC_V1_OP_LOCAL_INV,
528 	IONIC_V1_OP_BIND_MW,
529 
530 	/* flags */
531 	IONIC_V1_FLAG_FENCE		= BIT(0),
532 	IONIC_V1_FLAG_SOL		= BIT(1),
533 	IONIC_V1_FLAG_INL		= BIT(2),
534 	IONIC_V1_FLAG_SIG		= BIT(3),
535 
536 	/* flags last four bits for sgl spec format */
537 	IONIC_V1_FLAG_SPEC32		= (1u << 12),
538 	IONIC_V1_FLAG_SPEC16		= (2u << 12),
539 	IONIC_V1_SPEC_FIRST_SGE		= 2,
540 };
541 
542 /* queue pair v2 send opcodes */
543 enum ionic_v2_op {
544 	IONIC_V2_OPSL_OUT          = 0x20,
545 	IONIC_V2_OPSL_IMM          = 0x40,
546 	IONIC_V2_OPSL_INV          = 0x80,
547 
548 	IONIC_V2_OP_SEND           = 0x0 | IONIC_V2_OPSL_OUT,
549 	IONIC_V2_OP_SEND_IMM       = IONIC_V2_OP_SEND | IONIC_V2_OPSL_IMM,
550 	IONIC_V2_OP_SEND_INV       = IONIC_V2_OP_SEND | IONIC_V2_OPSL_INV,
551 
552 	IONIC_V2_OP_RDMA_WRITE     = 0x1 | IONIC_V2_OPSL_OUT,
553 	IONIC_V2_OP_RDMA_WRITE_IMM = IONIC_V2_OP_RDMA_WRITE | IONIC_V2_OPSL_IMM,
554 
555 	IONIC_V2_OP_RDMA_READ      = 0x2,
556 
557 	IONIC_V2_OP_ATOMIC_CS      = 0x4,
558 	IONIC_V2_OP_ATOMIC_FA      = 0x5,
559 	IONIC_V2_OP_REG_MR         = 0x6,
560 	IONIC_V2_OP_LOCAL_INV      = 0x7,
561 	IONIC_V2_OP_BIND_MW        = 0x8,
562 };
563 
564 static inline size_t ionic_v1_send_wqe_min_size(int min_sge, int min_data,
565 						int spec, bool expdb)
566 {
567 	size_t sz_wqe, sz_sgl, sz_data;
568 
569 	if (spec > IONIC_V1_SPEC_FIRST_SGE)
570 		min_sge += IONIC_V1_SPEC_FIRST_SGE;
571 
572 	if (expdb) {
573 		min_sge += 1;
574 		min_data += IONIC_EXP_DBELL_SZ;
575 	}
576 
577 	sz_wqe = sizeof(struct ionic_v1_wqe);
578 	sz_sgl = offsetof(struct ionic_v1_wqe, common.pld.sgl[min_sge]);
579 	sz_data = offsetof(struct ionic_v1_wqe, common.pld.data[min_data]);
580 
581 	if (sz_sgl > sz_wqe)
582 		sz_wqe = sz_sgl;
583 
584 	if (sz_data > sz_wqe)
585 		sz_wqe = sz_data;
586 
587 	return sz_wqe;
588 }
589 
590 static inline int ionic_v1_send_wqe_max_sge(u8 stride_log2, int spec,
591 					    bool expdb)
592 {
593 	struct ionic_sge *sge = (void *)(1ull << stride_log2);
594 	struct ionic_v1_wqe *wqe = (void *)0;
595 	int num_sge = 0;
596 
597 	if (expdb)
598 		sge -= 1;
599 
600 	if (spec > IONIC_V1_SPEC_FIRST_SGE)
601 		num_sge = IONIC_V1_SPEC_FIRST_SGE;
602 
603 	num_sge = sge - &wqe->common.pld.sgl[num_sge];
604 
605 	if (spec && num_sge > spec)
606 		num_sge = spec;
607 
608 	return num_sge;
609 }
610 
611 static inline int ionic_v1_send_wqe_max_data(u8 stride_log2, bool expdb)
612 {
613 	struct ionic_v1_wqe *wqe = (void *)0;
614 	__u8 *data = (void *)(1ull << stride_log2);
615 
616 	if (expdb)
617 		data -= IONIC_EXP_DBELL_SZ;
618 
619 	return data - wqe->common.pld.data;
620 }
621 
622 static inline size_t ionic_v1_recv_wqe_min_size(int min_sge, int spec,
623 						bool expdb)
624 {
625 	size_t sz_wqe, sz_sgl;
626 
627 	if (spec > IONIC_V1_SPEC_FIRST_SGE)
628 		min_sge += IONIC_V1_SPEC_FIRST_SGE;
629 
630 	if (expdb)
631 		min_sge += 1;
632 
633 	sz_wqe = sizeof(struct ionic_v1_wqe);
634 	sz_sgl = offsetof(struct ionic_v1_wqe, recv.pld.sgl[min_sge]);
635 
636 	if (sz_sgl > sz_wqe)
637 		sz_wqe = sz_sgl;
638 
639 	return sz_wqe;
640 }
641 
642 static inline int ionic_v1_recv_wqe_max_sge(u8 stride_log2, int spec,
643 					    bool expdb)
644 {
645 	struct ionic_sge *sge = (void *)(1ull << stride_log2);
646 	struct ionic_v1_wqe *wqe = (void *)0;
647 	int num_sge = 0;
648 
649 	if (expdb)
650 		sge -= 1;
651 
652 	if (spec > IONIC_V1_SPEC_FIRST_SGE)
653 		num_sge = IONIC_V1_SPEC_FIRST_SGE;
654 
655 	num_sge = sge - &wqe->recv.pld.sgl[num_sge];
656 
657 	if (spec && num_sge > spec)
658 		num_sge = spec;
659 
660 	return num_sge;
661 }
662 
663 static inline int ionic_v1_use_spec_sge(int min_sge, int spec)
664 {
665 	if (!spec || min_sge > spec)
666 		return 0;
667 
668 	if (min_sge <= IONIC_V1_SPEC_FIRST_SGE)
669 		return IONIC_V1_SPEC_FIRST_SGE;
670 
671 	return spec;
672 }
673 
674 struct ionic_admin_stats_hdr {
675 	__le64		dma_addr;
676 	__le32		length;
677 	__le32		id_ver;
678 	__u8		type_state;
679 } __packed;
680 
681 #define IONIC_ADMIN_STATS_HDRS_IN_V1_LEN 17
682 static_assert(sizeof(struct ionic_admin_stats_hdr) ==
683 	       IONIC_ADMIN_STATS_HDRS_IN_V1_LEN);
684 
685 struct ionic_admin_create_ah {
686 	__le64		dma_addr;
687 	__le32		length;
688 	__le32		pd_id;
689 	__le32		id_ver;
690 	__le16		dbid_flags;
691 	__u8		csum_profile;
692 	__u8		crypto;
693 } __packed;
694 
695 #define IONIC_ADMIN_CREATE_AH_IN_V1_LEN 24
696 static_assert(sizeof(struct ionic_admin_create_ah) ==
697 	       IONIC_ADMIN_CREATE_AH_IN_V1_LEN);
698 
699 struct ionic_admin_destroy_ah {
700 	__le32		ah_id;
701 } __packed;
702 
703 #define IONIC_ADMIN_DESTROY_AH_IN_V1_LEN 4
704 static_assert(sizeof(struct ionic_admin_destroy_ah) ==
705 	       IONIC_ADMIN_DESTROY_AH_IN_V1_LEN);
706 
707 struct ionic_admin_query_ah {
708 	__le64		dma_addr;
709 } __packed;
710 
711 #define IONIC_ADMIN_QUERY_AH_IN_V1_LEN 8
712 static_assert(sizeof(struct ionic_admin_query_ah) ==
713 	       IONIC_ADMIN_QUERY_AH_IN_V1_LEN);
714 
715 struct ionic_admin_create_mr {
716 	__le64		va;
717 	__le64		length;
718 	__le32		pd_id;
719 	__le32		id_ver;
720 	__le32		tbl_index;
721 	__le32		map_count;
722 	__le64		dma_addr;
723 	__le16		dbid_flags;
724 	__u8		pt_type;
725 	__u8		dir_size_log2;
726 	__u8		page_size_log2;
727 } __packed;
728 
729 #define IONIC_ADMIN_CREATE_MR_IN_V1_LEN 45
730 static_assert(sizeof(struct ionic_admin_create_mr) ==
731 	       IONIC_ADMIN_CREATE_MR_IN_V1_LEN);
732 
733 struct ionic_admin_destroy_mr {
734 	__le32		mr_id;
735 } __packed;
736 
737 #define IONIC_ADMIN_DESTROY_MR_IN_V1_LEN 4
738 static_assert(sizeof(struct ionic_admin_destroy_mr) ==
739 	       IONIC_ADMIN_DESTROY_MR_IN_V1_LEN);
740 
741 struct ionic_admin_create_cq {
742 	__le32		eq_id;
743 	__u8		depth_log2;
744 	__u8		stride_log2;
745 	__u8		dir_size_log2_rsvd;
746 	__u8		page_size_log2;
747 	__le32		cq_flags;
748 	__le32		id_ver;
749 	__le32		tbl_index;
750 	__le32		map_count;
751 	__le64		dma_addr;
752 	__le16		dbid_flags;
753 	__u8		udma_idx;
754 	__le32		resp_buf_len;
755 	__le64		resp_dma_addr;
756 } __packed;
757 
758 #define IONIC_ADMIN_CREATE_CQ_IN_V1_LEN 34
759 #define IONIC_ADMIN_CREATE_CQ_IN_V2_LEN 47
760 static_assert(sizeof(struct ionic_admin_create_cq) == IONIC_ADMIN_CREATE_CQ_IN_V2_LEN);
761 
762 struct ionic_admin_create_cq_resp {
763 	__le32		id;
764 	__u8		udma_idx;
765 } __packed;
766 
767 #define IONIC_ADMIN_CREATE_CQ_OUT_V1_LEN 5
768 static_assert(sizeof(struct ionic_admin_create_cq_resp) == IONIC_ADMIN_CREATE_CQ_OUT_V1_LEN);
769 
770 struct ionic_admin_destroy_cq {
771 	__le32		cq_id;
772 } __packed;
773 
774 #define IONIC_ADMIN_DESTROY_CQ_IN_V1_LEN 4
775 static_assert(sizeof(struct ionic_admin_destroy_cq) ==
776 	       IONIC_ADMIN_DESTROY_CQ_IN_V1_LEN);
777 
778 struct ionic_admin_create_qp {
779 	__le32		pd_id;
780 	__be32		priv_flags;
781 	__le32		sq_cq_id;
782 	__u8		sq_depth_log2;
783 	__u8		sq_stride_log2;
784 	__u8		sq_dir_size_log2_rsvd;
785 	__u8		sq_page_size_log2;
786 	__le32		sq_tbl_index_xrcd_id;
787 	__le32		sq_map_count;
788 	__le64		sq_dma_addr;
789 	__le32		rq_cq_id;
790 	__u8		rq_depth_log2;
791 	__u8		rq_stride_log2;
792 	__u8		rq_dir_size_log2_rsvd;
793 	__u8		rq_page_size_log2;
794 	__le32		rq_tbl_index_srq_id;
795 	__le32		rq_map_count;
796 	__le64		rq_dma_addr;
797 	__le32		id_ver;
798 	__le16		dbid_flags;
799 	__u8		type_state;
800 	__u8		rsvd;
801 } __packed;
802 
803 #define IONIC_ADMIN_CREATE_QP_IN_V1_LEN 64
804 static_assert(sizeof(struct ionic_admin_create_qp) ==
805 	       IONIC_ADMIN_CREATE_QP_IN_V1_LEN);
806 
807 struct ionic_admin_destroy_qp {
808 	__le32		qp_id;
809 } __packed;
810 
811 #define IONIC_ADMIN_DESTROY_QP_IN_V1_LEN 4
812 static_assert(sizeof(struct ionic_admin_destroy_qp) ==
813 	       IONIC_ADMIN_DESTROY_QP_IN_V1_LEN);
814 
815 struct ionic_admin_mod_qp {
816 	__be32		attr_mask;
817 	__u8		dcqcn_profile;
818 	__u8		tfp_csum_profile;
819 	__be16		access_flags;
820 	__le32		rq_psn;
821 	__le32		sq_psn;
822 	__le32		qkey_dest_qpn;
823 	__le32		rate_limit_kbps;
824 	__u8		pmtu;
825 	__u8		retry;
826 	__u8		rnr_timer;
827 	__u8		retry_timeout;
828 	__u8		rsq_depth;
829 	__u8		rrq_depth;
830 	__le16		pkey_id;
831 	__le32		ah_id_len;
832 	__u8		en_pcp;
833 	__u8		ip_dscp;
834 	__u8		rsvd2;
835 	__u8		type_state;
836 	union {
837 		struct {
838 			__le16		rsvd1;
839 		};
840 		__le32		rrq_index;
841 	};
842 	__le32		rsq_index;
843 	__le64		dma_addr;
844 	__le32		id_ver;
845 } __packed;
846 
847 #define IONIC_ADMIN_MODIFY_QP_IN_V1_LEN 60
848 static_assert(sizeof(struct ionic_admin_mod_qp) ==
849 	       IONIC_ADMIN_MODIFY_QP_IN_V1_LEN);
850 
851 struct ionic_admin_query_qp {
852 	__le64		hdr_dma_addr;
853 	__le64		sq_dma_addr;
854 	__le64		rq_dma_addr;
855 	__le32		ah_id;
856 	__le32		id_ver;
857 	__le16		dbid_flags;
858 } __packed;
859 
860 #define IONIC_ADMIN_QUERY_QP_IN_V1_LEN 34
861 static_assert(sizeof(struct ionic_admin_query_qp) ==
862 	       IONIC_ADMIN_QUERY_QP_IN_V1_LEN);
863 
864 struct ionic_admin_create_srq {
865 	__le64		dma_addr;
866 	__le32		map_count;
867 	__le32		pd_id;
868 	__le32		qid;
869 	__le16		dbid;
870 	__le16		low_wqes_limit;
871 	__le16		flags;
872 	__u8		depth_log2;
873 	__u8		stride_log2;
874 	__u8		page_size_log2;
875 	__u8		udma_mask;
876 	__le32		resp_buf_len;
877 	__le64		resp_dma_addr;
878 } __packed;
879 
880 #define IONIC_ADMIN_CREATE_SRQ_IN_V1_LEN 42
881 static_assert(sizeof(struct ionic_admin_create_srq) == IONIC_ADMIN_CREATE_SRQ_IN_V1_LEN);
882 
883 struct ionic_admin_create_srq_resp {
884 	__le32          id;
885 	__u8            udma_idx;
886 } __packed;
887 
888 #define IONIC_ADMIN_CREATE_SRQ_OUT_V1_LEN 5
889 static_assert(sizeof(struct ionic_admin_create_srq_resp) == IONIC_ADMIN_CREATE_SRQ_OUT_V1_LEN);
890 
891 struct ionic_admin_modify_srq {
892 	__le32		qid;
893 	__le16		low_wqes_limit;
894 } __packed;
895 
896 #define IONIC_ADMIN_MODIFY_SRQ_IN_V1_LEN 6
897 static_assert(sizeof(struct ionic_admin_modify_srq) == IONIC_ADMIN_MODIFY_SRQ_IN_V1_LEN);
898 
899 struct ionic_admin_destroy_srq {
900 	__le32		qid;
901 } __packed;
902 
903 #define IONIC_ADMIN_DESTROY_SRQ_IN_V1_LEN 4
904 static_assert(sizeof(struct ionic_admin_destroy_srq) == IONIC_ADMIN_DESTROY_SRQ_IN_V1_LEN);
905 
906 #define ADMIN_WQE_STRIDE	64
907 #define ADMIN_WQE_HDR_LEN	4
908 
909 /* admin queue v1 wqe */
910 struct ionic_v1_admin_wqe {
911 	__u8				op;
912 	__u8				rsvd;
913 	__le16				len;
914 
915 	union {
916 		struct ionic_admin_stats_hdr stats;
917 		struct ionic_admin_create_ah create_ah;
918 		struct ionic_admin_destroy_ah destroy_ah;
919 		struct ionic_admin_query_ah query_ah;
920 		struct ionic_admin_create_mr create_mr;
921 		struct ionic_admin_destroy_mr destroy_mr;
922 		struct ionic_admin_create_cq create_cq;
923 		struct ionic_admin_destroy_cq destroy_cq;
924 		struct ionic_admin_create_qp create_qp;
925 		struct ionic_admin_destroy_qp destroy_qp;
926 		struct ionic_admin_mod_qp mod_qp;
927 		struct ionic_admin_query_qp query_qp;
928 		struct ionic_admin_create_srq create_srq;
929 		struct ionic_admin_modify_srq modify_srq;
930 		struct ionic_admin_destroy_srq destroy_srq;
931 	} cmd;
932 };
933 
934 /* side data for query qp */
935 struct ionic_v1_admin_query_qp_sq {
936 	__u8				rnr_timer;
937 	__u8				retry_timeout;
938 	__be16				access_perms_flags;
939 	__be16				rsvd;
940 	__be16				pkey_id;
941 	__be32				qkey_dest_qpn;
942 	__be32				rate_limit_kbps;
943 	__be32				rq_psn;
944 };
945 
946 struct ionic_v1_admin_query_qp_rq {
947 	__u8				state_pmtu;
948 	__u8				retry_rnrtry;
949 	__u8				rrq_depth;
950 	__u8				rsq_depth;
951 	__be32				sq_psn;
952 	__be16				access_perms_flags;
953 	__be16				rsvd;
954 };
955 
956 /* admin queue v1 opcodes */
957 enum ionic_v1_admin_op {
958 	IONIC_V1_ADMIN_NOOP,
959 	IONIC_V1_ADMIN_CREATE_CQ,
960 	IONIC_V1_ADMIN_CREATE_QP,
961 	IONIC_V1_ADMIN_CREATE_MR,
962 	IONIC_V1_ADMIN_STATS_HDRS,
963 	IONIC_V1_ADMIN_STATS_VALS,
964 	IONIC_V1_ADMIN_DESTROY_MR,
965 	IONIC_V1_ADMIN_RSVD_7,		/* RESIZE_CQ */
966 	IONIC_V1_ADMIN_DESTROY_CQ,
967 	IONIC_V1_ADMIN_MODIFY_QP,
968 	IONIC_V1_ADMIN_QUERY_QP,
969 	IONIC_V1_ADMIN_DESTROY_QP,
970 	IONIC_V1_ADMIN_DEBUG,
971 	IONIC_V1_ADMIN_CREATE_AH,
972 	IONIC_V1_ADMIN_QUERY_AH,
973 	IONIC_V1_ADMIN_MODIFY_DCQCN,
974 	IONIC_V1_ADMIN_DESTROY_AH,
975 	IONIC_V1_ADMIN_QP_STATS_HDRS,
976 	IONIC_V1_ADMIN_QP_STATS_VALS,
977 	IONIC_V1_ADMIN_CREATE_SRQ = 26,
978 	IONIC_V1_ADMIN_MODIFY_SRQ,
979 	IONIC_V1_ADMIN_QUERY_SRQ,
980 	IONIC_V1_ADMIN_DESTROY_SRQ,
981 	IONIC_V1_ADMIN_OPCODES_MAX,
982 };
983 
984 /* admin queue v1 cqe status */
985 enum ionic_v1_admin_status {
986 	IONIC_V1_ASTS_OK,
987 	IONIC_V1_ASTS_BAD_CMD,
988 	IONIC_V1_ASTS_BAD_INDEX,
989 	IONIC_V1_ASTS_BAD_STATE,
990 	IONIC_V1_ASTS_BAD_TYPE,
991 	IONIC_V1_ASTS_BAD_ATTR,
992 	IONIC_V1_ASTS_MSG_TOO_BIG,
993 };
994 
995 /* event queue v1 eqe */
996 struct ionic_v1_eqe {
997 	__be32				evt;
998 };
999 
1000 /* bits for cqe queue_type_flags */
1001 enum ionic_v1_eqe_evt_bits {
1002 	IONIC_V1_EQE_COLOR		= BIT(0),
1003 	IONIC_V1_EQE_TYPE_SHIFT		= 1,
1004 	IONIC_V1_EQE_TYPE_MASK		= 0x7,
1005 	IONIC_V1_EQE_CODE_SHIFT		= 4,
1006 	IONIC_V1_EQE_CODE_MASK		= 0xf,
1007 	IONIC_V1_EQE_QID_SHIFT		= 8,
1008 
1009 	/* cq events */
1010 	IONIC_V1_EQE_TYPE_CQ		= 0,
1011 	/* cq normal events */
1012 	IONIC_V1_EQE_CQ_NOTIFY		= 0,
1013 	/* cq error events */
1014 	IONIC_V1_EQE_CQ_ERR		= 8,
1015 
1016 	/* qp events */
1017 	IONIC_V1_EQE_TYPE_QP		= 1,
1018 	/* qp normal events */
1019 	IONIC_V1_EQE_SRQ_LEVEL		= 0,
1020 	IONIC_V1_EQE_SQ_DRAIN		= 1,
1021 	IONIC_V1_EQE_QP_COMM_EST	= 2,
1022 	IONIC_V1_EQE_QP_LAST_WQE	= 3,
1023 	/* qp error events */
1024 	IONIC_V1_EQE_QP_ERR		= 8,
1025 	IONIC_V1_EQE_QP_ERR_REQUEST	= 9,
1026 	IONIC_V1_EQE_QP_ERR_ACCESS	= 10,
1027 	/* srq events */
1028 	IONIC_V1_EQE_TYPE_SRQ		= 2,
1029 	IONIC_V1_EQE_SRQ_LIMIT_REACHED	= 0,
1030 	IONIC_V1_EQE_SRQ_ERR		= 1,
1031 };
1032 
1033 enum ionic_tfp_csum_profiles {
1034 	IONIC_TFP_CSUM_PROF_ETH_IPV4_UDP				= 0,
1035 	IONIC_TFP_CSUM_PROF_ETH_QTAG_IPV4_UDP				= 1,
1036 	IONIC_TFP_CSUM_PROF_ETH_IPV6_UDP				= 2,
1037 	IONIC_TFP_CSUM_PROF_ETH_QTAG_IPV6_UDP				= 3,
1038 	IONIC_TFP_CSUM_PROF_IPV4_UDP_VXLAN_ETH_QTAG_IPV4_UDP		= 4,
1039 	IONIC_TFP_CSUM_PROF_IPV4_UDP_VXLAN_ETH_QTAG_IPV6_UDP		= 5,
1040 	IONIC_TFP_CSUM_PROF_QTAG_IPV4_UDP_VXLAN_ETH_QTAG_IPV4_UDP	= 6,
1041 	IONIC_TFP_CSUM_PROF_QTAG_IPV4_UDP_VXLAN_ETH_QTAG_IPV6_UDP	= 7,
1042 	IONIC_TFP_CSUM_PROF_ETH_QTAG_IPV4_UDP_ESP_IPV4_UDP		= 8,
1043 	IONIC_TFP_CSUM_PROF_ETH_QTAG_IPV4_ESP_UDP			= 9,
1044 	IONIC_TFP_CSUM_PROF_ETH_QTAG_IPV4_UDP_ESP_UDP			= 10,
1045 	IONIC_TFP_CSUM_PROF_ETH_QTAG_IPV6_ESP_UDP			= 11,
1046 	IONIC_TFP_CSUM_PROF_ETH_QTAG_IPV4_UDP_CSUM			= 12,
1047 };
1048 
1049 static inline bool ionic_v1_eqe_color(struct ionic_v1_eqe *eqe)
1050 {
1051 	return eqe->evt & cpu_to_be32(IONIC_V1_EQE_COLOR);
1052 }
1053 
1054 static inline u32 ionic_v1_eqe_evt(struct ionic_v1_eqe *eqe)
1055 {
1056 	return be32_to_cpu(eqe->evt);
1057 }
1058 
1059 static inline u8 ionic_v1_eqe_evt_type(u32 evt)
1060 {
1061 	return (evt >> IONIC_V1_EQE_TYPE_SHIFT) & IONIC_V1_EQE_TYPE_MASK;
1062 }
1063 
1064 static inline u8 ionic_v1_eqe_evt_code(u32 evt)
1065 {
1066 	return (evt >> IONIC_V1_EQE_CODE_SHIFT) & IONIC_V1_EQE_CODE_MASK;
1067 }
1068 
1069 static inline u32 ionic_v1_eqe_evt_qid(u32 evt)
1070 {
1071 	return evt >> IONIC_V1_EQE_QID_SHIFT;
1072 }
1073 
1074 enum ionic_v1_stat_bits {
1075 	IONIC_V1_STAT_TYPE_SHIFT	= 28,
1076 	IONIC_V1_STAT_TYPE_NONE		= 0,
1077 	IONIC_V1_STAT_TYPE_8		= 1,
1078 	IONIC_V1_STAT_TYPE_LE16		= 2,
1079 	IONIC_V1_STAT_TYPE_LE32		= 3,
1080 	IONIC_V1_STAT_TYPE_LE64		= 4,
1081 	IONIC_V1_STAT_TYPE_BE16		= 5,
1082 	IONIC_V1_STAT_TYPE_BE32		= 6,
1083 	IONIC_V1_STAT_TYPE_BE64		= 7,
1084 	IONIC_V1_STAT_OFF_MASK		= BIT(IONIC_V1_STAT_TYPE_SHIFT) - 1,
1085 };
1086 
1087 struct ionic_v1_stat {
1088 	union {
1089 		__be32		be_type_off;
1090 		u32		type_off;
1091 	};
1092 	char			name[28];
1093 };
1094 
1095 static inline int ionic_v1_stat_type(struct ionic_v1_stat *hdr)
1096 {
1097 	return hdr->type_off >> IONIC_V1_STAT_TYPE_SHIFT;
1098 }
1099 
1100 static inline unsigned int ionic_v1_stat_off(struct ionic_v1_stat *hdr)
1101 {
1102 	return hdr->type_off & IONIC_V1_STAT_OFF_MASK;
1103 }
1104 
1105 #endif /* _IONIC_FW_H_ */
1106