1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2001-2021 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 enum ice_status 17 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 if (!tbl->act_pairs_per_entry) 24 return ICE_ERR_PARAM; 25 26 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 if (tbl->concurr) { 34 if (!tbl->num_dependent_alloc_ids) 35 return ICE_ERR_PARAM; 36 if (tbl->num_dependent_alloc_ids > 37 ICE_AQC_MAX_CONCURRENT_ACL_TBL) 38 return ICE_ERR_INVAL_SIZE; 39 } 40 41 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_alloc_acl_tbl); 42 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); 43 44 cmd = &desc.params.alloc_table; 45 cmd->table_width = CPU_TO_LE16(tbl->width * BITS_PER_BYTE); 46 cmd->table_depth = CPU_TO_LE16(tbl->depth); 47 cmd->act_pairs_per_entry = tbl->act_pairs_per_entry; 48 if (tbl->concurr) 49 cmd->table_type = tbl->num_dependent_alloc_ids; 50 51 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 enum ice_status 68 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 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_dealloc_acl_tbl); 75 cmd = &desc.params.tbl_actpair; 76 cmd->alloc_id = CPU_TO_LE16(alloc_id); 77 78 return ice_aq_send_cmd(hw, &desc, buf, sizeof(*buf), cd); 79 } 80 81 static enum ice_status 82 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 ice_fill_dflt_direct_cmd_desc(&desc, opcode); 89 90 if (opcode == ice_aqc_opc_program_acl_entry) 91 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); 92 93 cmd = &desc.params.program_query_entry; 94 cmd->tcam_index = tcam_idx; 95 cmd->entry_index = CPU_TO_LE16(entry_idx); 96 97 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 enum ice_status 111 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 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 enum ice_status 132 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 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 enum ice_status 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 ice_fill_dflt_direct_cmd_desc(&desc, opcode); 148 cmd = &desc.params.tbl_actpair; 149 cmd->alloc_id = CPU_TO_LE16(alloc_id); 150 151 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 enum ice_status 167 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 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 enum ice_status 184 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 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 enum ice_status 193 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 ice_fill_dflt_direct_cmd_desc(&desc, opcode); 201 202 if (opcode == ice_aqc_opc_program_acl_actpair) 203 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); 204 205 cmd = &desc.params.program_query_actpair; 206 cmd->act_mem_index = act_mem_idx; 207 cmd->act_entry_index = CPU_TO_LE16(act_entry_idx); 208 209 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 enum ice_status 223 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 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 enum ice_status 241 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 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 enum ice_status ice_aq_dealloc_acl_res(struct ice_hw *hw, struct ice_sq_cd *cd) 257 { 258 struct ice_aq_desc desc; 259 260 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_dealloc_acl_res); 261 262 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 enum ice_status 276 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 ice_fill_dflt_direct_cmd_desc(&desc, opc); 283 desc.params.profile.profile_id = prof_id; 284 if (opc == ice_aqc_opc_program_acl_prof_extraction || 285 opc == ice_aqc_opc_program_acl_prof_ranges) 286 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); 287 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 enum ice_status 300 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 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 enum ice_status 318 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 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 enum ice_status ice_aq_acl_cntrs_chk_params(struct ice_acl_cntrs *cntrs) 334 { 335 enum ice_status status = ICE_SUCCESS; 336 337 if (!cntrs || !cntrs->amount) 338 return ICE_ERR_PARAM; 339 340 switch (cntrs->type) { 341 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 if (cntrs->bank > ICE_AQC_ACL_MAX_CNT_SINGLE) 347 status = ICE_ERR_OUT_OF_RANGE; 348 break; 349 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 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 enum ice_status 377 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 enum ice_status status; 384 385 /* check for invalid params */ 386 status = ice_aq_acl_cntrs_chk_params(cntrs); 387 if (status) 388 return status; 389 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_alloc_acl_counters); 390 cmd = &desc.params.alloc_counters; 391 cmd->counter_amount = cntrs->amount; 392 cmd->counters_type = cntrs->type; 393 cmd->bank_alloc = cntrs->bank; 394 status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 395 if (!status) { 396 first_cntr = LE16_TO_CPU(cmd->ops.resp.first_counter); 397 last_cntr = LE16_TO_CPU(cmd->ops.resp.last_counter); 398 if (first_cntr == ICE_AQC_ACL_ALLOC_CNT_INVAL || 399 last_cntr == ICE_AQC_ACL_ALLOC_CNT_INVAL) 400 return ICE_ERR_OUT_OF_RANGE; 401 cntrs->first_cntr = first_cntr; 402 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 enum ice_status 416 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 enum ice_status status; 422 423 /* check for invalid params */ 424 status = ice_aq_acl_cntrs_chk_params(cntrs); 425 if (status) 426 return status; 427 428 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_dealloc_acl_counters); 429 cmd = &desc.params.dealloc_counters; 430 cmd->first_counter = CPU_TO_LE16(cntrs->first_cntr); 431 cmd->last_counter = CPU_TO_LE16(cntrs->last_cntr); 432 cmd->counters_type = cntrs->type; 433 cmd->bank_alloc = cntrs->bank; 434 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 enum ice_status 447 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 ice_fill_dflt_direct_cmd_desc(&desc, 454 ice_aqc_opc_program_acl_prof_ranges); 455 desc.params.profile.profile_id = prof_id; 456 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); 457 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 enum ice_status 470 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 ice_fill_dflt_direct_cmd_desc(&desc, 477 ice_aqc_opc_query_acl_prof_ranges); 478 desc.params.profile.profile_id = prof_id; 479 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 enum ice_status 492 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 enum ice_status status; 498 499 if (!scen_id) 500 return ICE_ERR_PARAM; 501 502 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_alloc_acl_scen); 503 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); 504 cmd = &desc.params.alloc_scen; 505 506 status = ice_aq_send_cmd(hw, &desc, buf, sizeof(*buf), cd); 507 if (!status) 508 *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 enum ice_status 522 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 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_dealloc_acl_scen); 528 cmd = &desc.params.dealloc_scen; 529 cmd->scen_id = CPU_TO_LE16(scen_id); 530 531 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 enum ice_status 545 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 ice_fill_dflt_direct_cmd_desc(&desc, opcode); 552 if (opcode == ice_aqc_opc_update_acl_scen) 553 desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD); 554 cmd = &desc.params.update_query_scen; 555 cmd->scen_id = CPU_TO_LE16(scen_id); 556 557 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 enum ice_status 570 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 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 enum ice_status 587 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 return ice_aq_update_query_scen(hw, ice_aqc_opc_query_acl_scen, 591 scen_id, buf, cd); 592 } 593