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 
fun_dataop_gl_init(struct fun_dataop_gl * s,u8 flags,u16 sgl_off,u32 sgl_len,u64 sgl_data)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 
fun_eth_offload_init(struct fun_eth_offload * s,u16 flags,u16 mss,__be16 tcp_doff_flags,__be16 vlan,u16 inner_l3_off,u16 inner_l4_off,u16 outer_l3_off,u16 outer_l4_off)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 */
1243