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