Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2001-2023 Intel Corporation
3 : : */
4 : :
5 : : #include "ice_acl.h"
6 : : #include "ice_adminq_cmd.h"
7 : :
8 : : /**
9 : : * ice_aq_alloc_acl_tbl - allocate ACL table
10 : : * @hw: pointer to the HW struct
11 : : * @tbl: pointer to ice_acl_alloc_tbl struct
12 : : * @cd: pointer to command details structure or NULL
13 : : *
14 : : * Allocate ACL table (indirect 0x0C10)
15 : : */
16 : : int
17 : 0 : ice_aq_alloc_acl_tbl(struct ice_hw *hw, struct ice_acl_alloc_tbl *tbl,
18 : : struct ice_sq_cd *cd)
19 : : {
20 : : struct ice_aqc_acl_alloc_table *cmd;
21 : : struct ice_aq_desc desc;
22 : :
23 [ # # ]: 0 : if (!tbl->act_pairs_per_entry)
24 : : return ICE_ERR_PARAM;
25 : :
26 [ # # ]: 0 : if (tbl->act_pairs_per_entry > ICE_AQC_MAX_ACTION_MEMORIES)
27 : : return ICE_ERR_MAX_LIMIT;
28 : :
29 : : /* If this is concurrent table, then buffer shall be valid and
30 : : * contain DependentAllocIDs, 'num_dependent_alloc_ids' should be valid
31 : : * and within limit
32 : : */
33 [ # # ]: 0 : if (tbl->concurr) {
34 [ # # ]: 0 : if (!tbl->num_dependent_alloc_ids)
35 : : return ICE_ERR_PARAM;
36 [ # # ]: 0 : if (tbl->num_dependent_alloc_ids >
37 : : ICE_AQC_MAX_CONCURRENT_ACL_TBL)
38 : : return ICE_ERR_INVAL_SIZE;
39 : : }
40 : :
41 : 0 : ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_alloc_acl_tbl);
42 : 0 : desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
43 : :
44 : : cmd = &desc.params.alloc_table;
45 : 0 : cmd->table_width = CPU_TO_LE16(tbl->width * BITS_PER_BYTE);
46 : 0 : cmd->table_depth = CPU_TO_LE16(tbl->depth);
47 : 0 : cmd->act_pairs_per_entry = tbl->act_pairs_per_entry;
48 [ # # ]: 0 : if (tbl->concurr)
49 : 0 : cmd->table_type = tbl->num_dependent_alloc_ids;
50 : :
51 : 0 : return ice_aq_send_cmd(hw, &desc, &tbl->buf, sizeof(tbl->buf), cd);
52 : : }
53 : :
54 : : /**
55 : : * ice_aq_dealloc_acl_tbl - deallocate ACL table
56 : : * @hw: pointer to the HW struct
57 : : * @alloc_id: allocation ID of the table being released
58 : : * @buf: address of indirect data buffer
59 : : * @cd: pointer to command details structure or NULL
60 : : *
61 : : * Deallocate ACL table (indirect 0x0C11)
62 : : *
63 : : * NOTE: This command has no buffer format for command itself but response
64 : : * format is 'struct ice_aqc_acl_generic', pass ptr to that struct
65 : : * as 'buf' and its size as 'buf_size'
66 : : */
67 : : int
68 : 0 : ice_aq_dealloc_acl_tbl(struct ice_hw *hw, u16 alloc_id,
69 : : struct ice_aqc_acl_generic *buf, struct ice_sq_cd *cd)
70 : : {
71 : : struct ice_aqc_acl_tbl_actpair *cmd;
72 : : struct ice_aq_desc desc;
73 : :
74 : 0 : ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_dealloc_acl_tbl);
75 : : cmd = &desc.params.tbl_actpair;
76 : 0 : cmd->alloc_id = CPU_TO_LE16(alloc_id);
77 : :
78 : 0 : return ice_aq_send_cmd(hw, &desc, buf, sizeof(*buf), cd);
79 : : }
80 : :
81 : : static int
82 : 0 : ice_aq_acl_entry(struct ice_hw *hw, u16 opcode, u8 tcam_idx, u16 entry_idx,
83 : : struct ice_aqc_acl_data *buf, struct ice_sq_cd *cd)
84 : : {
85 : : struct ice_aqc_acl_entry *cmd;
86 : : struct ice_aq_desc desc;
87 : :
88 : 0 : ice_fill_dflt_direct_cmd_desc(&desc, opcode);
89 : :
90 [ # # ]: 0 : if (opcode == ice_aqc_opc_program_acl_entry)
91 : 0 : desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
92 : :
93 : : cmd = &desc.params.program_query_entry;
94 : 0 : cmd->tcam_index = tcam_idx;
95 : 0 : cmd->entry_index = CPU_TO_LE16(entry_idx);
96 : :
97 : 0 : return ice_aq_send_cmd(hw, &desc, buf, sizeof(*buf), cd);
98 : : }
99 : :
100 : : /**
101 : : * ice_aq_program_acl_entry - program ACL entry
102 : : * @hw: pointer to the HW struct
103 : : * @tcam_idx: Updated TCAM block index
104 : : * @entry_idx: updated entry index
105 : : * @buf: address of indirect data buffer
106 : : * @cd: pointer to command details structure or NULL
107 : : *
108 : : * Program ACL entry (direct 0x0C20)
109 : : */
110 : : int
111 : 0 : ice_aq_program_acl_entry(struct ice_hw *hw, u8 tcam_idx, u16 entry_idx,
112 : : struct ice_aqc_acl_data *buf, struct ice_sq_cd *cd)
113 : : {
114 : 0 : return ice_aq_acl_entry(hw, ice_aqc_opc_program_acl_entry, tcam_idx,
115 : : entry_idx, buf, cd);
116 : : }
117 : :
118 : : /**
119 : : * ice_aq_query_acl_entry - query ACL entry
120 : : * @hw: pointer to the HW struct
121 : : * @tcam_idx: Updated TCAM block index
122 : : * @entry_idx: updated entry index
123 : : * @buf: address of indirect data buffer
124 : : * @cd: pointer to command details structure or NULL
125 : : *
126 : : * Query ACL entry (direct 0x0C24)
127 : : *
128 : : * NOTE: Caller of this API to parse 'buf' appropriately since it contains
129 : : * response (key and key invert)
130 : : */
131 : : int
132 : 0 : ice_aq_query_acl_entry(struct ice_hw *hw, u8 tcam_idx, u16 entry_idx,
133 : : struct ice_aqc_acl_data *buf, struct ice_sq_cd *cd)
134 : : {
135 : 0 : return ice_aq_acl_entry(hw, ice_aqc_opc_query_acl_entry, tcam_idx,
136 : : entry_idx, buf, cd);
137 : : }
138 : :
139 : : /* Helper function to alloc/dealloc ACL action pair */
140 : : static int
141 : : ice_aq_actpair_a_d(struct ice_hw *hw, u16 opcode, u16 alloc_id,
142 : : struct ice_aqc_acl_generic *buf, struct ice_sq_cd *cd)
143 : : {
144 : : struct ice_aqc_acl_tbl_actpair *cmd;
145 : : struct ice_aq_desc desc;
146 : :
147 : 0 : ice_fill_dflt_direct_cmd_desc(&desc, opcode);
148 : : cmd = &desc.params.tbl_actpair;
149 : 0 : cmd->alloc_id = CPU_TO_LE16(alloc_id);
150 : :
151 : 0 : return ice_aq_send_cmd(hw, &desc, buf, sizeof(*buf), cd);
152 : : }
153 : :
154 : : /**
155 : : * ice_aq_alloc_actpair - allocate actionpair for specified ACL table
156 : : * @hw: pointer to the HW struct
157 : : * @alloc_id: allocation ID of the table being associated with the actionpair
158 : : * @buf: address of indirect data buffer
159 : : * @cd: pointer to command details structure or NULL
160 : : *
161 : : * Allocate ACL actionpair (direct 0x0C12)
162 : : *
163 : : * This command doesn't need and doesn't have its own command buffer
164 : : * but for response format is as specified in 'struct ice_aqc_acl_generic'
165 : : */
166 : : int
167 : 0 : ice_aq_alloc_actpair(struct ice_hw *hw, u16 alloc_id,
168 : : struct ice_aqc_acl_generic *buf, struct ice_sq_cd *cd)
169 : : {
170 : 0 : return ice_aq_actpair_a_d(hw, ice_aqc_opc_alloc_acl_actpair, alloc_id,
171 : : buf, cd);
172 : : }
173 : :
174 : : /**
175 : : * ice_aq_dealloc_actpair - dealloc actionpair for specified ACL table
176 : : * @hw: pointer to the HW struct
177 : : * @alloc_id: allocation ID of the table being associated with the actionpair
178 : : * @buf: address of indirect data buffer
179 : : * @cd: pointer to command details structure or NULL
180 : : *
181 : : * Deallocate ACL actionpair (direct 0x0C13)
182 : : */
183 : : int
184 : 0 : ice_aq_dealloc_actpair(struct ice_hw *hw, u16 alloc_id,
185 : : struct ice_aqc_acl_generic *buf, struct ice_sq_cd *cd)
186 : : {
187 : 0 : return ice_aq_actpair_a_d(hw, ice_aqc_opc_dealloc_acl_actpair, alloc_id,
188 : : buf, cd);
189 : : }
190 : :
191 : : /* Helper function to program/query ACL action pair */
192 : : static int
193 : 0 : ice_aq_actpair_p_q(struct ice_hw *hw, u16 opcode, u8 act_mem_idx,
194 : : u16 act_entry_idx, struct ice_aqc_actpair *buf,
195 : : struct ice_sq_cd *cd)
196 : : {
197 : : struct ice_aqc_acl_actpair *cmd;
198 : : struct ice_aq_desc desc;
199 : :
200 : 0 : ice_fill_dflt_direct_cmd_desc(&desc, opcode);
201 : :
202 [ # # ]: 0 : if (opcode == ice_aqc_opc_program_acl_actpair)
203 : 0 : desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
204 : :
205 : : cmd = &desc.params.program_query_actpair;
206 : 0 : cmd->act_mem_index = act_mem_idx;
207 : 0 : cmd->act_entry_index = CPU_TO_LE16(act_entry_idx);
208 : :
209 : 0 : return ice_aq_send_cmd(hw, &desc, buf, sizeof(*buf), cd);
210 : : }
211 : :
212 : : /**
213 : : * ice_aq_program_actpair - program ACL actionpair
214 : : * @hw: pointer to the HW struct
215 : : * @act_mem_idx: action memory index to program/update/query
216 : : * @act_entry_idx: the entry index in action memory to be programmed/updated
217 : : * @buf: address of indirect data buffer
218 : : * @cd: pointer to command details structure or NULL
219 : : *
220 : : * Program action entries (indirect 0x0C1C)
221 : : */
222 : : int
223 : 0 : ice_aq_program_actpair(struct ice_hw *hw, u8 act_mem_idx, u16 act_entry_idx,
224 : : struct ice_aqc_actpair *buf, struct ice_sq_cd *cd)
225 : : {
226 : 0 : return ice_aq_actpair_p_q(hw, ice_aqc_opc_program_acl_actpair,
227 : : act_mem_idx, act_entry_idx, buf, cd);
228 : : }
229 : :
230 : : /**
231 : : * ice_aq_query_actpair - query ACL actionpair
232 : : * @hw: pointer to the HW struct
233 : : * @act_mem_idx: action memory index to program/update/query
234 : : * @act_entry_idx: the entry index in action memory to be programmed/updated
235 : : * @buf: address of indirect data buffer
236 : : * @cd: pointer to command details structure or NULL
237 : : *
238 : : * Query ACL actionpair (indirect 0x0C25)
239 : : */
240 : : int
241 : 0 : ice_aq_query_actpair(struct ice_hw *hw, u8 act_mem_idx, u16 act_entry_idx,
242 : : struct ice_aqc_actpair *buf, struct ice_sq_cd *cd)
243 : : {
244 : 0 : return ice_aq_actpair_p_q(hw, ice_aqc_opc_query_acl_actpair,
245 : : act_mem_idx, act_entry_idx, buf, cd);
246 : : }
247 : :
248 : : /**
249 : : * ice_aq_dealloc_acl_res - deallocate ACL resources
250 : : * @hw: pointer to the HW struct
251 : : * @cd: pointer to command details structure or NULL
252 : : *
253 : : * De-allocate ACL resources (direct 0x0C1A). Used by SW to release all the
254 : : * resources allocated for it using a single command
255 : : */
256 : 0 : int ice_aq_dealloc_acl_res(struct ice_hw *hw, struct ice_sq_cd *cd)
257 : : {
258 : : struct ice_aq_desc desc;
259 : :
260 : 0 : ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_dealloc_acl_res);
261 : :
262 : 0 : return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
263 : : }
264 : :
265 : : /**
266 : : * ice_acl_prof_aq_send - sending ACL profile AQ commands
267 : : * @hw: pointer to the HW struct
268 : : * @opc: command opcode
269 : : * @prof_id: profile ID
270 : : * @buf: ptr to buffer
271 : : * @cd: pointer to command details structure or NULL
272 : : *
273 : : * This function sends ACL profile commands
274 : : */
275 : : static int
276 : 0 : ice_acl_prof_aq_send(struct ice_hw *hw, u16 opc, u8 prof_id,
277 : : struct ice_aqc_acl_prof_generic_frmt *buf,
278 : : struct ice_sq_cd *cd)
279 : : {
280 : : struct ice_aq_desc desc;
281 : :
282 : 0 : ice_fill_dflt_direct_cmd_desc(&desc, opc);
283 : 0 : desc.params.profile.profile_id = prof_id;
284 [ # # ]: 0 : if (opc == ice_aqc_opc_program_acl_prof_extraction ||
285 : : opc == ice_aqc_opc_program_acl_prof_ranges)
286 : 0 : desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
287 : 0 : return ice_aq_send_cmd(hw, &desc, buf, sizeof(*buf), cd);
288 : : }
289 : :
290 : : /**
291 : : * ice_prgm_acl_prof_xtrct - program ACL profile extraction sequence
292 : : * @hw: pointer to the HW struct
293 : : * @prof_id: profile ID
294 : : * @buf: ptr to buffer
295 : : * @cd: pointer to command details structure or NULL
296 : : *
297 : : * Program ACL profile extraction (indirect 0x0C1D)
298 : : */
299 : : int
300 : 0 : ice_prgm_acl_prof_xtrct(struct ice_hw *hw, u8 prof_id,
301 : : struct ice_aqc_acl_prof_generic_frmt *buf,
302 : : struct ice_sq_cd *cd)
303 : : {
304 : 0 : return ice_acl_prof_aq_send(hw, ice_aqc_opc_program_acl_prof_extraction,
305 : : prof_id, buf, cd);
306 : : }
307 : :
308 : : /**
309 : : * ice_query_acl_prof - query ACL profile
310 : : * @hw: pointer to the HW struct
311 : : * @prof_id: profile ID
312 : : * @buf: ptr to buffer (which will contain response of this command)
313 : : * @cd: pointer to command details structure or NULL
314 : : *
315 : : * Query ACL profile (indirect 0x0C21)
316 : : */
317 : : int
318 : 0 : ice_query_acl_prof(struct ice_hw *hw, u8 prof_id,
319 : : struct ice_aqc_acl_prof_generic_frmt *buf,
320 : : struct ice_sq_cd *cd)
321 : : {
322 : 0 : return ice_acl_prof_aq_send(hw, ice_aqc_opc_query_acl_prof, prof_id,
323 : : buf, cd);
324 : : }
325 : :
326 : : /**
327 : : * ice_aq_acl_cntrs_chk_params - Checks ACL counter parameters
328 : : * @cntrs: ptr to buffer describing input and output params
329 : : *
330 : : * This function checks the counter bank range for counter type and returns
331 : : * success or failure.
332 : : */
333 : : static int ice_aq_acl_cntrs_chk_params(struct ice_acl_cntrs *cntrs)
334 : : {
335 : : int status = 0;
336 : :
337 [ # # # # ]: 0 : if (!cntrs || !cntrs->amount)
338 : : return ICE_ERR_PARAM;
339 : :
340 [ # # # # : 0 : switch (cntrs->type) {
# # ]
341 : 0 : case ICE_AQC_ACL_CNT_TYPE_SINGLE:
342 : : /* Single counter type - configured to count either bytes
343 : : * or packets, the valid values for byte or packet counters
344 : : * shall be 0-3.
345 : : */
346 [ # # # # ]: 0 : if (cntrs->bank > ICE_AQC_ACL_MAX_CNT_SINGLE)
347 : : status = ICE_ERR_OUT_OF_RANGE;
348 : : break;
349 : 0 : case ICE_AQC_ACL_CNT_TYPE_DUAL:
350 : : /* Pair counter type - counts number of bytes and packets
351 : : * The valid values for byte/packet counter duals shall be 0-1
352 : : */
353 [ # # # # ]: 0 : if (cntrs->bank > ICE_AQC_ACL_MAX_CNT_DUAL)
354 : : status = ICE_ERR_OUT_OF_RANGE;
355 : : break;
356 : : default:
357 : : /* Unspecified counter type - Invalid or error */
358 : : status = ICE_ERR_PARAM;
359 : : }
360 : :
361 : : return status;
362 : : }
363 : :
364 : : /**
365 : : * ice_aq_alloc_acl_cntrs - allocate ACL counters
366 : : * @hw: pointer to the HW struct
367 : : * @cntrs: ptr to buffer describing input and output params
368 : : * @cd: pointer to command details structure or NULL
369 : : *
370 : : * Allocate ACL counters (indirect 0x0C16). This function attempts to
371 : : * allocate a contiguous block of counters. In case of failures, caller can
372 : : * attempt to allocate a smaller chunk. The allocation is considered
373 : : * unsuccessful if returned counter value is invalid. In this case it returns
374 : : * an error otherwise success.
375 : : */
376 : : int
377 [ # # ]: 0 : ice_aq_alloc_acl_cntrs(struct ice_hw *hw, struct ice_acl_cntrs *cntrs,
378 : : struct ice_sq_cd *cd)
379 : : {
380 : : struct ice_aqc_acl_alloc_counters *cmd;
381 : : u16 first_cntr, last_cntr;
382 : : struct ice_aq_desc desc;
383 : : int status;
384 : :
385 : : /* check for invalid params */
386 : : status = ice_aq_acl_cntrs_chk_params(cntrs);
387 : : if (status)
388 : 0 : return status;
389 : 0 : ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_alloc_acl_counters);
390 : : cmd = &desc.params.alloc_counters;
391 : 0 : cmd->counter_amount = cntrs->amount;
392 : 0 : cmd->counters_type = cntrs->type;
393 : 0 : cmd->bank_alloc = cntrs->bank;
394 : 0 : status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
395 [ # # ]: 0 : if (!status) {
396 : 0 : first_cntr = LE16_TO_CPU(cmd->ops.resp.first_counter);
397 : 0 : last_cntr = LE16_TO_CPU(cmd->ops.resp.last_counter);
398 : 0 : if (first_cntr == ICE_AQC_ACL_ALLOC_CNT_INVAL ||
399 [ # # ]: 0 : last_cntr == ICE_AQC_ACL_ALLOC_CNT_INVAL)
400 : : return ICE_ERR_OUT_OF_RANGE;
401 : 0 : cntrs->first_cntr = first_cntr;
402 : 0 : cntrs->last_cntr = last_cntr;
403 : : }
404 : : return status;
405 : : }
406 : :
407 : : /**
408 : : * ice_aq_dealloc_acl_cntrs - deallocate ACL counters
409 : : * @hw: pointer to the HW struct
410 : : * @cntrs: ptr to buffer describing input and output params
411 : : * @cd: pointer to command details structure or NULL
412 : : *
413 : : * De-allocate ACL counters (direct 0x0C17)
414 : : */
415 : : int
416 [ # # ]: 0 : ice_aq_dealloc_acl_cntrs(struct ice_hw *hw, struct ice_acl_cntrs *cntrs,
417 : : struct ice_sq_cd *cd)
418 : : {
419 : : struct ice_aqc_acl_dealloc_counters *cmd;
420 : : struct ice_aq_desc desc;
421 : : int status;
422 : :
423 : : /* check for invalid params */
424 : : status = ice_aq_acl_cntrs_chk_params(cntrs);
425 : : if (status)
426 : 0 : return status;
427 : :
428 : 0 : ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_dealloc_acl_counters);
429 : : cmd = &desc.params.dealloc_counters;
430 : 0 : cmd->first_counter = CPU_TO_LE16(cntrs->first_cntr);
431 : 0 : cmd->last_counter = CPU_TO_LE16(cntrs->last_cntr);
432 : 0 : cmd->counters_type = cntrs->type;
433 : 0 : cmd->bank_alloc = cntrs->bank;
434 : 0 : return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
435 : : }
436 : :
437 : : /**
438 : : * ice_prog_acl_prof_ranges - program ACL profile ranges
439 : : * @hw: pointer to the HW struct
440 : : * @prof_id: programmed or updated profile ID
441 : : * @buf: pointer to input buffer
442 : : * @cd: pointer to command details structure or NULL
443 : : *
444 : : * Program ACL profile ranges (indirect 0x0C1E)
445 : : */
446 : : int
447 : 0 : ice_prog_acl_prof_ranges(struct ice_hw *hw, u8 prof_id,
448 : : struct ice_aqc_acl_profile_ranges *buf,
449 : : struct ice_sq_cd *cd)
450 : : {
451 : : struct ice_aq_desc desc;
452 : :
453 : 0 : ice_fill_dflt_direct_cmd_desc(&desc,
454 : : ice_aqc_opc_program_acl_prof_ranges);
455 : 0 : desc.params.profile.profile_id = prof_id;
456 : 0 : desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
457 : 0 : return ice_aq_send_cmd(hw, &desc, buf, sizeof(*buf), cd);
458 : : }
459 : :
460 : : /**
461 : : * ice_query_acl_prof_ranges - query ACL profile ranges
462 : : * @hw: pointer to the HW struct
463 : : * @prof_id: programmed or updated profile ID
464 : : * @buf: pointer to response buffer
465 : : * @cd: pointer to command details structure or NULL
466 : : *
467 : : * Query ACL profile ranges (indirect 0x0C22)
468 : : */
469 : : int
470 : 0 : ice_query_acl_prof_ranges(struct ice_hw *hw, u8 prof_id,
471 : : struct ice_aqc_acl_profile_ranges *buf,
472 : : struct ice_sq_cd *cd)
473 : : {
474 : : struct ice_aq_desc desc;
475 : :
476 : 0 : ice_fill_dflt_direct_cmd_desc(&desc,
477 : : ice_aqc_opc_query_acl_prof_ranges);
478 : 0 : desc.params.profile.profile_id = prof_id;
479 : 0 : return ice_aq_send_cmd(hw, &desc, buf, sizeof(*buf), cd);
480 : : }
481 : :
482 : : /**
483 : : * ice_aq_alloc_acl_scen - allocate ACL scenario
484 : : * @hw: pointer to the HW struct
485 : : * @scen_id: memory location to receive allocated scenario ID
486 : : * @buf: address of indirect data buffer
487 : : * @cd: pointer to command details structure or NULL
488 : : *
489 : : * Allocate ACL scenario (indirect 0x0C14)
490 : : */
491 : : int
492 : 0 : ice_aq_alloc_acl_scen(struct ice_hw *hw, u16 *scen_id,
493 : : struct ice_aqc_acl_scen *buf, struct ice_sq_cd *cd)
494 : : {
495 : : struct ice_aqc_acl_alloc_scen *cmd;
496 : : struct ice_aq_desc desc;
497 : : int status;
498 : :
499 [ # # ]: 0 : if (!scen_id)
500 : : return ICE_ERR_PARAM;
501 : :
502 : 0 : ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_alloc_acl_scen);
503 : 0 : desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
504 : : cmd = &desc.params.alloc_scen;
505 : :
506 : 0 : status = ice_aq_send_cmd(hw, &desc, buf, sizeof(*buf), cd);
507 [ # # ]: 0 : if (!status)
508 : 0 : *scen_id = LE16_TO_CPU(cmd->ops.resp.scen_id);
509 : :
510 : : return status;
511 : : }
512 : :
513 : : /**
514 : : * ice_aq_dealloc_acl_scen - deallocate ACL scenario
515 : : * @hw: pointer to the HW struct
516 : : * @scen_id: scen_id to be deallocated (input and output field)
517 : : * @cd: pointer to command details structure or NULL
518 : : *
519 : : * Deallocate ACL scenario (direct 0x0C15)
520 : : */
521 : : int
522 : 0 : ice_aq_dealloc_acl_scen(struct ice_hw *hw, u16 scen_id, struct ice_sq_cd *cd)
523 : : {
524 : : struct ice_aqc_acl_dealloc_scen *cmd;
525 : : struct ice_aq_desc desc;
526 : :
527 : 0 : ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_dealloc_acl_scen);
528 : : cmd = &desc.params.dealloc_scen;
529 : 0 : cmd->scen_id = CPU_TO_LE16(scen_id);
530 : :
531 : 0 : return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
532 : : }
533 : :
534 : : /**
535 : : * ice_aq_update_query_scen - update or query ACL scenario
536 : : * @hw: pointer to the HW struct
537 : : * @opcode: AQ command opcode for either query or update scenario
538 : : * @scen_id: scen_id to be updated or queried
539 : : * @buf: address of indirect data buffer
540 : : * @cd: pointer to command details structure or NULL
541 : : *
542 : : * Calls update or query ACL scenario
543 : : */
544 : : static int
545 : 0 : ice_aq_update_query_scen(struct ice_hw *hw, u16 opcode, u16 scen_id,
546 : : struct ice_aqc_acl_scen *buf, struct ice_sq_cd *cd)
547 : : {
548 : : struct ice_aqc_acl_update_query_scen *cmd;
549 : : struct ice_aq_desc desc;
550 : :
551 : 0 : ice_fill_dflt_direct_cmd_desc(&desc, opcode);
552 [ # # ]: 0 : if (opcode == ice_aqc_opc_update_acl_scen)
553 : 0 : desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
554 : : cmd = &desc.params.update_query_scen;
555 : 0 : cmd->scen_id = CPU_TO_LE16(scen_id);
556 : :
557 : 0 : return ice_aq_send_cmd(hw, &desc, buf, sizeof(*buf), cd);
558 : : }
559 : :
560 : : /**
561 : : * ice_aq_update_acl_scen - update ACL scenario
562 : : * @hw: pointer to the HW struct
563 : : * @scen_id: scen_id to be updated
564 : : * @buf: address of indirect data buffer
565 : : * @cd: pointer to command details structure or NULL
566 : : *
567 : : * Update ACL scenario (indirect 0x0C1B)
568 : : */
569 : : int
570 : 0 : ice_aq_update_acl_scen(struct ice_hw *hw, u16 scen_id,
571 : : struct ice_aqc_acl_scen *buf, struct ice_sq_cd *cd)
572 : : {
573 : 0 : return ice_aq_update_query_scen(hw, ice_aqc_opc_update_acl_scen,
574 : : scen_id, buf, cd);
575 : : }
576 : :
577 : : /**
578 : : * ice_aq_query_acl_scen - query ACL scenario
579 : : * @hw: pointer to the HW struct
580 : : * @scen_id: scen_id to be queried
581 : : * @buf: address of indirect data buffer
582 : : * @cd: pointer to command details structure or NULL
583 : : *
584 : : * Query ACL scenario (indirect 0x0C23)
585 : : */
586 : : int
587 : 0 : ice_aq_query_acl_scen(struct ice_hw *hw, u16 scen_id,
588 : : struct ice_aqc_acl_scen *buf, struct ice_sq_cd *cd)
589 : : {
590 : 0 : return ice_aq_update_query_scen(hw, ice_aqc_opc_query_acl_scen,
591 : : scen_id, buf, cd);
592 : : }
|
