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