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 | = 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 | = 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 | = 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 { |
736 | = 0x28, |
737 | = 0x40, |
738 | }; |
739 | |
740 | enum fun_eth_hash_alg { |
741 | = 0x0, |
742 | = 0x1, |
743 | = 0x2, |
744 | }; |
745 | |
746 | struct { |
747 | struct fun_admin_req_common ; |
748 | |
749 | union { |
750 | struct { |
751 | __u8 ; |
752 | __u8 ; |
753 | __be16 ; |
754 | __be32 ; |
755 | |
756 | __be32 ; |
757 | __be32 ; /* VI flow id */ |
758 | |
759 | __be64 [1]; |
760 | |
761 | __u8 ; |
762 | __u8 ; |
763 | __u8 ; |
764 | __u8 ; |
765 | __be16 ; |
766 | __be16 ; |
767 | |
768 | struct fun_dataop_hdr ; |
769 | } ; |
770 | } ; |
771 | }; |
772 | |
773 | #define (_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 */ |
1243 | |