1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2019-2021, Intel Corporation. */
3 
4 #include "ice_vsi_vlan_lib.h"
5 #include "ice_lib.h"
6 #include "ice_fltr.h"
7 #include "ice.h"
8 
9 static void print_invalid_tpid(struct ice_vsi *vsi, u16 tpid)
10 {
11 	dev_err(ice_pf_to_dev(vsi->back), "%s %d specified invalid VLAN tpid 0x%04x\n",
12 		ice_vsi_type_str(vsi->type), vsi->idx, tpid);
13 }
14 
15 /**
16  * validate_vlan - check if the ice_vlan passed in is valid
17  * @vsi: VSI used for printing error message
18  * @vlan: ice_vlan structure to validate
19  *
20  * Return true if the VLAN TPID is valid or if the VLAN TPID is 0 and the VLAN
21  * VID is 0, which allows for non-zero VLAN filters with the specified VLAN TPID
22  * and untagged VLAN 0 filters to be added to the prune list respectively.
23  */
24 static bool validate_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
25 {
26 	if (vlan->tpid != ETH_P_8021Q && vlan->tpid != ETH_P_8021AD &&
27 	    vlan->tpid != ETH_P_QINQ1 && (vlan->tpid || vlan->vid)) {
28 		print_invalid_tpid(vsi, vlan->tpid);
29 		return false;
30 	}
31 
32 	return true;
33 }
34 
35 /**
36  * ice_vsi_add_vlan - default add VLAN implementation for all VSI types
37  * @vsi: VSI being configured
38  * @vlan: VLAN filter to add
39  */
40 int ice_vsi_add_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
41 {
42 	int err;
43 
44 	if (!validate_vlan(vsi, vlan))
45 		return -EINVAL;
46 
47 	err = ice_fltr_add_vlan(vsi, vlan);
48 	if (!err)
49 		vsi->num_vlan++;
50 	else if (err == -EEXIST)
51 		err = 0;
52 	else
53 		dev_err(ice_pf_to_dev(vsi->back), "Failure Adding VLAN %d on VSI %i, status %d\n",
54 			vlan->vid, vsi->vsi_num, err);
55 
56 	return err;
57 }
58 
59 /**
60  * ice_vsi_del_vlan - default del VLAN implementation for all VSI types
61  * @vsi: VSI being configured
62  * @vlan: VLAN filter to delete
63  */
64 int ice_vsi_del_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
65 {
66 	struct ice_pf *pf = vsi->back;
67 	struct device *dev;
68 	int err;
69 
70 	if (!validate_vlan(vsi, vlan))
71 		return -EINVAL;
72 
73 	dev = ice_pf_to_dev(pf);
74 
75 	err = ice_fltr_remove_vlan(vsi, vlan);
76 	if (!err)
77 		vsi->num_vlan--;
78 	else if (err == -ENOENT || err == -EBUSY)
79 		err = 0;
80 	else
81 		dev_err(dev, "Error removing VLAN %d on VSI %i error: %d\n",
82 			vlan->vid, vsi->vsi_num, err);
83 
84 	return err;
85 }
86 
87 /**
88  * ice_vsi_manage_vlan_insertion - Manage VLAN insertion for the VSI for Tx
89  * @vsi: the VSI being changed
90  */
91 static int ice_vsi_manage_vlan_insertion(struct ice_vsi *vsi)
92 {
93 	struct ice_hw *hw = &vsi->back->hw;
94 	struct ice_vsi_ctx *ctxt;
95 	int err;
96 
97 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
98 	if (!ctxt)
99 		return -ENOMEM;
100 
101 	/* Here we are configuring the VSI to let the driver add VLAN tags by
102 	 * setting inner_vlan_flags to ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL. The actual VLAN tag
103 	 * insertion happens in the Tx hot path, in ice_tx_map.
104 	 */
105 	ctxt->info.inner_vlan_flags = ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL;
106 
107 	/* Preserve existing VLAN strip setting */
108 	ctxt->info.inner_vlan_flags |= (vsi->info.inner_vlan_flags &
109 					ICE_AQ_VSI_INNER_VLAN_EMODE_M);
110 
111 	ctxt->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID);
112 
113 	err = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
114 	if (err) {
115 		dev_err(ice_pf_to_dev(vsi->back), "update VSI for VLAN insert failed, err %d aq_err %s\n",
116 			err, ice_aq_str(hw->adminq.sq_last_status));
117 		goto out;
118 	}
119 
120 	vsi->info.inner_vlan_flags = ctxt->info.inner_vlan_flags;
121 out:
122 	kfree(ctxt);
123 	return err;
124 }
125 
126 /**
127  * ice_vsi_manage_vlan_stripping - Manage VLAN stripping for the VSI for Rx
128  * @vsi: the VSI being changed
129  * @ena: boolean value indicating if this is a enable or disable request
130  */
131 static int ice_vsi_manage_vlan_stripping(struct ice_vsi *vsi, bool ena)
132 {
133 	struct ice_hw *hw = &vsi->back->hw;
134 	struct ice_vsi_ctx *ctxt;
135 	u8 *ivf;
136 	int err;
137 
138 	/* do not allow modifying VLAN stripping when a port VLAN is configured
139 	 * on this VSI
140 	 */
141 	if (vsi->info.port_based_inner_vlan)
142 		return 0;
143 
144 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
145 	if (!ctxt)
146 		return -ENOMEM;
147 
148 	ivf = &ctxt->info.inner_vlan_flags;
149 
150 	/* Here we are configuring what the VSI should do with the VLAN tag in
151 	 * the Rx packet. We can either leave the tag in the packet or put it in
152 	 * the Rx descriptor.
153 	 */
154 	if (ena) {
155 		/* Strip VLAN tag from Rx packet and put it in the desc */
156 		*ivf = FIELD_PREP(ICE_AQ_VSI_INNER_VLAN_EMODE_M,
157 				  ICE_AQ_VSI_INNER_VLAN_EMODE_STR_BOTH);
158 	} else {
159 		/* Disable stripping. Leave tag in packet */
160 		*ivf = FIELD_PREP(ICE_AQ_VSI_INNER_VLAN_EMODE_M,
161 				  ICE_AQ_VSI_INNER_VLAN_EMODE_NOTHING);
162 	}
163 
164 	/* Allow all packets untagged/tagged */
165 	*ivf |= ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL;
166 
167 	ctxt->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID);
168 
169 	err = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
170 	if (err) {
171 		dev_err(ice_pf_to_dev(vsi->back), "update VSI for VLAN strip failed, ena = %d err %d aq_err %s\n",
172 			ena, err, ice_aq_str(hw->adminq.sq_last_status));
173 		goto out;
174 	}
175 
176 	vsi->info.inner_vlan_flags = ctxt->info.inner_vlan_flags;
177 out:
178 	kfree(ctxt);
179 	return err;
180 }
181 
182 int ice_vsi_ena_inner_stripping(struct ice_vsi *vsi, const u16 tpid)
183 {
184 	if (tpid != ETH_P_8021Q) {
185 		print_invalid_tpid(vsi, tpid);
186 		return -EINVAL;
187 	}
188 
189 	return ice_vsi_manage_vlan_stripping(vsi, true);
190 }
191 
192 int ice_vsi_dis_inner_stripping(struct ice_vsi *vsi)
193 {
194 	return ice_vsi_manage_vlan_stripping(vsi, false);
195 }
196 
197 int ice_vsi_ena_inner_insertion(struct ice_vsi *vsi, const u16 tpid)
198 {
199 	if (tpid != ETH_P_8021Q) {
200 		print_invalid_tpid(vsi, tpid);
201 		return -EINVAL;
202 	}
203 
204 	return ice_vsi_manage_vlan_insertion(vsi);
205 }
206 
207 int ice_vsi_dis_inner_insertion(struct ice_vsi *vsi)
208 {
209 	return ice_vsi_manage_vlan_insertion(vsi);
210 }
211 
212 static void
213 ice_save_vlan_info(struct ice_aqc_vsi_props *info,
214 		   struct ice_vsi_vlan_info *vlan)
215 {
216 	vlan->sw_flags2 = info->sw_flags2;
217 	vlan->inner_vlan_flags = info->inner_vlan_flags;
218 	vlan->outer_vlan_flags = info->outer_vlan_flags;
219 }
220 
221 static void
222 ice_restore_vlan_info(struct ice_aqc_vsi_props *info,
223 		      struct ice_vsi_vlan_info *vlan)
224 {
225 	info->sw_flags2 = vlan->sw_flags2;
226 	info->inner_vlan_flags = vlan->inner_vlan_flags;
227 	info->outer_vlan_flags = vlan->outer_vlan_flags;
228 }
229 
230 /**
231  * __ice_vsi_set_inner_port_vlan - set port VLAN VSI context settings to enable a port VLAN
232  * @vsi: the VSI to update
233  * @pvid_info: VLAN ID and QoS used to set the PVID VSI context field
234  */
235 static int __ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, u16 pvid_info)
236 {
237 	struct ice_hw *hw = &vsi->back->hw;
238 	struct ice_aqc_vsi_props *info;
239 	struct ice_vsi_ctx *ctxt;
240 	int ret;
241 
242 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
243 	if (!ctxt)
244 		return -ENOMEM;
245 
246 	ice_save_vlan_info(&vsi->info, &vsi->vlan_info);
247 	ctxt->info = vsi->info;
248 	info = &ctxt->info;
249 	info->inner_vlan_flags = ICE_AQ_VSI_INNER_VLAN_TX_MODE_ACCEPTUNTAGGED |
250 		ICE_AQ_VSI_INNER_VLAN_INSERT_PVID |
251 		ICE_AQ_VSI_INNER_VLAN_EMODE_STR;
252 	info->sw_flags2 |= ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA;
253 
254 	info->port_based_inner_vlan = cpu_to_le16(pvid_info);
255 	info->valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID |
256 					   ICE_AQ_VSI_PROP_SW_VALID);
257 
258 	ret = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
259 	if (ret) {
260 		dev_info(ice_hw_to_dev(hw), "update VSI for port VLAN failed, err %d aq_err %s\n",
261 			 ret, ice_aq_str(hw->adminq.sq_last_status));
262 		goto out;
263 	}
264 
265 	vsi->info.inner_vlan_flags = info->inner_vlan_flags;
266 	vsi->info.sw_flags2 = info->sw_flags2;
267 	vsi->info.port_based_inner_vlan = info->port_based_inner_vlan;
268 out:
269 	kfree(ctxt);
270 	return ret;
271 }
272 
273 int ice_vsi_set_inner_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
274 {
275 	u16 port_vlan_info;
276 
277 	if (vlan->tpid != ETH_P_8021Q)
278 		return -EINVAL;
279 
280 	if (vlan->prio > 7)
281 		return -EINVAL;
282 
283 	port_vlan_info = vlan->vid | (vlan->prio << VLAN_PRIO_SHIFT);
284 
285 	return __ice_vsi_set_inner_port_vlan(vsi, port_vlan_info);
286 }
287 
288 int ice_vsi_clear_inner_port_vlan(struct ice_vsi *vsi)
289 {
290 	struct ice_hw *hw = &vsi->back->hw;
291 	struct ice_aqc_vsi_props *info;
292 	struct ice_vsi_ctx *ctxt;
293 	int ret;
294 
295 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
296 	if (!ctxt)
297 		return -ENOMEM;
298 
299 	ice_restore_vlan_info(&vsi->info, &vsi->vlan_info);
300 	vsi->info.port_based_inner_vlan = 0;
301 	ctxt->info = vsi->info;
302 	info = &ctxt->info;
303 	info->valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID |
304 					   ICE_AQ_VSI_PROP_SW_VALID);
305 
306 	ret = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
307 	if (ret)
308 		dev_err(ice_hw_to_dev(hw), "update VSI for port VLAN failed, err %d aq_err %s\n",
309 			ret, ice_aq_str(hw->adminq.sq_last_status));
310 
311 	kfree(ctxt);
312 	return ret;
313 }
314 
315 /**
316  * ice_cfg_vlan_pruning - enable or disable VLAN pruning on the VSI
317  * @vsi: VSI to enable or disable VLAN pruning on
318  * @ena: set to true to enable VLAN pruning and false to disable it
319  *
320  * returns 0 if VSI is updated, negative otherwise
321  */
322 static int ice_cfg_vlan_pruning(struct ice_vsi *vsi, bool ena)
323 {
324 	struct ice_vsi_ctx *ctxt;
325 	struct ice_pf *pf;
326 	int status;
327 
328 	if (!vsi)
329 		return -EINVAL;
330 
331 	/* Don't enable VLAN pruning if the netdev is currently in promiscuous
332 	 * mode. VLAN pruning will be enabled when the interface exits
333 	 * promiscuous mode if any VLAN filters are active.
334 	 */
335 	if (vsi->netdev && vsi->netdev->flags & IFF_PROMISC && ena)
336 		return 0;
337 
338 	pf = vsi->back;
339 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
340 	if (!ctxt)
341 		return -ENOMEM;
342 
343 	ctxt->info = vsi->info;
344 
345 	if (ena)
346 		ctxt->info.sw_flags2 |= ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA;
347 	else
348 		ctxt->info.sw_flags2 &= ~ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA;
349 
350 	ctxt->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SW_VALID);
351 
352 	status = ice_update_vsi(&pf->hw, vsi->idx, ctxt, NULL);
353 	if (status) {
354 		netdev_err(vsi->netdev, "%sabling VLAN pruning on VSI handle: %d, VSI HW ID: %d failed, err = %d, aq_err = %s\n",
355 			   ena ? "En" : "Dis", vsi->idx, vsi->vsi_num, status,
356 			   ice_aq_str(pf->hw.adminq.sq_last_status));
357 		goto err_out;
358 	}
359 
360 	vsi->info.sw_flags2 = ctxt->info.sw_flags2;
361 
362 	kfree(ctxt);
363 	return 0;
364 
365 err_out:
366 	kfree(ctxt);
367 	return status;
368 }
369 
370 int ice_vsi_ena_rx_vlan_filtering(struct ice_vsi *vsi)
371 {
372 	return ice_cfg_vlan_pruning(vsi, true);
373 }
374 
375 int ice_vsi_dis_rx_vlan_filtering(struct ice_vsi *vsi)
376 {
377 	return ice_cfg_vlan_pruning(vsi, false);
378 }
379 
380 static int ice_cfg_vlan_antispoof(struct ice_vsi *vsi, bool enable)
381 {
382 	struct ice_vsi_ctx *ctx;
383 	int err;
384 
385 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
386 	if (!ctx)
387 		return -ENOMEM;
388 
389 	ctx->info.sec_flags = vsi->info.sec_flags;
390 	ctx->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SECURITY_VALID);
391 
392 	if (enable)
393 		ctx->info.sec_flags |= ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA <<
394 			ICE_AQ_VSI_SEC_TX_PRUNE_ENA_S;
395 	else
396 		ctx->info.sec_flags &= ~(ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA <<
397 					 ICE_AQ_VSI_SEC_TX_PRUNE_ENA_S);
398 
399 	err = ice_update_vsi(&vsi->back->hw, vsi->idx, ctx, NULL);
400 	if (err)
401 		dev_err(ice_pf_to_dev(vsi->back), "Failed to configure Tx VLAN anti-spoof %s for VSI %d, error %d\n",
402 			enable ? "ON" : "OFF", vsi->vsi_num, err);
403 	else
404 		vsi->info.sec_flags = ctx->info.sec_flags;
405 
406 	kfree(ctx);
407 
408 	return err;
409 }
410 
411 int ice_vsi_ena_tx_vlan_filtering(struct ice_vsi *vsi)
412 {
413 	return ice_cfg_vlan_antispoof(vsi, true);
414 }
415 
416 int ice_vsi_dis_tx_vlan_filtering(struct ice_vsi *vsi)
417 {
418 	return ice_cfg_vlan_antispoof(vsi, false);
419 }
420 
421 /**
422  * tpid_to_vsi_outer_vlan_type - convert from TPID to VSI context based tag_type
423  * @tpid: tpid used to translate into VSI context based tag_type
424  * @tag_type: output variable to hold the VSI context based tag type
425  */
426 static int tpid_to_vsi_outer_vlan_type(u16 tpid, u8 *tag_type)
427 {
428 	switch (tpid) {
429 	case ETH_P_8021Q:
430 		*tag_type = ICE_AQ_VSI_OUTER_TAG_VLAN_8100;
431 		break;
432 	case ETH_P_8021AD:
433 		*tag_type = ICE_AQ_VSI_OUTER_TAG_STAG;
434 		break;
435 	case ETH_P_QINQ1:
436 		*tag_type = ICE_AQ_VSI_OUTER_TAG_VLAN_9100;
437 		break;
438 	default:
439 		*tag_type = 0;
440 		return -EINVAL;
441 	}
442 
443 	return 0;
444 }
445 
446 /**
447  * ice_vsi_ena_outer_stripping - enable outer VLAN stripping
448  * @vsi: VSI to configure
449  * @tpid: TPID to enable outer VLAN stripping for
450  *
451  * Enable outer VLAN stripping via VSI context. This function should only be
452  * used if DVM is supported. Also, this function should never be called directly
453  * as it should be part of ice_vsi_vlan_ops if it's needed.
454  *
455  * Since the VSI context only supports a single TPID for insertion and
456  * stripping, setting the TPID for stripping will affect the TPID for insertion.
457  * Callers need to be aware of this limitation.
458  *
459  * Only modify outer VLAN stripping settings and the VLAN TPID. Outer VLAN
460  * insertion settings are unmodified.
461  *
462  * This enables hardware to strip a VLAN tag with the specified TPID to be
463  * stripped from the packet and placed in the receive descriptor.
464  */
465 int ice_vsi_ena_outer_stripping(struct ice_vsi *vsi, u16 tpid)
466 {
467 	struct ice_hw *hw = &vsi->back->hw;
468 	struct ice_vsi_ctx *ctxt;
469 	u8 tag_type;
470 	int err;
471 
472 	/* do not allow modifying VLAN stripping when a port VLAN is configured
473 	 * on this VSI
474 	 */
475 	if (vsi->info.port_based_outer_vlan)
476 		return 0;
477 
478 	if (tpid_to_vsi_outer_vlan_type(tpid, &tag_type))
479 		return -EINVAL;
480 
481 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
482 	if (!ctxt)
483 		return -ENOMEM;
484 
485 	ctxt->info.valid_sections =
486 		cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID);
487 	/* clear current outer VLAN strip settings */
488 	ctxt->info.outer_vlan_flags = vsi->info.outer_vlan_flags &
489 		~(ICE_AQ_VSI_OUTER_VLAN_EMODE_M | ICE_AQ_VSI_OUTER_TAG_TYPE_M);
490 	ctxt->info.outer_vlan_flags |=
491 		((ICE_AQ_VSI_OUTER_VLAN_EMODE_SHOW_BOTH <<
492 		  ICE_AQ_VSI_OUTER_VLAN_EMODE_S) |
493 		 ((tag_type << ICE_AQ_VSI_OUTER_TAG_TYPE_S) &
494 		  ICE_AQ_VSI_OUTER_TAG_TYPE_M));
495 
496 	err = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
497 	if (err)
498 		dev_err(ice_pf_to_dev(vsi->back), "update VSI for enabling outer VLAN stripping failed, err %d aq_err %s\n",
499 			err, ice_aq_str(hw->adminq.sq_last_status));
500 	else
501 		vsi->info.outer_vlan_flags = ctxt->info.outer_vlan_flags;
502 
503 	kfree(ctxt);
504 	return err;
505 }
506 
507 /**
508  * ice_vsi_dis_outer_stripping - disable outer VLAN stripping
509  * @vsi: VSI to configure
510  *
511  * Disable outer VLAN stripping via VSI context. This function should only be
512  * used if DVM is supported. Also, this function should never be called directly
513  * as it should be part of ice_vsi_vlan_ops if it's needed.
514  *
515  * Only modify the outer VLAN stripping settings. The VLAN TPID and outer VLAN
516  * insertion settings are unmodified.
517  *
518  * This tells the hardware to not strip any VLAN tagged packets, thus leaving
519  * them in the packet. This enables software offloaded VLAN stripping and
520  * disables hardware offloaded VLAN stripping.
521  */
522 int ice_vsi_dis_outer_stripping(struct ice_vsi *vsi)
523 {
524 	struct ice_hw *hw = &vsi->back->hw;
525 	struct ice_vsi_ctx *ctxt;
526 	int err;
527 
528 	if (vsi->info.port_based_outer_vlan)
529 		return 0;
530 
531 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
532 	if (!ctxt)
533 		return -ENOMEM;
534 
535 	ctxt->info.valid_sections =
536 		cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID);
537 	/* clear current outer VLAN strip settings */
538 	ctxt->info.outer_vlan_flags = vsi->info.outer_vlan_flags &
539 		~ICE_AQ_VSI_OUTER_VLAN_EMODE_M;
540 	ctxt->info.outer_vlan_flags |= ICE_AQ_VSI_OUTER_VLAN_EMODE_NOTHING <<
541 		ICE_AQ_VSI_OUTER_VLAN_EMODE_S;
542 
543 	err = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
544 	if (err)
545 		dev_err(ice_pf_to_dev(vsi->back), "update VSI for disabling outer VLAN stripping failed, err %d aq_err %s\n",
546 			err, ice_aq_str(hw->adminq.sq_last_status));
547 	else
548 		vsi->info.outer_vlan_flags = ctxt->info.outer_vlan_flags;
549 
550 	kfree(ctxt);
551 	return err;
552 }
553 
554 /**
555  * ice_vsi_ena_outer_insertion - enable outer VLAN insertion
556  * @vsi: VSI to configure
557  * @tpid: TPID to enable outer VLAN insertion for
558  *
559  * Enable outer VLAN insertion via VSI context. This function should only be
560  * used if DVM is supported. Also, this function should never be called directly
561  * as it should be part of ice_vsi_vlan_ops if it's needed.
562  *
563  * Since the VSI context only supports a single TPID for insertion and
564  * stripping, setting the TPID for insertion will affect the TPID for stripping.
565  * Callers need to be aware of this limitation.
566  *
567  * Only modify outer VLAN insertion settings and the VLAN TPID. Outer VLAN
568  * stripping settings are unmodified.
569  *
570  * This allows a VLAN tag with the specified TPID to be inserted in the transmit
571  * descriptor.
572  */
573 int ice_vsi_ena_outer_insertion(struct ice_vsi *vsi, u16 tpid)
574 {
575 	struct ice_hw *hw = &vsi->back->hw;
576 	struct ice_vsi_ctx *ctxt;
577 	u8 tag_type;
578 	int err;
579 
580 	if (vsi->info.port_based_outer_vlan)
581 		return 0;
582 
583 	if (tpid_to_vsi_outer_vlan_type(tpid, &tag_type))
584 		return -EINVAL;
585 
586 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
587 	if (!ctxt)
588 		return -ENOMEM;
589 
590 	ctxt->info.valid_sections =
591 		cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID);
592 	/* clear current outer VLAN insertion settings */
593 	ctxt->info.outer_vlan_flags = vsi->info.outer_vlan_flags &
594 		~(ICE_AQ_VSI_OUTER_VLAN_PORT_BASED_INSERT |
595 		  ICE_AQ_VSI_OUTER_VLAN_BLOCK_TX_DESC |
596 		  ICE_AQ_VSI_OUTER_VLAN_TX_MODE_M |
597 		  ICE_AQ_VSI_OUTER_TAG_TYPE_M);
598 	ctxt->info.outer_vlan_flags |=
599 		((ICE_AQ_VSI_OUTER_VLAN_TX_MODE_ALL <<
600 		  ICE_AQ_VSI_OUTER_VLAN_TX_MODE_S) &
601 		 ICE_AQ_VSI_OUTER_VLAN_TX_MODE_M) |
602 		((tag_type << ICE_AQ_VSI_OUTER_TAG_TYPE_S) &
603 		 ICE_AQ_VSI_OUTER_TAG_TYPE_M);
604 
605 	err = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
606 	if (err)
607 		dev_err(ice_pf_to_dev(vsi->back), "update VSI for enabling outer VLAN insertion failed, err %d aq_err %s\n",
608 			err, ice_aq_str(hw->adminq.sq_last_status));
609 	else
610 		vsi->info.outer_vlan_flags = ctxt->info.outer_vlan_flags;
611 
612 	kfree(ctxt);
613 	return err;
614 }
615 
616 /**
617  * ice_vsi_dis_outer_insertion - disable outer VLAN insertion
618  * @vsi: VSI to configure
619  *
620  * Disable outer VLAN insertion via VSI context. This function should only be
621  * used if DVM is supported. Also, this function should never be called directly
622  * as it should be part of ice_vsi_vlan_ops if it's needed.
623  *
624  * Only modify the outer VLAN insertion settings. The VLAN TPID and outer VLAN
625  * settings are unmodified.
626  *
627  * This tells the hardware to not allow any VLAN tagged packets in the transmit
628  * descriptor. This enables software offloaded VLAN insertion and disables
629  * hardware offloaded VLAN insertion.
630  */
631 int ice_vsi_dis_outer_insertion(struct ice_vsi *vsi)
632 {
633 	struct ice_hw *hw = &vsi->back->hw;
634 	struct ice_vsi_ctx *ctxt;
635 	int err;
636 
637 	if (vsi->info.port_based_outer_vlan)
638 		return 0;
639 
640 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
641 	if (!ctxt)
642 		return -ENOMEM;
643 
644 	ctxt->info.valid_sections =
645 		cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID);
646 	/* clear current outer VLAN insertion settings */
647 	ctxt->info.outer_vlan_flags = vsi->info.outer_vlan_flags &
648 		~(ICE_AQ_VSI_OUTER_VLAN_PORT_BASED_INSERT |
649 		  ICE_AQ_VSI_OUTER_VLAN_TX_MODE_M);
650 	ctxt->info.outer_vlan_flags |=
651 		ICE_AQ_VSI_OUTER_VLAN_BLOCK_TX_DESC |
652 		((ICE_AQ_VSI_OUTER_VLAN_TX_MODE_ALL <<
653 		  ICE_AQ_VSI_OUTER_VLAN_TX_MODE_S) &
654 		 ICE_AQ_VSI_OUTER_VLAN_TX_MODE_M);
655 
656 	err = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
657 	if (err)
658 		dev_err(ice_pf_to_dev(vsi->back), "update VSI for disabling outer VLAN insertion failed, err %d aq_err %s\n",
659 			err, ice_aq_str(hw->adminq.sq_last_status));
660 	else
661 		vsi->info.outer_vlan_flags = ctxt->info.outer_vlan_flags;
662 
663 	kfree(ctxt);
664 	return err;
665 }
666 
667 /**
668  * __ice_vsi_set_outer_port_vlan - set the outer port VLAN and related settings
669  * @vsi: VSI to configure
670  * @vlan_info: packed u16 that contains the VLAN prio and ID
671  * @tpid: TPID of the port VLAN
672  *
673  * Set the port VLAN prio, ID, and TPID.
674  *
675  * Enable VLAN pruning so the VSI doesn't receive any traffic that doesn't match
676  * a VLAN prune rule. The caller should take care to add a VLAN prune rule that
677  * matches the port VLAN ID and TPID.
678  *
679  * Tell hardware to strip outer VLAN tagged packets on receive and don't put
680  * them in the receive descriptor. VSI(s) in port VLANs should not be aware of
681  * the port VLAN ID or TPID they are assigned to.
682  *
683  * Tell hardware to prevent outer VLAN tag insertion on transmit and only allow
684  * untagged outer packets from the transmit descriptor.
685  *
686  * Also, tell the hardware to insert the port VLAN on transmit.
687  */
688 static int
689 __ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, u16 vlan_info, u16 tpid)
690 {
691 	struct ice_hw *hw = &vsi->back->hw;
692 	struct ice_vsi_ctx *ctxt;
693 	u8 tag_type;
694 	int err;
695 
696 	if (tpid_to_vsi_outer_vlan_type(tpid, &tag_type))
697 		return -EINVAL;
698 
699 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
700 	if (!ctxt)
701 		return -ENOMEM;
702 
703 	ice_save_vlan_info(&vsi->info, &vsi->vlan_info);
704 	ctxt->info = vsi->info;
705 
706 	ctxt->info.sw_flags2 |= ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA;
707 
708 	ctxt->info.port_based_outer_vlan = cpu_to_le16(vlan_info);
709 	ctxt->info.outer_vlan_flags =
710 		(ICE_AQ_VSI_OUTER_VLAN_EMODE_SHOW <<
711 		 ICE_AQ_VSI_OUTER_VLAN_EMODE_S) |
712 		((tag_type << ICE_AQ_VSI_OUTER_TAG_TYPE_S) &
713 		 ICE_AQ_VSI_OUTER_TAG_TYPE_M) |
714 		ICE_AQ_VSI_OUTER_VLAN_BLOCK_TX_DESC |
715 		(ICE_AQ_VSI_OUTER_VLAN_TX_MODE_ACCEPTUNTAGGED <<
716 		 ICE_AQ_VSI_OUTER_VLAN_TX_MODE_S) |
717 		ICE_AQ_VSI_OUTER_VLAN_PORT_BASED_INSERT;
718 
719 	ctxt->info.valid_sections =
720 		cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID |
721 			    ICE_AQ_VSI_PROP_SW_VALID);
722 
723 	err = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
724 	if (err) {
725 		dev_err(ice_pf_to_dev(vsi->back), "update VSI for setting outer port based VLAN failed, err %d aq_err %s\n",
726 			err, ice_aq_str(hw->adminq.sq_last_status));
727 	} else {
728 		vsi->info.port_based_outer_vlan = ctxt->info.port_based_outer_vlan;
729 		vsi->info.outer_vlan_flags = ctxt->info.outer_vlan_flags;
730 		vsi->info.sw_flags2 = ctxt->info.sw_flags2;
731 	}
732 
733 	kfree(ctxt);
734 	return err;
735 }
736 
737 /**
738  * ice_vsi_set_outer_port_vlan - public version of __ice_vsi_set_outer_port_vlan
739  * @vsi: VSI to configure
740  * @vlan: ice_vlan structure used to set the port VLAN
741  *
742  * Set the outer port VLAN via VSI context. This function should only be
743  * used if DVM is supported. Also, this function should never be called directly
744  * as it should be part of ice_vsi_vlan_ops if it's needed.
745  *
746  * Use the ice_vlan structure passed in to set this VSI in a port VLAN.
747  */
748 int ice_vsi_set_outer_port_vlan(struct ice_vsi *vsi, struct ice_vlan *vlan)
749 {
750 	u16 port_vlan_info;
751 
752 	if (vlan->prio > (VLAN_PRIO_MASK >> VLAN_PRIO_SHIFT))
753 		return -EINVAL;
754 
755 	port_vlan_info = vlan->vid | (vlan->prio << VLAN_PRIO_SHIFT);
756 
757 	return __ice_vsi_set_outer_port_vlan(vsi, port_vlan_info, vlan->tpid);
758 }
759 
760 /**
761  * ice_vsi_clear_outer_port_vlan - clear outer port vlan
762  * @vsi: VSI to configure
763  *
764  * The function is restoring previously set vlan config (saved in
765  * vsi->vlan_info). Setting happens in port vlan configuration.
766  */
767 int ice_vsi_clear_outer_port_vlan(struct ice_vsi *vsi)
768 {
769 	struct ice_hw *hw = &vsi->back->hw;
770 	struct ice_vsi_ctx *ctxt;
771 	int err;
772 
773 	ctxt = kzalloc(sizeof(*ctxt), GFP_KERNEL);
774 	if (!ctxt)
775 		return -ENOMEM;
776 
777 	ice_restore_vlan_info(&vsi->info, &vsi->vlan_info);
778 	vsi->info.port_based_outer_vlan = 0;
779 	ctxt->info = vsi->info;
780 
781 	ctxt->info.valid_sections =
782 		cpu_to_le16(ICE_AQ_VSI_PROP_OUTER_TAG_VALID |
783 			    ICE_AQ_VSI_PROP_SW_VALID);
784 
785 	err = ice_update_vsi(hw, vsi->idx, ctxt, NULL);
786 	if (err)
787 		dev_err(ice_pf_to_dev(vsi->back), "update VSI for clearing outer port based VLAN failed, err %d aq_err %s\n",
788 			err, ice_aq_str(hw->adminq.sq_last_status));
789 
790 	kfree(ctxt);
791 	return err;
792 }
793