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