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