xref: /freebsd/sys/dev/ice/ice_switch.c (revision 6ba2210ee039f2f12878c217bcf058e9c8b26b29)
1 /* SPDX-License-Identifier: BSD-3-Clause */
2 /*  Copyright (c) 2021, Intel Corporation
3  *  All rights reserved.
4  *
5  *  Redistribution and use in source and binary forms, with or without
6  *  modification, are permitted provided that the following conditions are met:
7  *
8  *   1. Redistributions of source code must retain the above copyright notice,
9  *      this list of conditions and the following disclaimer.
10  *
11  *   2. Redistributions in binary form must reproduce the above copyright
12  *      notice, this list of conditions and the following disclaimer in the
13  *      documentation and/or other materials provided with the distribution.
14  *
15  *   3. Neither the name of the Intel Corporation nor the names of its
16  *      contributors may be used to endorse or promote products derived from
17  *      this software without specific prior written permission.
18  *
19  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20  *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
23  *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26  *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27  *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28  *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29  *  POSSIBILITY OF SUCH DAMAGE.
30  */
31 /*$FreeBSD$*/
32 
33 #include "ice_switch.h"
34 #include "ice_flex_type.h"
35 #include "ice_flow.h"
36 
37 #define ICE_ETH_DA_OFFSET		0
38 #define ICE_ETH_ETHTYPE_OFFSET		12
39 #define ICE_ETH_VLAN_TCI_OFFSET		14
40 #define ICE_MAX_VLAN_ID			0xFFF
41 
42 /* Dummy ethernet header needed in the ice_aqc_sw_rules_elem
43  * struct to configure any switch filter rules.
44  * {DA (6 bytes), SA(6 bytes),
45  * Ether type (2 bytes for header without VLAN tag) OR
46  * VLAN tag (4 bytes for header with VLAN tag) }
47  *
48  * Word on Hardcoded values
49  * byte 0 = 0x2: to identify it as locally administered DA MAC
50  * byte 6 = 0x2: to identify it as locally administered SA MAC
51  * byte 12 = 0x81 & byte 13 = 0x00:
52  *	In case of VLAN filter first two bytes defines ether type (0x8100)
53  *	and remaining two bytes are placeholder for programming a given VLAN ID
54  *	In case of Ether type filter it is treated as header without VLAN tag
55  *	and byte 12 and 13 is used to program a given Ether type instead
56  */
57 static const u8 dummy_eth_header[DUMMY_ETH_HDR_LEN] = { 0x2, 0, 0, 0, 0, 0,
58 							0x2, 0, 0, 0, 0, 0,
59 							0x81, 0, 0, 0};
60 
61 /**
62  * ice_init_def_sw_recp - initialize the recipe book keeping tables
63  * @hw: pointer to the HW struct
64  * @recp_list: pointer to sw recipe list
65  *
66  * Allocate memory for the entire recipe table and initialize the structures/
67  * entries corresponding to basic recipes.
68  */
69 enum ice_status
70 ice_init_def_sw_recp(struct ice_hw *hw, struct ice_sw_recipe **recp_list)
71 {
72 	struct ice_sw_recipe *recps;
73 	u8 i;
74 
75 	recps = (struct ice_sw_recipe *)
76 		ice_calloc(hw, ICE_MAX_NUM_RECIPES, sizeof(*recps));
77 	if (!recps)
78 		return ICE_ERR_NO_MEMORY;
79 
80 	for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) {
81 		recps[i].root_rid = i;
82 		INIT_LIST_HEAD(&recps[i].filt_rules);
83 		INIT_LIST_HEAD(&recps[i].filt_replay_rules);
84 		INIT_LIST_HEAD(&recps[i].rg_list);
85 		ice_init_lock(&recps[i].filt_rule_lock);
86 	}
87 
88 	*recp_list = recps;
89 
90 	return ICE_SUCCESS;
91 }
92 
93 /**
94  * ice_aq_get_sw_cfg - get switch configuration
95  * @hw: pointer to the hardware structure
96  * @buf: pointer to the result buffer
97  * @buf_size: length of the buffer available for response
98  * @req_desc: pointer to requested descriptor
99  * @num_elems: pointer to number of elements
100  * @cd: pointer to command details structure or NULL
101  *
102  * Get switch configuration (0x0200) to be placed in buf.
103  * This admin command returns information such as initial VSI/port number
104  * and switch ID it belongs to.
105  *
106  * NOTE: *req_desc is both an input/output parameter.
107  * The caller of this function first calls this function with *request_desc set
108  * to 0. If the response from f/w has *req_desc set to 0, all the switch
109  * configuration information has been returned; if non-zero (meaning not all
110  * the information was returned), the caller should call this function again
111  * with *req_desc set to the previous value returned by f/w to get the
112  * next block of switch configuration information.
113  *
114  * *num_elems is output only parameter. This reflects the number of elements
115  * in response buffer. The caller of this function to use *num_elems while
116  * parsing the response buffer.
117  */
118 static enum ice_status
119 ice_aq_get_sw_cfg(struct ice_hw *hw, struct ice_aqc_get_sw_cfg_resp_elem *buf,
120 		  u16 buf_size, u16 *req_desc, u16 *num_elems,
121 		  struct ice_sq_cd *cd)
122 {
123 	struct ice_aqc_get_sw_cfg *cmd;
124 	struct ice_aq_desc desc;
125 	enum ice_status status;
126 
127 	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_sw_cfg);
128 	cmd = &desc.params.get_sw_conf;
129 	cmd->element = CPU_TO_LE16(*req_desc);
130 
131 	status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd);
132 	if (!status) {
133 		*req_desc = LE16_TO_CPU(cmd->element);
134 		*num_elems = LE16_TO_CPU(cmd->num_elems);
135 	}
136 
137 	return status;
138 }
139 
140 /**
141  * ice_alloc_rss_global_lut - allocate a RSS global LUT
142  * @hw: pointer to the HW struct
143  * @shared_res: true to allocate as a shared resource and false to allocate as a dedicated resource
144  * @global_lut_id: output parameter for the RSS global LUT's ID
145  */
146 enum ice_status ice_alloc_rss_global_lut(struct ice_hw *hw, bool shared_res, u16 *global_lut_id)
147 {
148 	struct ice_aqc_alloc_free_res_elem *sw_buf;
149 	enum ice_status status;
150 	u16 buf_len;
151 
152 	buf_len = ice_struct_size(sw_buf, elem, 1);
153 	sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len);
154 	if (!sw_buf)
155 		return ICE_ERR_NO_MEMORY;
156 
157 	sw_buf->num_elems = CPU_TO_LE16(1);
158 	sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_GLOBAL_RSS_HASH |
159 				       (shared_res ? ICE_AQC_RES_TYPE_FLAG_SHARED :
160 				       ICE_AQC_RES_TYPE_FLAG_DEDICATED));
161 
162 	status = ice_aq_alloc_free_res(hw, 1, sw_buf, buf_len, ice_aqc_opc_alloc_res, NULL);
163 	if (status) {
164 		ice_debug(hw, ICE_DBG_RES, "Failed to allocate %s RSS global LUT, status %d\n",
165 			  shared_res ? "shared" : "dedicated", status);
166 		goto ice_alloc_global_lut_exit;
167 	}
168 
169 	*global_lut_id = LE16_TO_CPU(sw_buf->elem[0].e.sw_resp);
170 
171 ice_alloc_global_lut_exit:
172 	ice_free(hw, sw_buf);
173 	return status;
174 }
175 
176 /**
177  * ice_free_global_lut - free a RSS global LUT
178  * @hw: pointer to the HW struct
179  * @global_lut_id: ID of the RSS global LUT to free
180  */
181 enum ice_status ice_free_rss_global_lut(struct ice_hw *hw, u16 global_lut_id)
182 {
183 	struct ice_aqc_alloc_free_res_elem *sw_buf;
184 	u16 buf_len, num_elems = 1;
185 	enum ice_status status;
186 
187 	buf_len = ice_struct_size(sw_buf, elem, num_elems);
188 	sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len);
189 	if (!sw_buf)
190 		return ICE_ERR_NO_MEMORY;
191 
192 	sw_buf->num_elems = CPU_TO_LE16(num_elems);
193 	sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_GLOBAL_RSS_HASH);
194 	sw_buf->elem[0].e.sw_resp = CPU_TO_LE16(global_lut_id);
195 
196 	status = ice_aq_alloc_free_res(hw, num_elems, sw_buf, buf_len, ice_aqc_opc_free_res, NULL);
197 	if (status)
198 		ice_debug(hw, ICE_DBG_RES, "Failed to free RSS global LUT %d, status %d\n",
199 			  global_lut_id, status);
200 
201 	ice_free(hw, sw_buf);
202 	return status;
203 }
204 
205 /**
206  * ice_alloc_sw - allocate resources specific to switch
207  * @hw: pointer to the HW struct
208  * @ena_stats: true to turn on VEB stats
209  * @shared_res: true for shared resource, false for dedicated resource
210  * @sw_id: switch ID returned
211  * @counter_id: VEB counter ID returned
212  *
213  * allocates switch resources (SWID and VEB counter) (0x0208)
214  */
215 enum ice_status
216 ice_alloc_sw(struct ice_hw *hw, bool ena_stats, bool shared_res, u16 *sw_id,
217 	     u16 *counter_id)
218 {
219 	struct ice_aqc_alloc_free_res_elem *sw_buf;
220 	struct ice_aqc_res_elem *sw_ele;
221 	enum ice_status status;
222 	u16 buf_len;
223 
224 	buf_len = ice_struct_size(sw_buf, elem, 1);
225 	sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len);
226 	if (!sw_buf)
227 		return ICE_ERR_NO_MEMORY;
228 
229 	/* Prepare buffer for switch ID.
230 	 * The number of resource entries in buffer is passed as 1 since only a
231 	 * single switch/VEB instance is allocated, and hence a single sw_id
232 	 * is requested.
233 	 */
234 	sw_buf->num_elems = CPU_TO_LE16(1);
235 	sw_buf->res_type =
236 		CPU_TO_LE16(ICE_AQC_RES_TYPE_SWID |
237 			    (shared_res ? ICE_AQC_RES_TYPE_FLAG_SHARED :
238 			    ICE_AQC_RES_TYPE_FLAG_DEDICATED));
239 
240 	status = ice_aq_alloc_free_res(hw, 1, sw_buf, buf_len,
241 				       ice_aqc_opc_alloc_res, NULL);
242 
243 	if (status)
244 		goto ice_alloc_sw_exit;
245 
246 	sw_ele = &sw_buf->elem[0];
247 	*sw_id = LE16_TO_CPU(sw_ele->e.sw_resp);
248 
249 	if (ena_stats) {
250 		/* Prepare buffer for VEB Counter */
251 		enum ice_adminq_opc opc = ice_aqc_opc_alloc_res;
252 		struct ice_aqc_alloc_free_res_elem *counter_buf;
253 		struct ice_aqc_res_elem *counter_ele;
254 
255 		counter_buf = (struct ice_aqc_alloc_free_res_elem *)
256 				ice_malloc(hw, buf_len);
257 		if (!counter_buf) {
258 			status = ICE_ERR_NO_MEMORY;
259 			goto ice_alloc_sw_exit;
260 		}
261 
262 		/* The number of resource entries in buffer is passed as 1 since
263 		 * only a single switch/VEB instance is allocated, and hence a
264 		 * single VEB counter is requested.
265 		 */
266 		counter_buf->num_elems = CPU_TO_LE16(1);
267 		counter_buf->res_type =
268 			CPU_TO_LE16(ICE_AQC_RES_TYPE_VEB_COUNTER |
269 				    ICE_AQC_RES_TYPE_FLAG_DEDICATED);
270 		status = ice_aq_alloc_free_res(hw, 1, counter_buf, buf_len,
271 					       opc, NULL);
272 
273 		if (status) {
274 			ice_free(hw, counter_buf);
275 			goto ice_alloc_sw_exit;
276 		}
277 		counter_ele = &counter_buf->elem[0];
278 		*counter_id = LE16_TO_CPU(counter_ele->e.sw_resp);
279 		ice_free(hw, counter_buf);
280 	}
281 
282 ice_alloc_sw_exit:
283 	ice_free(hw, sw_buf);
284 	return status;
285 }
286 
287 /**
288  * ice_free_sw - free resources specific to switch
289  * @hw: pointer to the HW struct
290  * @sw_id: switch ID returned
291  * @counter_id: VEB counter ID returned
292  *
293  * free switch resources (SWID and VEB counter) (0x0209)
294  *
295  * NOTE: This function frees multiple resources. It continues
296  * releasing other resources even after it encounters error.
297  * The error code returned is the last error it encountered.
298  */
299 enum ice_status ice_free_sw(struct ice_hw *hw, u16 sw_id, u16 counter_id)
300 {
301 	struct ice_aqc_alloc_free_res_elem *sw_buf, *counter_buf;
302 	enum ice_status status, ret_status;
303 	u16 buf_len;
304 
305 	buf_len = ice_struct_size(sw_buf, elem, 1);
306 	sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len);
307 	if (!sw_buf)
308 		return ICE_ERR_NO_MEMORY;
309 
310 	/* Prepare buffer to free for switch ID res.
311 	 * The number of resource entries in buffer is passed as 1 since only a
312 	 * single switch/VEB instance is freed, and hence a single sw_id
313 	 * is released.
314 	 */
315 	sw_buf->num_elems = CPU_TO_LE16(1);
316 	sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_SWID);
317 	sw_buf->elem[0].e.sw_resp = CPU_TO_LE16(sw_id);
318 
319 	ret_status = ice_aq_alloc_free_res(hw, 1, sw_buf, buf_len,
320 					   ice_aqc_opc_free_res, NULL);
321 
322 	if (ret_status)
323 		ice_debug(hw, ICE_DBG_SW, "CQ CMD Buffer:\n");
324 
325 	/* Prepare buffer to free for VEB Counter resource */
326 	counter_buf = (struct ice_aqc_alloc_free_res_elem *)
327 			ice_malloc(hw, buf_len);
328 	if (!counter_buf) {
329 		ice_free(hw, sw_buf);
330 		return ICE_ERR_NO_MEMORY;
331 	}
332 
333 	/* The number of resource entries in buffer is passed as 1 since only a
334 	 * single switch/VEB instance is freed, and hence a single VEB counter
335 	 * is released
336 	 */
337 	counter_buf->num_elems = CPU_TO_LE16(1);
338 	counter_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_VEB_COUNTER);
339 	counter_buf->elem[0].e.sw_resp = CPU_TO_LE16(counter_id);
340 
341 	status = ice_aq_alloc_free_res(hw, 1, counter_buf, buf_len,
342 				       ice_aqc_opc_free_res, NULL);
343 	if (status) {
344 		ice_debug(hw, ICE_DBG_SW, "VEB counter resource could not be freed\n");
345 		ret_status = status;
346 	}
347 
348 	ice_free(hw, counter_buf);
349 	ice_free(hw, sw_buf);
350 	return ret_status;
351 }
352 
353 /**
354  * ice_aq_add_vsi
355  * @hw: pointer to the HW struct
356  * @vsi_ctx: pointer to a VSI context struct
357  * @cd: pointer to command details structure or NULL
358  *
359  * Add a VSI context to the hardware (0x0210)
360  */
361 enum ice_status
362 ice_aq_add_vsi(struct ice_hw *hw, struct ice_vsi_ctx *vsi_ctx,
363 	       struct ice_sq_cd *cd)
364 {
365 	struct ice_aqc_add_update_free_vsi_resp *res;
366 	struct ice_aqc_add_get_update_free_vsi *cmd;
367 	struct ice_aq_desc desc;
368 	enum ice_status status;
369 
370 	cmd = &desc.params.vsi_cmd;
371 	res = &desc.params.add_update_free_vsi_res;
372 
373 	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_add_vsi);
374 
375 	if (!vsi_ctx->alloc_from_pool)
376 		cmd->vsi_num = CPU_TO_LE16(vsi_ctx->vsi_num |
377 					   ICE_AQ_VSI_IS_VALID);
378 	cmd->vf_id = vsi_ctx->vf_num;
379 
380 	cmd->vsi_flags = CPU_TO_LE16(vsi_ctx->flags);
381 
382 	desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
383 
384 	status = ice_aq_send_cmd(hw, &desc, &vsi_ctx->info,
385 				 sizeof(vsi_ctx->info), cd);
386 
387 	if (!status) {
388 		vsi_ctx->vsi_num = LE16_TO_CPU(res->vsi_num) & ICE_AQ_VSI_NUM_M;
389 		vsi_ctx->vsis_allocd = LE16_TO_CPU(res->vsi_used);
390 		vsi_ctx->vsis_unallocated = LE16_TO_CPU(res->vsi_free);
391 	}
392 
393 	return status;
394 }
395 
396 /**
397  * ice_aq_free_vsi
398  * @hw: pointer to the HW struct
399  * @vsi_ctx: pointer to a VSI context struct
400  * @keep_vsi_alloc: keep VSI allocation as part of this PF's resources
401  * @cd: pointer to command details structure or NULL
402  *
403  * Free VSI context info from hardware (0x0213)
404  */
405 enum ice_status
406 ice_aq_free_vsi(struct ice_hw *hw, struct ice_vsi_ctx *vsi_ctx,
407 		bool keep_vsi_alloc, struct ice_sq_cd *cd)
408 {
409 	struct ice_aqc_add_update_free_vsi_resp *resp;
410 	struct ice_aqc_add_get_update_free_vsi *cmd;
411 	struct ice_aq_desc desc;
412 	enum ice_status status;
413 
414 	cmd = &desc.params.vsi_cmd;
415 	resp = &desc.params.add_update_free_vsi_res;
416 
417 	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_free_vsi);
418 
419 	cmd->vsi_num = CPU_TO_LE16(vsi_ctx->vsi_num | ICE_AQ_VSI_IS_VALID);
420 	if (keep_vsi_alloc)
421 		cmd->cmd_flags = CPU_TO_LE16(ICE_AQ_VSI_KEEP_ALLOC);
422 
423 	status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
424 	if (!status) {
425 		vsi_ctx->vsis_allocd = LE16_TO_CPU(resp->vsi_used);
426 		vsi_ctx->vsis_unallocated = LE16_TO_CPU(resp->vsi_free);
427 	}
428 
429 	return status;
430 }
431 
432 /**
433  * ice_aq_update_vsi
434  * @hw: pointer to the HW struct
435  * @vsi_ctx: pointer to a VSI context struct
436  * @cd: pointer to command details structure or NULL
437  *
438  * Update VSI context in the hardware (0x0211)
439  */
440 enum ice_status
441 ice_aq_update_vsi(struct ice_hw *hw, struct ice_vsi_ctx *vsi_ctx,
442 		  struct ice_sq_cd *cd)
443 {
444 	struct ice_aqc_add_update_free_vsi_resp *resp;
445 	struct ice_aqc_add_get_update_free_vsi *cmd;
446 	struct ice_aq_desc desc;
447 	enum ice_status status;
448 
449 	cmd = &desc.params.vsi_cmd;
450 	resp = &desc.params.add_update_free_vsi_res;
451 
452 	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_update_vsi);
453 
454 	cmd->vsi_num = CPU_TO_LE16(vsi_ctx->vsi_num | ICE_AQ_VSI_IS_VALID);
455 
456 	desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
457 
458 	status = ice_aq_send_cmd(hw, &desc, &vsi_ctx->info,
459 				 sizeof(vsi_ctx->info), cd);
460 
461 	if (!status) {
462 		vsi_ctx->vsis_allocd = LE16_TO_CPU(resp->vsi_used);
463 		vsi_ctx->vsis_unallocated = LE16_TO_CPU(resp->vsi_free);
464 	}
465 
466 	return status;
467 }
468 
469 /**
470  * ice_is_vsi_valid - check whether the VSI is valid or not
471  * @hw: pointer to the HW struct
472  * @vsi_handle: VSI handle
473  *
474  * check whether the VSI is valid or not
475  */
476 bool ice_is_vsi_valid(struct ice_hw *hw, u16 vsi_handle)
477 {
478 	return vsi_handle < ICE_MAX_VSI && hw->vsi_ctx[vsi_handle];
479 }
480 
481 /**
482  * ice_get_hw_vsi_num - return the HW VSI number
483  * @hw: pointer to the HW struct
484  * @vsi_handle: VSI handle
485  *
486  * return the HW VSI number
487  * Caution: call this function only if VSI is valid (ice_is_vsi_valid)
488  */
489 u16 ice_get_hw_vsi_num(struct ice_hw *hw, u16 vsi_handle)
490 {
491 	return hw->vsi_ctx[vsi_handle]->vsi_num;
492 }
493 
494 /**
495  * ice_get_vsi_ctx - return the VSI context entry for a given VSI handle
496  * @hw: pointer to the HW struct
497  * @vsi_handle: VSI handle
498  *
499  * return the VSI context entry for a given VSI handle
500  */
501 struct ice_vsi_ctx *ice_get_vsi_ctx(struct ice_hw *hw, u16 vsi_handle)
502 {
503 	return (vsi_handle >= ICE_MAX_VSI) ? NULL : hw->vsi_ctx[vsi_handle];
504 }
505 
506 /**
507  * ice_save_vsi_ctx - save the VSI context for a given VSI handle
508  * @hw: pointer to the HW struct
509  * @vsi_handle: VSI handle
510  * @vsi: VSI context pointer
511  *
512  * save the VSI context entry for a given VSI handle
513  */
514 static void
515 ice_save_vsi_ctx(struct ice_hw *hw, u16 vsi_handle, struct ice_vsi_ctx *vsi)
516 {
517 	hw->vsi_ctx[vsi_handle] = vsi;
518 }
519 
520 /**
521  * ice_clear_vsi_q_ctx - clear VSI queue contexts for all TCs
522  * @hw: pointer to the HW struct
523  * @vsi_handle: VSI handle
524  */
525 static void ice_clear_vsi_q_ctx(struct ice_hw *hw, u16 vsi_handle)
526 {
527 	struct ice_vsi_ctx *vsi;
528 	u8 i;
529 
530 	vsi = ice_get_vsi_ctx(hw, vsi_handle);
531 	if (!vsi)
532 		return;
533 	ice_for_each_traffic_class(i) {
534 		if (vsi->lan_q_ctx[i]) {
535 			ice_free(hw, vsi->lan_q_ctx[i]);
536 			vsi->lan_q_ctx[i] = NULL;
537 		}
538 	}
539 }
540 
541 /**
542  * ice_clear_vsi_ctx - clear the VSI context entry
543  * @hw: pointer to the HW struct
544  * @vsi_handle: VSI handle
545  *
546  * clear the VSI context entry
547  */
548 static void ice_clear_vsi_ctx(struct ice_hw *hw, u16 vsi_handle)
549 {
550 	struct ice_vsi_ctx *vsi;
551 
552 	vsi = ice_get_vsi_ctx(hw, vsi_handle);
553 	if (vsi) {
554 		ice_clear_vsi_q_ctx(hw, vsi_handle);
555 		ice_free(hw, vsi);
556 		hw->vsi_ctx[vsi_handle] = NULL;
557 	}
558 }
559 
560 /**
561  * ice_clear_all_vsi_ctx - clear all the VSI context entries
562  * @hw: pointer to the HW struct
563  */
564 void ice_clear_all_vsi_ctx(struct ice_hw *hw)
565 {
566 	u16 i;
567 
568 	for (i = 0; i < ICE_MAX_VSI; i++)
569 		ice_clear_vsi_ctx(hw, i);
570 }
571 
572 /**
573  * ice_add_vsi - add VSI context to the hardware and VSI handle list
574  * @hw: pointer to the HW struct
575  * @vsi_handle: unique VSI handle provided by drivers
576  * @vsi_ctx: pointer to a VSI context struct
577  * @cd: pointer to command details structure or NULL
578  *
579  * Add a VSI context to the hardware also add it into the VSI handle list.
580  * If this function gets called after reset for existing VSIs then update
581  * with the new HW VSI number in the corresponding VSI handle list entry.
582  */
583 enum ice_status
584 ice_add_vsi(struct ice_hw *hw, u16 vsi_handle, struct ice_vsi_ctx *vsi_ctx,
585 	    struct ice_sq_cd *cd)
586 {
587 	struct ice_vsi_ctx *tmp_vsi_ctx;
588 	enum ice_status status;
589 
590 	if (vsi_handle >= ICE_MAX_VSI)
591 		return ICE_ERR_PARAM;
592 	status = ice_aq_add_vsi(hw, vsi_ctx, cd);
593 	if (status)
594 		return status;
595 	tmp_vsi_ctx = ice_get_vsi_ctx(hw, vsi_handle);
596 	if (!tmp_vsi_ctx) {
597 		/* Create a new VSI context */
598 		tmp_vsi_ctx = (struct ice_vsi_ctx *)
599 			ice_malloc(hw, sizeof(*tmp_vsi_ctx));
600 		if (!tmp_vsi_ctx) {
601 			ice_aq_free_vsi(hw, vsi_ctx, false, cd);
602 			return ICE_ERR_NO_MEMORY;
603 		}
604 		*tmp_vsi_ctx = *vsi_ctx;
605 
606 		ice_save_vsi_ctx(hw, vsi_handle, tmp_vsi_ctx);
607 	} else {
608 		/* update with new HW VSI num */
609 		tmp_vsi_ctx->vsi_num = vsi_ctx->vsi_num;
610 	}
611 
612 	return ICE_SUCCESS;
613 }
614 
615 /**
616  * ice_free_vsi- free VSI context from hardware and VSI handle list
617  * @hw: pointer to the HW struct
618  * @vsi_handle: unique VSI handle
619  * @vsi_ctx: pointer to a VSI context struct
620  * @keep_vsi_alloc: keep VSI allocation as part of this PF's resources
621  * @cd: pointer to command details structure or NULL
622  *
623  * Free VSI context info from hardware as well as from VSI handle list
624  */
625 enum ice_status
626 ice_free_vsi(struct ice_hw *hw, u16 vsi_handle, struct ice_vsi_ctx *vsi_ctx,
627 	     bool keep_vsi_alloc, struct ice_sq_cd *cd)
628 {
629 	enum ice_status status;
630 
631 	if (!ice_is_vsi_valid(hw, vsi_handle))
632 		return ICE_ERR_PARAM;
633 	vsi_ctx->vsi_num = ice_get_hw_vsi_num(hw, vsi_handle);
634 	status = ice_aq_free_vsi(hw, vsi_ctx, keep_vsi_alloc, cd);
635 	if (!status)
636 		ice_clear_vsi_ctx(hw, vsi_handle);
637 	return status;
638 }
639 
640 /**
641  * ice_update_vsi
642  * @hw: pointer to the HW struct
643  * @vsi_handle: unique VSI handle
644  * @vsi_ctx: pointer to a VSI context struct
645  * @cd: pointer to command details structure or NULL
646  *
647  * Update VSI context in the hardware
648  */
649 enum ice_status
650 ice_update_vsi(struct ice_hw *hw, u16 vsi_handle, struct ice_vsi_ctx *vsi_ctx,
651 	       struct ice_sq_cd *cd)
652 {
653 	if (!ice_is_vsi_valid(hw, vsi_handle))
654 		return ICE_ERR_PARAM;
655 	vsi_ctx->vsi_num = ice_get_hw_vsi_num(hw, vsi_handle);
656 	return ice_aq_update_vsi(hw, vsi_ctx, cd);
657 }
658 
659 /**
660  * ice_aq_get_vsi_params
661  * @hw: pointer to the HW struct
662  * @vsi_ctx: pointer to a VSI context struct
663  * @cd: pointer to command details structure or NULL
664  *
665  * Get VSI context info from hardware (0x0212)
666  */
667 enum ice_status
668 ice_aq_get_vsi_params(struct ice_hw *hw, struct ice_vsi_ctx *vsi_ctx,
669 		      struct ice_sq_cd *cd)
670 {
671 	struct ice_aqc_add_get_update_free_vsi *cmd;
672 	struct ice_aqc_get_vsi_resp *resp;
673 	struct ice_aq_desc desc;
674 	enum ice_status status;
675 
676 	cmd = &desc.params.vsi_cmd;
677 	resp = &desc.params.get_vsi_resp;
678 
679 	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_vsi_params);
680 
681 	cmd->vsi_num = CPU_TO_LE16(vsi_ctx->vsi_num | ICE_AQ_VSI_IS_VALID);
682 
683 	status = ice_aq_send_cmd(hw, &desc, &vsi_ctx->info,
684 				 sizeof(vsi_ctx->info), cd);
685 	if (!status) {
686 		vsi_ctx->vsi_num = LE16_TO_CPU(resp->vsi_num) &
687 					ICE_AQ_VSI_NUM_M;
688 		vsi_ctx->vf_num = resp->vf_id;
689 		vsi_ctx->vsis_allocd = LE16_TO_CPU(resp->vsi_used);
690 		vsi_ctx->vsis_unallocated = LE16_TO_CPU(resp->vsi_free);
691 	}
692 
693 	return status;
694 }
695 
696 /**
697  * ice_aq_add_update_mir_rule - add/update a mirror rule
698  * @hw: pointer to the HW struct
699  * @rule_type: Rule Type
700  * @dest_vsi: VSI number to which packets will be mirrored
701  * @count: length of the list
702  * @mr_buf: buffer for list of mirrored VSI numbers
703  * @cd: pointer to command details structure or NULL
704  * @rule_id: Rule ID
705  *
706  * Add/Update Mirror Rule (0x260).
707  */
708 enum ice_status
709 ice_aq_add_update_mir_rule(struct ice_hw *hw, u16 rule_type, u16 dest_vsi,
710 			   u16 count, struct ice_mir_rule_buf *mr_buf,
711 			   struct ice_sq_cd *cd, u16 *rule_id)
712 {
713 	struct ice_aqc_add_update_mir_rule *cmd;
714 	struct ice_aq_desc desc;
715 	enum ice_status status;
716 	__le16 *mr_list = NULL;
717 	u16 buf_size = 0;
718 
719 	switch (rule_type) {
720 	case ICE_AQC_RULE_TYPE_VPORT_INGRESS:
721 	case ICE_AQC_RULE_TYPE_VPORT_EGRESS:
722 		/* Make sure count and mr_buf are set for these rule_types */
723 		if (!(count && mr_buf))
724 			return ICE_ERR_PARAM;
725 
726 		buf_size = count * sizeof(__le16);
727 		mr_list = (_FORCE_ __le16 *)ice_malloc(hw, buf_size);
728 		if (!mr_list)
729 			return ICE_ERR_NO_MEMORY;
730 		break;
731 	case ICE_AQC_RULE_TYPE_PPORT_INGRESS:
732 	case ICE_AQC_RULE_TYPE_PPORT_EGRESS:
733 		/* Make sure count and mr_buf are not set for these
734 		 * rule_types
735 		 */
736 		if (count || mr_buf)
737 			return ICE_ERR_PARAM;
738 		break;
739 	default:
740 		ice_debug(hw, ICE_DBG_SW, "Error due to unsupported rule_type %u\n", rule_type);
741 		return ICE_ERR_OUT_OF_RANGE;
742 	}
743 
744 	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_add_update_mir_rule);
745 
746 	/* Pre-process 'mr_buf' items for add/update of virtual port
747 	 * ingress/egress mirroring (but not physical port ingress/egress
748 	 * mirroring)
749 	 */
750 	if (mr_buf) {
751 		int i;
752 
753 		for (i = 0; i < count; i++) {
754 			u16 id;
755 
756 			id = mr_buf[i].vsi_idx & ICE_AQC_RULE_MIRRORED_VSI_M;
757 
758 			/* Validate specified VSI number, make sure it is less
759 			 * than ICE_MAX_VSI, if not return with error.
760 			 */
761 			if (id >= ICE_MAX_VSI) {
762 				ice_debug(hw, ICE_DBG_SW, "Error VSI index (%u) out-of-range\n",
763 					  id);
764 				ice_free(hw, mr_list);
765 				return ICE_ERR_OUT_OF_RANGE;
766 			}
767 
768 			/* add VSI to mirror rule */
769 			if (mr_buf[i].add)
770 				mr_list[i] =
771 					CPU_TO_LE16(id | ICE_AQC_RULE_ACT_M);
772 			else /* remove VSI from mirror rule */
773 				mr_list[i] = CPU_TO_LE16(id);
774 		}
775 	}
776 
777 	cmd = &desc.params.add_update_rule;
778 	if ((*rule_id) != ICE_INVAL_MIRROR_RULE_ID)
779 		cmd->rule_id = CPU_TO_LE16(((*rule_id) & ICE_AQC_RULE_ID_M) |
780 					   ICE_AQC_RULE_ID_VALID_M);
781 	cmd->rule_type = CPU_TO_LE16(rule_type & ICE_AQC_RULE_TYPE_M);
782 	cmd->num_entries = CPU_TO_LE16(count);
783 	cmd->dest = CPU_TO_LE16(dest_vsi);
784 
785 	status = ice_aq_send_cmd(hw, &desc, mr_list, buf_size, cd);
786 	if (!status)
787 		*rule_id = LE16_TO_CPU(cmd->rule_id) & ICE_AQC_RULE_ID_M;
788 
789 	ice_free(hw, mr_list);
790 
791 	return status;
792 }
793 
794 /**
795  * ice_aq_delete_mir_rule - delete a mirror rule
796  * @hw: pointer to the HW struct
797  * @rule_id: Mirror rule ID (to be deleted)
798  * @keep_allocd: if set, the VSI stays part of the PF allocated res,
799  *		 otherwise it is returned to the shared pool
800  * @cd: pointer to command details structure or NULL
801  *
802  * Delete Mirror Rule (0x261).
803  */
804 enum ice_status
805 ice_aq_delete_mir_rule(struct ice_hw *hw, u16 rule_id, bool keep_allocd,
806 		       struct ice_sq_cd *cd)
807 {
808 	struct ice_aqc_delete_mir_rule *cmd;
809 	struct ice_aq_desc desc;
810 
811 	/* rule_id should be in the range 0...63 */
812 	if (rule_id >= ICE_MAX_NUM_MIRROR_RULES)
813 		return ICE_ERR_OUT_OF_RANGE;
814 
815 	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_del_mir_rule);
816 
817 	cmd = &desc.params.del_rule;
818 	rule_id |= ICE_AQC_RULE_ID_VALID_M;
819 	cmd->rule_id = CPU_TO_LE16(rule_id);
820 
821 	if (keep_allocd)
822 		cmd->flags = CPU_TO_LE16(ICE_AQC_FLAG_KEEP_ALLOCD_M);
823 
824 	return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);
825 }
826 
827 /**
828  * ice_aq_alloc_free_vsi_list
829  * @hw: pointer to the HW struct
830  * @vsi_list_id: VSI list ID returned or used for lookup
831  * @lkup_type: switch rule filter lookup type
832  * @opc: switch rules population command type - pass in the command opcode
833  *
834  * allocates or free a VSI list resource
835  */
836 static enum ice_status
837 ice_aq_alloc_free_vsi_list(struct ice_hw *hw, u16 *vsi_list_id,
838 			   enum ice_sw_lkup_type lkup_type,
839 			   enum ice_adminq_opc opc)
840 {
841 	struct ice_aqc_alloc_free_res_elem *sw_buf;
842 	struct ice_aqc_res_elem *vsi_ele;
843 	enum ice_status status;
844 	u16 buf_len;
845 
846 	buf_len = ice_struct_size(sw_buf, elem, 1);
847 	sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len);
848 	if (!sw_buf)
849 		return ICE_ERR_NO_MEMORY;
850 	sw_buf->num_elems = CPU_TO_LE16(1);
851 
852 	if (lkup_type == ICE_SW_LKUP_MAC ||
853 	    lkup_type == ICE_SW_LKUP_MAC_VLAN ||
854 	    lkup_type == ICE_SW_LKUP_ETHERTYPE ||
855 	    lkup_type == ICE_SW_LKUP_ETHERTYPE_MAC ||
856 	    lkup_type == ICE_SW_LKUP_PROMISC ||
857 	    lkup_type == ICE_SW_LKUP_PROMISC_VLAN ||
858 	    lkup_type == ICE_SW_LKUP_LAST) {
859 		sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_VSI_LIST_REP);
860 	} else if (lkup_type == ICE_SW_LKUP_VLAN) {
861 		sw_buf->res_type =
862 			CPU_TO_LE16(ICE_AQC_RES_TYPE_VSI_LIST_PRUNE);
863 	} else {
864 		status = ICE_ERR_PARAM;
865 		goto ice_aq_alloc_free_vsi_list_exit;
866 	}
867 
868 	if (opc == ice_aqc_opc_free_res)
869 		sw_buf->elem[0].e.sw_resp = CPU_TO_LE16(*vsi_list_id);
870 
871 	status = ice_aq_alloc_free_res(hw, 1, sw_buf, buf_len, opc, NULL);
872 	if (status)
873 		goto ice_aq_alloc_free_vsi_list_exit;
874 
875 	if (opc == ice_aqc_opc_alloc_res) {
876 		vsi_ele = &sw_buf->elem[0];
877 		*vsi_list_id = LE16_TO_CPU(vsi_ele->e.sw_resp);
878 	}
879 
880 ice_aq_alloc_free_vsi_list_exit:
881 	ice_free(hw, sw_buf);
882 	return status;
883 }
884 
885 /**
886  * ice_aq_set_storm_ctrl - Sets storm control configuration
887  * @hw: pointer to the HW struct
888  * @bcast_thresh: represents the upper threshold for broadcast storm control
889  * @mcast_thresh: represents the upper threshold for multicast storm control
890  * @ctl_bitmask: storm control knobs
891  *
892  * Sets the storm control configuration (0x0280)
893  */
894 enum ice_status
895 ice_aq_set_storm_ctrl(struct ice_hw *hw, u32 bcast_thresh, u32 mcast_thresh,
896 		      u32 ctl_bitmask)
897 {
898 	struct ice_aqc_storm_cfg *cmd;
899 	struct ice_aq_desc desc;
900 
901 	cmd = &desc.params.storm_conf;
902 
903 	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_storm_cfg);
904 
905 	cmd->bcast_thresh_size = CPU_TO_LE32(bcast_thresh & ICE_AQ_THRESHOLD_M);
906 	cmd->mcast_thresh_size = CPU_TO_LE32(mcast_thresh & ICE_AQ_THRESHOLD_M);
907 	cmd->storm_ctrl_ctrl = CPU_TO_LE32(ctl_bitmask);
908 
909 	return ice_aq_send_cmd(hw, &desc, NULL, 0, NULL);
910 }
911 
912 /**
913  * ice_aq_get_storm_ctrl - gets storm control configuration
914  * @hw: pointer to the HW struct
915  * @bcast_thresh: represents the upper threshold for broadcast storm control
916  * @mcast_thresh: represents the upper threshold for multicast storm control
917  * @ctl_bitmask: storm control knobs
918  *
919  * Gets the storm control configuration (0x0281)
920  */
921 enum ice_status
922 ice_aq_get_storm_ctrl(struct ice_hw *hw, u32 *bcast_thresh, u32 *mcast_thresh,
923 		      u32 *ctl_bitmask)
924 {
925 	enum ice_status status;
926 	struct ice_aq_desc desc;
927 
928 	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_storm_cfg);
929 
930 	status = ice_aq_send_cmd(hw, &desc, NULL, 0, NULL);
931 	if (!status) {
932 		struct ice_aqc_storm_cfg *resp = &desc.params.storm_conf;
933 
934 		if (bcast_thresh)
935 			*bcast_thresh = LE32_TO_CPU(resp->bcast_thresh_size) &
936 				ICE_AQ_THRESHOLD_M;
937 		if (mcast_thresh)
938 			*mcast_thresh = LE32_TO_CPU(resp->mcast_thresh_size) &
939 				ICE_AQ_THRESHOLD_M;
940 		if (ctl_bitmask)
941 			*ctl_bitmask = LE32_TO_CPU(resp->storm_ctrl_ctrl);
942 	}
943 
944 	return status;
945 }
946 
947 /**
948  * ice_aq_sw_rules - add/update/remove switch rules
949  * @hw: pointer to the HW struct
950  * @rule_list: pointer to switch rule population list
951  * @rule_list_sz: total size of the rule list in bytes
952  * @num_rules: number of switch rules in the rule_list
953  * @opc: switch rules population command type - pass in the command opcode
954  * @cd: pointer to command details structure or NULL
955  *
956  * Add(0x02a0)/Update(0x02a1)/Remove(0x02a2) switch rules commands to firmware
957  */
958 static enum ice_status
959 ice_aq_sw_rules(struct ice_hw *hw, void *rule_list, u16 rule_list_sz,
960 		u8 num_rules, enum ice_adminq_opc opc, struct ice_sq_cd *cd)
961 {
962 	struct ice_aq_desc desc;
963 	enum ice_status status;
964 
965 	ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
966 
967 	if (opc != ice_aqc_opc_add_sw_rules &&
968 	    opc != ice_aqc_opc_update_sw_rules &&
969 	    opc != ice_aqc_opc_remove_sw_rules)
970 		return ICE_ERR_PARAM;
971 
972 	ice_fill_dflt_direct_cmd_desc(&desc, opc);
973 
974 	desc.flags |= CPU_TO_LE16(ICE_AQ_FLAG_RD);
975 	desc.params.sw_rules.num_rules_fltr_entry_index =
976 		CPU_TO_LE16(num_rules);
977 	status = ice_aq_send_cmd(hw, &desc, rule_list, rule_list_sz, cd);
978 	if (opc != ice_aqc_opc_add_sw_rules &&
979 	    hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT)
980 		status = ICE_ERR_DOES_NOT_EXIST;
981 
982 	return status;
983 }
984 
985 /* ice_init_port_info - Initialize port_info with switch configuration data
986  * @pi: pointer to port_info
987  * @vsi_port_num: VSI number or port number
988  * @type: Type of switch element (port or VSI)
989  * @swid: switch ID of the switch the element is attached to
990  * @pf_vf_num: PF or VF number
991  * @is_vf: true if the element is a VF, false otherwise
992  */
993 static void
994 ice_init_port_info(struct ice_port_info *pi, u16 vsi_port_num, u8 type,
995 		   u16 swid, u16 pf_vf_num, bool is_vf)
996 {
997 	switch (type) {
998 	case ICE_AQC_GET_SW_CONF_RESP_PHYS_PORT:
999 		pi->lport = (u8)(vsi_port_num & ICE_LPORT_MASK);
1000 		pi->sw_id = swid;
1001 		pi->pf_vf_num = pf_vf_num;
1002 		pi->is_vf = is_vf;
1003 		pi->dflt_tx_vsi_num = ICE_DFLT_VSI_INVAL;
1004 		pi->dflt_rx_vsi_num = ICE_DFLT_VSI_INVAL;
1005 		break;
1006 	default:
1007 		ice_debug(pi->hw, ICE_DBG_SW, "incorrect VSI/port type received\n");
1008 		break;
1009 	}
1010 }
1011 
1012 /* ice_get_initial_sw_cfg - Get initial port and default VSI data
1013  * @hw: pointer to the hardware structure
1014  */
1015 enum ice_status ice_get_initial_sw_cfg(struct ice_hw *hw)
1016 {
1017 	struct ice_aqc_get_sw_cfg_resp_elem *rbuf;
1018 	enum ice_status status;
1019 	u8 num_total_ports;
1020 	u16 req_desc = 0;
1021 	u16 num_elems;
1022 	u8 j = 0;
1023 	u16 i;
1024 
1025 	num_total_ports = 1;
1026 
1027 	rbuf = (struct ice_aqc_get_sw_cfg_resp_elem *)
1028 		ice_malloc(hw, ICE_SW_CFG_MAX_BUF_LEN);
1029 
1030 	if (!rbuf)
1031 		return ICE_ERR_NO_MEMORY;
1032 
1033 	/* Multiple calls to ice_aq_get_sw_cfg may be required
1034 	 * to get all the switch configuration information. The need
1035 	 * for additional calls is indicated by ice_aq_get_sw_cfg
1036 	 * writing a non-zero value in req_desc
1037 	 */
1038 	do {
1039 		struct ice_aqc_get_sw_cfg_resp_elem *ele;
1040 
1041 		status = ice_aq_get_sw_cfg(hw, rbuf, ICE_SW_CFG_MAX_BUF_LEN,
1042 					   &req_desc, &num_elems, NULL);
1043 
1044 		if (status)
1045 			break;
1046 
1047 		for (i = 0, ele = rbuf; i < num_elems; i++, ele++) {
1048 			u16 pf_vf_num, swid, vsi_port_num;
1049 			bool is_vf = false;
1050 			u8 res_type;
1051 
1052 			vsi_port_num = LE16_TO_CPU(ele->vsi_port_num) &
1053 				ICE_AQC_GET_SW_CONF_RESP_VSI_PORT_NUM_M;
1054 
1055 			pf_vf_num = LE16_TO_CPU(ele->pf_vf_num) &
1056 				ICE_AQC_GET_SW_CONF_RESP_FUNC_NUM_M;
1057 
1058 			swid = LE16_TO_CPU(ele->swid);
1059 
1060 			if (LE16_TO_CPU(ele->pf_vf_num) &
1061 			    ICE_AQC_GET_SW_CONF_RESP_IS_VF)
1062 				is_vf = true;
1063 
1064 			res_type = (u8)(LE16_TO_CPU(ele->vsi_port_num) >>
1065 					ICE_AQC_GET_SW_CONF_RESP_TYPE_S);
1066 
1067 			switch (res_type) {
1068 			case ICE_AQC_GET_SW_CONF_RESP_PHYS_PORT:
1069 			case ICE_AQC_GET_SW_CONF_RESP_VIRT_PORT:
1070 				if (j == num_total_ports) {
1071 					ice_debug(hw, ICE_DBG_SW, "more ports than expected\n");
1072 					status = ICE_ERR_CFG;
1073 					goto out;
1074 				}
1075 				ice_init_port_info(hw->port_info,
1076 						   vsi_port_num, res_type, swid,
1077 						   pf_vf_num, is_vf);
1078 				j++;
1079 				break;
1080 			default:
1081 				break;
1082 			}
1083 		}
1084 	} while (req_desc && !status);
1085 
1086 out:
1087 	ice_free(hw, rbuf);
1088 	return status;
1089 }
1090 
1091 /**
1092  * ice_fill_sw_info - Helper function to populate lb_en and lan_en
1093  * @hw: pointer to the hardware structure
1094  * @fi: filter info structure to fill/update
1095  *
1096  * This helper function populates the lb_en and lan_en elements of the provided
1097  * ice_fltr_info struct using the switch's type and characteristics of the
1098  * switch rule being configured.
1099  */
1100 static void ice_fill_sw_info(struct ice_hw *hw, struct ice_fltr_info *fi)
1101 {
1102 	fi->lb_en = false;
1103 	fi->lan_en = false;
1104 	if ((fi->flag & ICE_FLTR_TX) &&
1105 	    (fi->fltr_act == ICE_FWD_TO_VSI ||
1106 	     fi->fltr_act == ICE_FWD_TO_VSI_LIST ||
1107 	     fi->fltr_act == ICE_FWD_TO_Q ||
1108 	     fi->fltr_act == ICE_FWD_TO_QGRP)) {
1109 		/* Setting LB for prune actions will result in replicated
1110 		 * packets to the internal switch that will be dropped.
1111 		 */
1112 		if (fi->lkup_type != ICE_SW_LKUP_VLAN)
1113 			fi->lb_en = true;
1114 
1115 		/* Set lan_en to TRUE if
1116 		 * 1. The switch is a VEB AND
1117 		 * 2
1118 		 * 2.1 The lookup is a directional lookup like ethertype,
1119 		 * promiscuous, ethertype-MAC, promiscuous-VLAN
1120 		 * and default-port OR
1121 		 * 2.2 The lookup is VLAN, OR
1122 		 * 2.3 The lookup is MAC with mcast or bcast addr for MAC, OR
1123 		 * 2.4 The lookup is MAC_VLAN with mcast or bcast addr for MAC.
1124 		 *
1125 		 * OR
1126 		 *
1127 		 * The switch is a VEPA.
1128 		 *
1129 		 * In all other cases, the LAN enable has to be set to false.
1130 		 */
1131 		if (hw->evb_veb) {
1132 			if (fi->lkup_type == ICE_SW_LKUP_ETHERTYPE ||
1133 			    fi->lkup_type == ICE_SW_LKUP_PROMISC ||
1134 			    fi->lkup_type == ICE_SW_LKUP_ETHERTYPE_MAC ||
1135 			    fi->lkup_type == ICE_SW_LKUP_PROMISC_VLAN ||
1136 			    fi->lkup_type == ICE_SW_LKUP_DFLT ||
1137 			    fi->lkup_type == ICE_SW_LKUP_VLAN ||
1138 			    (fi->lkup_type == ICE_SW_LKUP_MAC &&
1139 			     !IS_UNICAST_ETHER_ADDR(fi->l_data.mac.mac_addr)) ||
1140 			    (fi->lkup_type == ICE_SW_LKUP_MAC_VLAN &&
1141 			     !IS_UNICAST_ETHER_ADDR(fi->l_data.mac.mac_addr)))
1142 				fi->lan_en = true;
1143 		} else {
1144 			fi->lan_en = true;
1145 		}
1146 	}
1147 }
1148 
1149 /**
1150  * ice_fill_sw_rule - Helper function to fill switch rule structure
1151  * @hw: pointer to the hardware structure
1152  * @f_info: entry containing packet forwarding information
1153  * @s_rule: switch rule structure to be filled in based on mac_entry
1154  * @opc: switch rules population command type - pass in the command opcode
1155  */
1156 static void
1157 ice_fill_sw_rule(struct ice_hw *hw, struct ice_fltr_info *f_info,
1158 		 struct ice_aqc_sw_rules_elem *s_rule, enum ice_adminq_opc opc)
1159 {
1160 	u16 vlan_id = ICE_MAX_VLAN_ID + 1;
1161 	void *daddr = NULL;
1162 	u16 eth_hdr_sz;
1163 	u8 *eth_hdr;
1164 	u32 act = 0;
1165 	__be16 *off;
1166 	u8 q_rgn;
1167 
1168 	if (opc == ice_aqc_opc_remove_sw_rules) {
1169 		s_rule->pdata.lkup_tx_rx.act = 0;
1170 		s_rule->pdata.lkup_tx_rx.index =
1171 			CPU_TO_LE16(f_info->fltr_rule_id);
1172 		s_rule->pdata.lkup_tx_rx.hdr_len = 0;
1173 		return;
1174 	}
1175 
1176 	eth_hdr_sz = sizeof(dummy_eth_header);
1177 	eth_hdr = s_rule->pdata.lkup_tx_rx.hdr;
1178 
1179 	/* initialize the ether header with a dummy header */
1180 	ice_memcpy(eth_hdr, dummy_eth_header, eth_hdr_sz, ICE_NONDMA_TO_NONDMA);
1181 	ice_fill_sw_info(hw, f_info);
1182 
1183 	switch (f_info->fltr_act) {
1184 	case ICE_FWD_TO_VSI:
1185 		act |= (f_info->fwd_id.hw_vsi_id << ICE_SINGLE_ACT_VSI_ID_S) &
1186 			ICE_SINGLE_ACT_VSI_ID_M;
1187 		if (f_info->lkup_type != ICE_SW_LKUP_VLAN)
1188 			act |= ICE_SINGLE_ACT_VSI_FORWARDING |
1189 				ICE_SINGLE_ACT_VALID_BIT;
1190 		break;
1191 	case ICE_FWD_TO_VSI_LIST:
1192 		act |= ICE_SINGLE_ACT_VSI_LIST;
1193 		act |= (f_info->fwd_id.vsi_list_id <<
1194 			ICE_SINGLE_ACT_VSI_LIST_ID_S) &
1195 			ICE_SINGLE_ACT_VSI_LIST_ID_M;
1196 		if (f_info->lkup_type != ICE_SW_LKUP_VLAN)
1197 			act |= ICE_SINGLE_ACT_VSI_FORWARDING |
1198 				ICE_SINGLE_ACT_VALID_BIT;
1199 		break;
1200 	case ICE_FWD_TO_Q:
1201 		act |= ICE_SINGLE_ACT_TO_Q;
1202 		act |= (f_info->fwd_id.q_id << ICE_SINGLE_ACT_Q_INDEX_S) &
1203 			ICE_SINGLE_ACT_Q_INDEX_M;
1204 		break;
1205 	case ICE_DROP_PACKET:
1206 		act |= ICE_SINGLE_ACT_VSI_FORWARDING | ICE_SINGLE_ACT_DROP |
1207 			ICE_SINGLE_ACT_VALID_BIT;
1208 		break;
1209 	case ICE_FWD_TO_QGRP:
1210 		q_rgn = f_info->qgrp_size > 0 ?
1211 			(u8)ice_ilog2(f_info->qgrp_size) : 0;
1212 		act |= ICE_SINGLE_ACT_TO_Q;
1213 		act |= (f_info->fwd_id.q_id << ICE_SINGLE_ACT_Q_INDEX_S) &
1214 			ICE_SINGLE_ACT_Q_INDEX_M;
1215 		act |= (q_rgn << ICE_SINGLE_ACT_Q_REGION_S) &
1216 			ICE_SINGLE_ACT_Q_REGION_M;
1217 		break;
1218 	default:
1219 		return;
1220 	}
1221 
1222 	if (f_info->lb_en)
1223 		act |= ICE_SINGLE_ACT_LB_ENABLE;
1224 	if (f_info->lan_en)
1225 		act |= ICE_SINGLE_ACT_LAN_ENABLE;
1226 
1227 	switch (f_info->lkup_type) {
1228 	case ICE_SW_LKUP_MAC:
1229 		daddr = f_info->l_data.mac.mac_addr;
1230 		break;
1231 	case ICE_SW_LKUP_VLAN:
1232 		vlan_id = f_info->l_data.vlan.vlan_id;
1233 		if (f_info->fltr_act == ICE_FWD_TO_VSI ||
1234 		    f_info->fltr_act == ICE_FWD_TO_VSI_LIST) {
1235 			act |= ICE_SINGLE_ACT_PRUNE;
1236 			act |= ICE_SINGLE_ACT_EGRESS | ICE_SINGLE_ACT_INGRESS;
1237 		}
1238 		break;
1239 	case ICE_SW_LKUP_ETHERTYPE_MAC:
1240 		daddr = f_info->l_data.ethertype_mac.mac_addr;
1241 		/* fall-through */
1242 	case ICE_SW_LKUP_ETHERTYPE:
1243 		off = (_FORCE_ __be16 *)(eth_hdr + ICE_ETH_ETHTYPE_OFFSET);
1244 		*off = CPU_TO_BE16(f_info->l_data.ethertype_mac.ethertype);
1245 		break;
1246 	case ICE_SW_LKUP_MAC_VLAN:
1247 		daddr = f_info->l_data.mac_vlan.mac_addr;
1248 		vlan_id = f_info->l_data.mac_vlan.vlan_id;
1249 		break;
1250 	case ICE_SW_LKUP_PROMISC_VLAN:
1251 		vlan_id = f_info->l_data.mac_vlan.vlan_id;
1252 		/* fall-through */
1253 	case ICE_SW_LKUP_PROMISC:
1254 		daddr = f_info->l_data.mac_vlan.mac_addr;
1255 		break;
1256 	default:
1257 		break;
1258 	}
1259 
1260 	s_rule->type = (f_info->flag & ICE_FLTR_RX) ?
1261 		CPU_TO_LE16(ICE_AQC_SW_RULES_T_LKUP_RX) :
1262 		CPU_TO_LE16(ICE_AQC_SW_RULES_T_LKUP_TX);
1263 
1264 	/* Recipe set depending on lookup type */
1265 	s_rule->pdata.lkup_tx_rx.recipe_id = CPU_TO_LE16(f_info->lkup_type);
1266 	s_rule->pdata.lkup_tx_rx.src = CPU_TO_LE16(f_info->src);
1267 	s_rule->pdata.lkup_tx_rx.act = CPU_TO_LE32(act);
1268 
1269 	if (daddr)
1270 		ice_memcpy(eth_hdr + ICE_ETH_DA_OFFSET, daddr, ETH_ALEN,
1271 			   ICE_NONDMA_TO_NONDMA);
1272 
1273 	if (!(vlan_id > ICE_MAX_VLAN_ID)) {
1274 		off = (_FORCE_ __be16 *)(eth_hdr + ICE_ETH_VLAN_TCI_OFFSET);
1275 		*off = CPU_TO_BE16(vlan_id);
1276 	}
1277 
1278 	/* Create the switch rule with the final dummy Ethernet header */
1279 	if (opc != ice_aqc_opc_update_sw_rules)
1280 		s_rule->pdata.lkup_tx_rx.hdr_len = CPU_TO_LE16(eth_hdr_sz);
1281 }
1282 
1283 /**
1284  * ice_add_marker_act
1285  * @hw: pointer to the hardware structure
1286  * @m_ent: the management entry for which sw marker needs to be added
1287  * @sw_marker: sw marker to tag the Rx descriptor with
1288  * @l_id: large action resource ID
1289  *
1290  * Create a large action to hold software marker and update the switch rule
1291  * entry pointed by m_ent with newly created large action
1292  */
1293 static enum ice_status
1294 ice_add_marker_act(struct ice_hw *hw, struct ice_fltr_mgmt_list_entry *m_ent,
1295 		   u16 sw_marker, u16 l_id)
1296 {
1297 	struct ice_aqc_sw_rules_elem *lg_act, *rx_tx;
1298 	/* For software marker we need 3 large actions
1299 	 * 1. FWD action: FWD TO VSI or VSI LIST
1300 	 * 2. GENERIC VALUE action to hold the profile ID
1301 	 * 3. GENERIC VALUE action to hold the software marker ID
1302 	 */
1303 	const u16 num_lg_acts = 3;
1304 	enum ice_status status;
1305 	u16 lg_act_size;
1306 	u16 rules_size;
1307 	u32 act;
1308 	u16 id;
1309 
1310 	if (m_ent->fltr_info.lkup_type != ICE_SW_LKUP_MAC)
1311 		return ICE_ERR_PARAM;
1312 
1313 	/* Create two back-to-back switch rules and submit them to the HW using
1314 	 * one memory buffer:
1315 	 *    1. Large Action
1316 	 *    2. Look up Tx Rx
1317 	 */
1318 	lg_act_size = (u16)ICE_SW_RULE_LG_ACT_SIZE(num_lg_acts);
1319 	rules_size = lg_act_size + ICE_SW_RULE_RX_TX_ETH_HDR_SIZE;
1320 	lg_act = (struct ice_aqc_sw_rules_elem *)ice_malloc(hw, rules_size);
1321 	if (!lg_act)
1322 		return ICE_ERR_NO_MEMORY;
1323 
1324 	rx_tx = (struct ice_aqc_sw_rules_elem *)((u8 *)lg_act + lg_act_size);
1325 
1326 	/* Fill in the first switch rule i.e. large action */
1327 	lg_act->type = CPU_TO_LE16(ICE_AQC_SW_RULES_T_LG_ACT);
1328 	lg_act->pdata.lg_act.index = CPU_TO_LE16(l_id);
1329 	lg_act->pdata.lg_act.size = CPU_TO_LE16(num_lg_acts);
1330 
1331 	/* First action VSI forwarding or VSI list forwarding depending on how
1332 	 * many VSIs
1333 	 */
1334 	id = (m_ent->vsi_count > 1) ? m_ent->fltr_info.fwd_id.vsi_list_id :
1335 		m_ent->fltr_info.fwd_id.hw_vsi_id;
1336 
1337 	act = ICE_LG_ACT_VSI_FORWARDING | ICE_LG_ACT_VALID_BIT;
1338 	act |= (id << ICE_LG_ACT_VSI_LIST_ID_S) & ICE_LG_ACT_VSI_LIST_ID_M;
1339 	if (m_ent->vsi_count > 1)
1340 		act |= ICE_LG_ACT_VSI_LIST;
1341 	lg_act->pdata.lg_act.act[0] = CPU_TO_LE32(act);
1342 
1343 	/* Second action descriptor type */
1344 	act = ICE_LG_ACT_GENERIC;
1345 
1346 	act |= (1 << ICE_LG_ACT_GENERIC_VALUE_S) & ICE_LG_ACT_GENERIC_VALUE_M;
1347 	lg_act->pdata.lg_act.act[1] = CPU_TO_LE32(act);
1348 
1349 	act = (ICE_LG_ACT_GENERIC_OFF_RX_DESC_PROF_IDX <<
1350 	       ICE_LG_ACT_GENERIC_OFFSET_S) & ICE_LG_ACT_GENERIC_OFFSET_M;
1351 
1352 	/* Third action Marker value */
1353 	act |= ICE_LG_ACT_GENERIC;
1354 	act |= (sw_marker << ICE_LG_ACT_GENERIC_VALUE_S) &
1355 		ICE_LG_ACT_GENERIC_VALUE_M;
1356 
1357 	lg_act->pdata.lg_act.act[2] = CPU_TO_LE32(act);
1358 
1359 	/* call the fill switch rule to fill the lookup Tx Rx structure */
1360 	ice_fill_sw_rule(hw, &m_ent->fltr_info, rx_tx,
1361 			 ice_aqc_opc_update_sw_rules);
1362 
1363 	/* Update the action to point to the large action ID */
1364 	rx_tx->pdata.lkup_tx_rx.act =
1365 		CPU_TO_LE32(ICE_SINGLE_ACT_PTR |
1366 			    ((l_id << ICE_SINGLE_ACT_PTR_VAL_S) &
1367 			     ICE_SINGLE_ACT_PTR_VAL_M));
1368 
1369 	/* Use the filter rule ID of the previously created rule with single
1370 	 * act. Once the update happens, hardware will treat this as large
1371 	 * action
1372 	 */
1373 	rx_tx->pdata.lkup_tx_rx.index =
1374 		CPU_TO_LE16(m_ent->fltr_info.fltr_rule_id);
1375 
1376 	status = ice_aq_sw_rules(hw, lg_act, rules_size, 2,
1377 				 ice_aqc_opc_update_sw_rules, NULL);
1378 	if (!status) {
1379 		m_ent->lg_act_idx = l_id;
1380 		m_ent->sw_marker_id = sw_marker;
1381 	}
1382 
1383 	ice_free(hw, lg_act);
1384 	return status;
1385 }
1386 
1387 /**
1388  * ice_add_counter_act - add/update filter rule with counter action
1389  * @hw: pointer to the hardware structure
1390  * @m_ent: the management entry for which counter needs to be added
1391  * @counter_id: VLAN counter ID returned as part of allocate resource
1392  * @l_id: large action resource ID
1393  */
1394 static enum ice_status
1395 ice_add_counter_act(struct ice_hw *hw, struct ice_fltr_mgmt_list_entry *m_ent,
1396 		    u16 counter_id, u16 l_id)
1397 {
1398 	struct ice_aqc_sw_rules_elem *lg_act;
1399 	struct ice_aqc_sw_rules_elem *rx_tx;
1400 	enum ice_status status;
1401 	/* 2 actions will be added while adding a large action counter */
1402 	const int num_acts = 2;
1403 	u16 lg_act_size;
1404 	u16 rules_size;
1405 	u16 f_rule_id;
1406 	u32 act;
1407 	u16 id;
1408 
1409 	if (m_ent->fltr_info.lkup_type != ICE_SW_LKUP_MAC)
1410 		return ICE_ERR_PARAM;
1411 
1412 	/* Create two back-to-back switch rules and submit them to the HW using
1413 	 * one memory buffer:
1414 	 * 1. Large Action
1415 	 * 2. Look up Tx Rx
1416 	 */
1417 	lg_act_size = (u16)ICE_SW_RULE_LG_ACT_SIZE(num_acts);
1418 	rules_size = lg_act_size + ICE_SW_RULE_RX_TX_ETH_HDR_SIZE;
1419 	lg_act = (struct ice_aqc_sw_rules_elem *)ice_malloc(hw, rules_size);
1420 	if (!lg_act)
1421 		return ICE_ERR_NO_MEMORY;
1422 
1423 	rx_tx = (struct ice_aqc_sw_rules_elem *)((u8 *)lg_act + lg_act_size);
1424 
1425 	/* Fill in the first switch rule i.e. large action */
1426 	lg_act->type = CPU_TO_LE16(ICE_AQC_SW_RULES_T_LG_ACT);
1427 	lg_act->pdata.lg_act.index = CPU_TO_LE16(l_id);
1428 	lg_act->pdata.lg_act.size = CPU_TO_LE16(num_acts);
1429 
1430 	/* First action VSI forwarding or VSI list forwarding depending on how
1431 	 * many VSIs
1432 	 */
1433 	id = (m_ent->vsi_count > 1) ?  m_ent->fltr_info.fwd_id.vsi_list_id :
1434 		m_ent->fltr_info.fwd_id.hw_vsi_id;
1435 
1436 	act = ICE_LG_ACT_VSI_FORWARDING | ICE_LG_ACT_VALID_BIT;
1437 	act |= (id << ICE_LG_ACT_VSI_LIST_ID_S) &
1438 		ICE_LG_ACT_VSI_LIST_ID_M;
1439 	if (m_ent->vsi_count > 1)
1440 		act |= ICE_LG_ACT_VSI_LIST;
1441 	lg_act->pdata.lg_act.act[0] = CPU_TO_LE32(act);
1442 
1443 	/* Second action counter ID */
1444 	act = ICE_LG_ACT_STAT_COUNT;
1445 	act |= (counter_id << ICE_LG_ACT_STAT_COUNT_S) &
1446 		ICE_LG_ACT_STAT_COUNT_M;
1447 	lg_act->pdata.lg_act.act[1] = CPU_TO_LE32(act);
1448 
1449 	/* call the fill switch rule to fill the lookup Tx Rx structure */
1450 	ice_fill_sw_rule(hw, &m_ent->fltr_info, rx_tx,
1451 			 ice_aqc_opc_update_sw_rules);
1452 
1453 	act = ICE_SINGLE_ACT_PTR;
1454 	act |= (l_id << ICE_SINGLE_ACT_PTR_VAL_S) & ICE_SINGLE_ACT_PTR_VAL_M;
1455 	rx_tx->pdata.lkup_tx_rx.act = CPU_TO_LE32(act);
1456 
1457 	/* Use the filter rule ID of the previously created rule with single
1458 	 * act. Once the update happens, hardware will treat this as large
1459 	 * action
1460 	 */
1461 	f_rule_id = m_ent->fltr_info.fltr_rule_id;
1462 	rx_tx->pdata.lkup_tx_rx.index = CPU_TO_LE16(f_rule_id);
1463 
1464 	status = ice_aq_sw_rules(hw, lg_act, rules_size, 2,
1465 				 ice_aqc_opc_update_sw_rules, NULL);
1466 	if (!status) {
1467 		m_ent->lg_act_idx = l_id;
1468 		m_ent->counter_index = counter_id;
1469 	}
1470 
1471 	ice_free(hw, lg_act);
1472 	return status;
1473 }
1474 
1475 /**
1476  * ice_create_vsi_list_map
1477  * @hw: pointer to the hardware structure
1478  * @vsi_handle_arr: array of VSI handles to set in the VSI mapping
1479  * @num_vsi: number of VSI handles in the array
1480  * @vsi_list_id: VSI list ID generated as part of allocate resource
1481  *
1482  * Helper function to create a new entry of VSI list ID to VSI mapping
1483  * using the given VSI list ID
1484  */
1485 static struct ice_vsi_list_map_info *
1486 ice_create_vsi_list_map(struct ice_hw *hw, u16 *vsi_handle_arr, u16 num_vsi,
1487 			u16 vsi_list_id)
1488 {
1489 	struct ice_switch_info *sw = hw->switch_info;
1490 	struct ice_vsi_list_map_info *v_map;
1491 	int i;
1492 
1493 	v_map = (struct ice_vsi_list_map_info *)ice_malloc(hw, sizeof(*v_map));
1494 	if (!v_map)
1495 		return NULL;
1496 
1497 	v_map->vsi_list_id = vsi_list_id;
1498 	v_map->ref_cnt = 1;
1499 	for (i = 0; i < num_vsi; i++)
1500 		ice_set_bit(vsi_handle_arr[i], v_map->vsi_map);
1501 
1502 	LIST_ADD(&v_map->list_entry, &sw->vsi_list_map_head);
1503 	return v_map;
1504 }
1505 
1506 /**
1507  * ice_update_vsi_list_rule
1508  * @hw: pointer to the hardware structure
1509  * @vsi_handle_arr: array of VSI handles to form a VSI list
1510  * @num_vsi: number of VSI handles in the array
1511  * @vsi_list_id: VSI list ID generated as part of allocate resource
1512  * @remove: Boolean value to indicate if this is a remove action
1513  * @opc: switch rules population command type - pass in the command opcode
1514  * @lkup_type: lookup type of the filter
1515  *
1516  * Call AQ command to add a new switch rule or update existing switch rule
1517  * using the given VSI list ID
1518  */
1519 static enum ice_status
1520 ice_update_vsi_list_rule(struct ice_hw *hw, u16 *vsi_handle_arr, u16 num_vsi,
1521 			 u16 vsi_list_id, bool remove, enum ice_adminq_opc opc,
1522 			 enum ice_sw_lkup_type lkup_type)
1523 {
1524 	struct ice_aqc_sw_rules_elem *s_rule;
1525 	enum ice_status status;
1526 	u16 s_rule_size;
1527 	u16 rule_type;
1528 	int i;
1529 
1530 	if (!num_vsi)
1531 		return ICE_ERR_PARAM;
1532 
1533 	if (lkup_type == ICE_SW_LKUP_MAC ||
1534 	    lkup_type == ICE_SW_LKUP_MAC_VLAN ||
1535 	    lkup_type == ICE_SW_LKUP_ETHERTYPE ||
1536 	    lkup_type == ICE_SW_LKUP_ETHERTYPE_MAC ||
1537 	    lkup_type == ICE_SW_LKUP_PROMISC ||
1538 	    lkup_type == ICE_SW_LKUP_PROMISC_VLAN ||
1539 	    lkup_type == ICE_SW_LKUP_LAST)
1540 		rule_type = remove ? ICE_AQC_SW_RULES_T_VSI_LIST_CLEAR :
1541 			ICE_AQC_SW_RULES_T_VSI_LIST_SET;
1542 	else if (lkup_type == ICE_SW_LKUP_VLAN)
1543 		rule_type = remove ? ICE_AQC_SW_RULES_T_PRUNE_LIST_CLEAR :
1544 			ICE_AQC_SW_RULES_T_PRUNE_LIST_SET;
1545 	else
1546 		return ICE_ERR_PARAM;
1547 
1548 	s_rule_size = (u16)ICE_SW_RULE_VSI_LIST_SIZE(num_vsi);
1549 	s_rule = (struct ice_aqc_sw_rules_elem *)ice_malloc(hw, s_rule_size);
1550 	if (!s_rule)
1551 		return ICE_ERR_NO_MEMORY;
1552 	for (i = 0; i < num_vsi; i++) {
1553 		if (!ice_is_vsi_valid(hw, vsi_handle_arr[i])) {
1554 			status = ICE_ERR_PARAM;
1555 			goto exit;
1556 		}
1557 		/* AQ call requires hw_vsi_id(s) */
1558 		s_rule->pdata.vsi_list.vsi[i] =
1559 			CPU_TO_LE16(ice_get_hw_vsi_num(hw, vsi_handle_arr[i]));
1560 	}
1561 
1562 	s_rule->type = CPU_TO_LE16(rule_type);
1563 	s_rule->pdata.vsi_list.number_vsi = CPU_TO_LE16(num_vsi);
1564 	s_rule->pdata.vsi_list.index = CPU_TO_LE16(vsi_list_id);
1565 
1566 	status = ice_aq_sw_rules(hw, s_rule, s_rule_size, 1, opc, NULL);
1567 
1568 exit:
1569 	ice_free(hw, s_rule);
1570 	return status;
1571 }
1572 
1573 /**
1574  * ice_create_vsi_list_rule - Creates and populates a VSI list rule
1575  * @hw: pointer to the HW struct
1576  * @vsi_handle_arr: array of VSI handles to form a VSI list
1577  * @num_vsi: number of VSI handles in the array
1578  * @vsi_list_id: stores the ID of the VSI list to be created
1579  * @lkup_type: switch rule filter's lookup type
1580  */
1581 static enum ice_status
1582 ice_create_vsi_list_rule(struct ice_hw *hw, u16 *vsi_handle_arr, u16 num_vsi,
1583 			 u16 *vsi_list_id, enum ice_sw_lkup_type lkup_type)
1584 {
1585 	enum ice_status status;
1586 
1587 	status = ice_aq_alloc_free_vsi_list(hw, vsi_list_id, lkup_type,
1588 					    ice_aqc_opc_alloc_res);
1589 	if (status)
1590 		return status;
1591 
1592 	/* Update the newly created VSI list to include the specified VSIs */
1593 	return ice_update_vsi_list_rule(hw, vsi_handle_arr, num_vsi,
1594 					*vsi_list_id, false,
1595 					ice_aqc_opc_add_sw_rules, lkup_type);
1596 }
1597 
1598 /**
1599  * ice_create_pkt_fwd_rule
1600  * @hw: pointer to the hardware structure
1601  * @recp_list: corresponding filter management list
1602  * @f_entry: entry containing packet forwarding information
1603  *
1604  * Create switch rule with given filter information and add an entry
1605  * to the corresponding filter management list to track this switch rule
1606  * and VSI mapping
1607  */
1608 static enum ice_status
1609 ice_create_pkt_fwd_rule(struct ice_hw *hw, struct ice_sw_recipe *recp_list,
1610 			struct ice_fltr_list_entry *f_entry)
1611 {
1612 	struct ice_fltr_mgmt_list_entry *fm_entry;
1613 	struct ice_aqc_sw_rules_elem *s_rule;
1614 	enum ice_status status;
1615 
1616 	s_rule = (struct ice_aqc_sw_rules_elem *)
1617 		ice_malloc(hw, ICE_SW_RULE_RX_TX_ETH_HDR_SIZE);
1618 	if (!s_rule)
1619 		return ICE_ERR_NO_MEMORY;
1620 	fm_entry = (struct ice_fltr_mgmt_list_entry *)
1621 		   ice_malloc(hw, sizeof(*fm_entry));
1622 	if (!fm_entry) {
1623 		status = ICE_ERR_NO_MEMORY;
1624 		goto ice_create_pkt_fwd_rule_exit;
1625 	}
1626 
1627 	fm_entry->fltr_info = f_entry->fltr_info;
1628 
1629 	/* Initialize all the fields for the management entry */
1630 	fm_entry->vsi_count = 1;
1631 	fm_entry->lg_act_idx = ICE_INVAL_LG_ACT_INDEX;
1632 	fm_entry->sw_marker_id = ICE_INVAL_SW_MARKER_ID;
1633 	fm_entry->counter_index = ICE_INVAL_COUNTER_ID;
1634 
1635 	ice_fill_sw_rule(hw, &fm_entry->fltr_info, s_rule,
1636 			 ice_aqc_opc_add_sw_rules);
1637 
1638 	status = ice_aq_sw_rules(hw, s_rule, ICE_SW_RULE_RX_TX_ETH_HDR_SIZE, 1,
1639 				 ice_aqc_opc_add_sw_rules, NULL);
1640 	if (status) {
1641 		ice_free(hw, fm_entry);
1642 		goto ice_create_pkt_fwd_rule_exit;
1643 	}
1644 
1645 	f_entry->fltr_info.fltr_rule_id =
1646 		LE16_TO_CPU(s_rule->pdata.lkup_tx_rx.index);
1647 	fm_entry->fltr_info.fltr_rule_id =
1648 		LE16_TO_CPU(s_rule->pdata.lkup_tx_rx.index);
1649 
1650 	/* The book keeping entries will get removed when base driver
1651 	 * calls remove filter AQ command
1652 	 */
1653 	LIST_ADD(&fm_entry->list_entry, &recp_list->filt_rules);
1654 
1655 ice_create_pkt_fwd_rule_exit:
1656 	ice_free(hw, s_rule);
1657 	return status;
1658 }
1659 
1660 /**
1661  * ice_update_pkt_fwd_rule
1662  * @hw: pointer to the hardware structure
1663  * @f_info: filter information for switch rule
1664  *
1665  * Call AQ command to update a previously created switch rule with a
1666  * VSI list ID
1667  */
1668 static enum ice_status
1669 ice_update_pkt_fwd_rule(struct ice_hw *hw, struct ice_fltr_info *f_info)
1670 {
1671 	struct ice_aqc_sw_rules_elem *s_rule;
1672 	enum ice_status status;
1673 
1674 	s_rule = (struct ice_aqc_sw_rules_elem *)
1675 		ice_malloc(hw, ICE_SW_RULE_RX_TX_ETH_HDR_SIZE);
1676 	if (!s_rule)
1677 		return ICE_ERR_NO_MEMORY;
1678 
1679 	ice_fill_sw_rule(hw, f_info, s_rule, ice_aqc_opc_update_sw_rules);
1680 
1681 	s_rule->pdata.lkup_tx_rx.index = CPU_TO_LE16(f_info->fltr_rule_id);
1682 
1683 	/* Update switch rule with new rule set to forward VSI list */
1684 	status = ice_aq_sw_rules(hw, s_rule, ICE_SW_RULE_RX_TX_ETH_HDR_SIZE, 1,
1685 				 ice_aqc_opc_update_sw_rules, NULL);
1686 
1687 	ice_free(hw, s_rule);
1688 	return status;
1689 }
1690 
1691 /**
1692  * ice_update_sw_rule_bridge_mode
1693  * @hw: pointer to the HW struct
1694  *
1695  * Updates unicast switch filter rules based on VEB/VEPA mode
1696  */
1697 enum ice_status ice_update_sw_rule_bridge_mode(struct ice_hw *hw)
1698 {
1699 	struct ice_switch_info *sw = hw->switch_info;
1700 	struct ice_fltr_mgmt_list_entry *fm_entry;
1701 	enum ice_status status = ICE_SUCCESS;
1702 	struct LIST_HEAD_TYPE *rule_head;
1703 	struct ice_lock *rule_lock; /* Lock to protect filter rule list */
1704 
1705 	rule_lock = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock;
1706 	rule_head = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rules;
1707 
1708 	ice_acquire_lock(rule_lock);
1709 	LIST_FOR_EACH_ENTRY(fm_entry, rule_head, ice_fltr_mgmt_list_entry,
1710 			    list_entry) {
1711 		struct ice_fltr_info *fi = &fm_entry->fltr_info;
1712 		u8 *addr = fi->l_data.mac.mac_addr;
1713 
1714 		/* Update unicast Tx rules to reflect the selected
1715 		 * VEB/VEPA mode
1716 		 */
1717 		if ((fi->flag & ICE_FLTR_TX) && IS_UNICAST_ETHER_ADDR(addr) &&
1718 		    (fi->fltr_act == ICE_FWD_TO_VSI ||
1719 		     fi->fltr_act == ICE_FWD_TO_VSI_LIST ||
1720 		     fi->fltr_act == ICE_FWD_TO_Q ||
1721 		     fi->fltr_act == ICE_FWD_TO_QGRP)) {
1722 			status = ice_update_pkt_fwd_rule(hw, fi);
1723 			if (status)
1724 				break;
1725 		}
1726 	}
1727 
1728 	ice_release_lock(rule_lock);
1729 
1730 	return status;
1731 }
1732 
1733 /**
1734  * ice_add_update_vsi_list
1735  * @hw: pointer to the hardware structure
1736  * @m_entry: pointer to current filter management list entry
1737  * @cur_fltr: filter information from the book keeping entry
1738  * @new_fltr: filter information with the new VSI to be added
1739  *
1740  * Call AQ command to add or update previously created VSI list with new VSI.
1741  *
1742  * Helper function to do book keeping associated with adding filter information
1743  * The algorithm to do the book keeping is described below :
1744  * When a VSI needs to subscribe to a given filter (MAC/VLAN/Ethtype etc.)
1745  *	if only one VSI has been added till now
1746  *		Allocate a new VSI list and add two VSIs
1747  *		to this list using switch rule command
1748  *		Update the previously created switch rule with the
1749  *		newly created VSI list ID
1750  *	if a VSI list was previously created
1751  *		Add the new VSI to the previously created VSI list set
1752  *		using the update switch rule command
1753  */
1754 static enum ice_status
1755 ice_add_update_vsi_list(struct ice_hw *hw,
1756 			struct ice_fltr_mgmt_list_entry *m_entry,
1757 			struct ice_fltr_info *cur_fltr,
1758 			struct ice_fltr_info *new_fltr)
1759 {
1760 	enum ice_status status = ICE_SUCCESS;
1761 	u16 vsi_list_id = 0;
1762 
1763 	if ((cur_fltr->fltr_act == ICE_FWD_TO_Q ||
1764 	     cur_fltr->fltr_act == ICE_FWD_TO_QGRP))
1765 		return ICE_ERR_NOT_IMPL;
1766 
1767 	if ((new_fltr->fltr_act == ICE_FWD_TO_Q ||
1768 	     new_fltr->fltr_act == ICE_FWD_TO_QGRP) &&
1769 	    (cur_fltr->fltr_act == ICE_FWD_TO_VSI ||
1770 	     cur_fltr->fltr_act == ICE_FWD_TO_VSI_LIST))
1771 		return ICE_ERR_NOT_IMPL;
1772 
1773 	if (m_entry->vsi_count < 2 && !m_entry->vsi_list_info) {
1774 		/* Only one entry existed in the mapping and it was not already
1775 		 * a part of a VSI list. So, create a VSI list with the old and
1776 		 * new VSIs.
1777 		 */
1778 		struct ice_fltr_info tmp_fltr;
1779 		u16 vsi_handle_arr[2];
1780 
1781 		/* A rule already exists with the new VSI being added */
1782 		if (cur_fltr->fwd_id.hw_vsi_id == new_fltr->fwd_id.hw_vsi_id)
1783 			return ICE_ERR_ALREADY_EXISTS;
1784 
1785 		vsi_handle_arr[0] = cur_fltr->vsi_handle;
1786 		vsi_handle_arr[1] = new_fltr->vsi_handle;
1787 		status = ice_create_vsi_list_rule(hw, &vsi_handle_arr[0], 2,
1788 						  &vsi_list_id,
1789 						  new_fltr->lkup_type);
1790 		if (status)
1791 			return status;
1792 
1793 		tmp_fltr = *new_fltr;
1794 		tmp_fltr.fltr_rule_id = cur_fltr->fltr_rule_id;
1795 		tmp_fltr.fltr_act = ICE_FWD_TO_VSI_LIST;
1796 		tmp_fltr.fwd_id.vsi_list_id = vsi_list_id;
1797 		/* Update the previous switch rule of "MAC forward to VSI" to
1798 		 * "MAC fwd to VSI list"
1799 		 */
1800 		status = ice_update_pkt_fwd_rule(hw, &tmp_fltr);
1801 		if (status)
1802 			return status;
1803 
1804 		cur_fltr->fwd_id.vsi_list_id = vsi_list_id;
1805 		cur_fltr->fltr_act = ICE_FWD_TO_VSI_LIST;
1806 		m_entry->vsi_list_info =
1807 			ice_create_vsi_list_map(hw, &vsi_handle_arr[0], 2,
1808 						vsi_list_id);
1809 
1810 		/* If this entry was large action then the large action needs
1811 		 * to be updated to point to FWD to VSI list
1812 		 */
1813 		if (m_entry->sw_marker_id != ICE_INVAL_SW_MARKER_ID)
1814 			status =
1815 			    ice_add_marker_act(hw, m_entry,
1816 					       m_entry->sw_marker_id,
1817 					       m_entry->lg_act_idx);
1818 	} else {
1819 		u16 vsi_handle = new_fltr->vsi_handle;
1820 		enum ice_adminq_opc opcode;
1821 
1822 		if (!m_entry->vsi_list_info)
1823 			return ICE_ERR_CFG;
1824 
1825 		/* A rule already exists with the new VSI being added */
1826 		if (ice_is_bit_set(m_entry->vsi_list_info->vsi_map, vsi_handle))
1827 			return ICE_SUCCESS;
1828 
1829 		/* Update the previously created VSI list set with
1830 		 * the new VSI ID passed in
1831 		 */
1832 		vsi_list_id = cur_fltr->fwd_id.vsi_list_id;
1833 		opcode = ice_aqc_opc_update_sw_rules;
1834 
1835 		status = ice_update_vsi_list_rule(hw, &vsi_handle, 1,
1836 						  vsi_list_id, false, opcode,
1837 						  new_fltr->lkup_type);
1838 		/* update VSI list mapping info with new VSI ID */
1839 		if (!status)
1840 			ice_set_bit(vsi_handle,
1841 				    m_entry->vsi_list_info->vsi_map);
1842 	}
1843 	if (!status)
1844 		m_entry->vsi_count++;
1845 	return status;
1846 }
1847 
1848 /**
1849  * ice_find_rule_entry - Search a rule entry
1850  * @list_head: head of rule list
1851  * @f_info: rule information
1852  *
1853  * Helper function to search for a given rule entry
1854  * Returns pointer to entry storing the rule if found
1855  */
1856 static struct ice_fltr_mgmt_list_entry *
1857 ice_find_rule_entry(struct LIST_HEAD_TYPE *list_head,
1858 		    struct ice_fltr_info *f_info)
1859 {
1860 	struct ice_fltr_mgmt_list_entry *list_itr, *ret = NULL;
1861 
1862 	LIST_FOR_EACH_ENTRY(list_itr, list_head, ice_fltr_mgmt_list_entry,
1863 			    list_entry) {
1864 		if (!memcmp(&f_info->l_data, &list_itr->fltr_info.l_data,
1865 			    sizeof(f_info->l_data)) &&
1866 		    f_info->flag == list_itr->fltr_info.flag) {
1867 			ret = list_itr;
1868 			break;
1869 		}
1870 	}
1871 	return ret;
1872 }
1873 
1874 /**
1875  * ice_find_vsi_list_entry - Search VSI list map with VSI count 1
1876  * @recp_list: VSI lists needs to be searched
1877  * @vsi_handle: VSI handle to be found in VSI list
1878  * @vsi_list_id: VSI list ID found containing vsi_handle
1879  *
1880  * Helper function to search a VSI list with single entry containing given VSI
1881  * handle element. This can be extended further to search VSI list with more
1882  * than 1 vsi_count. Returns pointer to VSI list entry if found.
1883  */
1884 static struct ice_vsi_list_map_info *
1885 ice_find_vsi_list_entry(struct ice_sw_recipe *recp_list, u16 vsi_handle,
1886 			u16 *vsi_list_id)
1887 {
1888 	struct ice_vsi_list_map_info *map_info = NULL;
1889 	struct LIST_HEAD_TYPE *list_head;
1890 
1891 	list_head = &recp_list->filt_rules;
1892 	if (recp_list->adv_rule) {
1893 		struct ice_adv_fltr_mgmt_list_entry *list_itr;
1894 
1895 		LIST_FOR_EACH_ENTRY(list_itr, list_head,
1896 				    ice_adv_fltr_mgmt_list_entry,
1897 				    list_entry) {
1898 			if (list_itr->vsi_list_info) {
1899 				map_info = list_itr->vsi_list_info;
1900 				if (ice_is_bit_set(map_info->vsi_map,
1901 						   vsi_handle)) {
1902 					*vsi_list_id = map_info->vsi_list_id;
1903 					return map_info;
1904 				}
1905 			}
1906 		}
1907 	} else {
1908 		struct ice_fltr_mgmt_list_entry *list_itr;
1909 
1910 		LIST_FOR_EACH_ENTRY(list_itr, list_head,
1911 				    ice_fltr_mgmt_list_entry,
1912 				    list_entry) {
1913 			if (list_itr->vsi_count == 1 &&
1914 			    list_itr->vsi_list_info) {
1915 				map_info = list_itr->vsi_list_info;
1916 				if (ice_is_bit_set(map_info->vsi_map,
1917 						   vsi_handle)) {
1918 					*vsi_list_id = map_info->vsi_list_id;
1919 					return map_info;
1920 				}
1921 			}
1922 		}
1923 	}
1924 	return NULL;
1925 }
1926 
1927 /**
1928  * ice_add_rule_internal - add rule for a given lookup type
1929  * @hw: pointer to the hardware structure
1930  * @recp_list: recipe list for which rule has to be added
1931  * @lport: logic port number on which function add rule
1932  * @f_entry: structure containing MAC forwarding information
1933  *
1934  * Adds or updates the rule lists for a given recipe
1935  */
1936 static enum ice_status
1937 ice_add_rule_internal(struct ice_hw *hw, struct ice_sw_recipe *recp_list,
1938 		      u8 lport, struct ice_fltr_list_entry *f_entry)
1939 {
1940 	struct ice_fltr_info *new_fltr, *cur_fltr;
1941 	struct ice_fltr_mgmt_list_entry *m_entry;
1942 	struct ice_lock *rule_lock; /* Lock to protect filter rule list */
1943 	enum ice_status status = ICE_SUCCESS;
1944 
1945 	if (!ice_is_vsi_valid(hw, f_entry->fltr_info.vsi_handle))
1946 		return ICE_ERR_PARAM;
1947 
1948 	/* Load the hw_vsi_id only if the fwd action is fwd to VSI */
1949 	if (f_entry->fltr_info.fltr_act == ICE_FWD_TO_VSI)
1950 		f_entry->fltr_info.fwd_id.hw_vsi_id =
1951 			ice_get_hw_vsi_num(hw, f_entry->fltr_info.vsi_handle);
1952 
1953 	rule_lock = &recp_list->filt_rule_lock;
1954 
1955 	ice_acquire_lock(rule_lock);
1956 	new_fltr = &f_entry->fltr_info;
1957 	if (new_fltr->flag & ICE_FLTR_RX)
1958 		new_fltr->src = lport;
1959 	else if (new_fltr->flag & ICE_FLTR_TX)
1960 		new_fltr->src =
1961 			ice_get_hw_vsi_num(hw, f_entry->fltr_info.vsi_handle);
1962 
1963 	m_entry = ice_find_rule_entry(&recp_list->filt_rules, new_fltr);
1964 	if (!m_entry) {
1965 		status = ice_create_pkt_fwd_rule(hw, recp_list, f_entry);
1966 		goto exit_add_rule_internal;
1967 	}
1968 
1969 	cur_fltr = &m_entry->fltr_info;
1970 	status = ice_add_update_vsi_list(hw, m_entry, cur_fltr, new_fltr);
1971 
1972 exit_add_rule_internal:
1973 	ice_release_lock(rule_lock);
1974 	return status;
1975 }
1976 
1977 /**
1978  * ice_remove_vsi_list_rule
1979  * @hw: pointer to the hardware structure
1980  * @vsi_list_id: VSI list ID generated as part of allocate resource
1981  * @lkup_type: switch rule filter lookup type
1982  *
1983  * The VSI list should be emptied before this function is called to remove the
1984  * VSI list.
1985  */
1986 static enum ice_status
1987 ice_remove_vsi_list_rule(struct ice_hw *hw, u16 vsi_list_id,
1988 			 enum ice_sw_lkup_type lkup_type)
1989 {
1990 	/* Free the vsi_list resource that we allocated. It is assumed that the
1991 	 * list is empty at this point.
1992 	 */
1993 	return ice_aq_alloc_free_vsi_list(hw, &vsi_list_id, lkup_type,
1994 					    ice_aqc_opc_free_res);
1995 }
1996 
1997 /**
1998  * ice_rem_update_vsi_list
1999  * @hw: pointer to the hardware structure
2000  * @vsi_handle: VSI handle of the VSI to remove
2001  * @fm_list: filter management entry for which the VSI list management needs to
2002  *	     be done
2003  */
2004 static enum ice_status
2005 ice_rem_update_vsi_list(struct ice_hw *hw, u16 vsi_handle,
2006 			struct ice_fltr_mgmt_list_entry *fm_list)
2007 {
2008 	enum ice_sw_lkup_type lkup_type;
2009 	enum ice_status status = ICE_SUCCESS;
2010 	u16 vsi_list_id;
2011 
2012 	if (fm_list->fltr_info.fltr_act != ICE_FWD_TO_VSI_LIST ||
2013 	    fm_list->vsi_count == 0)
2014 		return ICE_ERR_PARAM;
2015 
2016 	/* A rule with the VSI being removed does not exist */
2017 	if (!ice_is_bit_set(fm_list->vsi_list_info->vsi_map, vsi_handle))
2018 		return ICE_ERR_DOES_NOT_EXIST;
2019 
2020 	lkup_type = fm_list->fltr_info.lkup_type;
2021 	vsi_list_id = fm_list->fltr_info.fwd_id.vsi_list_id;
2022 	status = ice_update_vsi_list_rule(hw, &vsi_handle, 1, vsi_list_id, true,
2023 					  ice_aqc_opc_update_sw_rules,
2024 					  lkup_type);
2025 	if (status)
2026 		return status;
2027 
2028 	fm_list->vsi_count--;
2029 	ice_clear_bit(vsi_handle, fm_list->vsi_list_info->vsi_map);
2030 
2031 	if (fm_list->vsi_count == 1 && lkup_type != ICE_SW_LKUP_VLAN) {
2032 		struct ice_fltr_info tmp_fltr_info = fm_list->fltr_info;
2033 		struct ice_vsi_list_map_info *vsi_list_info =
2034 			fm_list->vsi_list_info;
2035 		u16 rem_vsi_handle;
2036 
2037 		rem_vsi_handle = ice_find_first_bit(vsi_list_info->vsi_map,
2038 						    ICE_MAX_VSI);
2039 		if (!ice_is_vsi_valid(hw, rem_vsi_handle))
2040 			return ICE_ERR_OUT_OF_RANGE;
2041 
2042 		/* Make sure VSI list is empty before removing it below */
2043 		status = ice_update_vsi_list_rule(hw, &rem_vsi_handle, 1,
2044 						  vsi_list_id, true,
2045 						  ice_aqc_opc_update_sw_rules,
2046 						  lkup_type);
2047 		if (status)
2048 			return status;
2049 
2050 		tmp_fltr_info.fltr_act = ICE_FWD_TO_VSI;
2051 		tmp_fltr_info.fwd_id.hw_vsi_id =
2052 			ice_get_hw_vsi_num(hw, rem_vsi_handle);
2053 		tmp_fltr_info.vsi_handle = rem_vsi_handle;
2054 		status = ice_update_pkt_fwd_rule(hw, &tmp_fltr_info);
2055 		if (status) {
2056 			ice_debug(hw, ICE_DBG_SW, "Failed to update pkt fwd rule to FWD_TO_VSI on HW VSI %d, error %d\n",
2057 				  tmp_fltr_info.fwd_id.hw_vsi_id, status);
2058 			return status;
2059 		}
2060 
2061 		fm_list->fltr_info = tmp_fltr_info;
2062 	}
2063 
2064 	if ((fm_list->vsi_count == 1 && lkup_type != ICE_SW_LKUP_VLAN) ||
2065 	    (fm_list->vsi_count == 0 && lkup_type == ICE_SW_LKUP_VLAN)) {
2066 		struct ice_vsi_list_map_info *vsi_list_info =
2067 			fm_list->vsi_list_info;
2068 
2069 		/* Remove the VSI list since it is no longer used */
2070 		status = ice_remove_vsi_list_rule(hw, vsi_list_id, lkup_type);
2071 		if (status) {
2072 			ice_debug(hw, ICE_DBG_SW, "Failed to remove VSI list %d, error %d\n",
2073 				  vsi_list_id, status);
2074 			return status;
2075 		}
2076 
2077 		LIST_DEL(&vsi_list_info->list_entry);
2078 		ice_free(hw, vsi_list_info);
2079 		fm_list->vsi_list_info = NULL;
2080 	}
2081 
2082 	return status;
2083 }
2084 
2085 /**
2086  * ice_remove_rule_internal - Remove a filter rule of a given type
2087  *
2088  * @hw: pointer to the hardware structure
2089  * @recp_list: recipe list for which the rule needs to removed
2090  * @f_entry: rule entry containing filter information
2091  */
2092 static enum ice_status
2093 ice_remove_rule_internal(struct ice_hw *hw, struct ice_sw_recipe *recp_list,
2094 			 struct ice_fltr_list_entry *f_entry)
2095 {
2096 	struct ice_fltr_mgmt_list_entry *list_elem;
2097 	struct ice_lock *rule_lock; /* Lock to protect filter rule list */
2098 	enum ice_status status = ICE_SUCCESS;
2099 	bool remove_rule = false;
2100 	u16 vsi_handle;
2101 
2102 	if (!ice_is_vsi_valid(hw, f_entry->fltr_info.vsi_handle))
2103 		return ICE_ERR_PARAM;
2104 	f_entry->fltr_info.fwd_id.hw_vsi_id =
2105 		ice_get_hw_vsi_num(hw, f_entry->fltr_info.vsi_handle);
2106 
2107 	rule_lock = &recp_list->filt_rule_lock;
2108 	ice_acquire_lock(rule_lock);
2109 	list_elem = ice_find_rule_entry(&recp_list->filt_rules,
2110 					&f_entry->fltr_info);
2111 	if (!list_elem) {
2112 		status = ICE_ERR_DOES_NOT_EXIST;
2113 		goto exit;
2114 	}
2115 
2116 	if (list_elem->fltr_info.fltr_act != ICE_FWD_TO_VSI_LIST) {
2117 		remove_rule = true;
2118 	} else if (!list_elem->vsi_list_info) {
2119 		status = ICE_ERR_DOES_NOT_EXIST;
2120 		goto exit;
2121 	} else if (list_elem->vsi_list_info->ref_cnt > 1) {
2122 		/* a ref_cnt > 1 indicates that the vsi_list is being
2123 		 * shared by multiple rules. Decrement the ref_cnt and
2124 		 * remove this rule, but do not modify the list, as it
2125 		 * is in-use by other rules.
2126 		 */
2127 		list_elem->vsi_list_info->ref_cnt--;
2128 		remove_rule = true;
2129 	} else {
2130 		/* a ref_cnt of 1 indicates the vsi_list is only used
2131 		 * by one rule. However, the original removal request is only
2132 		 * for a single VSI. Update the vsi_list first, and only
2133 		 * remove the rule if there are no further VSIs in this list.
2134 		 */
2135 		vsi_handle = f_entry->fltr_info.vsi_handle;
2136 		status = ice_rem_update_vsi_list(hw, vsi_handle, list_elem);
2137 		if (status)
2138 			goto exit;
2139 		/* if VSI count goes to zero after updating the VSI list */
2140 		if (list_elem->vsi_count == 0)
2141 			remove_rule = true;
2142 	}
2143 
2144 	if (remove_rule) {
2145 		/* Remove the lookup rule */
2146 		struct ice_aqc_sw_rules_elem *s_rule;
2147 
2148 		s_rule = (struct ice_aqc_sw_rules_elem *)
2149 			ice_malloc(hw, ICE_SW_RULE_RX_TX_NO_HDR_SIZE);
2150 		if (!s_rule) {
2151 			status = ICE_ERR_NO_MEMORY;
2152 			goto exit;
2153 		}
2154 
2155 		ice_fill_sw_rule(hw, &list_elem->fltr_info, s_rule,
2156 				 ice_aqc_opc_remove_sw_rules);
2157 
2158 		status = ice_aq_sw_rules(hw, s_rule,
2159 					 ICE_SW_RULE_RX_TX_NO_HDR_SIZE, 1,
2160 					 ice_aqc_opc_remove_sw_rules, NULL);
2161 
2162 		/* Remove a book keeping from the list */
2163 		ice_free(hw, s_rule);
2164 
2165 		if (status)
2166 			goto exit;
2167 
2168 		LIST_DEL(&list_elem->list_entry);
2169 		ice_free(hw, list_elem);
2170 	}
2171 exit:
2172 	ice_release_lock(rule_lock);
2173 	return status;
2174 }
2175 
2176 /**
2177  * ice_aq_get_res_alloc - get allocated resources
2178  * @hw: pointer to the HW struct
2179  * @num_entries: pointer to u16 to store the number of resource entries returned
2180  * @buf: pointer to buffer
2181  * @buf_size: size of buf
2182  * @cd: pointer to command details structure or NULL
2183  *
2184  * The caller-supplied buffer must be large enough to store the resource
2185  * information for all resource types. Each resource type is an
2186  * ice_aqc_get_res_resp_elem structure.
2187  */
2188 enum ice_status
2189 ice_aq_get_res_alloc(struct ice_hw *hw, u16 *num_entries,
2190 		     struct ice_aqc_get_res_resp_elem *buf, u16 buf_size,
2191 		     struct ice_sq_cd *cd)
2192 {
2193 	struct ice_aqc_get_res_alloc *resp;
2194 	enum ice_status status;
2195 	struct ice_aq_desc desc;
2196 
2197 	if (!buf)
2198 		return ICE_ERR_BAD_PTR;
2199 
2200 	if (buf_size < ICE_AQ_GET_RES_ALLOC_BUF_LEN)
2201 		return ICE_ERR_INVAL_SIZE;
2202 
2203 	resp = &desc.params.get_res;
2204 
2205 	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_res_alloc);
2206 	status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd);
2207 
2208 	if (!status && num_entries)
2209 		*num_entries = LE16_TO_CPU(resp->resp_elem_num);
2210 
2211 	return status;
2212 }
2213 
2214 /**
2215  * ice_aq_get_res_descs - get allocated resource descriptors
2216  * @hw: pointer to the hardware structure
2217  * @num_entries: number of resource entries in buffer
2218  * @buf: structure to hold response data buffer
2219  * @buf_size: size of buffer
2220  * @res_type: resource type
2221  * @res_shared: is resource shared
2222  * @desc_id: input - first desc ID to start; output - next desc ID
2223  * @cd: pointer to command details structure or NULL
2224  */
2225 enum ice_status
2226 ice_aq_get_res_descs(struct ice_hw *hw, u16 num_entries,
2227 		     struct ice_aqc_res_elem *buf, u16 buf_size, u16 res_type,
2228 		     bool res_shared, u16 *desc_id, struct ice_sq_cd *cd)
2229 {
2230 	struct ice_aqc_get_allocd_res_desc *cmd;
2231 	struct ice_aq_desc desc;
2232 	enum ice_status status;
2233 
2234 	ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
2235 
2236 	cmd = &desc.params.get_res_desc;
2237 
2238 	if (!buf)
2239 		return ICE_ERR_PARAM;
2240 
2241 	if (buf_size != (num_entries * sizeof(*buf)))
2242 		return ICE_ERR_PARAM;
2243 
2244 	ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_allocd_res_desc);
2245 
2246 	cmd->ops.cmd.res = CPU_TO_LE16(((res_type << ICE_AQC_RES_TYPE_S) &
2247 					 ICE_AQC_RES_TYPE_M) | (res_shared ?
2248 					ICE_AQC_RES_TYPE_FLAG_SHARED : 0));
2249 	cmd->ops.cmd.first_desc = CPU_TO_LE16(*desc_id);
2250 
2251 	status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd);
2252 	if (!status)
2253 		*desc_id = LE16_TO_CPU(cmd->ops.resp.next_desc);
2254 
2255 	return status;
2256 }
2257 
2258 /**
2259  * ice_add_mac_rule - Add a MAC address based filter rule
2260  * @hw: pointer to the hardware structure
2261  * @m_list: list of MAC addresses and forwarding information
2262  * @sw: pointer to switch info struct for which function add rule
2263  * @lport: logic port number on which function add rule
2264  *
2265  * IMPORTANT: When the ucast_shared flag is set to false and m_list has
2266  * multiple unicast addresses, the function assumes that all the
2267  * addresses are unique in a given add_mac call. It doesn't
2268  * check for duplicates in this case, removing duplicates from a given
2269  * list should be taken care of in the caller of this function.
2270  */
2271 static enum ice_status
2272 ice_add_mac_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *m_list,
2273 		 struct ice_switch_info *sw, u8 lport)
2274 {
2275 	struct ice_sw_recipe *recp_list = &sw->recp_list[ICE_SW_LKUP_MAC];
2276 	struct ice_aqc_sw_rules_elem *s_rule, *r_iter;
2277 	struct ice_fltr_list_entry *m_list_itr;
2278 	struct LIST_HEAD_TYPE *rule_head;
2279 	u16 total_elem_left, s_rule_size;
2280 	struct ice_lock *rule_lock; /* Lock to protect filter rule list */
2281 	enum ice_status status = ICE_SUCCESS;
2282 	u16 num_unicast = 0;
2283 	u8 elem_sent;
2284 
2285 	s_rule = NULL;
2286 	rule_lock = &recp_list->filt_rule_lock;
2287 	rule_head = &recp_list->filt_rules;
2288 
2289 	LIST_FOR_EACH_ENTRY(m_list_itr, m_list, ice_fltr_list_entry,
2290 			    list_entry) {
2291 		u8 *add = &m_list_itr->fltr_info.l_data.mac.mac_addr[0];
2292 		u16 vsi_handle;
2293 		u16 hw_vsi_id;
2294 
2295 		m_list_itr->fltr_info.flag = ICE_FLTR_TX;
2296 		vsi_handle = m_list_itr->fltr_info.vsi_handle;
2297 		if (!ice_is_vsi_valid(hw, vsi_handle))
2298 			return ICE_ERR_PARAM;
2299 		hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle);
2300 		m_list_itr->fltr_info.fwd_id.hw_vsi_id = hw_vsi_id;
2301 		/* update the src in case it is VSI num */
2302 		if (m_list_itr->fltr_info.src_id != ICE_SRC_ID_VSI)
2303 			return ICE_ERR_PARAM;
2304 		m_list_itr->fltr_info.src = hw_vsi_id;
2305 		if (m_list_itr->fltr_info.lkup_type != ICE_SW_LKUP_MAC ||
2306 		    IS_ZERO_ETHER_ADDR(add))
2307 			return ICE_ERR_PARAM;
2308 		if (IS_UNICAST_ETHER_ADDR(add) && !hw->ucast_shared) {
2309 			/* Don't overwrite the unicast address */
2310 			ice_acquire_lock(rule_lock);
2311 			if (ice_find_rule_entry(rule_head,
2312 						&m_list_itr->fltr_info)) {
2313 				ice_release_lock(rule_lock);
2314 				return ICE_ERR_ALREADY_EXISTS;
2315 			}
2316 			ice_release_lock(rule_lock);
2317 			num_unicast++;
2318 		} else if (IS_MULTICAST_ETHER_ADDR(add) ||
2319 			   (IS_UNICAST_ETHER_ADDR(add) && hw->ucast_shared)) {
2320 			m_list_itr->status =
2321 				ice_add_rule_internal(hw, recp_list, lport,
2322 						      m_list_itr);
2323 			if (m_list_itr->status)
2324 				return m_list_itr->status;
2325 		}
2326 	}
2327 
2328 	ice_acquire_lock(rule_lock);
2329 	/* Exit if no suitable entries were found for adding bulk switch rule */
2330 	if (!num_unicast) {
2331 		status = ICE_SUCCESS;
2332 		goto ice_add_mac_exit;
2333 	}
2334 
2335 	/* Allocate switch rule buffer for the bulk update for unicast */
2336 	s_rule_size = ICE_SW_RULE_RX_TX_ETH_HDR_SIZE;
2337 	s_rule = (struct ice_aqc_sw_rules_elem *)
2338 		ice_calloc(hw, num_unicast, s_rule_size);
2339 	if (!s_rule) {
2340 		status = ICE_ERR_NO_MEMORY;
2341 		goto ice_add_mac_exit;
2342 	}
2343 
2344 	r_iter = s_rule;
2345 	LIST_FOR_EACH_ENTRY(m_list_itr, m_list, ice_fltr_list_entry,
2346 			    list_entry) {
2347 		struct ice_fltr_info *f_info = &m_list_itr->fltr_info;
2348 		u8 *mac_addr = &f_info->l_data.mac.mac_addr[0];
2349 
2350 		if (IS_UNICAST_ETHER_ADDR(mac_addr)) {
2351 			ice_fill_sw_rule(hw, &m_list_itr->fltr_info, r_iter,
2352 					 ice_aqc_opc_add_sw_rules);
2353 			r_iter = (struct ice_aqc_sw_rules_elem *)
2354 				((u8 *)r_iter + s_rule_size);
2355 		}
2356 	}
2357 
2358 	/* Call AQ bulk switch rule update for all unicast addresses */
2359 	r_iter = s_rule;
2360 	/* Call AQ switch rule in AQ_MAX chunk */
2361 	for (total_elem_left = num_unicast; total_elem_left > 0;
2362 	     total_elem_left -= elem_sent) {
2363 		struct ice_aqc_sw_rules_elem *entry = r_iter;
2364 
2365 		elem_sent = MIN_T(u8, total_elem_left,
2366 				  (ICE_AQ_MAX_BUF_LEN / s_rule_size));
2367 		status = ice_aq_sw_rules(hw, entry, elem_sent * s_rule_size,
2368 					 elem_sent, ice_aqc_opc_add_sw_rules,
2369 					 NULL);
2370 		if (status)
2371 			goto ice_add_mac_exit;
2372 		r_iter = (struct ice_aqc_sw_rules_elem *)
2373 			((u8 *)r_iter + (elem_sent * s_rule_size));
2374 	}
2375 
2376 	/* Fill up rule ID based on the value returned from FW */
2377 	r_iter = s_rule;
2378 	LIST_FOR_EACH_ENTRY(m_list_itr, m_list, ice_fltr_list_entry,
2379 			    list_entry) {
2380 		struct ice_fltr_info *f_info = &m_list_itr->fltr_info;
2381 		u8 *mac_addr = &f_info->l_data.mac.mac_addr[0];
2382 		struct ice_fltr_mgmt_list_entry *fm_entry;
2383 
2384 		if (IS_UNICAST_ETHER_ADDR(mac_addr)) {
2385 			f_info->fltr_rule_id =
2386 				LE16_TO_CPU(r_iter->pdata.lkup_tx_rx.index);
2387 			f_info->fltr_act = ICE_FWD_TO_VSI;
2388 			/* Create an entry to track this MAC address */
2389 			fm_entry = (struct ice_fltr_mgmt_list_entry *)
2390 				ice_malloc(hw, sizeof(*fm_entry));
2391 			if (!fm_entry) {
2392 				status = ICE_ERR_NO_MEMORY;
2393 				goto ice_add_mac_exit;
2394 			}
2395 			fm_entry->fltr_info = *f_info;
2396 			fm_entry->vsi_count = 1;
2397 			/* The book keeping entries will get removed when
2398 			 * base driver calls remove filter AQ command
2399 			 */
2400 
2401 			LIST_ADD(&fm_entry->list_entry, rule_head);
2402 			r_iter = (struct ice_aqc_sw_rules_elem *)
2403 				((u8 *)r_iter + s_rule_size);
2404 		}
2405 	}
2406 
2407 ice_add_mac_exit:
2408 	ice_release_lock(rule_lock);
2409 	if (s_rule)
2410 		ice_free(hw, s_rule);
2411 	return status;
2412 }
2413 
2414 /**
2415  * ice_add_mac - Add a MAC address based filter rule
2416  * @hw: pointer to the hardware structure
2417  * @m_list: list of MAC addresses and forwarding information
2418  *
2419  * Function add MAC rule for logical port from HW struct
2420  */
2421 enum ice_status ice_add_mac(struct ice_hw *hw, struct LIST_HEAD_TYPE *m_list)
2422 {
2423 	if (!m_list || !hw)
2424 		return ICE_ERR_PARAM;
2425 
2426 	return ice_add_mac_rule(hw, m_list, hw->switch_info,
2427 				hw->port_info->lport);
2428 }
2429 
2430 /**
2431  * ice_add_vlan_internal - Add one VLAN based filter rule
2432  * @hw: pointer to the hardware structure
2433  * @recp_list: recipe list for which rule has to be added
2434  * @f_entry: filter entry containing one VLAN information
2435  */
2436 static enum ice_status
2437 ice_add_vlan_internal(struct ice_hw *hw, struct ice_sw_recipe *recp_list,
2438 		      struct ice_fltr_list_entry *f_entry)
2439 {
2440 	struct ice_fltr_mgmt_list_entry *v_list_itr;
2441 	struct ice_fltr_info *new_fltr, *cur_fltr;
2442 	enum ice_sw_lkup_type lkup_type;
2443 	u16 vsi_list_id = 0, vsi_handle;
2444 	struct ice_lock *rule_lock; /* Lock to protect filter rule list */
2445 	enum ice_status status = ICE_SUCCESS;
2446 
2447 	if (!ice_is_vsi_valid(hw, f_entry->fltr_info.vsi_handle))
2448 		return ICE_ERR_PARAM;
2449 
2450 	f_entry->fltr_info.fwd_id.hw_vsi_id =
2451 		ice_get_hw_vsi_num(hw, f_entry->fltr_info.vsi_handle);
2452 	new_fltr = &f_entry->fltr_info;
2453 
2454 	/* VLAN ID should only be 12 bits */
2455 	if (new_fltr->l_data.vlan.vlan_id > ICE_MAX_VLAN_ID)
2456 		return ICE_ERR_PARAM;
2457 
2458 	if (new_fltr->src_id != ICE_SRC_ID_VSI)
2459 		return ICE_ERR_PARAM;
2460 
2461 	new_fltr->src = new_fltr->fwd_id.hw_vsi_id;
2462 	lkup_type = new_fltr->lkup_type;
2463 	vsi_handle = new_fltr->vsi_handle;
2464 	rule_lock = &recp_list->filt_rule_lock;
2465 	ice_acquire_lock(rule_lock);
2466 	v_list_itr = ice_find_rule_entry(&recp_list->filt_rules, new_fltr);
2467 	if (!v_list_itr) {
2468 		struct ice_vsi_list_map_info *map_info = NULL;
2469 
2470 		if (new_fltr->fltr_act == ICE_FWD_TO_VSI) {
2471 			/* All VLAN pruning rules use a VSI list. Check if
2472 			 * there is already a VSI list containing VSI that we
2473 			 * want to add. If found, use the same vsi_list_id for
2474 			 * this new VLAN rule or else create a new list.
2475 			 */
2476 			map_info = ice_find_vsi_list_entry(recp_list,
2477 							   vsi_handle,
2478 							   &vsi_list_id);
2479 			if (!map_info) {
2480 				status = ice_create_vsi_list_rule(hw,
2481 								  &vsi_handle,
2482 								  1,
2483 								  &vsi_list_id,
2484 								  lkup_type);
2485 				if (status)
2486 					goto exit;
2487 			}
2488 			/* Convert the action to forwarding to a VSI list. */
2489 			new_fltr->fltr_act = ICE_FWD_TO_VSI_LIST;
2490 			new_fltr->fwd_id.vsi_list_id = vsi_list_id;
2491 		}
2492 
2493 		status = ice_create_pkt_fwd_rule(hw, recp_list, f_entry);
2494 		if (!status) {
2495 			v_list_itr = ice_find_rule_entry(&recp_list->filt_rules,
2496 							 new_fltr);
2497 			if (!v_list_itr) {
2498 				status = ICE_ERR_DOES_NOT_EXIST;
2499 				goto exit;
2500 			}
2501 			/* reuse VSI list for new rule and increment ref_cnt */
2502 			if (map_info) {
2503 				v_list_itr->vsi_list_info = map_info;
2504 				map_info->ref_cnt++;
2505 			} else {
2506 				v_list_itr->vsi_list_info =
2507 					ice_create_vsi_list_map(hw, &vsi_handle,
2508 								1, vsi_list_id);
2509 			}
2510 		}
2511 	} else if (v_list_itr->vsi_list_info->ref_cnt == 1) {
2512 		/* Update existing VSI list to add new VSI ID only if it used
2513 		 * by one VLAN rule.
2514 		 */
2515 		cur_fltr = &v_list_itr->fltr_info;
2516 		status = ice_add_update_vsi_list(hw, v_list_itr, cur_fltr,
2517 						 new_fltr);
2518 	} else {
2519 		/* If VLAN rule exists and VSI list being used by this rule is
2520 		 * referenced by more than 1 VLAN rule. Then create a new VSI
2521 		 * list appending previous VSI with new VSI and update existing
2522 		 * VLAN rule to point to new VSI list ID
2523 		 */
2524 		struct ice_fltr_info tmp_fltr;
2525 		u16 vsi_handle_arr[2];
2526 		u16 cur_handle;
2527 
2528 		/* Current implementation only supports reusing VSI list with
2529 		 * one VSI count. We should never hit below condition
2530 		 */
2531 		if (v_list_itr->vsi_count > 1 &&
2532 		    v_list_itr->vsi_list_info->ref_cnt > 1) {
2533 			ice_debug(hw, ICE_DBG_SW, "Invalid configuration: Optimization to reuse VSI list with more than one VSI is not being done yet\n");
2534 			status = ICE_ERR_CFG;
2535 			goto exit;
2536 		}
2537 
2538 		cur_handle =
2539 			ice_find_first_bit(v_list_itr->vsi_list_info->vsi_map,
2540 					   ICE_MAX_VSI);
2541 
2542 		/* A rule already exists with the new VSI being added */
2543 		if (cur_handle == vsi_handle) {
2544 			status = ICE_ERR_ALREADY_EXISTS;
2545 			goto exit;
2546 		}
2547 
2548 		vsi_handle_arr[0] = cur_handle;
2549 		vsi_handle_arr[1] = vsi_handle;
2550 		status = ice_create_vsi_list_rule(hw, &vsi_handle_arr[0], 2,
2551 						  &vsi_list_id, lkup_type);
2552 		if (status)
2553 			goto exit;
2554 
2555 		tmp_fltr = v_list_itr->fltr_info;
2556 		tmp_fltr.fltr_rule_id = v_list_itr->fltr_info.fltr_rule_id;
2557 		tmp_fltr.fwd_id.vsi_list_id = vsi_list_id;
2558 		tmp_fltr.fltr_act = ICE_FWD_TO_VSI_LIST;
2559 		/* Update the previous switch rule to a new VSI list which
2560 		 * includes current VSI that is requested
2561 		 */
2562 		status = ice_update_pkt_fwd_rule(hw, &tmp_fltr);
2563 		if (status)
2564 			goto exit;
2565 
2566 		/* before overriding VSI list map info. decrement ref_cnt of
2567 		 * previous VSI list
2568 		 */
2569 		v_list_itr->vsi_list_info->ref_cnt--;
2570 
2571 		/* now update to newly created list */
2572 		v_list_itr->fltr_info.fwd_id.vsi_list_id = vsi_list_id;
2573 		v_list_itr->vsi_list_info =
2574 			ice_create_vsi_list_map(hw, &vsi_handle_arr[0], 2,
2575 						vsi_list_id);
2576 		v_list_itr->vsi_count++;
2577 	}
2578 
2579 exit:
2580 	ice_release_lock(rule_lock);
2581 	return status;
2582 }
2583 
2584 /**
2585  * ice_add_vlan_rule - Add VLAN based filter rule
2586  * @hw: pointer to the hardware structure
2587  * @v_list: list of VLAN entries and forwarding information
2588  * @sw: pointer to switch info struct for which function add rule
2589  */
2590 static enum ice_status
2591 ice_add_vlan_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *v_list,
2592 		  struct ice_switch_info *sw)
2593 {
2594 	struct ice_fltr_list_entry *v_list_itr;
2595 	struct ice_sw_recipe *recp_list;
2596 
2597 	recp_list = &sw->recp_list[ICE_SW_LKUP_VLAN];
2598 	LIST_FOR_EACH_ENTRY(v_list_itr, v_list, ice_fltr_list_entry,
2599 			    list_entry) {
2600 		if (v_list_itr->fltr_info.lkup_type != ICE_SW_LKUP_VLAN)
2601 			return ICE_ERR_PARAM;
2602 		v_list_itr->fltr_info.flag = ICE_FLTR_TX;
2603 		v_list_itr->status = ice_add_vlan_internal(hw, recp_list,
2604 							   v_list_itr);
2605 		if (v_list_itr->status)
2606 			return v_list_itr->status;
2607 	}
2608 	return ICE_SUCCESS;
2609 }
2610 
2611 /**
2612  * ice_add_vlan - Add a VLAN based filter rule
2613  * @hw: pointer to the hardware structure
2614  * @v_list: list of VLAN and forwarding information
2615  *
2616  * Function add VLAN rule for logical port from HW struct
2617  */
2618 enum ice_status ice_add_vlan(struct ice_hw *hw, struct LIST_HEAD_TYPE *v_list)
2619 {
2620 	if (!v_list || !hw)
2621 		return ICE_ERR_PARAM;
2622 
2623 	return ice_add_vlan_rule(hw, v_list, hw->switch_info);
2624 }
2625 
2626 /**
2627  * ice_add_eth_mac_rule - Add ethertype and MAC based filter rule
2628  * @hw: pointer to the hardware structure
2629  * @em_list: list of ether type MAC filter, MAC is optional
2630  * @sw: pointer to switch info struct for which function add rule
2631  * @lport: logic port number on which function add rule
2632  *
2633  * This function requires the caller to populate the entries in
2634  * the filter list with the necessary fields (including flags to
2635  * indicate Tx or Rx rules).
2636  */
2637 static enum ice_status
2638 ice_add_eth_mac_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *em_list,
2639 		     struct ice_switch_info *sw, u8 lport)
2640 {
2641 	struct ice_fltr_list_entry *em_list_itr;
2642 
2643 	LIST_FOR_EACH_ENTRY(em_list_itr, em_list, ice_fltr_list_entry,
2644 			    list_entry) {
2645 		struct ice_sw_recipe *recp_list;
2646 		enum ice_sw_lkup_type l_type;
2647 
2648 		l_type = em_list_itr->fltr_info.lkup_type;
2649 		recp_list = &sw->recp_list[l_type];
2650 
2651 		if (l_type != ICE_SW_LKUP_ETHERTYPE_MAC &&
2652 		    l_type != ICE_SW_LKUP_ETHERTYPE)
2653 			return ICE_ERR_PARAM;
2654 
2655 		em_list_itr->status = ice_add_rule_internal(hw, recp_list,
2656 							    lport,
2657 							    em_list_itr);
2658 		if (em_list_itr->status)
2659 			return em_list_itr->status;
2660 	}
2661 	return ICE_SUCCESS;
2662 }
2663 
2664 /**
2665  * ice_add_eth_mac - Add a ethertype based filter rule
2666  * @hw: pointer to the hardware structure
2667  * @em_list: list of ethertype and forwarding information
2668  *
2669  * Function add ethertype rule for logical port from HW struct
2670  */
2671 enum ice_status
2672 ice_add_eth_mac(struct ice_hw *hw, struct LIST_HEAD_TYPE *em_list)
2673 {
2674 	if (!em_list || !hw)
2675 		return ICE_ERR_PARAM;
2676 
2677 	return ice_add_eth_mac_rule(hw, em_list, hw->switch_info,
2678 				    hw->port_info->lport);
2679 }
2680 
2681 /**
2682  * ice_remove_eth_mac_rule - Remove an ethertype (or MAC) based filter rule
2683  * @hw: pointer to the hardware structure
2684  * @em_list: list of ethertype or ethertype MAC entries
2685  * @sw: pointer to switch info struct for which function add rule
2686  */
2687 static enum ice_status
2688 ice_remove_eth_mac_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *em_list,
2689 			struct ice_switch_info *sw)
2690 {
2691 	struct ice_fltr_list_entry *em_list_itr, *tmp;
2692 
2693 	LIST_FOR_EACH_ENTRY_SAFE(em_list_itr, tmp, em_list, ice_fltr_list_entry,
2694 				 list_entry) {
2695 		struct ice_sw_recipe *recp_list;
2696 		enum ice_sw_lkup_type l_type;
2697 
2698 		l_type = em_list_itr->fltr_info.lkup_type;
2699 
2700 		if (l_type != ICE_SW_LKUP_ETHERTYPE_MAC &&
2701 		    l_type != ICE_SW_LKUP_ETHERTYPE)
2702 			return ICE_ERR_PARAM;
2703 
2704 		recp_list = &sw->recp_list[l_type];
2705 		em_list_itr->status = ice_remove_rule_internal(hw, recp_list,
2706 							       em_list_itr);
2707 		if (em_list_itr->status)
2708 			return em_list_itr->status;
2709 	}
2710 	return ICE_SUCCESS;
2711 }
2712 
2713 /**
2714  * ice_remove_eth_mac - remove a ethertype based filter rule
2715  * @hw: pointer to the hardware structure
2716  * @em_list: list of ethertype and forwarding information
2717  *
2718  */
2719 enum ice_status
2720 ice_remove_eth_mac(struct ice_hw *hw, struct LIST_HEAD_TYPE *em_list)
2721 {
2722 	if (!em_list || !hw)
2723 		return ICE_ERR_PARAM;
2724 
2725 	return ice_remove_eth_mac_rule(hw, em_list, hw->switch_info);
2726 }
2727 
2728 /**
2729  * ice_rem_sw_rule_info
2730  * @hw: pointer to the hardware structure
2731  * @rule_head: pointer to the switch list structure that we want to delete
2732  */
2733 static void
2734 ice_rem_sw_rule_info(struct ice_hw *hw, struct LIST_HEAD_TYPE *rule_head)
2735 {
2736 	if (!LIST_EMPTY(rule_head)) {
2737 		struct ice_fltr_mgmt_list_entry *entry;
2738 		struct ice_fltr_mgmt_list_entry *tmp;
2739 
2740 		LIST_FOR_EACH_ENTRY_SAFE(entry, tmp, rule_head,
2741 					 ice_fltr_mgmt_list_entry, list_entry) {
2742 			LIST_DEL(&entry->list_entry);
2743 			ice_free(hw, entry);
2744 		}
2745 	}
2746 }
2747 
2748 /**
2749  * ice_rem_all_sw_rules_info
2750  * @hw: pointer to the hardware structure
2751  */
2752 void ice_rem_all_sw_rules_info(struct ice_hw *hw)
2753 {
2754 	struct ice_switch_info *sw = hw->switch_info;
2755 	u8 i;
2756 
2757 	for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) {
2758 		struct LIST_HEAD_TYPE *rule_head;
2759 
2760 		rule_head = &sw->recp_list[i].filt_rules;
2761 		if (!sw->recp_list[i].adv_rule)
2762 			ice_rem_sw_rule_info(hw, rule_head);
2763 	}
2764 }
2765 
2766 /**
2767  * ice_cfg_dflt_vsi - change state of VSI to set/clear default
2768  * @pi: pointer to the port_info structure
2769  * @vsi_handle: VSI handle to set as default
2770  * @set: true to add the above mentioned switch rule, false to remove it
2771  * @direction: ICE_FLTR_RX or ICE_FLTR_TX
2772  *
2773  * add filter rule to set/unset given VSI as default VSI for the switch
2774  * (represented by swid)
2775  */
2776 enum ice_status
2777 ice_cfg_dflt_vsi(struct ice_port_info *pi, u16 vsi_handle, bool set,
2778 		 u8 direction)
2779 {
2780 	struct ice_aqc_sw_rules_elem *s_rule;
2781 	struct ice_fltr_info f_info;
2782 	struct ice_hw *hw = pi->hw;
2783 	enum ice_adminq_opc opcode;
2784 	enum ice_status status;
2785 	u16 s_rule_size;
2786 	u16 hw_vsi_id;
2787 
2788 	if (!ice_is_vsi_valid(hw, vsi_handle))
2789 		return ICE_ERR_PARAM;
2790 	hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle);
2791 
2792 	s_rule_size = set ? ICE_SW_RULE_RX_TX_ETH_HDR_SIZE :
2793 		ICE_SW_RULE_RX_TX_NO_HDR_SIZE;
2794 
2795 	s_rule = (struct ice_aqc_sw_rules_elem *)ice_malloc(hw, s_rule_size);
2796 	if (!s_rule)
2797 		return ICE_ERR_NO_MEMORY;
2798 
2799 	ice_memset(&f_info, 0, sizeof(f_info), ICE_NONDMA_MEM);
2800 
2801 	f_info.lkup_type = ICE_SW_LKUP_DFLT;
2802 	f_info.flag = direction;
2803 	f_info.fltr_act = ICE_FWD_TO_VSI;
2804 	f_info.fwd_id.hw_vsi_id = hw_vsi_id;
2805 
2806 	if (f_info.flag & ICE_FLTR_RX) {
2807 		f_info.src = pi->lport;
2808 		f_info.src_id = ICE_SRC_ID_LPORT;
2809 		if (!set)
2810 			f_info.fltr_rule_id =
2811 				pi->dflt_rx_vsi_rule_id;
2812 	} else if (f_info.flag & ICE_FLTR_TX) {
2813 		f_info.src_id = ICE_SRC_ID_VSI;
2814 		f_info.src = hw_vsi_id;
2815 		if (!set)
2816 			f_info.fltr_rule_id =
2817 				pi->dflt_tx_vsi_rule_id;
2818 	}
2819 
2820 	if (set)
2821 		opcode = ice_aqc_opc_add_sw_rules;
2822 	else
2823 		opcode = ice_aqc_opc_remove_sw_rules;
2824 
2825 	ice_fill_sw_rule(hw, &f_info, s_rule, opcode);
2826 
2827 	status = ice_aq_sw_rules(hw, s_rule, s_rule_size, 1, opcode, NULL);
2828 	if (status || !(f_info.flag & ICE_FLTR_TX_RX))
2829 		goto out;
2830 	if (set) {
2831 		u16 index = LE16_TO_CPU(s_rule->pdata.lkup_tx_rx.index);
2832 
2833 		if (f_info.flag & ICE_FLTR_TX) {
2834 			pi->dflt_tx_vsi_num = hw_vsi_id;
2835 			pi->dflt_tx_vsi_rule_id = index;
2836 		} else if (f_info.flag & ICE_FLTR_RX) {
2837 			pi->dflt_rx_vsi_num = hw_vsi_id;
2838 			pi->dflt_rx_vsi_rule_id = index;
2839 		}
2840 	} else {
2841 		if (f_info.flag & ICE_FLTR_TX) {
2842 			pi->dflt_tx_vsi_num = ICE_DFLT_VSI_INVAL;
2843 			pi->dflt_tx_vsi_rule_id = ICE_INVAL_ACT;
2844 		} else if (f_info.flag & ICE_FLTR_RX) {
2845 			pi->dflt_rx_vsi_num = ICE_DFLT_VSI_INVAL;
2846 			pi->dflt_rx_vsi_rule_id = ICE_INVAL_ACT;
2847 		}
2848 	}
2849 
2850 out:
2851 	ice_free(hw, s_rule);
2852 	return status;
2853 }
2854 
2855 /**
2856  * ice_find_ucast_rule_entry - Search for a unicast MAC filter rule entry
2857  * @list_head: head of rule list
2858  * @f_info: rule information
2859  *
2860  * Helper function to search for a unicast rule entry - this is to be used
2861  * to remove unicast MAC filter that is not shared with other VSIs on the
2862  * PF switch.
2863  *
2864  * Returns pointer to entry storing the rule if found
2865  */
2866 static struct ice_fltr_mgmt_list_entry *
2867 ice_find_ucast_rule_entry(struct LIST_HEAD_TYPE *list_head,
2868 			  struct ice_fltr_info *f_info)
2869 {
2870 	struct ice_fltr_mgmt_list_entry *list_itr;
2871 
2872 	LIST_FOR_EACH_ENTRY(list_itr, list_head, ice_fltr_mgmt_list_entry,
2873 			    list_entry) {
2874 		if (!memcmp(&f_info->l_data, &list_itr->fltr_info.l_data,
2875 			    sizeof(f_info->l_data)) &&
2876 		    f_info->fwd_id.hw_vsi_id ==
2877 		    list_itr->fltr_info.fwd_id.hw_vsi_id &&
2878 		    f_info->flag == list_itr->fltr_info.flag)
2879 			return list_itr;
2880 	}
2881 	return NULL;
2882 }
2883 
2884 /**
2885  * ice_remove_mac_rule - remove a MAC based filter rule
2886  * @hw: pointer to the hardware structure
2887  * @m_list: list of MAC addresses and forwarding information
2888  * @recp_list: list from which function remove MAC address
2889  *
2890  * This function removes either a MAC filter rule or a specific VSI from a
2891  * VSI list for a multicast MAC address.
2892  *
2893  * Returns ICE_ERR_DOES_NOT_EXIST if a given entry was not added by
2894  * ice_add_mac. Caller should be aware that this call will only work if all
2895  * the entries passed into m_list were added previously. It will not attempt to
2896  * do a partial remove of entries that were found.
2897  */
2898 static enum ice_status
2899 ice_remove_mac_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *m_list,
2900 		    struct ice_sw_recipe *recp_list)
2901 {
2902 	struct ice_fltr_list_entry *list_itr, *tmp;
2903 	struct ice_lock *rule_lock; /* Lock to protect filter rule list */
2904 
2905 	if (!m_list)
2906 		return ICE_ERR_PARAM;
2907 
2908 	rule_lock = &recp_list->filt_rule_lock;
2909 	LIST_FOR_EACH_ENTRY_SAFE(list_itr, tmp, m_list, ice_fltr_list_entry,
2910 				 list_entry) {
2911 		enum ice_sw_lkup_type l_type = list_itr->fltr_info.lkup_type;
2912 		u8 *add = &list_itr->fltr_info.l_data.mac.mac_addr[0];
2913 		u16 vsi_handle;
2914 
2915 		if (l_type != ICE_SW_LKUP_MAC)
2916 			return ICE_ERR_PARAM;
2917 
2918 		vsi_handle = list_itr->fltr_info.vsi_handle;
2919 		if (!ice_is_vsi_valid(hw, vsi_handle))
2920 			return ICE_ERR_PARAM;
2921 
2922 		list_itr->fltr_info.fwd_id.hw_vsi_id =
2923 					ice_get_hw_vsi_num(hw, vsi_handle);
2924 		if (IS_UNICAST_ETHER_ADDR(add) && !hw->ucast_shared) {
2925 			/* Don't remove the unicast address that belongs to
2926 			 * another VSI on the switch, since it is not being
2927 			 * shared...
2928 			 */
2929 			ice_acquire_lock(rule_lock);
2930 			if (!ice_find_ucast_rule_entry(&recp_list->filt_rules,
2931 						       &list_itr->fltr_info)) {
2932 				ice_release_lock(rule_lock);
2933 				return ICE_ERR_DOES_NOT_EXIST;
2934 			}
2935 			ice_release_lock(rule_lock);
2936 		}
2937 		list_itr->status = ice_remove_rule_internal(hw, recp_list,
2938 							    list_itr);
2939 		if (list_itr->status)
2940 			return list_itr->status;
2941 	}
2942 	return ICE_SUCCESS;
2943 }
2944 
2945 /**
2946  * ice_remove_mac - remove a MAC address based filter rule
2947  * @hw: pointer to the hardware structure
2948  * @m_list: list of MAC addresses and forwarding information
2949  *
2950  */
2951 enum ice_status ice_remove_mac(struct ice_hw *hw, struct LIST_HEAD_TYPE *m_list)
2952 {
2953 	struct ice_sw_recipe *recp_list;
2954 
2955 	recp_list = &hw->switch_info->recp_list[ICE_SW_LKUP_MAC];
2956 	return ice_remove_mac_rule(hw, m_list, recp_list);
2957 }
2958 
2959 /**
2960  * ice_remove_vlan_rule - Remove VLAN based filter rule
2961  * @hw: pointer to the hardware structure
2962  * @v_list: list of VLAN entries and forwarding information
2963  * @recp_list: list from which function remove VLAN
2964  */
2965 static enum ice_status
2966 ice_remove_vlan_rule(struct ice_hw *hw, struct LIST_HEAD_TYPE *v_list,
2967 		     struct ice_sw_recipe *recp_list)
2968 {
2969 	struct ice_fltr_list_entry *v_list_itr, *tmp;
2970 
2971 	LIST_FOR_EACH_ENTRY_SAFE(v_list_itr, tmp, v_list, ice_fltr_list_entry,
2972 				 list_entry) {
2973 		enum ice_sw_lkup_type l_type = v_list_itr->fltr_info.lkup_type;
2974 
2975 		if (l_type != ICE_SW_LKUP_VLAN)
2976 			return ICE_ERR_PARAM;
2977 		v_list_itr->status = ice_remove_rule_internal(hw, recp_list,
2978 							      v_list_itr);
2979 		if (v_list_itr->status)
2980 			return v_list_itr->status;
2981 	}
2982 	return ICE_SUCCESS;
2983 }
2984 
2985 /**
2986  * ice_remove_vlan - remove a VLAN address based filter rule
2987  * @hw: pointer to the hardware structure
2988  * @v_list: list of VLAN and forwarding information
2989  *
2990  */
2991 enum ice_status
2992 ice_remove_vlan(struct ice_hw *hw, struct LIST_HEAD_TYPE *v_list)
2993 {
2994 	struct ice_sw_recipe *recp_list;
2995 
2996 	if (!v_list || !hw)
2997 		return ICE_ERR_PARAM;
2998 
2999 	recp_list = &hw->switch_info->recp_list[ICE_SW_LKUP_VLAN];
3000 	return ice_remove_vlan_rule(hw, v_list, recp_list);
3001 }
3002 
3003 /**
3004  * ice_vsi_uses_fltr - Determine if given VSI uses specified filter
3005  * @fm_entry: filter entry to inspect
3006  * @vsi_handle: VSI handle to compare with filter info
3007  */
3008 static bool
3009 ice_vsi_uses_fltr(struct ice_fltr_mgmt_list_entry *fm_entry, u16 vsi_handle)
3010 {
3011 	return ((fm_entry->fltr_info.fltr_act == ICE_FWD_TO_VSI &&
3012 		 fm_entry->fltr_info.vsi_handle == vsi_handle) ||
3013 		(fm_entry->fltr_info.fltr_act == ICE_FWD_TO_VSI_LIST &&
3014 		 (ice_is_bit_set(fm_entry->vsi_list_info->vsi_map,
3015 				 vsi_handle))));
3016 }
3017 
3018 /**
3019  * ice_add_entry_to_vsi_fltr_list - Add copy of fltr_list_entry to remove list
3020  * @hw: pointer to the hardware structure
3021  * @vsi_handle: VSI handle to remove filters from
3022  * @vsi_list_head: pointer to the list to add entry to
3023  * @fi: pointer to fltr_info of filter entry to copy & add
3024  *
3025  * Helper function, used when creating a list of filters to remove from
3026  * a specific VSI. The entry added to vsi_list_head is a COPY of the
3027  * original filter entry, with the exception of fltr_info.fltr_act and
3028  * fltr_info.fwd_id fields. These are set such that later logic can
3029  * extract which VSI to remove the fltr from, and pass on that information.
3030  */
3031 static enum ice_status
3032 ice_add_entry_to_vsi_fltr_list(struct ice_hw *hw, u16 vsi_handle,
3033 			       struct LIST_HEAD_TYPE *vsi_list_head,
3034 			       struct ice_fltr_info *fi)
3035 {
3036 	struct ice_fltr_list_entry *tmp;
3037 
3038 	/* this memory is freed up in the caller function
3039 	 * once filters for this VSI are removed
3040 	 */
3041 	tmp = (struct ice_fltr_list_entry *)ice_malloc(hw, sizeof(*tmp));
3042 	if (!tmp)
3043 		return ICE_ERR_NO_MEMORY;
3044 
3045 	tmp->fltr_info = *fi;
3046 
3047 	/* Overwrite these fields to indicate which VSI to remove filter from,
3048 	 * so find and remove logic can extract the information from the
3049 	 * list entries. Note that original entries will still have proper
3050 	 * values.
3051 	 */
3052 	tmp->fltr_info.fltr_act = ICE_FWD_TO_VSI;
3053 	tmp->fltr_info.vsi_handle = vsi_handle;
3054 	tmp->fltr_info.fwd_id.hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle);
3055 
3056 	LIST_ADD(&tmp->list_entry, vsi_list_head);
3057 
3058 	return ICE_SUCCESS;
3059 }
3060 
3061 /**
3062  * ice_add_to_vsi_fltr_list - Add VSI filters to the list
3063  * @hw: pointer to the hardware structure
3064  * @vsi_handle: VSI handle to remove filters from
3065  * @lkup_list_head: pointer to the list that has certain lookup type filters
3066  * @vsi_list_head: pointer to the list pertaining to VSI with vsi_handle
3067  *
3068  * Locates all filters in lkup_list_head that are used by the given VSI,
3069  * and adds COPIES of those entries to vsi_list_head (intended to be used
3070  * to remove the listed filters).
3071  * Note that this means all entries in vsi_list_head must be explicitly
3072  * deallocated by the caller when done with list.
3073  */
3074 static enum ice_status
3075 ice_add_to_vsi_fltr_list(struct ice_hw *hw, u16 vsi_handle,
3076 			 struct LIST_HEAD_TYPE *lkup_list_head,
3077 			 struct LIST_HEAD_TYPE *vsi_list_head)
3078 {
3079 	struct ice_fltr_mgmt_list_entry *fm_entry;
3080 	enum ice_status status = ICE_SUCCESS;
3081 
3082 	/* check to make sure VSI ID is valid and within boundary */
3083 	if (!ice_is_vsi_valid(hw, vsi_handle))
3084 		return ICE_ERR_PARAM;
3085 
3086 	LIST_FOR_EACH_ENTRY(fm_entry, lkup_list_head,
3087 			    ice_fltr_mgmt_list_entry, list_entry) {
3088 		struct ice_fltr_info *fi;
3089 
3090 		fi = &fm_entry->fltr_info;
3091 		if (!fi || !ice_vsi_uses_fltr(fm_entry, vsi_handle))
3092 			continue;
3093 
3094 		status = ice_add_entry_to_vsi_fltr_list(hw, vsi_handle,
3095 							vsi_list_head, fi);
3096 		if (status)
3097 			return status;
3098 	}
3099 	return status;
3100 }
3101 
3102 /**
3103  * ice_determine_promisc_mask
3104  * @fi: filter info to parse
3105  *
3106  * Helper function to determine which ICE_PROMISC_ mask corresponds
3107  * to given filter into.
3108  */
3109 static u8 ice_determine_promisc_mask(struct ice_fltr_info *fi)
3110 {
3111 	u16 vid = fi->l_data.mac_vlan.vlan_id;
3112 	u8 *macaddr = fi->l_data.mac.mac_addr;
3113 	bool is_tx_fltr = false;
3114 	u8 promisc_mask = 0;
3115 
3116 	if (fi->flag == ICE_FLTR_TX)
3117 		is_tx_fltr = true;
3118 
3119 	if (IS_BROADCAST_ETHER_ADDR(macaddr))
3120 		promisc_mask |= is_tx_fltr ?
3121 			ICE_PROMISC_BCAST_TX : ICE_PROMISC_BCAST_RX;
3122 	else if (IS_MULTICAST_ETHER_ADDR(macaddr))
3123 		promisc_mask |= is_tx_fltr ?
3124 			ICE_PROMISC_MCAST_TX : ICE_PROMISC_MCAST_RX;
3125 	else if (IS_UNICAST_ETHER_ADDR(macaddr))
3126 		promisc_mask |= is_tx_fltr ?
3127 			ICE_PROMISC_UCAST_TX : ICE_PROMISC_UCAST_RX;
3128 	if (vid)
3129 		promisc_mask |= is_tx_fltr ?
3130 			ICE_PROMISC_VLAN_TX : ICE_PROMISC_VLAN_RX;
3131 
3132 	return promisc_mask;
3133 }
3134 
3135 /**
3136  * _ice_get_vsi_promisc - get promiscuous mode of given VSI
3137  * @hw: pointer to the hardware structure
3138  * @vsi_handle: VSI handle to retrieve info from
3139  * @promisc_mask: pointer to mask to be filled in
3140  * @vid: VLAN ID of promisc VLAN VSI
3141  * @sw: pointer to switch info struct for which function add rule
3142  */
3143 static enum ice_status
3144 _ice_get_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 *promisc_mask,
3145 		     u16 *vid, struct ice_switch_info *sw)
3146 {
3147 	struct ice_fltr_mgmt_list_entry *itr;
3148 	struct LIST_HEAD_TYPE *rule_head;
3149 	struct ice_lock *rule_lock;	/* Lock to protect filter rule list */
3150 
3151 	if (!ice_is_vsi_valid(hw, vsi_handle))
3152 		return ICE_ERR_PARAM;
3153 
3154 	*vid = 0;
3155 	*promisc_mask = 0;
3156 	rule_head = &sw->recp_list[ICE_SW_LKUP_PROMISC].filt_rules;
3157 	rule_lock = &sw->recp_list[ICE_SW_LKUP_PROMISC].filt_rule_lock;
3158 
3159 	ice_acquire_lock(rule_lock);
3160 	LIST_FOR_EACH_ENTRY(itr, rule_head,
3161 			    ice_fltr_mgmt_list_entry, list_entry) {
3162 		/* Continue if this filter doesn't apply to this VSI or the
3163 		 * VSI ID is not in the VSI map for this filter
3164 		 */
3165 		if (!ice_vsi_uses_fltr(itr, vsi_handle))
3166 			continue;
3167 
3168 		*promisc_mask |= ice_determine_promisc_mask(&itr->fltr_info);
3169 	}
3170 	ice_release_lock(rule_lock);
3171 
3172 	return ICE_SUCCESS;
3173 }
3174 
3175 /**
3176  * ice_get_vsi_promisc - get promiscuous mode of given VSI
3177  * @hw: pointer to the hardware structure
3178  * @vsi_handle: VSI handle to retrieve info from
3179  * @promisc_mask: pointer to mask to be filled in
3180  * @vid: VLAN ID of promisc VLAN VSI
3181  */
3182 enum ice_status
3183 ice_get_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 *promisc_mask,
3184 		    u16 *vid)
3185 {
3186 	return _ice_get_vsi_promisc(hw, vsi_handle, promisc_mask,
3187 				    vid, hw->switch_info);
3188 }
3189 
3190 /**
3191  * ice_get_vsi_vlan_promisc - get VLAN promiscuous mode of given VSI
3192  * @hw: pointer to the hardware structure
3193  * @vsi_handle: VSI handle to retrieve info from
3194  * @promisc_mask: pointer to mask to be filled in
3195  * @vid: VLAN ID of promisc VLAN VSI
3196  * @sw: pointer to switch info struct for which function add rule
3197  */
3198 static enum ice_status
3199 _ice_get_vsi_vlan_promisc(struct ice_hw *hw, u16 vsi_handle, u8 *promisc_mask,
3200 			  u16 *vid, struct ice_switch_info *sw)
3201 {
3202 	struct ice_fltr_mgmt_list_entry *itr;
3203 	struct LIST_HEAD_TYPE *rule_head;
3204 	struct ice_lock *rule_lock;	/* Lock to protect filter rule list */
3205 
3206 	if (!ice_is_vsi_valid(hw, vsi_handle))
3207 		return ICE_ERR_PARAM;
3208 
3209 	*vid = 0;
3210 	*promisc_mask = 0;
3211 	rule_head = &sw->recp_list[ICE_SW_LKUP_PROMISC_VLAN].filt_rules;
3212 	rule_lock = &sw->recp_list[ICE_SW_LKUP_PROMISC_VLAN].filt_rule_lock;
3213 
3214 	ice_acquire_lock(rule_lock);
3215 	LIST_FOR_EACH_ENTRY(itr, rule_head, ice_fltr_mgmt_list_entry,
3216 			    list_entry) {
3217 		/* Continue if this filter doesn't apply to this VSI or the
3218 		 * VSI ID is not in the VSI map for this filter
3219 		 */
3220 		if (!ice_vsi_uses_fltr(itr, vsi_handle))
3221 			continue;
3222 
3223 		*promisc_mask |= ice_determine_promisc_mask(&itr->fltr_info);
3224 	}
3225 	ice_release_lock(rule_lock);
3226 
3227 	return ICE_SUCCESS;
3228 }
3229 
3230 /**
3231  * ice_get_vsi_vlan_promisc - get VLAN promiscuous mode of given VSI
3232  * @hw: pointer to the hardware structure
3233  * @vsi_handle: VSI handle to retrieve info from
3234  * @promisc_mask: pointer to mask to be filled in
3235  * @vid: VLAN ID of promisc VLAN VSI
3236  */
3237 enum ice_status
3238 ice_get_vsi_vlan_promisc(struct ice_hw *hw, u16 vsi_handle, u8 *promisc_mask,
3239 			 u16 *vid)
3240 {
3241 	return _ice_get_vsi_vlan_promisc(hw, vsi_handle, promisc_mask,
3242 					 vid, hw->switch_info);
3243 }
3244 
3245 /**
3246  * ice_remove_promisc - Remove promisc based filter rules
3247  * @hw: pointer to the hardware structure
3248  * @recp_id: recipe ID for which the rule needs to removed
3249  * @v_list: list of promisc entries
3250  */
3251 static enum ice_status
3252 ice_remove_promisc(struct ice_hw *hw, u8 recp_id,
3253 		   struct LIST_HEAD_TYPE *v_list)
3254 {
3255 	struct ice_fltr_list_entry *v_list_itr, *tmp;
3256 	struct ice_sw_recipe *recp_list;
3257 
3258 	recp_list = &hw->switch_info->recp_list[recp_id];
3259 	LIST_FOR_EACH_ENTRY_SAFE(v_list_itr, tmp, v_list, ice_fltr_list_entry,
3260 				 list_entry) {
3261 		v_list_itr->status =
3262 			ice_remove_rule_internal(hw, recp_list, v_list_itr);
3263 		if (v_list_itr->status)
3264 			return v_list_itr->status;
3265 	}
3266 	return ICE_SUCCESS;
3267 }
3268 
3269 /**
3270  * _ice_clear_vsi_promisc - clear specified promiscuous mode(s)
3271  * @hw: pointer to the hardware structure
3272  * @vsi_handle: VSI handle to clear mode
3273  * @promisc_mask: mask of promiscuous config bits to clear
3274  * @vid: VLAN ID to clear VLAN promiscuous
3275  * @sw: pointer to switch info struct for which function add rule
3276  */
3277 static enum ice_status
3278 _ice_clear_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask,
3279 		       u16 vid, struct ice_switch_info *sw)
3280 {
3281 	struct ice_fltr_list_entry *fm_entry, *tmp;
3282 	struct LIST_HEAD_TYPE remove_list_head;
3283 	struct ice_fltr_mgmt_list_entry *itr;
3284 	struct LIST_HEAD_TYPE *rule_head;
3285 	struct ice_lock *rule_lock;	/* Lock to protect filter rule list */
3286 	enum ice_status status = ICE_SUCCESS;
3287 	u8 recipe_id;
3288 
3289 	if (!ice_is_vsi_valid(hw, vsi_handle))
3290 		return ICE_ERR_PARAM;
3291 
3292 	if (promisc_mask & (ICE_PROMISC_VLAN_RX | ICE_PROMISC_VLAN_TX))
3293 		recipe_id = ICE_SW_LKUP_PROMISC_VLAN;
3294 	else
3295 		recipe_id = ICE_SW_LKUP_PROMISC;
3296 
3297 	rule_head = &sw->recp_list[recipe_id].filt_rules;
3298 	rule_lock = &sw->recp_list[recipe_id].filt_rule_lock;
3299 
3300 	INIT_LIST_HEAD(&remove_list_head);
3301 
3302 	ice_acquire_lock(rule_lock);
3303 	LIST_FOR_EACH_ENTRY(itr, rule_head,
3304 			    ice_fltr_mgmt_list_entry, list_entry) {
3305 		struct ice_fltr_info *fltr_info;
3306 		u8 fltr_promisc_mask = 0;
3307 
3308 		if (!ice_vsi_uses_fltr(itr, vsi_handle))
3309 			continue;
3310 		fltr_info = &itr->fltr_info;
3311 
3312 		if (recipe_id == ICE_SW_LKUP_PROMISC_VLAN &&
3313 		    vid != fltr_info->l_data.mac_vlan.vlan_id)
3314 			continue;
3315 
3316 		fltr_promisc_mask |= ice_determine_promisc_mask(fltr_info);
3317 
3318 		/* Skip if filter is not completely specified by given mask */
3319 		if (fltr_promisc_mask & ~promisc_mask)
3320 			continue;
3321 
3322 		status = ice_add_entry_to_vsi_fltr_list(hw, vsi_handle,
3323 							&remove_list_head,
3324 							fltr_info);
3325 		if (status) {
3326 			ice_release_lock(rule_lock);
3327 			goto free_fltr_list;
3328 		}
3329 	}
3330 	ice_release_lock(rule_lock);
3331 
3332 	status = ice_remove_promisc(hw, recipe_id, &remove_list_head);
3333 
3334 free_fltr_list:
3335 	LIST_FOR_EACH_ENTRY_SAFE(fm_entry, tmp, &remove_list_head,
3336 				 ice_fltr_list_entry, list_entry) {
3337 		LIST_DEL(&fm_entry->list_entry);
3338 		ice_free(hw, fm_entry);
3339 	}
3340 
3341 	return status;
3342 }
3343 
3344 /**
3345  * ice_clear_vsi_promisc - clear specified promiscuous mode(s) for given VSI
3346  * @hw: pointer to the hardware structure
3347  * @vsi_handle: VSI handle to clear mode
3348  * @promisc_mask: mask of promiscuous config bits to clear
3349  * @vid: VLAN ID to clear VLAN promiscuous
3350  */
3351 enum ice_status
3352 ice_clear_vsi_promisc(struct ice_hw *hw, u16 vsi_handle,
3353 		      u8 promisc_mask, u16 vid)
3354 {
3355 	return _ice_clear_vsi_promisc(hw, vsi_handle, promisc_mask,
3356 				      vid, hw->switch_info);
3357 }
3358 
3359 /**
3360  * _ice_set_vsi_promisc - set given VSI to given promiscuous mode(s)
3361  * @hw: pointer to the hardware structure
3362  * @vsi_handle: VSI handle to configure
3363  * @promisc_mask: mask of promiscuous config bits
3364  * @vid: VLAN ID to set VLAN promiscuous
3365  * @lport: logical port number to configure promisc mode
3366  * @sw: pointer to switch info struct for which function add rule
3367  */
3368 static enum ice_status
3369 _ice_set_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask,
3370 		     u16 vid, u8 lport, struct ice_switch_info *sw)
3371 {
3372 	enum { UCAST_FLTR = 1, MCAST_FLTR, BCAST_FLTR };
3373 	struct ice_fltr_list_entry f_list_entry;
3374 	struct ice_fltr_info new_fltr;
3375 	enum ice_status status = ICE_SUCCESS;
3376 	bool is_tx_fltr;
3377 	u16 hw_vsi_id;
3378 	int pkt_type;
3379 	u8 recipe_id;
3380 
3381 	ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
3382 
3383 	if (!ice_is_vsi_valid(hw, vsi_handle))
3384 		return ICE_ERR_PARAM;
3385 	hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle);
3386 
3387 	ice_memset(&new_fltr, 0, sizeof(new_fltr), ICE_NONDMA_MEM);
3388 
3389 	if (promisc_mask & (ICE_PROMISC_VLAN_RX | ICE_PROMISC_VLAN_TX)) {
3390 		new_fltr.lkup_type = ICE_SW_LKUP_PROMISC_VLAN;
3391 		new_fltr.l_data.mac_vlan.vlan_id = vid;
3392 		recipe_id = ICE_SW_LKUP_PROMISC_VLAN;
3393 	} else {
3394 		new_fltr.lkup_type = ICE_SW_LKUP_PROMISC;
3395 		recipe_id = ICE_SW_LKUP_PROMISC;
3396 	}
3397 
3398 	/* Separate filters must be set for each direction/packet type
3399 	 * combination, so we will loop over the mask value, store the
3400 	 * individual type, and clear it out in the input mask as it
3401 	 * is found.
3402 	 */
3403 	while (promisc_mask) {
3404 		struct ice_sw_recipe *recp_list;
3405 		u8 *mac_addr;
3406 
3407 		pkt_type = 0;
3408 		is_tx_fltr = false;
3409 
3410 		if (promisc_mask & ICE_PROMISC_UCAST_RX) {
3411 			promisc_mask &= ~ICE_PROMISC_UCAST_RX;
3412 			pkt_type = UCAST_FLTR;
3413 		} else if (promisc_mask & ICE_PROMISC_UCAST_TX) {
3414 			promisc_mask &= ~ICE_PROMISC_UCAST_TX;
3415 			pkt_type = UCAST_FLTR;
3416 			is_tx_fltr = true;
3417 		} else if (promisc_mask & ICE_PROMISC_MCAST_RX) {
3418 			promisc_mask &= ~ICE_PROMISC_MCAST_RX;
3419 			pkt_type = MCAST_FLTR;
3420 		} else if (promisc_mask & ICE_PROMISC_MCAST_TX) {
3421 			promisc_mask &= ~ICE_PROMISC_MCAST_TX;
3422 			pkt_type = MCAST_FLTR;
3423 			is_tx_fltr = true;
3424 		} else if (promisc_mask & ICE_PROMISC_BCAST_RX) {
3425 			promisc_mask &= ~ICE_PROMISC_BCAST_RX;
3426 			pkt_type = BCAST_FLTR;
3427 		} else if (promisc_mask & ICE_PROMISC_BCAST_TX) {
3428 			promisc_mask &= ~ICE_PROMISC_BCAST_TX;
3429 			pkt_type = BCAST_FLTR;
3430 			is_tx_fltr = true;
3431 		}
3432 
3433 		/* Check for VLAN promiscuous flag */
3434 		if (promisc_mask & ICE_PROMISC_VLAN_RX) {
3435 			promisc_mask &= ~ICE_PROMISC_VLAN_RX;
3436 		} else if (promisc_mask & ICE_PROMISC_VLAN_TX) {
3437 			promisc_mask &= ~ICE_PROMISC_VLAN_TX;
3438 			is_tx_fltr = true;
3439 		}
3440 
3441 		/* Set filter DA based on packet type */
3442 		mac_addr = new_fltr.l_data.mac.mac_addr;
3443 		if (pkt_type == BCAST_FLTR) {
3444 			ice_memset(mac_addr, 0xff, ETH_ALEN, ICE_NONDMA_MEM);
3445 		} else if (pkt_type == MCAST_FLTR ||
3446 			   pkt_type == UCAST_FLTR) {
3447 			/* Use the dummy ether header DA */
3448 			ice_memcpy(mac_addr, dummy_eth_header, ETH_ALEN,
3449 				   ICE_NONDMA_TO_NONDMA);
3450 			if (pkt_type == MCAST_FLTR)
3451 				mac_addr[0] |= 0x1;	/* Set multicast bit */
3452 		}
3453 
3454 		/* Need to reset this to zero for all iterations */
3455 		new_fltr.flag = 0;
3456 		if (is_tx_fltr) {
3457 			new_fltr.flag |= ICE_FLTR_TX;
3458 			new_fltr.src = hw_vsi_id;
3459 		} else {
3460 			new_fltr.flag |= ICE_FLTR_RX;
3461 			new_fltr.src = lport;
3462 		}
3463 
3464 		new_fltr.fltr_act = ICE_FWD_TO_VSI;
3465 		new_fltr.vsi_handle = vsi_handle;
3466 		new_fltr.fwd_id.hw_vsi_id = hw_vsi_id;
3467 		f_list_entry.fltr_info = new_fltr;
3468 		recp_list = &sw->recp_list[recipe_id];
3469 
3470 		status = ice_add_rule_internal(hw, recp_list, lport,
3471 					       &f_list_entry);
3472 		if (status != ICE_SUCCESS)
3473 			goto set_promisc_exit;
3474 	}
3475 
3476 set_promisc_exit:
3477 	return status;
3478 }
3479 
3480 /**
3481  * ice_set_vsi_promisc - set given VSI to given promiscuous mode(s)
3482  * @hw: pointer to the hardware structure
3483  * @vsi_handle: VSI handle to configure
3484  * @promisc_mask: mask of promiscuous config bits
3485  * @vid: VLAN ID to set VLAN promiscuous
3486  */
3487 enum ice_status
3488 ice_set_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask,
3489 		    u16 vid)
3490 {
3491 	return _ice_set_vsi_promisc(hw, vsi_handle, promisc_mask, vid,
3492 				    hw->port_info->lport,
3493 				    hw->switch_info);
3494 }
3495 
3496 /**
3497  * _ice_set_vlan_vsi_promisc
3498  * @hw: pointer to the hardware structure
3499  * @vsi_handle: VSI handle to configure
3500  * @promisc_mask: mask of promiscuous config bits
3501  * @rm_vlan_promisc: Clear VLANs VSI promisc mode
3502  * @lport: logical port number to configure promisc mode
3503  * @sw: pointer to switch info struct for which function add rule
3504  *
3505  * Configure VSI with all associated VLANs to given promiscuous mode(s)
3506  */
3507 static enum ice_status
3508 _ice_set_vlan_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask,
3509 			  bool rm_vlan_promisc, u8 lport,
3510 			  struct ice_switch_info *sw)
3511 {
3512 	struct ice_fltr_list_entry *list_itr, *tmp;
3513 	struct LIST_HEAD_TYPE vsi_list_head;
3514 	struct LIST_HEAD_TYPE *vlan_head;
3515 	struct ice_lock *vlan_lock; /* Lock to protect filter rule list */
3516 	enum ice_status status;
3517 	u16 vlan_id;
3518 
3519 	INIT_LIST_HEAD(&vsi_list_head);
3520 	vlan_lock = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rule_lock;
3521 	vlan_head = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rules;
3522 	ice_acquire_lock(vlan_lock);
3523 	status = ice_add_to_vsi_fltr_list(hw, vsi_handle, vlan_head,
3524 					  &vsi_list_head);
3525 	ice_release_lock(vlan_lock);
3526 	if (status)
3527 		goto free_fltr_list;
3528 
3529 	LIST_FOR_EACH_ENTRY(list_itr, &vsi_list_head, ice_fltr_list_entry,
3530 			    list_entry) {
3531 		vlan_id = list_itr->fltr_info.l_data.vlan.vlan_id;
3532 		if (rm_vlan_promisc)
3533 			status =  _ice_clear_vsi_promisc(hw, vsi_handle,
3534 							 promisc_mask,
3535 							 vlan_id, sw);
3536 		else
3537 			status =  _ice_set_vsi_promisc(hw, vsi_handle,
3538 						       promisc_mask, vlan_id,
3539 						       lport, sw);
3540 		if (status)
3541 			break;
3542 	}
3543 
3544 free_fltr_list:
3545 	LIST_FOR_EACH_ENTRY_SAFE(list_itr, tmp, &vsi_list_head,
3546 				 ice_fltr_list_entry, list_entry) {
3547 		LIST_DEL(&list_itr->list_entry);
3548 		ice_free(hw, list_itr);
3549 	}
3550 	return status;
3551 }
3552 
3553 /**
3554  * ice_set_vlan_vsi_promisc
3555  * @hw: pointer to the hardware structure
3556  * @vsi_handle: VSI handle to configure
3557  * @promisc_mask: mask of promiscuous config bits
3558  * @rm_vlan_promisc: Clear VLANs VSI promisc mode
3559  *
3560  * Configure VSI with all associated VLANs to given promiscuous mode(s)
3561  */
3562 enum ice_status
3563 ice_set_vlan_vsi_promisc(struct ice_hw *hw, u16 vsi_handle, u8 promisc_mask,
3564 			 bool rm_vlan_promisc)
3565 {
3566 	return _ice_set_vlan_vsi_promisc(hw, vsi_handle, promisc_mask,
3567 					 rm_vlan_promisc, hw->port_info->lport,
3568 					 hw->switch_info);
3569 }
3570 
3571 /**
3572  * ice_remove_vsi_lkup_fltr - Remove lookup type filters for a VSI
3573  * @hw: pointer to the hardware structure
3574  * @vsi_handle: VSI handle to remove filters from
3575  * @recp_list: recipe list from which function remove fltr
3576  * @lkup: switch rule filter lookup type
3577  */
3578 static void
3579 ice_remove_vsi_lkup_fltr(struct ice_hw *hw, u16 vsi_handle,
3580 			 struct ice_sw_recipe *recp_list,
3581 			 enum ice_sw_lkup_type lkup)
3582 {
3583 	struct ice_fltr_list_entry *fm_entry;
3584 	struct LIST_HEAD_TYPE remove_list_head;
3585 	struct LIST_HEAD_TYPE *rule_head;
3586 	struct ice_fltr_list_entry *tmp;
3587 	struct ice_lock *rule_lock;	/* Lock to protect filter rule list */
3588 	enum ice_status status;
3589 
3590 	INIT_LIST_HEAD(&remove_list_head);
3591 	rule_lock = &recp_list[lkup].filt_rule_lock;
3592 	rule_head = &recp_list[lkup].filt_rules;
3593 	ice_acquire_lock(rule_lock);
3594 	status = ice_add_to_vsi_fltr_list(hw, vsi_handle, rule_head,
3595 					  &remove_list_head);
3596 	ice_release_lock(rule_lock);
3597 	if (status)
3598 		return;
3599 
3600 	switch (lkup) {
3601 	case ICE_SW_LKUP_MAC:
3602 		ice_remove_mac_rule(hw, &remove_list_head, &recp_list[lkup]);
3603 		break;
3604 	case ICE_SW_LKUP_VLAN:
3605 		ice_remove_vlan_rule(hw, &remove_list_head, &recp_list[lkup]);
3606 		break;
3607 	case ICE_SW_LKUP_PROMISC:
3608 	case ICE_SW_LKUP_PROMISC_VLAN:
3609 		ice_remove_promisc(hw, lkup, &remove_list_head);
3610 		break;
3611 	case ICE_SW_LKUP_MAC_VLAN:
3612 		ice_debug(hw, ICE_DBG_SW, "MAC VLAN look up is not supported yet\n");
3613 		break;
3614 	case ICE_SW_LKUP_ETHERTYPE:
3615 	case ICE_SW_LKUP_ETHERTYPE_MAC:
3616 		ice_remove_eth_mac(hw, &remove_list_head);
3617 		break;
3618 	case ICE_SW_LKUP_DFLT:
3619 		ice_debug(hw, ICE_DBG_SW, "Remove filters for this lookup type hasn't been implemented yet\n");
3620 		break;
3621 	case ICE_SW_LKUP_LAST:
3622 		ice_debug(hw, ICE_DBG_SW, "Unsupported lookup type\n");
3623 		break;
3624 	}
3625 
3626 	LIST_FOR_EACH_ENTRY_SAFE(fm_entry, tmp, &remove_list_head,
3627 				 ice_fltr_list_entry, list_entry) {
3628 		LIST_DEL(&fm_entry->list_entry);
3629 		ice_free(hw, fm_entry);
3630 	}
3631 }
3632 
3633 /**
3634  * ice_remove_vsi_fltr_rule - Remove all filters for a VSI
3635  * @hw: pointer to the hardware structure
3636  * @vsi_handle: VSI handle to remove filters from
3637  * @sw: pointer to switch info struct
3638  */
3639 static void
3640 ice_remove_vsi_fltr_rule(struct ice_hw *hw, u16 vsi_handle,
3641 			 struct ice_switch_info *sw)
3642 {
3643 	ice_debug(hw, ICE_DBG_TRACE, "%s\n", __func__);
3644 
3645 	ice_remove_vsi_lkup_fltr(hw, vsi_handle,
3646 				 sw->recp_list, ICE_SW_LKUP_MAC);
3647 	ice_remove_vsi_lkup_fltr(hw, vsi_handle,
3648 				 sw->recp_list, ICE_SW_LKUP_MAC_VLAN);
3649 	ice_remove_vsi_lkup_fltr(hw, vsi_handle,
3650 				 sw->recp_list, ICE_SW_LKUP_PROMISC);
3651 	ice_remove_vsi_lkup_fltr(hw, vsi_handle,
3652 				 sw->recp_list, ICE_SW_LKUP_VLAN);
3653 	ice_remove_vsi_lkup_fltr(hw, vsi_handle,
3654 				 sw->recp_list, ICE_SW_LKUP_DFLT);
3655 	ice_remove_vsi_lkup_fltr(hw, vsi_handle,
3656 				 sw->recp_list, ICE_SW_LKUP_ETHERTYPE);
3657 	ice_remove_vsi_lkup_fltr(hw, vsi_handle,
3658 				 sw->recp_list, ICE_SW_LKUP_ETHERTYPE_MAC);
3659 	ice_remove_vsi_lkup_fltr(hw, vsi_handle,
3660 				 sw->recp_list, ICE_SW_LKUP_PROMISC_VLAN);
3661 }
3662 
3663 /**
3664  * ice_remove_vsi_fltr - Remove all filters for a VSI
3665  * @hw: pointer to the hardware structure
3666  * @vsi_handle: VSI handle to remove filters from
3667  */
3668 void ice_remove_vsi_fltr(struct ice_hw *hw, u16 vsi_handle)
3669 {
3670 	ice_remove_vsi_fltr_rule(hw, vsi_handle, hw->switch_info);
3671 }
3672 
3673 /**
3674  * ice_alloc_res_cntr - allocating resource counter
3675  * @hw: pointer to the hardware structure
3676  * @type: type of resource
3677  * @alloc_shared: if set it is shared else dedicated
3678  * @num_items: number of entries requested for FD resource type
3679  * @counter_id: counter index returned by AQ call
3680  */
3681 static enum ice_status
3682 ice_alloc_res_cntr(struct ice_hw *hw, u8 type, u8 alloc_shared, u16 num_items,
3683 		   u16 *counter_id)
3684 {
3685 	struct ice_aqc_alloc_free_res_elem *buf;
3686 	enum ice_status status;
3687 	u16 buf_len;
3688 
3689 	/* Allocate resource */
3690 	buf_len = ice_struct_size(buf, elem, 1);
3691 	buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len);
3692 	if (!buf)
3693 		return ICE_ERR_NO_MEMORY;
3694 
3695 	buf->num_elems = CPU_TO_LE16(num_items);
3696 	buf->res_type = CPU_TO_LE16(((type << ICE_AQC_RES_TYPE_S) &
3697 				      ICE_AQC_RES_TYPE_M) | alloc_shared);
3698 
3699 	status = ice_aq_alloc_free_res(hw, 1, buf, buf_len,
3700 				       ice_aqc_opc_alloc_res, NULL);
3701 	if (status)
3702 		goto exit;
3703 
3704 	*counter_id = LE16_TO_CPU(buf->elem[0].e.sw_resp);
3705 
3706 exit:
3707 	ice_free(hw, buf);
3708 	return status;
3709 }
3710 
3711 /**
3712  * ice_free_res_cntr - free resource counter
3713  * @hw: pointer to the hardware structure
3714  * @type: type of resource
3715  * @alloc_shared: if set it is shared else dedicated
3716  * @num_items: number of entries to be freed for FD resource type
3717  * @counter_id: counter ID resource which needs to be freed
3718  */
3719 static enum ice_status
3720 ice_free_res_cntr(struct ice_hw *hw, u8 type, u8 alloc_shared, u16 num_items,
3721 		  u16 counter_id)
3722 {
3723 	struct ice_aqc_alloc_free_res_elem *buf;
3724 	enum ice_status status;
3725 	u16 buf_len;
3726 
3727 	/* Free resource */
3728 	buf_len = ice_struct_size(buf, elem, 1);
3729 	buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len);
3730 	if (!buf)
3731 		return ICE_ERR_NO_MEMORY;
3732 
3733 	buf->num_elems = CPU_TO_LE16(num_items);
3734 	buf->res_type = CPU_TO_LE16(((type << ICE_AQC_RES_TYPE_S) &
3735 				      ICE_AQC_RES_TYPE_M) | alloc_shared);
3736 	buf->elem[0].e.sw_resp = CPU_TO_LE16(counter_id);
3737 
3738 	status = ice_aq_alloc_free_res(hw, 1, buf, buf_len,
3739 				       ice_aqc_opc_free_res, NULL);
3740 	if (status)
3741 		ice_debug(hw, ICE_DBG_SW, "counter resource could not be freed\n");
3742 
3743 	ice_free(hw, buf);
3744 	return status;
3745 }
3746 
3747 /**
3748  * ice_alloc_vlan_res_counter - obtain counter resource for VLAN type
3749  * @hw: pointer to the hardware structure
3750  * @counter_id: returns counter index
3751  */
3752 enum ice_status ice_alloc_vlan_res_counter(struct ice_hw *hw, u16 *counter_id)
3753 {
3754 	return ice_alloc_res_cntr(hw, ICE_AQC_RES_TYPE_VLAN_COUNTER,
3755 				  ICE_AQC_RES_TYPE_FLAG_DEDICATED, 1,
3756 				  counter_id);
3757 }
3758 
3759 /**
3760  * ice_free_vlan_res_counter - Free counter resource for VLAN type
3761  * @hw: pointer to the hardware structure
3762  * @counter_id: counter index to be freed
3763  */
3764 enum ice_status ice_free_vlan_res_counter(struct ice_hw *hw, u16 counter_id)
3765 {
3766 	return ice_free_res_cntr(hw, ICE_AQC_RES_TYPE_VLAN_COUNTER,
3767 				 ICE_AQC_RES_TYPE_FLAG_DEDICATED, 1,
3768 				 counter_id);
3769 }
3770 
3771 /**
3772  * ice_alloc_res_lg_act - add large action resource
3773  * @hw: pointer to the hardware structure
3774  * @l_id: large action ID to fill it in
3775  * @num_acts: number of actions to hold with a large action entry
3776  */
3777 static enum ice_status
3778 ice_alloc_res_lg_act(struct ice_hw *hw, u16 *l_id, u16 num_acts)
3779 {
3780 	struct ice_aqc_alloc_free_res_elem *sw_buf;
3781 	enum ice_status status;
3782 	u16 buf_len;
3783 
3784 	if (num_acts > ICE_MAX_LG_ACT || num_acts == 0)
3785 		return ICE_ERR_PARAM;
3786 
3787 	/* Allocate resource for large action */
3788 	buf_len = ice_struct_size(sw_buf, elem, 1);
3789 	sw_buf = (struct ice_aqc_alloc_free_res_elem *)ice_malloc(hw, buf_len);
3790 	if (!sw_buf)
3791 		return ICE_ERR_NO_MEMORY;
3792 
3793 	sw_buf->num_elems = CPU_TO_LE16(1);
3794 
3795 	/* If num_acts is 1, use ICE_AQC_RES_TYPE_WIDE_TABLE_1.
3796 	 * If num_acts is 2, use ICE_AQC_RES_TYPE_WIDE_TABLE_3.
3797 	 * If num_acts is greater than 2, then use
3798 	 * ICE_AQC_RES_TYPE_WIDE_TABLE_4.
3799 	 * The num_acts cannot exceed 4. This was ensured at the
3800 	 * beginning of the function.
3801 	 */
3802 	if (num_acts == 1)
3803 		sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_WIDE_TABLE_1);
3804 	else if (num_acts == 2)
3805 		sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_WIDE_TABLE_2);
3806 	else
3807 		sw_buf->res_type = CPU_TO_LE16(ICE_AQC_RES_TYPE_WIDE_TABLE_4);
3808 
3809 	status = ice_aq_alloc_free_res(hw, 1, sw_buf, buf_len,
3810 				       ice_aqc_opc_alloc_res, NULL);
3811 	if (!status)
3812 		*l_id = LE16_TO_CPU(sw_buf->elem[0].e.sw_resp);
3813 
3814 	ice_free(hw, sw_buf);
3815 	return status;
3816 }
3817 
3818 /**
3819  * ice_add_mac_with_sw_marker - add filter with sw marker
3820  * @hw: pointer to the hardware structure
3821  * @f_info: filter info structure containing the MAC filter information
3822  * @sw_marker: sw marker to tag the Rx descriptor with
3823  */
3824 enum ice_status
3825 ice_add_mac_with_sw_marker(struct ice_hw *hw, struct ice_fltr_info *f_info,
3826 			   u16 sw_marker)
3827 {
3828 	struct ice_fltr_mgmt_list_entry *m_entry;
3829 	struct ice_fltr_list_entry fl_info;
3830 	struct ice_sw_recipe *recp_list;
3831 	struct LIST_HEAD_TYPE l_head;
3832 	struct ice_lock *rule_lock;	/* Lock to protect filter rule list */
3833 	enum ice_status ret;
3834 	bool entry_exists;
3835 	u16 lg_act_id;
3836 
3837 	if (f_info->fltr_act != ICE_FWD_TO_VSI)
3838 		return ICE_ERR_PARAM;
3839 
3840 	if (f_info->lkup_type != ICE_SW_LKUP_MAC)
3841 		return ICE_ERR_PARAM;
3842 
3843 	if (sw_marker == ICE_INVAL_SW_MARKER_ID)
3844 		return ICE_ERR_PARAM;
3845 
3846 	if (!ice_is_vsi_valid(hw, f_info->vsi_handle))
3847 		return ICE_ERR_PARAM;
3848 	f_info->fwd_id.hw_vsi_id = ice_get_hw_vsi_num(hw, f_info->vsi_handle);
3849 
3850 	/* Add filter if it doesn't exist so then the adding of large
3851 	 * action always results in update
3852 	 */
3853 
3854 	INIT_LIST_HEAD(&l_head);
3855 	fl_info.fltr_info = *f_info;
3856 	LIST_ADD(&fl_info.list_entry, &l_head);
3857 
3858 	entry_exists = false;
3859 	ret = ice_add_mac_rule(hw, &l_head, hw->switch_info,
3860 			       hw->port_info->lport);
3861 	if (ret == ICE_ERR_ALREADY_EXISTS)
3862 		entry_exists = true;
3863 	else if (ret)
3864 		return ret;
3865 
3866 	recp_list = &hw->switch_info->recp_list[ICE_SW_LKUP_MAC];
3867 	rule_lock = &recp_list->filt_rule_lock;
3868 	ice_acquire_lock(rule_lock);
3869 	/* Get the book keeping entry for the filter */
3870 	m_entry = ice_find_rule_entry(&recp_list->filt_rules, f_info);
3871 	if (!m_entry)
3872 		goto exit_error;
3873 
3874 	/* If counter action was enabled for this rule then don't enable
3875 	 * sw marker large action
3876 	 */
3877 	if (m_entry->counter_index != ICE_INVAL_COUNTER_ID) {
3878 		ret = ICE_ERR_PARAM;
3879 		goto exit_error;
3880 	}
3881 
3882 	/* if same marker was added before */
3883 	if (m_entry->sw_marker_id == sw_marker) {
3884 		ret = ICE_ERR_ALREADY_EXISTS;
3885 		goto exit_error;
3886 	}
3887 
3888 	/* Allocate a hardware table entry to hold large act. Three actions
3889 	 * for marker based large action
3890 	 */
3891 	ret = ice_alloc_res_lg_act(hw, &lg_act_id, 3);
3892 	if (ret)
3893 		goto exit_error;
3894 
3895 	if (lg_act_id == ICE_INVAL_LG_ACT_INDEX)
3896 		goto exit_error;
3897 
3898 	/* Update the switch rule to add the marker action */
3899 	ret = ice_add_marker_act(hw, m_entry, sw_marker, lg_act_id);
3900 	if (!ret) {
3901 		ice_release_lock(rule_lock);
3902 		return ret;
3903 	}
3904 
3905 exit_error:
3906 	ice_release_lock(rule_lock);
3907 	/* only remove entry if it did not exist previously */
3908 	if (!entry_exists)
3909 		ret = ice_remove_mac(hw, &l_head);
3910 
3911 	return ret;
3912 }
3913 
3914 /**
3915  * ice_add_mac_with_counter - add filter with counter enabled
3916  * @hw: pointer to the hardware structure
3917  * @f_info: pointer to filter info structure containing the MAC filter
3918  *          information
3919  */
3920 enum ice_status
3921 ice_add_mac_with_counter(struct ice_hw *hw, struct ice_fltr_info *f_info)
3922 {
3923 	struct ice_fltr_mgmt_list_entry *m_entry;
3924 	struct ice_fltr_list_entry fl_info;
3925 	struct ice_sw_recipe *recp_list;
3926 	struct LIST_HEAD_TYPE l_head;
3927 	struct ice_lock *rule_lock;	/* Lock to protect filter rule list */
3928 	enum ice_status ret;
3929 	bool entry_exist;
3930 	u16 counter_id;
3931 	u16 lg_act_id;
3932 
3933 	if (f_info->fltr_act != ICE_FWD_TO_VSI)
3934 		return ICE_ERR_PARAM;
3935 
3936 	if (f_info->lkup_type != ICE_SW_LKUP_MAC)
3937 		return ICE_ERR_PARAM;
3938 
3939 	if (!ice_is_vsi_valid(hw, f_info->vsi_handle))
3940 		return ICE_ERR_PARAM;
3941 	f_info->fwd_id.hw_vsi_id = ice_get_hw_vsi_num(hw, f_info->vsi_handle);
3942 	recp_list = &hw->switch_info->recp_list[ICE_SW_LKUP_MAC];
3943 
3944 	entry_exist = false;
3945 
3946 	rule_lock = &recp_list->filt_rule_lock;
3947 
3948 	/* Add filter if it doesn't exist so then the adding of large
3949 	 * action always results in update
3950 	 */
3951 	INIT_LIST_HEAD(&l_head);
3952 
3953 	fl_info.fltr_info = *f_info;
3954 	LIST_ADD(&fl_info.list_entry, &l_head);
3955 
3956 	ret = ice_add_mac_rule(hw, &l_head, hw->switch_info,
3957 			       hw->port_info->lport);
3958 	if (ret == ICE_ERR_ALREADY_EXISTS)
3959 		entry_exist = true;
3960 	else if (ret)
3961 		return ret;
3962 
3963 	ice_acquire_lock(rule_lock);
3964 	m_entry = ice_find_rule_entry(&recp_list->filt_rules, f_info);
3965 	if (!m_entry) {
3966 		ret = ICE_ERR_BAD_PTR;
3967 		goto exit_error;
3968 	}
3969 
3970 	/* Don't enable counter for a filter for which sw marker was enabled */
3971 	if (m_entry->sw_marker_id != ICE_INVAL_SW_MARKER_ID) {
3972 		ret = ICE_ERR_PARAM;
3973 		goto exit_error;
3974 	}
3975 
3976 	/* If a counter was already enabled then don't need to add again */
3977 	if (m_entry->counter_index != ICE_INVAL_COUNTER_ID) {
3978 		ret = ICE_ERR_ALREADY_EXISTS;
3979 		goto exit_error;
3980 	}
3981 
3982 	/* Allocate a hardware table entry to VLAN counter */
3983 	ret = ice_alloc_vlan_res_counter(hw, &counter_id);
3984 	if (ret)
3985 		goto exit_error;
3986 
3987 	/* Allocate a hardware table entry to hold large act. Two actions for
3988 	 * counter based large action
3989 	 */
3990 	ret = ice_alloc_res_lg_act(hw, &lg_act_id, 2);
3991 	if (ret)
3992 		goto exit_error;
3993 
3994 	if (lg_act_id == ICE_INVAL_LG_ACT_INDEX)
3995 		goto exit_error;
3996 
3997 	/* Update the switch rule to add the counter action */
3998 	ret = ice_add_counter_act(hw, m_entry, counter_id, lg_act_id);
3999 	if (!ret) {
4000 		ice_release_lock(rule_lock);
4001 		return ret;
4002 	}
4003 
4004 exit_error:
4005 	ice_release_lock(rule_lock);
4006 	/* only remove entry if it did not exist previously */
4007 	if (!entry_exist)
4008 		ret = ice_remove_mac(hw, &l_head);
4009 
4010 	return ret;
4011 }
4012 
4013 /**
4014  * ice_replay_fltr - Replay all the filters stored by a specific list head
4015  * @hw: pointer to the hardware structure
4016  * @list_head: list for which filters needs to be replayed
4017  * @recp_id: Recipe ID for which rules need to be replayed
4018  */
4019 static enum ice_status
4020 ice_replay_fltr(struct ice_hw *hw, u8 recp_id, struct LIST_HEAD_TYPE *list_head)
4021 {
4022 	struct ice_fltr_mgmt_list_entry *itr;
4023 	enum ice_status status = ICE_SUCCESS;
4024 	struct ice_sw_recipe *recp_list;
4025 	u8 lport = hw->port_info->lport;
4026 	struct LIST_HEAD_TYPE l_head;
4027 
4028 	if (LIST_EMPTY(list_head))
4029 		return status;
4030 
4031 	recp_list = &hw->switch_info->recp_list[recp_id];
4032 	/* Move entries from the given list_head to a temporary l_head so that
4033 	 * they can be replayed. Otherwise when trying to re-add the same
4034 	 * filter, the function will return already exists
4035 	 */
4036 	LIST_REPLACE_INIT(list_head, &l_head);
4037 
4038 	/* Mark the given list_head empty by reinitializing it so filters
4039 	 * could be added again by *handler
4040 	 */
4041 	LIST_FOR_EACH_ENTRY(itr, &l_head, ice_fltr_mgmt_list_entry,
4042 			    list_entry) {
4043 		struct ice_fltr_list_entry f_entry;
4044 		u16 vsi_handle;
4045 
4046 		f_entry.fltr_info = itr->fltr_info;
4047 		if (itr->vsi_count < 2 && recp_id != ICE_SW_LKUP_VLAN) {
4048 			status = ice_add_rule_internal(hw, recp_list, lport,
4049 						       &f_entry);
4050 			if (status != ICE_SUCCESS)
4051 				goto end;
4052 			continue;
4053 		}
4054 
4055 		/* Add a filter per VSI separately */
4056 		ice_for_each_set_bit(vsi_handle, itr->vsi_list_info->vsi_map,
4057 				     ICE_MAX_VSI) {
4058 			if (!ice_is_vsi_valid(hw, vsi_handle))
4059 				break;
4060 
4061 			ice_clear_bit(vsi_handle, itr->vsi_list_info->vsi_map);
4062 			f_entry.fltr_info.vsi_handle = vsi_handle;
4063 			f_entry.fltr_info.fwd_id.hw_vsi_id =
4064 				ice_get_hw_vsi_num(hw, vsi_handle);
4065 			f_entry.fltr_info.fltr_act = ICE_FWD_TO_VSI;
4066 			if (recp_id == ICE_SW_LKUP_VLAN)
4067 				status = ice_add_vlan_internal(hw, recp_list,
4068 							       &f_entry);
4069 			else
4070 				status = ice_add_rule_internal(hw, recp_list,
4071 							       lport,
4072 							       &f_entry);
4073 			if (status != ICE_SUCCESS)
4074 				goto end;
4075 		}
4076 	}
4077 end:
4078 	/* Clear the filter management list */
4079 	ice_rem_sw_rule_info(hw, &l_head);
4080 	return status;
4081 }
4082 
4083 /**
4084  * ice_replay_all_fltr - replay all filters stored in bookkeeping lists
4085  * @hw: pointer to the hardware structure
4086  *
4087  * NOTE: This function does not clean up partially added filters on error.
4088  * It is up to caller of the function to issue a reset or fail early.
4089  */
4090 enum ice_status ice_replay_all_fltr(struct ice_hw *hw)
4091 {
4092 	struct ice_switch_info *sw = hw->switch_info;
4093 	enum ice_status status = ICE_SUCCESS;
4094 	u8 i;
4095 
4096 	for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) {
4097 		struct LIST_HEAD_TYPE *head = &sw->recp_list[i].filt_rules;
4098 
4099 		status = ice_replay_fltr(hw, i, head);
4100 		if (status != ICE_SUCCESS)
4101 			return status;
4102 	}
4103 	return status;
4104 }
4105 
4106 /**
4107  * ice_replay_vsi_fltr - Replay filters for requested VSI
4108  * @hw: pointer to the hardware structure
4109  * @pi: pointer to port information structure
4110  * @sw: pointer to switch info struct for which function replays filters
4111  * @vsi_handle: driver VSI handle
4112  * @recp_id: Recipe ID for which rules need to be replayed
4113  * @list_head: list for which filters need to be replayed
4114  *
4115  * Replays the filter of recipe recp_id for a VSI represented via vsi_handle.
4116  * It is required to pass valid VSI handle.
4117  */
4118 static enum ice_status
4119 ice_replay_vsi_fltr(struct ice_hw *hw, struct ice_port_info *pi,
4120 		    struct ice_switch_info *sw, u16 vsi_handle, u8 recp_id,
4121 		    struct LIST_HEAD_TYPE *list_head)
4122 {
4123 	struct ice_fltr_mgmt_list_entry *itr;
4124 	enum ice_status status = ICE_SUCCESS;
4125 	struct ice_sw_recipe *recp_list;
4126 	u16 hw_vsi_id;
4127 
4128 	if (LIST_EMPTY(list_head))
4129 		return status;
4130 	recp_list = &sw->recp_list[recp_id];
4131 	hw_vsi_id = ice_get_hw_vsi_num(hw, vsi_handle);
4132 
4133 	LIST_FOR_EACH_ENTRY(itr, list_head, ice_fltr_mgmt_list_entry,
4134 			    list_entry) {
4135 		struct ice_fltr_list_entry f_entry;
4136 
4137 		f_entry.fltr_info = itr->fltr_info;
4138 		if (itr->vsi_count < 2 && recp_id != ICE_SW_LKUP_VLAN &&
4139 		    itr->fltr_info.vsi_handle == vsi_handle) {
4140 			/* update the src in case it is VSI num */
4141 			if (f_entry.fltr_info.src_id == ICE_SRC_ID_VSI)
4142 				f_entry.fltr_info.src = hw_vsi_id;
4143 			status = ice_add_rule_internal(hw, recp_list,
4144 						       pi->lport,
4145 						       &f_entry);
4146 			if (status != ICE_SUCCESS)
4147 				goto end;
4148 			continue;
4149 		}
4150 		if (!itr->vsi_list_info ||
4151 		    !ice_is_bit_set(itr->vsi_list_info->vsi_map, vsi_handle))
4152 			continue;
4153 		/* Clearing it so that the logic can add it back */
4154 		ice_clear_bit(vsi_handle, itr->vsi_list_info->vsi_map);
4155 		f_entry.fltr_info.vsi_handle = vsi_handle;
4156 		f_entry.fltr_info.fltr_act = ICE_FWD_TO_VSI;
4157 		/* update the src in case it is VSI num */
4158 		if (f_entry.fltr_info.src_id == ICE_SRC_ID_VSI)
4159 			f_entry.fltr_info.src = hw_vsi_id;
4160 		if (recp_id == ICE_SW_LKUP_VLAN)
4161 			status = ice_add_vlan_internal(hw, recp_list, &f_entry);
4162 		else
4163 			status = ice_add_rule_internal(hw, recp_list,
4164 						       pi->lport,
4165 						       &f_entry);
4166 		if (status != ICE_SUCCESS)
4167 			goto end;
4168 	}
4169 end:
4170 	return status;
4171 }
4172 
4173 /**
4174  * ice_replay_vsi_all_fltr - replay all filters stored in bookkeeping lists
4175  * @hw: pointer to the hardware structure
4176  * @pi: pointer to port information structure
4177  * @vsi_handle: driver VSI handle
4178  *
4179  * Replays filters for requested VSI via vsi_handle.
4180  */
4181 enum ice_status
4182 ice_replay_vsi_all_fltr(struct ice_hw *hw, struct ice_port_info *pi,
4183 			u16 vsi_handle)
4184 {
4185 	struct ice_switch_info *sw = hw->switch_info;
4186 	enum ice_status status = ICE_SUCCESS;
4187 	u8 i;
4188 
4189 	/* Update the recipes that were created */
4190 	for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) {
4191 		struct LIST_HEAD_TYPE *head;
4192 
4193 		head = &sw->recp_list[i].filt_replay_rules;
4194 		if (!sw->recp_list[i].adv_rule)
4195 			status = ice_replay_vsi_fltr(hw, pi, sw, vsi_handle, i,
4196 						     head);
4197 		if (status != ICE_SUCCESS)
4198 			return status;
4199 	}
4200 
4201 	return ICE_SUCCESS;
4202 }
4203 
4204 /**
4205  * ice_rm_all_sw_replay_rule - helper function to delete filter replay rules
4206  * @hw: pointer to the HW struct
4207  * @sw: pointer to switch info struct for which function removes filters
4208  *
4209  * Deletes the filter replay rules for given switch
4210  */
4211 void ice_rm_sw_replay_rule_info(struct ice_hw *hw, struct ice_switch_info *sw)
4212 {
4213 	u8 i;
4214 
4215 	if (!sw)
4216 		return;
4217 
4218 	for (i = 0; i < ICE_MAX_NUM_RECIPES; i++) {
4219 		if (!LIST_EMPTY(&sw->recp_list[i].filt_replay_rules)) {
4220 			struct LIST_HEAD_TYPE *l_head;
4221 
4222 			l_head = &sw->recp_list[i].filt_replay_rules;
4223 			if (!sw->recp_list[i].adv_rule)
4224 				ice_rem_sw_rule_info(hw, l_head);
4225 		}
4226 	}
4227 }
4228 
4229 /**
4230  * ice_rm_all_sw_replay_rule_info - deletes filter replay rules
4231  * @hw: pointer to the HW struct
4232  *
4233  * Deletes the filter replay rules.
4234  */
4235 void ice_rm_all_sw_replay_rule_info(struct ice_hw *hw)
4236 {
4237 	ice_rm_sw_replay_rule_info(hw, hw->switch_info);
4238 }
4239 
4240