drivers/net/ethernet/fungible/funcore/fun_hci.h

   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_XCVR_READ = 0x23,
 446         FUN_ADMIN_PORT_SUBOP_INETADDR_EVENT = 0x24,
 447 };
 448
 449 enum fun_admin_port_key {
 450         FUN_ADMIN_PORT_KEY_ILLEGAL = 0x0,
 451         FUN_ADMIN_PORT_KEY_MTU = 0x1,
 452         FUN_ADMIN_PORT_KEY_FEC = 0x2,
 453         FUN_ADMIN_PORT_KEY_SPEED = 0x3,
 454         FUN_ADMIN_PORT_KEY_DEBOUNCE = 0x4,
 455         FUN_ADMIN_PORT_KEY_DUPLEX = 0x5,
 456         FUN_ADMIN_PORT_KEY_MACADDR = 0x6,
 457         FUN_ADMIN_PORT_KEY_LINKMODE = 0x7,
 458         FUN_ADMIN_PORT_KEY_BREAKOUT = 0x8,
 459         FUN_ADMIN_PORT_KEY_ENABLE = 0x9,
 460         FUN_ADMIN_PORT_KEY_DISABLE = 0xa,
 461         FUN_ADMIN_PORT_KEY_ERR_DISABLE = 0xb,
 462         FUN_ADMIN_PORT_KEY_CAPABILITIES = 0xc,
 463         FUN_ADMIN_PORT_KEY_LP_CAPABILITIES = 0xd,
 464         FUN_ADMIN_PORT_KEY_STATS_DMA_LOW = 0xe,
 465         FUN_ADMIN_PORT_KEY_STATS_DMA_HIGH = 0xf,
 466         FUN_ADMIN_PORT_KEY_LANE_ATTRS = 0x10,
 467         FUN_ADMIN_PORT_KEY_LED = 0x11,
 468         FUN_ADMIN_PORT_KEY_ADVERT = 0x12,
 469 };
 470
 471 struct fun_subop_imm {
 472         __u8 subop; /* see fun_data_subop enum */
 473         __u8 flags;
 474         __u8 nsgl;
 475         __u8 rsvd0;
 476         __be32 len;
 477
 478         __u8 data[];
 479 };
 480
 481 enum fun_subop_sgl_flags {
 482         FUN_SUBOP_SGL_USE_OFF8 = 0x1,
 483         FUN_SUBOP_FLAG_FREE_BUF = 0x2,
 484         FUN_SUBOP_FLAG_IS_REFBUF = 0x4,
 485         FUN_SUBOP_SGL_FLAG_LOCAL = 0x8,
 486 };
 487
 488 enum fun_data_op {
 489         FUN_DATAOP_INVALID = 0x0,
 490         FUN_DATAOP_SL = 0x1, /* scatter */
 491         FUN_DATAOP_GL = 0x2, /* gather */
 492         FUN_DATAOP_SGL = 0x3, /* scatter-gather */
 493         FUN_DATAOP_IMM = 0x4, /* immediate data */
 494         FUN_DATAOP_RQBUF = 0x8, /* rq buffer */
 495 };
 496
 497 struct fun_dataop_gl {
 498         __u8 subop;
 499         __u8 flags;
 500         __be16 sgl_off;
 501         __be32 sgl_len;
 502
 503         __be64 sgl_data;
 504 };
 505
 506 static inline void fun_dataop_gl_init(struct fun_dataop_gl *s, u8 flags,
 507                                       u16 sgl_off, u32 sgl_len, u64 sgl_data)
 508 {
 509         s->subop = FUN_DATAOP_GL;
 510         s->flags = flags;
 511         s->sgl_off = cpu_to_be16(sgl_off);
 512         s->sgl_len = cpu_to_be32(sgl_len);
 513         s->sgl_data = cpu_to_be64(sgl_data);
 514 }
 515
 516 struct fun_dataop_imm {
 517         __u8 subop;
 518         __u8 flags;
 519         __be16 rsvd0;
 520         __be32 sgl_len;
 521 };
 522
 523 struct fun_subop_sgl {
 524         __u8 subop;
 525         __u8 flags;
 526         __u8 nsgl;
 527         __u8 rsvd0;
 528         __be32 sgl_len;
 529
 530         __be64 sgl_data;
 531 };
 532
 533 #define FUN_SUBOP_SGL_INIT(_subop, _flags, _nsgl, _sgl_len, _sgl_data) \
 534         (struct fun_subop_sgl) {                                       \
 535                 .subop = (_subop), .flags = (_flags), .nsgl = (_nsgl), \
 536                 .sgl_len = cpu_to_be32(_sgl_len),                      \
 537                 .sgl_data = cpu_to_be64(_sgl_data),                    \
 538         }
 539
 540 struct fun_dataop_rqbuf {
 541         __u8 subop;
 542         __u8 rsvd0;
 543         __be16 cid;
 544         __be32 bufoff;
 545 };
 546
 547 struct fun_dataop_hdr {
 548         __u8 nsgl;
 549         __u8 flags;
 550         __u8 ngather;
 551         __u8 nscatter;
 552         __be32 total_len;
 553
 554         struct fun_dataop_imm imm[];
 555 };
 556
 557 #define FUN_DATAOP_HDR_INIT(_nsgl, _flags, _ngather, _nscatter, _total_len)  \
 558         (struct fun_dataop_hdr) {                                            \
 559                 .nsgl = _nsgl, .flags = _flags, .ngather = _ngather,         \
 560                 .nscatter = _nscatter, .total_len = cpu_to_be32(_total_len), \
 561         }
 562
 563 enum fun_port_inetaddr_event_type {
 564         FUN_PORT_INETADDR_ADD = 0x1,
 565         FUN_PORT_INETADDR_DEL = 0x2,
 566 };
 567
 568 enum fun_port_inetaddr_addr_family {
 569         FUN_PORT_INETADDR_IPV4 = 0x1,
 570         FUN_PORT_INETADDR_IPV6 = 0x2,
 571 };
 572
 573 struct fun_admin_port_req {
 574         struct fun_admin_req_common common;
 575
 576         union port_req_subop {
 577                 struct fun_admin_port_create_req {
 578                         __u8 subop;
 579                         __u8 rsvd0;
 580                         __be16 flags;
 581                         __be32 id;
 582                 } create;
 583                 struct fun_admin_port_write_req {
 584                         __u8 subop;
 585                         __u8 rsvd0;
 586                         __be16 flags;
 587                         __be32 id; /* portid */
 588
 589                         struct fun_admin_write48_req write48[];
 590                 } write;
 591                 struct fun_admin_port_read_req {
 592                         __u8 subop;
 593                         __u8 rsvd0;
 594                         __be16 flags;
 595                         __be32 id; /* portid */
 596
 597                         struct fun_admin_read48_req read48[];
 598                 } read;
 599                 struct fun_admin_port_xcvr_read_req {
 600                         u8 subop;
 601                         u8 rsvd0;
 602                         __be16 flags;
 603                         __be32 id;
 604
 605                         u8 bank;
 606                         u8 page;
 607                         u8 offset;
 608                         u8 length;
 609                         u8 dev_addr;
 610                         u8 rsvd1[3];
 611                 } xcvr_read;
 612                 struct fun_admin_port_inetaddr_event_req {
 613                         __u8 subop;
 614                         __u8 rsvd0;
 615                         __u8 event_type;
 616                         __u8 addr_family;
 617                         __be32 id;
 618
 619                         __u8 addr[];
 620                 } inetaddr_event;
 621         } u;
 622 };
 623
 624 #define FUN_ADMIN_PORT_CREATE_REQ_INIT(_subop, _flags, _id)      \
 625         (struct fun_admin_port_create_req) {                     \
 626                 .subop = (_subop), .flags = cpu_to_be16(_flags), \
 627                 .id = cpu_to_be32(_id),                          \
 628         }
 629
 630 #define FUN_ADMIN_PORT_WRITE_REQ_INIT(_subop, _flags, _id)       \
 631         (struct fun_admin_port_write_req) {                      \
 632                 .subop = (_subop), .flags = cpu_to_be16(_flags), \
 633                 .id = cpu_to_be32(_id),                          \
 634         }
 635
 636 #define FUN_ADMIN_PORT_READ_REQ_INIT(_subop, _flags, _id)        \
 637         (struct fun_admin_port_read_req) {                       \
 638                 .subop = (_subop), .flags = cpu_to_be16(_flags), \
 639                 .id = cpu_to_be32(_id),                          \
 640         }
 641
 642 #define FUN_ADMIN_PORT_XCVR_READ_REQ_INIT(_flags, _id, _bank, _page,   \
 643                                           _offset, _length, _dev_addr) \
 644         ((struct fun_admin_port_xcvr_read_req) {                       \
 645                 .subop = FUN_ADMIN_PORT_SUBOP_XCVR_READ,               \
 646                 .flags = cpu_to_be16(_flags), .id = cpu_to_be32(_id),  \
 647                 .bank = (_bank), .page = (_page), .offset = (_offset), \
 648                 .length = (_length), .dev_addr = (_dev_addr),          \
 649         })
 650
 651 struct fun_admin_port_rsp {
 652         struct fun_admin_rsp_common common;
 653
 654         union port_rsp_subop {
 655                 struct fun_admin_port_create_rsp {
 656                         __u8 subop;
 657                         __u8 rsvd0[3];
 658                         __be32 id;
 659
 660                         __be16 lport;
 661                         __u8 rsvd1[6];
 662                 } create;
 663                 struct fun_admin_port_write_rsp {
 664                         __u8 subop;
 665                         __u8 rsvd0[3];
 666                         __be32 id; /* portid */
 667
 668                         struct fun_admin_write48_rsp write48[];
 669                 } write;
 670                 struct fun_admin_port_read_rsp {
 671                         __u8 subop;
 672                         __u8 rsvd0[3];
 673                         __be32 id; /* portid */
 674
 675                         struct fun_admin_read48_rsp read48[];
 676                 } read;
 677                 struct fun_admin_port_inetaddr_event_rsp {
 678                         __u8 subop;
 679                         __u8 rsvd0[3];
 680                         __be32 id; /* portid */
 681                 } inetaddr_event;
 682         } u;
 683 };
 684
 685 struct fun_admin_port_xcvr_read_rsp {
 686         struct fun_admin_rsp_common common;
 687
 688         u8 subop;
 689         u8 rsvd0[3];
 690         __be32 id;
 691
 692         u8 bank;
 693         u8 page;
 694         u8 offset;
 695         u8 length;
 696         u8 dev_addr;
 697         u8 rsvd1[3];
 698
 699         u8 data[128];
 700 };
 701
 702 enum fun_xcvr_type {
 703         FUN_XCVR_BASET = 0x0,
 704         FUN_XCVR_CU = 0x1,
 705         FUN_XCVR_SMF = 0x2,
 706         FUN_XCVR_MMF = 0x3,
 707         FUN_XCVR_AOC = 0x4,
 708         FUN_XCVR_SFPP = 0x10, /* SFP+ or later */
 709         FUN_XCVR_QSFPP = 0x11, /* QSFP+ or later */
 710         FUN_XCVR_QSFPDD = 0x12, /* QSFP-DD */
 711 };
 712
 713 struct fun_admin_port_notif {
 714         struct fun_admin_rsp_common common;
 715
 716         __u8 subop;
 717         __u8 rsvd0;
 718         __be16 id;
 719         __be32 speed; /* in 10 Mbps units */
 720
 721         __u8 link_state;
 722         __u8 missed_events;
 723         __u8 link_down_reason;
 724         __u8 xcvr_type;
 725         __u8 flow_ctrl;
 726         __u8 fec;
 727         __u8 active_lanes;
 728         __u8 rsvd1;
 729
 730         __be64 advertising;
 731
 732         __be64 lp_advertising;
 733 };
 734
 735 enum fun_eth_rss_const {
 736         FUN_ETH_RSS_MAX_KEY_SIZE = 0x28,
 737         FUN_ETH_RSS_MAX_INDIR_ENT = 0x40,
 738 };
 739
 740 enum fun_eth_hash_alg {
 741         FUN_ETH_RSS_ALG_INVALID = 0x0,
 742         FUN_ETH_RSS_ALG_TOEPLITZ = 0x1,
 743         FUN_ETH_RSS_ALG_CRC32 = 0x2,
 744 };
 745
 746 struct fun_admin_rss_req {
 747         struct fun_admin_req_common common;
 748
 749         union rss_req_subop {
 750                 struct fun_admin_rss_create_req {
 751                         __u8 subop;
 752                         __u8 rsvd0;
 753                         __be16 flags;
 754                         __be32 id;
 755
 756                         __be32 rsvd1;
 757                         __be32 viid; /* VI flow id */
 758
 759                         __be64 metadata[1];
 760
 761                         __u8 alg;
 762                         __u8 keylen;
 763                         __u8 indir_nent;
 764                         __u8 rsvd2;
 765                         __be16 key_off;
 766                         __be16 indir_off;
 767
 768                         struct fun_dataop_hdr dataop;
 769                 } create;
 770         } u;
 771 };
 772
 773 #define FUN_ADMIN_RSS_CREATE_REQ_INIT(_subop, _flags, _id, _viid, _alg,    \
 774                                       _keylen, _indir_nent, _key_off,      \
 775                                       _indir_off)                          \
 776         (struct fun_admin_rss_create_req) {                                \
 777                 .subop = (_subop), .flags = cpu_to_be16(_flags),           \
 778                 .id = cpu_to_be32(_id), .viid = cpu_to_be32(_viid),        \
 779                 .alg = _alg, .keylen = _keylen, .indir_nent = _indir_nent, \
 780                 .key_off = cpu_to_be16(_key_off),                          \
 781                 .indir_off = cpu_to_be16(_indir_off),                      \
 782         }
 783
 784 struct fun_admin_vi_req {
 785         struct fun_admin_req_common common;
 786
 787         union vi_req_subop {
 788                 struct fun_admin_vi_create_req {
 789                         __u8 subop;
 790                         __u8 rsvd0;
 791                         __be16 flags;
 792                         __be32 id;
 793
 794                         __be32 rsvd1;
 795                         __be32 portid; /* port flow id */
 796                 } create;
 797         } u;
 798 };
 799
 800 #define FUN_ADMIN_VI_CREATE_REQ_INIT(_subop, _flags, _id, _portid)      \
 801         (struct fun_admin_vi_create_req) {                              \
 802                 .subop = (_subop), .flags = cpu_to_be16(_flags),        \
 803                 .id = cpu_to_be32(_id), .portid = cpu_to_be32(_portid), \
 804         }
 805
 806 struct fun_admin_eth_req {
 807         struct fun_admin_req_common common;
 808
 809         union eth_req_subop {
 810                 struct fun_admin_eth_create_req {
 811                         __u8 subop;
 812                         __u8 rsvd0;
 813                         __be16 flags;
 814                         __be32 id;
 815
 816                         __be32 rsvd1;
 817                         __be32 portid; /* port flow id */
 818                 } create;
 819         } u;
 820 };
 821
 822 #define FUN_ADMIN_ETH_CREATE_REQ_INIT(_subop, _flags, _id, _portid)     \
 823         (struct fun_admin_eth_create_req) {                             \
 824                 .subop = (_subop), .flags = cpu_to_be16(_flags),        \
 825                 .id = cpu_to_be32(_id), .portid = cpu_to_be32(_portid), \
 826         }
 827
 828 enum {
 829         FUN_ADMIN_SWU_UPGRADE_FLAG_INIT = 0x10,
 830         FUN_ADMIN_SWU_UPGRADE_FLAG_COMPLETE = 0x20,
 831         FUN_ADMIN_SWU_UPGRADE_FLAG_DOWNGRADE = 0x40,
 832         FUN_ADMIN_SWU_UPGRADE_FLAG_ACTIVE_IMAGE = 0x80,
 833         FUN_ADMIN_SWU_UPGRADE_FLAG_ASYNC = 0x1,
 834 };
 835
 836 enum fun_admin_swu_subop {
 837         FUN_ADMIN_SWU_SUBOP_GET_VERSION = 0x20,
 838         FUN_ADMIN_SWU_SUBOP_UPGRADE = 0x21,
 839         FUN_ADMIN_SWU_SUBOP_UPGRADE_DATA = 0x22,
 840         FUN_ADMIN_SWU_SUBOP_GET_ALL_VERSIONS = 0x23,
 841 };
 842
 843 struct fun_admin_swu_req {
 844         struct fun_admin_req_common common;
 845
 846         union swu_req_subop {
 847                 struct fun_admin_swu_create_req {
 848                         __u8 subop;
 849                         __u8 rsvd0;
 850                         __be16 flags;
 851                         __be32 id;
 852                 } create;
 853                 struct fun_admin_swu_upgrade_req {
 854                         __u8 subop;
 855                         __u8 rsvd0;
 856                         __be16 flags;
 857                         __be32 id;
 858
 859                         __be32 fourcc;
 860                         __be32 rsvd1;
 861
 862                         __be64 image_size; /* upgrade image length */
 863                 } upgrade;
 864                 struct fun_admin_swu_upgrade_data_req {
 865                         __u8 subop;
 866                         __u8 rsvd0;
 867                         __be16 flags;
 868                         __be32 id;
 869
 870                         __be32 offset; /* offset of data in this command */
 871                         __be32 size; /* total size of data in this command */
 872                 } upgrade_data;
 873         } u;
 874
 875         struct fun_subop_sgl sgl[]; /* in, out buffers through sgl */
 876 };
 877
 878 #define FUN_ADMIN_SWU_CREATE_REQ_INIT(_subop, _flags, _id)       \
 879         (struct fun_admin_swu_create_req) {                      \
 880                 .subop = (_subop), .flags = cpu_to_be16(_flags), \
 881                 .id = cpu_to_be32(_id),                          \
 882         }
 883
 884 #define FUN_ADMIN_SWU_UPGRADE_REQ_INIT(_subop, _flags, _id, _fourcc,    \
 885                                        _image_size)                     \
 886         (struct fun_admin_swu_upgrade_req) {                            \
 887                 .subop = (_subop), .flags = cpu_to_be16(_flags),        \
 888                 .id = cpu_to_be32(_id), .fourcc = cpu_to_be32(_fourcc), \
 889                 .image_size = cpu_to_be64(_image_size),                 \
 890         }
 891
 892 #define FUN_ADMIN_SWU_UPGRADE_DATA_REQ_INIT(_subop, _flags, _id, _offset, \
 893                                             _size)                        \
 894         (struct fun_admin_swu_upgrade_data_req) {                         \
 895                 .subop = (_subop), .flags = cpu_to_be16(_flags),          \
 896                 .id = cpu_to_be32(_id), .offset = cpu_to_be32(_offset),   \
 897                 .size = cpu_to_be32(_size),                               \
 898         }
 899
 900 struct fun_admin_swu_rsp {
 901         struct fun_admin_rsp_common common;
 902
 903         union swu_rsp_subop {
 904                 struct fun_admin_swu_create_rsp {
 905                         __u8 subop;
 906                         __u8 rsvd0;
 907                         __be16 flags;
 908                         __be32 id;
 909                 } create;
 910                 struct fun_admin_swu_upgrade_rsp {
 911                         __u8 subop;
 912                         __u8 rsvd0[3];
 913                         __be32 id;
 914
 915                         __be32 fourcc;
 916                         __be32 status;
 917
 918                         __be32 progress;
 919                         __be32 unused;
 920                 } upgrade;
 921                 struct fun_admin_swu_upgrade_data_rsp {
 922                         __u8 subop;
 923                         __u8 rsvd0;
 924                         __be16 flags;
 925                         __be32 id;
 926
 927                         __be32 offset;
 928                         __be32 size;
 929                 } upgrade_data;
 930         } u;
 931 };
 932
 933 enum fun_ktls_version {
 934         FUN_KTLS_TLSV2 = 0x20,
 935         FUN_KTLS_TLSV3 = 0x30,
 936 };
 937
 938 enum fun_ktls_cipher {
 939         FUN_KTLS_CIPHER_AES_GCM_128 = 0x33,
 940         FUN_KTLS_CIPHER_AES_GCM_256 = 0x34,
 941         FUN_KTLS_CIPHER_AES_CCM_128 = 0x35,
 942         FUN_KTLS_CIPHER_CHACHA20_POLY1305 = 0x36,
 943 };
 944
 945 enum fun_ktls_modify_flags {
 946         FUN_KTLS_MODIFY_REMOVE = 0x1,
 947 };
 948
 949 struct fun_admin_ktls_create_req {
 950         struct fun_admin_req_common common;
 951
 952         __u8 subop;
 953         __u8 rsvd0;
 954         __be16 flags;
 955         __be32 id;
 956 };
 957
 958 #define FUN_ADMIN_KTLS_CREATE_REQ_INIT(_subop, _flags, _id)      \
 959         (struct fun_admin_ktls_create_req) {                     \
 960                 .subop = (_subop), .flags = cpu_to_be16(_flags), \
 961                 .id = cpu_to_be32(_id),                          \
 962         }
 963
 964 struct fun_admin_ktls_create_rsp {
 965         struct fun_admin_rsp_common common;
 966
 967         __u8 subop;
 968         __u8 rsvd0[3];
 969         __be32 id;
 970 };
 971
 972 struct fun_admin_ktls_modify_req {
 973         struct fun_admin_req_common common;
 974
 975         __u8 subop;
 976         __u8 rsvd0;
 977         __be16 flags;
 978         __be32 id;
 979
 980         __be64 tlsid;
 981
 982         __be32 tcp_seq;
 983         __u8 version;
 984         __u8 cipher;
 985         __u8 rsvd1[2];
 986
 987         __u8 record_seq[8];
 988
 989         __u8 key[32];
 990
 991         __u8 iv[16];
 992
 993         __u8 salt[8];
 994 };
 995
 996 #define FUN_ADMIN_KTLS_MODIFY_REQ_INIT(_subop, _flags, _id, _tlsid, _tcp_seq, \
 997                                        _version, _cipher)                     \
 998         (struct fun_admin_ktls_modify_req) {                                  \
 999                 .subop = (_subop), .flags = cpu_to_be16(_flags),              \
1000                 .id = cpu_to_be32(_id), .tlsid = cpu_to_be64(_tlsid),         \
1001                 .tcp_seq = cpu_to_be32(_tcp_seq), .version = _version,        \
1002                 .cipher = _cipher,                                            \
1003         }
1004
1005 struct fun_admin_ktls_modify_rsp {
1006         struct fun_admin_rsp_common common;
1007
1008         __u8 subop;
1009         __u8 rsvd0[3];
1010         __be32 id;
1011
1012         __be64 tlsid;
1013 };
1014
1015 struct fun_req_common {
1016         __u8 op;
1017         __u8 len8;
1018         __be16 flags;
1019         __u8 suboff8;
1020         __u8 rsvd0;
1021         __be16 cid;
1022 };
1023
1024 struct fun_rsp_common {
1025         __u8 op;
1026         __u8 len8;
1027         __be16 flags;
1028         __u8 suboff8;
1029         __u8 ret;
1030         __be16 cid;
1031 };
1032
1033 struct fun_cqe_info {
1034         __be16 sqhd;
1035         __be16 sqid;
1036         __be16 cid;
1037         __be16 sf_p;
1038 };
1039
1040 enum fun_eprq_def {
1041         FUN_EPRQ_PKT_ALIGN = 0x80,
1042 };
1043
1044 struct fun_eprq_rqbuf {
1045         __be64 bufaddr;
1046 };
1047
1048 #define FUN_EPRQ_RQBUF_INIT(_bufaddr)             \
1049         (struct fun_eprq_rqbuf) {                 \
1050                 .bufaddr = cpu_to_be64(_bufaddr), \
1051         }
1052
1053 enum fun_eth_op {
1054         FUN_ETH_OP_TX = 0x1,
1055         FUN_ETH_OP_RX = 0x2,
1056 };
1057
1058 enum {
1059         FUN_ETH_OFFLOAD_EN = 0x8000,
1060         FUN_ETH_OUTER_EN = 0x4000,
1061         FUN_ETH_INNER_LSO = 0x2000,
1062         FUN_ETH_INNER_TSO = 0x1000,
1063         FUN_ETH_OUTER_IPV6 = 0x800,
1064         FUN_ETH_OUTER_UDP = 0x400,
1065         FUN_ETH_INNER_IPV6 = 0x200,
1066         FUN_ETH_INNER_UDP = 0x100,
1067         FUN_ETH_UPDATE_OUTER_L3_LEN = 0x80,
1068         FUN_ETH_UPDATE_OUTER_L3_CKSUM = 0x40,
1069         FUN_ETH_UPDATE_OUTER_L4_LEN = 0x20,
1070         FUN_ETH_UPDATE_OUTER_L4_CKSUM = 0x10,
1071         FUN_ETH_UPDATE_INNER_L3_LEN = 0x8,
1072         FUN_ETH_UPDATE_INNER_L3_CKSUM = 0x4,
1073         FUN_ETH_UPDATE_INNER_L4_LEN = 0x2,
1074         FUN_ETH_UPDATE_INNER_L4_CKSUM = 0x1,
1075 };
1076
1077 struct fun_eth_offload {
1078         __be16 flags; /* combination of above flags */
1079         __be16 mss; /* TSO max seg size */
1080         __be16 tcp_doff_flags; /* TCP data offset + flags 16b word */
1081         __be16 vlan;
1082
1083         __be16 inner_l3_off; /* Inner L3 header offset */
1084         __be16 inner_l4_off; /* Inner L4 header offset */
1085         __be16 outer_l3_off; /* Outer L3 header offset */
1086         __be16 outer_l4_off; /* Outer L4 header offset */
1087 };
1088
1089 static inline void fun_eth_offload_init(struct fun_eth_offload *s, u16 flags,
1090                                         u16 mss, __be16 tcp_doff_flags,
1091                                         __be16 vlan, u16 inner_l3_off,
1092                                         u16 inner_l4_off, u16 outer_l3_off,
1093                                         u16 outer_l4_off)
1094 {
1095         s->flags = cpu_to_be16(flags);
1096         s->mss = cpu_to_be16(mss);
1097         s->tcp_doff_flags = tcp_doff_flags;
1098         s->vlan = vlan;
1099         s->inner_l3_off = cpu_to_be16(inner_l3_off);
1100         s->inner_l4_off = cpu_to_be16(inner_l4_off);
1101         s->outer_l3_off = cpu_to_be16(outer_l3_off);
1102         s->outer_l4_off = cpu_to_be16(outer_l4_off);
1103 }
1104
1105 struct fun_eth_tls {
1106         __be64 tlsid;
1107 };
1108
1109 enum {
1110         FUN_ETH_TX_TLS = 0x8000,
1111 };
1112
1113 struct fun_eth_tx_req {
1114         __u8 op;
1115         __u8 len8;
1116         __be16 flags;
1117         __u8 suboff8;
1118         __u8 repr_idn;
1119         __be16 encap_proto;
1120
1121         struct fun_eth_offload offload;
1122
1123         struct fun_dataop_hdr dataop;
1124 };
1125
1126 struct fun_eth_rx_cv {
1127         __be16 il4_prot_to_l2_type;
1128 };
1129
1130 #define FUN_ETH_RX_CV_IL4_PROT_S 13U
1131 #define FUN_ETH_RX_CV_IL4_PROT_M 0x3
1132
1133 #define FUN_ETH_RX_CV_IL3_PROT_S 11U
1134 #define FUN_ETH_RX_CV_IL3_PROT_M 0x3
1135
1136 #define FUN_ETH_RX_CV_OL4_PROT_S 8U
1137 #define FUN_ETH_RX_CV_OL4_PROT_M 0x7
1138
1139 #define FUN_ETH_RX_CV_ENCAP_TYPE_S 6U
1140 #define FUN_ETH_RX_CV_ENCAP_TYPE_M 0x3
1141
1142 #define FUN_ETH_RX_CV_OL3_PROT_S 4U
1143 #define FUN_ETH_RX_CV_OL3_PROT_M 0x3
1144
1145 #define FUN_ETH_RX_CV_VLAN_TYPE_S 3U
1146 #define FUN_ETH_RX_CV_VLAN_TYPE_M 0x1
1147
1148 #define FUN_ETH_RX_CV_L2_TYPE_S 2U
1149 #define FUN_ETH_RX_CV_L2_TYPE_M 0x1
1150
1151 enum fun_rx_cv {
1152         FUN_RX_CV_NONE = 0x0,
1153         FUN_RX_CV_IP = 0x2,
1154         FUN_RX_CV_IP6 = 0x3,
1155         FUN_RX_CV_TCP = 0x2,
1156         FUN_RX_CV_UDP = 0x3,
1157         FUN_RX_CV_VXLAN = 0x2,
1158         FUN_RX_CV_MPLS = 0x3,
1159 };
1160
1161 struct fun_eth_cqe {
1162         __u8 op;
1163         __u8 len8;
1164         __u8 nsgl;
1165         __u8 repr_idn;
1166         __be32 pkt_len;
1167
1168         __be64 timestamp;
1169
1170         __be16 pkt_cv;
1171         __be16 rsvd0;
1172         __be32 hash;
1173
1174         __be16 encap_proto;
1175         __be16 vlan;
1176         __be32 rsvd1;
1177
1178         __be32 buf_offset;
1179         __be16 headroom;
1180         __be16 csum;
1181 };
1182
1183 enum fun_admin_adi_attr {
1184         FUN_ADMIN_ADI_ATTR_MACADDR = 0x1,
1185         FUN_ADMIN_ADI_ATTR_VLAN = 0x2,
1186         FUN_ADMIN_ADI_ATTR_RATE = 0x3,
1187 };
1188
1189 struct fun_adi_param {
1190         union adi_param {
1191                 struct fun_adi_mac {
1192                         __be64 addr;
1193                 } mac;
1194                 struct fun_adi_vlan {
1195                         __be32 rsvd;
1196                         __be16 eth_type;
1197                         __be16 tci;
1198                 } vlan;
1199                 struct fun_adi_rate {
1200                         __be32 rsvd;
1201                         __be32 tx_mbps;
1202                 } rate;
1203         } u;
1204 };
1205
1206 #define FUN_ADI_MAC_INIT(_addr)             \
1207         (struct fun_adi_mac) {              \
1208                 .addr = cpu_to_be64(_addr), \
1209         }
1210
1211 #define FUN_ADI_VLAN_INIT(_eth_type, _tci)                                    \
1212         (struct fun_adi_vlan) {                                               \
1213                 .eth_type = cpu_to_be16(_eth_type), .tci = cpu_to_be16(_tci), \
1214         }
1215
1216 #define FUN_ADI_RATE_INIT(_tx_mbps)               \
1217         (struct fun_adi_rate) {                   \
1218                 .tx_mbps = cpu_to_be32(_tx_mbps), \
1219         }
1220
1221 struct fun_admin_adi_req {
1222         struct fun_admin_req_common common;
1223
1224         union adi_req_subop {
1225                 struct fun_admin_adi_write_req {
1226                         __u8 subop;
1227                         __u8 attribute;
1228                         __be16 rsvd;
1229                         __be32 id;
1230
1231                         struct fun_adi_param param;
1232                 } write;
1233         } u;
1234 };
1235
1236 #define FUN_ADMIN_ADI_WRITE_REQ_INIT(_subop, _attribute, _id) \
1237         (struct fun_admin_adi_write_req) {                    \
1238                 .subop = (_subop), .attribute = (_attribute), \
1239                 .id = cpu_to_be32(_id),                       \
1240         }
1241
1242 #endif /* __FUN_HCI_H */