1 /* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */ 2 3 #ifndef __FUN_HCI_H 4 #define __FUN_HCI_H 5 6 enum { 7 FUN_HCI_ID_INVALID = 0xffffffff, 8 }; 9 10 enum fun_admin_op { 11 FUN_ADMIN_OP_BIND = 0x1, 12 FUN_ADMIN_OP_EPCQ = 0x11, 13 FUN_ADMIN_OP_EPSQ = 0x12, 14 FUN_ADMIN_OP_PORT = 0x13, 15 FUN_ADMIN_OP_ETH = 0x14, 16 FUN_ADMIN_OP_VI = 0x15, 17 FUN_ADMIN_OP_SWUPGRADE = 0x1f, 18 FUN_ADMIN_OP_RSS = 0x21, 19 FUN_ADMIN_OP_ADI = 0x25, 20 FUN_ADMIN_OP_KTLS = 0x26, 21 }; 22 23 enum { 24 FUN_REQ_COMMON_FLAG_RSP = 0x1, 25 FUN_REQ_COMMON_FLAG_HEAD_WB = 0x2, 26 FUN_REQ_COMMON_FLAG_INT = 0x4, 27 FUN_REQ_COMMON_FLAG_CQE_IN_RQBUF = 0x8, 28 }; 29 30 struct fun_admin_req_common { 31 __u8 op; 32 __u8 len8; 33 __be16 flags; 34 __u8 suboff8; 35 __u8 rsvd0; 36 __be16 cid; 37 }; 38 39 #define FUN_ADMIN_REQ_COMMON_INIT(_op, _len8, _flags, _suboff8, _cid) \ 40 (struct fun_admin_req_common) { \ 41 .op = (_op), .len8 = (_len8), .flags = cpu_to_be16(_flags), \ 42 .suboff8 = (_suboff8), .cid = cpu_to_be16(_cid), \ 43 } 44 45 #define FUN_ADMIN_REQ_COMMON_INIT2(_op, _len) \ 46 (struct fun_admin_req_common) { \ 47 .op = (_op), .len8 = (_len) / 8, \ 48 } 49 50 struct fun_admin_rsp_common { 51 __u8 op; 52 __u8 len8; 53 __be16 flags; 54 __u8 suboff8; 55 __u8 ret; 56 __be16 cid; 57 }; 58 59 struct fun_admin_write48_req { 60 __be64 key_to_data; 61 }; 62 63 #define FUN_ADMIN_WRITE48_REQ_KEY_S 56U 64 #define FUN_ADMIN_WRITE48_REQ_KEY_M 0xff 65 #define FUN_ADMIN_WRITE48_REQ_KEY_P_NOSWAP(x) \ 66 (((__u64)x) << FUN_ADMIN_WRITE48_REQ_KEY_S) 67 68 #define FUN_ADMIN_WRITE48_REQ_DATA_S 0U 69 #define FUN_ADMIN_WRITE48_REQ_DATA_M 0xffffffffffff 70 #define FUN_ADMIN_WRITE48_REQ_DATA_P_NOSWAP(x) \ 71 (((__u64)x) << FUN_ADMIN_WRITE48_REQ_DATA_S) 72 73 #define FUN_ADMIN_WRITE48_REQ_INIT(key, data) \ 74 (struct fun_admin_write48_req) { \ 75 .key_to_data = cpu_to_be64( \ 76 FUN_ADMIN_WRITE48_REQ_KEY_P_NOSWAP(key) | \ 77 FUN_ADMIN_WRITE48_REQ_DATA_P_NOSWAP(data)), \ 78 } 79 80 struct fun_admin_write48_rsp { 81 __be64 key_to_data; 82 }; 83 84 struct fun_admin_read48_req { 85 __be64 key_pack; 86 }; 87 88 #define FUN_ADMIN_READ48_REQ_KEY_S 56U 89 #define FUN_ADMIN_READ48_REQ_KEY_M 0xff 90 #define FUN_ADMIN_READ48_REQ_KEY_P_NOSWAP(x) \ 91 (((__u64)x) << FUN_ADMIN_READ48_REQ_KEY_S) 92 93 #define FUN_ADMIN_READ48_REQ_INIT(key) \ 94 (struct fun_admin_read48_req) { \ 95 .key_pack = \ 96 cpu_to_be64(FUN_ADMIN_READ48_REQ_KEY_P_NOSWAP(key)), \ 97 } 98 99 struct fun_admin_read48_rsp { 100 __be64 key_to_data; 101 }; 102 103 #define FUN_ADMIN_READ48_RSP_KEY_S 56U 104 #define FUN_ADMIN_READ48_RSP_KEY_M 0xff 105 #define FUN_ADMIN_READ48_RSP_KEY_G(x) \ 106 ((be64_to_cpu(x) >> FUN_ADMIN_READ48_RSP_KEY_S) & \ 107 FUN_ADMIN_READ48_RSP_KEY_M) 108 109 #define FUN_ADMIN_READ48_RSP_RET_S 48U 110 #define FUN_ADMIN_READ48_RSP_RET_M 0xff 111 #define FUN_ADMIN_READ48_RSP_RET_G(x) \ 112 ((be64_to_cpu(x) >> FUN_ADMIN_READ48_RSP_RET_S) & \ 113 FUN_ADMIN_READ48_RSP_RET_M) 114 115 #define FUN_ADMIN_READ48_RSP_DATA_S 0U 116 #define FUN_ADMIN_READ48_RSP_DATA_M 0xffffffffffff 117 #define FUN_ADMIN_READ48_RSP_DATA_G(x) \ 118 ((be64_to_cpu(x) >> FUN_ADMIN_READ48_RSP_DATA_S) & \ 119 FUN_ADMIN_READ48_RSP_DATA_M) 120 121 enum fun_admin_bind_type { 122 FUN_ADMIN_BIND_TYPE_EPCQ = 0x1, 123 FUN_ADMIN_BIND_TYPE_EPSQ = 0x2, 124 FUN_ADMIN_BIND_TYPE_PORT = 0x3, 125 FUN_ADMIN_BIND_TYPE_RSS = 0x4, 126 FUN_ADMIN_BIND_TYPE_VI = 0x5, 127 FUN_ADMIN_BIND_TYPE_ETH = 0x6, 128 }; 129 130 struct fun_admin_bind_entry { 131 __u8 type; 132 __u8 rsvd0[3]; 133 __be32 id; 134 }; 135 136 #define FUN_ADMIN_BIND_ENTRY_INIT(_type, _id) \ 137 (struct fun_admin_bind_entry) { \ 138 .type = (_type), .id = cpu_to_be32(_id), \ 139 } 140 141 struct fun_admin_bind_req { 142 struct fun_admin_req_common common; 143 struct fun_admin_bind_entry entry[]; 144 }; 145 146 struct fun_admin_bind_rsp { 147 struct fun_admin_rsp_common bind_rsp_common; 148 }; 149 150 struct fun_admin_simple_subop { 151 __u8 subop; 152 __u8 rsvd0; 153 __be16 flags; 154 __be32 data; 155 }; 156 157 #define FUN_ADMIN_SIMPLE_SUBOP_INIT(_subop, _flags, _data) \ 158 (struct fun_admin_simple_subop) { \ 159 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 160 .data = cpu_to_be32(_data), \ 161 } 162 163 enum fun_admin_subop { 164 FUN_ADMIN_SUBOP_CREATE = 0x10, 165 FUN_ADMIN_SUBOP_DESTROY = 0x11, 166 FUN_ADMIN_SUBOP_MODIFY = 0x12, 167 FUN_ADMIN_SUBOP_RES_COUNT = 0x14, 168 FUN_ADMIN_SUBOP_READ = 0x15, 169 FUN_ADMIN_SUBOP_WRITE = 0x16, 170 FUN_ADMIN_SUBOP_NOTIFY = 0x17, 171 }; 172 173 enum { 174 FUN_ADMIN_RES_CREATE_FLAG_ALLOCATOR = 0x1, 175 }; 176 177 struct fun_admin_generic_destroy_req { 178 struct fun_admin_req_common common; 179 struct fun_admin_simple_subop destroy; 180 }; 181 182 struct fun_admin_generic_create_rsp { 183 struct fun_admin_rsp_common common; 184 185 __u8 subop; 186 __u8 rsvd0; 187 __be16 flags; 188 __be32 id; 189 }; 190 191 struct fun_admin_res_count_req { 192 struct fun_admin_req_common common; 193 struct fun_admin_simple_subop count; 194 }; 195 196 struct fun_admin_res_count_rsp { 197 struct fun_admin_rsp_common common; 198 struct fun_admin_simple_subop count; 199 }; 200 201 enum { 202 FUN_ADMIN_EPCQ_CREATE_FLAG_INT_EPCQ = 0x2, 203 FUN_ADMIN_EPCQ_CREATE_FLAG_ENTRY_WR_TPH = 0x4, 204 FUN_ADMIN_EPCQ_CREATE_FLAG_SL_WR_TPH = 0x8, 205 FUN_ADMIN_EPCQ_CREATE_FLAG_RQ = 0x80, 206 FUN_ADMIN_EPCQ_CREATE_FLAG_INT_IQ = 0x100, 207 FUN_ADMIN_EPCQ_CREATE_FLAG_INT_NOARM = 0x200, 208 FUN_ADMIN_EPCQ_CREATE_FLAG_DROP_ON_OVERFLOW = 0x400, 209 }; 210 211 struct fun_admin_epcq_req { 212 struct fun_admin_req_common common; 213 union epcq_req_subop { 214 struct fun_admin_epcq_create_req { 215 __u8 subop; 216 __u8 rsvd0; 217 __be16 flags; 218 __be32 id; 219 220 __be32 epsqid; 221 __u8 rsvd1; 222 __u8 entry_size_log2; 223 __be16 nentries; 224 225 __be64 address; 226 227 __be16 tailroom; /* per packet tailroom in bytes */ 228 __u8 headroom; /* per packet headroom in 2B units */ 229 __u8 intcoal_kbytes; 230 __u8 intcoal_holdoff_nentries; 231 __u8 intcoal_holdoff_usecs; 232 __be16 intid; 233 234 __be32 scan_start_id; 235 __be32 scan_end_id; 236 237 __be16 tph_cpuid; 238 __u8 rsvd3[6]; 239 } create; 240 241 struct fun_admin_epcq_modify_req { 242 __u8 subop; 243 __u8 rsvd0; 244 __be16 flags; 245 __be32 id; 246 247 __be16 headroom; /* headroom in bytes */ 248 __u8 rsvd1[6]; 249 } modify; 250 } u; 251 }; 252 253 #define FUN_ADMIN_EPCQ_CREATE_REQ_INIT( \ 254 _subop, _flags, _id, _epsqid, _entry_size_log2, _nentries, _address, \ 255 _tailroom, _headroom, _intcoal_kbytes, _intcoal_holdoff_nentries, \ 256 _intcoal_holdoff_usecs, _intid, _scan_start_id, _scan_end_id, \ 257 _tph_cpuid) \ 258 (struct fun_admin_epcq_create_req) { \ 259 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 260 .id = cpu_to_be32(_id), .epsqid = cpu_to_be32(_epsqid), \ 261 .entry_size_log2 = _entry_size_log2, \ 262 .nentries = cpu_to_be16(_nentries), \ 263 .address = cpu_to_be64(_address), \ 264 .tailroom = cpu_to_be16(_tailroom), .headroom = _headroom, \ 265 .intcoal_kbytes = _intcoal_kbytes, \ 266 .intcoal_holdoff_nentries = _intcoal_holdoff_nentries, \ 267 .intcoal_holdoff_usecs = _intcoal_holdoff_usecs, \ 268 .intid = cpu_to_be16(_intid), \ 269 .scan_start_id = cpu_to_be32(_scan_start_id), \ 270 .scan_end_id = cpu_to_be32(_scan_end_id), \ 271 .tph_cpuid = cpu_to_be16(_tph_cpuid), \ 272 } 273 274 #define FUN_ADMIN_EPCQ_MODIFY_REQ_INIT(_subop, _flags, _id, _headroom) \ 275 (struct fun_admin_epcq_modify_req) { \ 276 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 277 .id = cpu_to_be32(_id), .headroom = cpu_to_be16(_headroom), \ 278 } 279 280 enum { 281 FUN_ADMIN_EPSQ_CREATE_FLAG_INT_EPSQ = 0x2, 282 FUN_ADMIN_EPSQ_CREATE_FLAG_ENTRY_RD_TPH = 0x4, 283 FUN_ADMIN_EPSQ_CREATE_FLAG_GL_RD_TPH = 0x8, 284 FUN_ADMIN_EPSQ_CREATE_FLAG_HEAD_WB_ADDRESS = 0x10, 285 FUN_ADMIN_EPSQ_CREATE_FLAG_HEAD_WB_ADDRESS_TPH = 0x20, 286 FUN_ADMIN_EPSQ_CREATE_FLAG_HEAD_WB_EPCQ = 0x40, 287 FUN_ADMIN_EPSQ_CREATE_FLAG_RQ = 0x80, 288 FUN_ADMIN_EPSQ_CREATE_FLAG_INT_IQ = 0x100, 289 FUN_ADMIN_EPSQ_CREATE_FLAG_NO_CMPL = 0x200, 290 }; 291 292 struct fun_admin_epsq_req { 293 struct fun_admin_req_common common; 294 295 union epsq_req_subop { 296 struct fun_admin_epsq_create_req { 297 __u8 subop; 298 __u8 rsvd0; 299 __be16 flags; 300 __be32 id; 301 302 __be32 epcqid; 303 __u8 rsvd1; 304 __u8 entry_size_log2; 305 __be16 nentries; 306 307 __be64 address; /* DMA address of epsq */ 308 309 __u8 rsvd2[3]; 310 __u8 intcoal_kbytes; 311 __u8 intcoal_holdoff_nentries; 312 __u8 intcoal_holdoff_usecs; 313 __be16 intid; 314 315 __be32 scan_start_id; 316 __be32 scan_end_id; 317 318 __u8 rsvd3[4]; 319 __be16 tph_cpuid; 320 __u8 buf_size_log2; /* log2 of RQ buffer size */ 321 __u8 head_wb_size_log2; /* log2 of head write back size */ 322 323 __be64 head_wb_address; /* DMA address for head writeback */ 324 } create; 325 } u; 326 }; 327 328 #define FUN_ADMIN_EPSQ_CREATE_REQ_INIT( \ 329 _subop, _flags, _id, _epcqid, _entry_size_log2, _nentries, _address, \ 330 _intcoal_kbytes, _intcoal_holdoff_nentries, _intcoal_holdoff_usecs, \ 331 _intid, _scan_start_id, _scan_end_id, _tph_cpuid, _buf_size_log2, \ 332 _head_wb_size_log2, _head_wb_address) \ 333 (struct fun_admin_epsq_create_req) { \ 334 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 335 .id = cpu_to_be32(_id), .epcqid = cpu_to_be32(_epcqid), \ 336 .entry_size_log2 = _entry_size_log2, \ 337 .nentries = cpu_to_be16(_nentries), \ 338 .address = cpu_to_be64(_address), \ 339 .intcoal_kbytes = _intcoal_kbytes, \ 340 .intcoal_holdoff_nentries = _intcoal_holdoff_nentries, \ 341 .intcoal_holdoff_usecs = _intcoal_holdoff_usecs, \ 342 .intid = cpu_to_be16(_intid), \ 343 .scan_start_id = cpu_to_be32(_scan_start_id), \ 344 .scan_end_id = cpu_to_be32(_scan_end_id), \ 345 .tph_cpuid = cpu_to_be16(_tph_cpuid), \ 346 .buf_size_log2 = _buf_size_log2, \ 347 .head_wb_size_log2 = _head_wb_size_log2, \ 348 .head_wb_address = cpu_to_be64(_head_wb_address), \ 349 } 350 351 enum { 352 FUN_PORT_CAP_OFFLOADS = 0x1, 353 FUN_PORT_CAP_STATS = 0x2, 354 FUN_PORT_CAP_LOOPBACK = 0x4, 355 FUN_PORT_CAP_VPORT = 0x8, 356 FUN_PORT_CAP_TX_PAUSE = 0x10, 357 FUN_PORT_CAP_RX_PAUSE = 0x20, 358 FUN_PORT_CAP_AUTONEG = 0x40, 359 FUN_PORT_CAP_RSS = 0x80, 360 FUN_PORT_CAP_VLAN_OFFLOADS = 0x100, 361 FUN_PORT_CAP_ENCAP_OFFLOADS = 0x200, 362 FUN_PORT_CAP_1000_X = 0x1000, 363 FUN_PORT_CAP_10G_R = 0x2000, 364 FUN_PORT_CAP_40G_R4 = 0x4000, 365 FUN_PORT_CAP_25G_R = 0x8000, 366 FUN_PORT_CAP_50G_R2 = 0x10000, 367 FUN_PORT_CAP_50G_R = 0x20000, 368 FUN_PORT_CAP_100G_R4 = 0x40000, 369 FUN_PORT_CAP_100G_R2 = 0x80000, 370 FUN_PORT_CAP_200G_R4 = 0x100000, 371 FUN_PORT_CAP_FEC_NONE = 0x10000000, 372 FUN_PORT_CAP_FEC_FC = 0x20000000, 373 FUN_PORT_CAP_FEC_RS = 0x40000000, 374 }; 375 376 enum fun_port_brkout_mode { 377 FUN_PORT_BRKMODE_NA = 0x0, 378 FUN_PORT_BRKMODE_NONE = 0x1, 379 FUN_PORT_BRKMODE_2X = 0x2, 380 FUN_PORT_BRKMODE_4X = 0x3, 381 }; 382 383 enum { 384 FUN_PORT_SPEED_AUTO = 0x0, 385 FUN_PORT_SPEED_10M = 0x1, 386 FUN_PORT_SPEED_100M = 0x2, 387 FUN_PORT_SPEED_1G = 0x4, 388 FUN_PORT_SPEED_10G = 0x8, 389 FUN_PORT_SPEED_25G = 0x10, 390 FUN_PORT_SPEED_40G = 0x20, 391 FUN_PORT_SPEED_50G = 0x40, 392 FUN_PORT_SPEED_100G = 0x80, 393 FUN_PORT_SPEED_200G = 0x100, 394 }; 395 396 enum fun_port_duplex_mode { 397 FUN_PORT_FULL_DUPLEX = 0x0, 398 FUN_PORT_HALF_DUPLEX = 0x1, 399 }; 400 401 enum { 402 FUN_PORT_FEC_NA = 0x0, 403 FUN_PORT_FEC_OFF = 0x1, 404 FUN_PORT_FEC_RS = 0x2, 405 FUN_PORT_FEC_FC = 0x4, 406 FUN_PORT_FEC_AUTO = 0x8, 407 }; 408 409 enum fun_port_link_status { 410 FUN_PORT_LINK_UP = 0x0, 411 FUN_PORT_LINK_UP_WITH_ERR = 0x1, 412 FUN_PORT_LINK_DOWN = 0x2, 413 }; 414 415 enum fun_port_led_type { 416 FUN_PORT_LED_OFF = 0x0, 417 FUN_PORT_LED_AMBER = 0x1, 418 FUN_PORT_LED_GREEN = 0x2, 419 FUN_PORT_LED_BEACON_ON = 0x3, 420 FUN_PORT_LED_BEACON_OFF = 0x4, 421 }; 422 423 enum { 424 FUN_PORT_FLAG_MAC_DOWN = 0x1, 425 FUN_PORT_FLAG_MAC_UP = 0x2, 426 FUN_PORT_FLAG_NH_DOWN = 0x4, 427 FUN_PORT_FLAG_NH_UP = 0x8, 428 }; 429 430 enum { 431 FUN_PORT_FLAG_ENABLE_NOTIFY = 0x1, 432 }; 433 434 enum fun_port_lane_attr { 435 FUN_PORT_LANE_1 = 0x1, 436 FUN_PORT_LANE_2 = 0x2, 437 FUN_PORT_LANE_4 = 0x4, 438 FUN_PORT_LANE_SPEED_10G = 0x100, 439 FUN_PORT_LANE_SPEED_25G = 0x200, 440 FUN_PORT_LANE_SPEED_50G = 0x400, 441 FUN_PORT_LANE_SPLIT = 0x8000, 442 }; 443 444 enum fun_admin_port_subop { 445 FUN_ADMIN_PORT_SUBOP_INETADDR_EVENT = 0x24, 446 }; 447 448 enum fun_admin_port_key { 449 FUN_ADMIN_PORT_KEY_ILLEGAL = 0x0, 450 FUN_ADMIN_PORT_KEY_MTU = 0x1, 451 FUN_ADMIN_PORT_KEY_FEC = 0x2, 452 FUN_ADMIN_PORT_KEY_SPEED = 0x3, 453 FUN_ADMIN_PORT_KEY_DEBOUNCE = 0x4, 454 FUN_ADMIN_PORT_KEY_DUPLEX = 0x5, 455 FUN_ADMIN_PORT_KEY_MACADDR = 0x6, 456 FUN_ADMIN_PORT_KEY_LINKMODE = 0x7, 457 FUN_ADMIN_PORT_KEY_BREAKOUT = 0x8, 458 FUN_ADMIN_PORT_KEY_ENABLE = 0x9, 459 FUN_ADMIN_PORT_KEY_DISABLE = 0xa, 460 FUN_ADMIN_PORT_KEY_ERR_DISABLE = 0xb, 461 FUN_ADMIN_PORT_KEY_CAPABILITIES = 0xc, 462 FUN_ADMIN_PORT_KEY_LP_CAPABILITIES = 0xd, 463 FUN_ADMIN_PORT_KEY_STATS_DMA_LOW = 0xe, 464 FUN_ADMIN_PORT_KEY_STATS_DMA_HIGH = 0xf, 465 FUN_ADMIN_PORT_KEY_LANE_ATTRS = 0x10, 466 FUN_ADMIN_PORT_KEY_LED = 0x11, 467 FUN_ADMIN_PORT_KEY_ADVERT = 0x12, 468 }; 469 470 struct fun_subop_imm { 471 __u8 subop; /* see fun_data_subop enum */ 472 __u8 flags; 473 __u8 nsgl; 474 __u8 rsvd0; 475 __be32 len; 476 477 __u8 data[]; 478 }; 479 480 enum fun_subop_sgl_flags { 481 FUN_SUBOP_SGL_USE_OFF8 = 0x1, 482 FUN_SUBOP_FLAG_FREE_BUF = 0x2, 483 FUN_SUBOP_FLAG_IS_REFBUF = 0x4, 484 FUN_SUBOP_SGL_FLAG_LOCAL = 0x8, 485 }; 486 487 enum fun_data_op { 488 FUN_DATAOP_INVALID = 0x0, 489 FUN_DATAOP_SL = 0x1, /* scatter */ 490 FUN_DATAOP_GL = 0x2, /* gather */ 491 FUN_DATAOP_SGL = 0x3, /* scatter-gather */ 492 FUN_DATAOP_IMM = 0x4, /* immediate data */ 493 FUN_DATAOP_RQBUF = 0x8, /* rq buffer */ 494 }; 495 496 struct fun_dataop_gl { 497 __u8 subop; 498 __u8 flags; 499 __be16 sgl_off; 500 __be32 sgl_len; 501 502 __be64 sgl_data; 503 }; 504 505 static inline void fun_dataop_gl_init(struct fun_dataop_gl *s, u8 flags, 506 u16 sgl_off, u32 sgl_len, u64 sgl_data) 507 { 508 s->subop = FUN_DATAOP_GL; 509 s->flags = flags; 510 s->sgl_off = cpu_to_be16(sgl_off); 511 s->sgl_len = cpu_to_be32(sgl_len); 512 s->sgl_data = cpu_to_be64(sgl_data); 513 } 514 515 struct fun_dataop_imm { 516 __u8 subop; 517 __u8 flags; 518 __be16 rsvd0; 519 __be32 sgl_len; 520 }; 521 522 struct fun_subop_sgl { 523 __u8 subop; 524 __u8 flags; 525 __u8 nsgl; 526 __u8 rsvd0; 527 __be32 sgl_len; 528 529 __be64 sgl_data; 530 }; 531 532 #define FUN_SUBOP_SGL_INIT(_subop, _flags, _nsgl, _sgl_len, _sgl_data) \ 533 (struct fun_subop_sgl) { \ 534 .subop = (_subop), .flags = (_flags), .nsgl = (_nsgl), \ 535 .sgl_len = cpu_to_be32(_sgl_len), \ 536 .sgl_data = cpu_to_be64(_sgl_data), \ 537 } 538 539 struct fun_dataop_rqbuf { 540 __u8 subop; 541 __u8 rsvd0; 542 __be16 cid; 543 __be32 bufoff; 544 }; 545 546 struct fun_dataop_hdr { 547 __u8 nsgl; 548 __u8 flags; 549 __u8 ngather; 550 __u8 nscatter; 551 __be32 total_len; 552 553 struct fun_dataop_imm imm[]; 554 }; 555 556 #define FUN_DATAOP_HDR_INIT(_nsgl, _flags, _ngather, _nscatter, _total_len) \ 557 (struct fun_dataop_hdr) { \ 558 .nsgl = _nsgl, .flags = _flags, .ngather = _ngather, \ 559 .nscatter = _nscatter, .total_len = cpu_to_be32(_total_len), \ 560 } 561 562 enum fun_port_inetaddr_event_type { 563 FUN_PORT_INETADDR_ADD = 0x1, 564 FUN_PORT_INETADDR_DEL = 0x2, 565 }; 566 567 enum fun_port_inetaddr_addr_family { 568 FUN_PORT_INETADDR_IPV4 = 0x1, 569 FUN_PORT_INETADDR_IPV6 = 0x2, 570 }; 571 572 struct fun_admin_port_req { 573 struct fun_admin_req_common common; 574 575 union port_req_subop { 576 struct fun_admin_port_create_req { 577 __u8 subop; 578 __u8 rsvd0; 579 __be16 flags; 580 __be32 id; 581 } create; 582 struct fun_admin_port_write_req { 583 __u8 subop; 584 __u8 rsvd0; 585 __be16 flags; 586 __be32 id; /* portid */ 587 588 struct fun_admin_write48_req write48[]; 589 } write; 590 struct fun_admin_port_read_req { 591 __u8 subop; 592 __u8 rsvd0; 593 __be16 flags; 594 __be32 id; /* portid */ 595 596 struct fun_admin_read48_req read48[]; 597 } read; 598 struct fun_admin_port_inetaddr_event_req { 599 __u8 subop; 600 __u8 rsvd0; 601 __u8 event_type; 602 __u8 addr_family; 603 __be32 id; 604 605 __u8 addr[]; 606 } inetaddr_event; 607 } u; 608 }; 609 610 #define FUN_ADMIN_PORT_CREATE_REQ_INIT(_subop, _flags, _id) \ 611 (struct fun_admin_port_create_req) { \ 612 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 613 .id = cpu_to_be32(_id), \ 614 } 615 616 #define FUN_ADMIN_PORT_WRITE_REQ_INIT(_subop, _flags, _id) \ 617 (struct fun_admin_port_write_req) { \ 618 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 619 .id = cpu_to_be32(_id), \ 620 } 621 622 #define FUN_ADMIN_PORT_READ_REQ_INIT(_subop, _flags, _id) \ 623 (struct fun_admin_port_read_req) { \ 624 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 625 .id = cpu_to_be32(_id), \ 626 } 627 628 struct fun_admin_port_rsp { 629 struct fun_admin_rsp_common common; 630 631 union port_rsp_subop { 632 struct fun_admin_port_create_rsp { 633 __u8 subop; 634 __u8 rsvd0[3]; 635 __be32 id; 636 637 __be16 lport; 638 __u8 rsvd1[6]; 639 } create; 640 struct fun_admin_port_write_rsp { 641 __u8 subop; 642 __u8 rsvd0[3]; 643 __be32 id; /* portid */ 644 645 struct fun_admin_write48_rsp write48[]; 646 } write; 647 struct fun_admin_port_read_rsp { 648 __u8 subop; 649 __u8 rsvd0[3]; 650 __be32 id; /* portid */ 651 652 struct fun_admin_read48_rsp read48[]; 653 } read; 654 struct fun_admin_port_inetaddr_event_rsp { 655 __u8 subop; 656 __u8 rsvd0[3]; 657 __be32 id; /* portid */ 658 } inetaddr_event; 659 } u; 660 }; 661 662 enum fun_xcvr_type { 663 FUN_XCVR_BASET = 0x0, 664 FUN_XCVR_CU = 0x1, 665 FUN_XCVR_SMF = 0x2, 666 FUN_XCVR_MMF = 0x3, 667 FUN_XCVR_AOC = 0x4, 668 FUN_XCVR_SFPP = 0x10, /* SFP+ or later */ 669 FUN_XCVR_QSFPP = 0x11, /* QSFP+ or later */ 670 FUN_XCVR_QSFPDD = 0x12, /* QSFP-DD */ 671 }; 672 673 struct fun_admin_port_notif { 674 struct fun_admin_rsp_common common; 675 676 __u8 subop; 677 __u8 rsvd0; 678 __be16 id; 679 __be32 speed; /* in 10 Mbps units */ 680 681 __u8 link_state; 682 __u8 missed_events; 683 __u8 link_down_reason; 684 __u8 xcvr_type; 685 __u8 flow_ctrl; 686 __u8 fec; 687 __u8 active_lanes; 688 __u8 rsvd1; 689 690 __be64 advertising; 691 692 __be64 lp_advertising; 693 }; 694 695 enum fun_eth_rss_const { 696 FUN_ETH_RSS_MAX_KEY_SIZE = 0x28, 697 FUN_ETH_RSS_MAX_INDIR_ENT = 0x40, 698 }; 699 700 enum fun_eth_hash_alg { 701 FUN_ETH_RSS_ALG_INVALID = 0x0, 702 FUN_ETH_RSS_ALG_TOEPLITZ = 0x1, 703 FUN_ETH_RSS_ALG_CRC32 = 0x2, 704 }; 705 706 struct fun_admin_rss_req { 707 struct fun_admin_req_common common; 708 709 union rss_req_subop { 710 struct fun_admin_rss_create_req { 711 __u8 subop; 712 __u8 rsvd0; 713 __be16 flags; 714 __be32 id; 715 716 __be32 rsvd1; 717 __be32 viid; /* VI flow id */ 718 719 __be64 metadata[1]; 720 721 __u8 alg; 722 __u8 keylen; 723 __u8 indir_nent; 724 __u8 rsvd2; 725 __be16 key_off; 726 __be16 indir_off; 727 728 struct fun_dataop_hdr dataop; 729 } create; 730 } u; 731 }; 732 733 #define FUN_ADMIN_RSS_CREATE_REQ_INIT(_subop, _flags, _id, _viid, _alg, \ 734 _keylen, _indir_nent, _key_off, \ 735 _indir_off) \ 736 (struct fun_admin_rss_create_req) { \ 737 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 738 .id = cpu_to_be32(_id), .viid = cpu_to_be32(_viid), \ 739 .alg = _alg, .keylen = _keylen, .indir_nent = _indir_nent, \ 740 .key_off = cpu_to_be16(_key_off), \ 741 .indir_off = cpu_to_be16(_indir_off), \ 742 } 743 744 struct fun_admin_vi_req { 745 struct fun_admin_req_common common; 746 747 union vi_req_subop { 748 struct fun_admin_vi_create_req { 749 __u8 subop; 750 __u8 rsvd0; 751 __be16 flags; 752 __be32 id; 753 754 __be32 rsvd1; 755 __be32 portid; /* port flow id */ 756 } create; 757 } u; 758 }; 759 760 #define FUN_ADMIN_VI_CREATE_REQ_INIT(_subop, _flags, _id, _portid) \ 761 (struct fun_admin_vi_create_req) { \ 762 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 763 .id = cpu_to_be32(_id), .portid = cpu_to_be32(_portid), \ 764 } 765 766 struct fun_admin_eth_req { 767 struct fun_admin_req_common common; 768 769 union eth_req_subop { 770 struct fun_admin_eth_create_req { 771 __u8 subop; 772 __u8 rsvd0; 773 __be16 flags; 774 __be32 id; 775 776 __be32 rsvd1; 777 __be32 portid; /* port flow id */ 778 } create; 779 } u; 780 }; 781 782 #define FUN_ADMIN_ETH_CREATE_REQ_INIT(_subop, _flags, _id, _portid) \ 783 (struct fun_admin_eth_create_req) { \ 784 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 785 .id = cpu_to_be32(_id), .portid = cpu_to_be32(_portid), \ 786 } 787 788 enum { 789 FUN_ADMIN_SWU_UPGRADE_FLAG_INIT = 0x10, 790 FUN_ADMIN_SWU_UPGRADE_FLAG_COMPLETE = 0x20, 791 FUN_ADMIN_SWU_UPGRADE_FLAG_DOWNGRADE = 0x40, 792 FUN_ADMIN_SWU_UPGRADE_FLAG_ACTIVE_IMAGE = 0x80, 793 FUN_ADMIN_SWU_UPGRADE_FLAG_ASYNC = 0x1, 794 }; 795 796 enum fun_admin_swu_subop { 797 FUN_ADMIN_SWU_SUBOP_GET_VERSION = 0x20, 798 FUN_ADMIN_SWU_SUBOP_UPGRADE = 0x21, 799 FUN_ADMIN_SWU_SUBOP_UPGRADE_DATA = 0x22, 800 FUN_ADMIN_SWU_SUBOP_GET_ALL_VERSIONS = 0x23, 801 }; 802 803 struct fun_admin_swu_req { 804 struct fun_admin_req_common common; 805 806 union swu_req_subop { 807 struct fun_admin_swu_create_req { 808 __u8 subop; 809 __u8 rsvd0; 810 __be16 flags; 811 __be32 id; 812 } create; 813 struct fun_admin_swu_upgrade_req { 814 __u8 subop; 815 __u8 rsvd0; 816 __be16 flags; 817 __be32 id; 818 819 __be32 fourcc; 820 __be32 rsvd1; 821 822 __be64 image_size; /* upgrade image length */ 823 } upgrade; 824 struct fun_admin_swu_upgrade_data_req { 825 __u8 subop; 826 __u8 rsvd0; 827 __be16 flags; 828 __be32 id; 829 830 __be32 offset; /* offset of data in this command */ 831 __be32 size; /* total size of data in this command */ 832 } upgrade_data; 833 } u; 834 835 struct fun_subop_sgl sgl[]; /* in, out buffers through sgl */ 836 }; 837 838 #define FUN_ADMIN_SWU_CREATE_REQ_INIT(_subop, _flags, _id) \ 839 (struct fun_admin_swu_create_req) { \ 840 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 841 .id = cpu_to_be32(_id), \ 842 } 843 844 #define FUN_ADMIN_SWU_UPGRADE_REQ_INIT(_subop, _flags, _id, _fourcc, \ 845 _image_size) \ 846 (struct fun_admin_swu_upgrade_req) { \ 847 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 848 .id = cpu_to_be32(_id), .fourcc = cpu_to_be32(_fourcc), \ 849 .image_size = cpu_to_be64(_image_size), \ 850 } 851 852 #define FUN_ADMIN_SWU_UPGRADE_DATA_REQ_INIT(_subop, _flags, _id, _offset, \ 853 _size) \ 854 (struct fun_admin_swu_upgrade_data_req) { \ 855 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 856 .id = cpu_to_be32(_id), .offset = cpu_to_be32(_offset), \ 857 .size = cpu_to_be32(_size), \ 858 } 859 860 struct fun_admin_swu_rsp { 861 struct fun_admin_rsp_common common; 862 863 union swu_rsp_subop { 864 struct fun_admin_swu_create_rsp { 865 __u8 subop; 866 __u8 rsvd0; 867 __be16 flags; 868 __be32 id; 869 } create; 870 struct fun_admin_swu_upgrade_rsp { 871 __u8 subop; 872 __u8 rsvd0[3]; 873 __be32 id; 874 875 __be32 fourcc; 876 __be32 status; 877 878 __be32 progress; 879 __be32 unused; 880 } upgrade; 881 struct fun_admin_swu_upgrade_data_rsp { 882 __u8 subop; 883 __u8 rsvd0; 884 __be16 flags; 885 __be32 id; 886 887 __be32 offset; 888 __be32 size; 889 } upgrade_data; 890 } u; 891 }; 892 893 enum fun_ktls_version { 894 FUN_KTLS_TLSV2 = 0x20, 895 FUN_KTLS_TLSV3 = 0x30, 896 }; 897 898 enum fun_ktls_cipher { 899 FUN_KTLS_CIPHER_AES_GCM_128 = 0x33, 900 FUN_KTLS_CIPHER_AES_GCM_256 = 0x34, 901 FUN_KTLS_CIPHER_AES_CCM_128 = 0x35, 902 FUN_KTLS_CIPHER_CHACHA20_POLY1305 = 0x36, 903 }; 904 905 enum fun_ktls_modify_flags { 906 FUN_KTLS_MODIFY_REMOVE = 0x1, 907 }; 908 909 struct fun_admin_ktls_create_req { 910 struct fun_admin_req_common common; 911 912 __u8 subop; 913 __u8 rsvd0; 914 __be16 flags; 915 __be32 id; 916 }; 917 918 #define FUN_ADMIN_KTLS_CREATE_REQ_INIT(_subop, _flags, _id) \ 919 (struct fun_admin_ktls_create_req) { \ 920 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 921 .id = cpu_to_be32(_id), \ 922 } 923 924 struct fun_admin_ktls_create_rsp { 925 struct fun_admin_rsp_common common; 926 927 __u8 subop; 928 __u8 rsvd0[3]; 929 __be32 id; 930 }; 931 932 struct fun_admin_ktls_modify_req { 933 struct fun_admin_req_common common; 934 935 __u8 subop; 936 __u8 rsvd0; 937 __be16 flags; 938 __be32 id; 939 940 __be64 tlsid; 941 942 __be32 tcp_seq; 943 __u8 version; 944 __u8 cipher; 945 __u8 rsvd1[2]; 946 947 __u8 record_seq[8]; 948 949 __u8 key[32]; 950 951 __u8 iv[16]; 952 953 __u8 salt[8]; 954 }; 955 956 #define FUN_ADMIN_KTLS_MODIFY_REQ_INIT(_subop, _flags, _id, _tlsid, _tcp_seq, \ 957 _version, _cipher) \ 958 (struct fun_admin_ktls_modify_req) { \ 959 .subop = (_subop), .flags = cpu_to_be16(_flags), \ 960 .id = cpu_to_be32(_id), .tlsid = cpu_to_be64(_tlsid), \ 961 .tcp_seq = cpu_to_be32(_tcp_seq), .version = _version, \ 962 .cipher = _cipher, \ 963 } 964 965 struct fun_admin_ktls_modify_rsp { 966 struct fun_admin_rsp_common common; 967 968 __u8 subop; 969 __u8 rsvd0[3]; 970 __be32 id; 971 972 __be64 tlsid; 973 }; 974 975 struct fun_req_common { 976 __u8 op; 977 __u8 len8; 978 __be16 flags; 979 __u8 suboff8; 980 __u8 rsvd0; 981 __be16 cid; 982 }; 983 984 struct fun_rsp_common { 985 __u8 op; 986 __u8 len8; 987 __be16 flags; 988 __u8 suboff8; 989 __u8 ret; 990 __be16 cid; 991 }; 992 993 struct fun_cqe_info { 994 __be16 sqhd; 995 __be16 sqid; 996 __be16 cid; 997 __be16 sf_p; 998 }; 999 1000 enum fun_eprq_def { 1001 FUN_EPRQ_PKT_ALIGN = 0x80, 1002 }; 1003 1004 struct fun_eprq_rqbuf { 1005 __be64 bufaddr; 1006 }; 1007 1008 #define FUN_EPRQ_RQBUF_INIT(_bufaddr) \ 1009 (struct fun_eprq_rqbuf) { \ 1010 .bufaddr = cpu_to_be64(_bufaddr), \ 1011 } 1012 1013 enum fun_eth_op { 1014 FUN_ETH_OP_TX = 0x1, 1015 FUN_ETH_OP_RX = 0x2, 1016 }; 1017 1018 enum { 1019 FUN_ETH_OFFLOAD_EN = 0x8000, 1020 FUN_ETH_OUTER_EN = 0x4000, 1021 FUN_ETH_INNER_LSO = 0x2000, 1022 FUN_ETH_INNER_TSO = 0x1000, 1023 FUN_ETH_OUTER_IPV6 = 0x800, 1024 FUN_ETH_OUTER_UDP = 0x400, 1025 FUN_ETH_INNER_IPV6 = 0x200, 1026 FUN_ETH_INNER_UDP = 0x100, 1027 FUN_ETH_UPDATE_OUTER_L3_LEN = 0x80, 1028 FUN_ETH_UPDATE_OUTER_L3_CKSUM = 0x40, 1029 FUN_ETH_UPDATE_OUTER_L4_LEN = 0x20, 1030 FUN_ETH_UPDATE_OUTER_L4_CKSUM = 0x10, 1031 FUN_ETH_UPDATE_INNER_L3_LEN = 0x8, 1032 FUN_ETH_UPDATE_INNER_L3_CKSUM = 0x4, 1033 FUN_ETH_UPDATE_INNER_L4_LEN = 0x2, 1034 FUN_ETH_UPDATE_INNER_L4_CKSUM = 0x1, 1035 }; 1036 1037 struct fun_eth_offload { 1038 __be16 flags; /* combination of above flags */ 1039 __be16 mss; /* TSO max seg size */ 1040 __be16 tcp_doff_flags; /* TCP data offset + flags 16b word */ 1041 __be16 vlan; 1042 1043 __be16 inner_l3_off; /* Inner L3 header offset */ 1044 __be16 inner_l4_off; /* Inner L4 header offset */ 1045 __be16 outer_l3_off; /* Outer L3 header offset */ 1046 __be16 outer_l4_off; /* Outer L4 header offset */ 1047 }; 1048 1049 static inline void fun_eth_offload_init(struct fun_eth_offload *s, u16 flags, 1050 u16 mss, __be16 tcp_doff_flags, 1051 __be16 vlan, u16 inner_l3_off, 1052 u16 inner_l4_off, u16 outer_l3_off, 1053 u16 outer_l4_off) 1054 { 1055 s->flags = cpu_to_be16(flags); 1056 s->mss = cpu_to_be16(mss); 1057 s->tcp_doff_flags = tcp_doff_flags; 1058 s->vlan = vlan; 1059 s->inner_l3_off = cpu_to_be16(inner_l3_off); 1060 s->inner_l4_off = cpu_to_be16(inner_l4_off); 1061 s->outer_l3_off = cpu_to_be16(outer_l3_off); 1062 s->outer_l4_off = cpu_to_be16(outer_l4_off); 1063 } 1064 1065 struct fun_eth_tls { 1066 __be64 tlsid; 1067 }; 1068 1069 enum { 1070 FUN_ETH_TX_TLS = 0x8000, 1071 }; 1072 1073 struct fun_eth_tx_req { 1074 __u8 op; 1075 __u8 len8; 1076 __be16 flags; 1077 __u8 suboff8; 1078 __u8 repr_idn; 1079 __be16 encap_proto; 1080 1081 struct fun_eth_offload offload; 1082 1083 struct fun_dataop_hdr dataop; 1084 }; 1085 1086 struct fun_eth_rx_cv { 1087 __be16 il4_prot_to_l2_type; 1088 }; 1089 1090 #define FUN_ETH_RX_CV_IL4_PROT_S 13U 1091 #define FUN_ETH_RX_CV_IL4_PROT_M 0x3 1092 1093 #define FUN_ETH_RX_CV_IL3_PROT_S 11U 1094 #define FUN_ETH_RX_CV_IL3_PROT_M 0x3 1095 1096 #define FUN_ETH_RX_CV_OL4_PROT_S 8U 1097 #define FUN_ETH_RX_CV_OL4_PROT_M 0x7 1098 1099 #define FUN_ETH_RX_CV_ENCAP_TYPE_S 6U 1100 #define FUN_ETH_RX_CV_ENCAP_TYPE_M 0x3 1101 1102 #define FUN_ETH_RX_CV_OL3_PROT_S 4U 1103 #define FUN_ETH_RX_CV_OL3_PROT_M 0x3 1104 1105 #define FUN_ETH_RX_CV_VLAN_TYPE_S 3U 1106 #define FUN_ETH_RX_CV_VLAN_TYPE_M 0x1 1107 1108 #define FUN_ETH_RX_CV_L2_TYPE_S 2U 1109 #define FUN_ETH_RX_CV_L2_TYPE_M 0x1 1110 1111 enum fun_rx_cv { 1112 FUN_RX_CV_NONE = 0x0, 1113 FUN_RX_CV_IP = 0x2, 1114 FUN_RX_CV_IP6 = 0x3, 1115 FUN_RX_CV_TCP = 0x2, 1116 FUN_RX_CV_UDP = 0x3, 1117 FUN_RX_CV_VXLAN = 0x2, 1118 FUN_RX_CV_MPLS = 0x3, 1119 }; 1120 1121 struct fun_eth_cqe { 1122 __u8 op; 1123 __u8 len8; 1124 __u8 nsgl; 1125 __u8 repr_idn; 1126 __be32 pkt_len; 1127 1128 __be64 timestamp; 1129 1130 __be16 pkt_cv; 1131 __be16 rsvd0; 1132 __be32 hash; 1133 1134 __be16 encap_proto; 1135 __be16 vlan; 1136 __be32 rsvd1; 1137 1138 __be32 buf_offset; 1139 __be16 headroom; 1140 __be16 csum; 1141 }; 1142 1143 enum fun_admin_adi_attr { 1144 FUN_ADMIN_ADI_ATTR_MACADDR = 0x1, 1145 FUN_ADMIN_ADI_ATTR_VLAN = 0x2, 1146 FUN_ADMIN_ADI_ATTR_RATE = 0x3, 1147 }; 1148 1149 struct fun_adi_param { 1150 union adi_param { 1151 struct fun_adi_mac { 1152 __be64 addr; 1153 } mac; 1154 struct fun_adi_vlan { 1155 __be32 rsvd; 1156 __be16 eth_type; 1157 __be16 tci; 1158 } vlan; 1159 struct fun_adi_rate { 1160 __be32 rsvd; 1161 __be32 tx_mbps; 1162 } rate; 1163 } u; 1164 }; 1165 1166 #define FUN_ADI_MAC_INIT(_addr) \ 1167 (struct fun_adi_mac) { \ 1168 .addr = cpu_to_be64(_addr), \ 1169 } 1170 1171 #define FUN_ADI_VLAN_INIT(_eth_type, _tci) \ 1172 (struct fun_adi_vlan) { \ 1173 .eth_type = cpu_to_be16(_eth_type), .tci = cpu_to_be16(_tci), \ 1174 } 1175 1176 #define FUN_ADI_RATE_INIT(_tx_mbps) \ 1177 (struct fun_adi_rate) { \ 1178 .tx_mbps = cpu_to_be32(_tx_mbps), \ 1179 } 1180 1181 struct fun_admin_adi_req { 1182 struct fun_admin_req_common common; 1183 1184 union adi_req_subop { 1185 struct fun_admin_adi_write_req { 1186 __u8 subop; 1187 __u8 attribute; 1188 __be16 rsvd; 1189 __be32 id; 1190 1191 struct fun_adi_param param; 1192 } write; 1193 } u; 1194 }; 1195 1196 #define FUN_ADMIN_ADI_WRITE_REQ_INIT(_subop, _attribute, _id) \ 1197 (struct fun_admin_adi_write_req) { \ 1198 .subop = (_subop), .attribute = (_attribute), \ 1199 .id = cpu_to_be32(_id), \ 1200 } 1201 1202 #endif /* __FUN_HCI_H */ 1203