1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2019-2021, Intel Corporation. */
3 
4 #include "ice.h"
5 #include "ice_lib.h"
6 #include "ice_eswitch.h"
7 #include "ice_fltr.h"
8 #include "ice_repr.h"
9 #include "ice_devlink.h"
10 #include "ice_tc_lib.h"
11 
12 /**
13  * ice_eswitch_add_vf_mac_rule - add adv rule with VF's MAC
14  * @pf: pointer to PF struct
15  * @vf: pointer to VF struct
16  * @mac: VF's MAC address
17  *
18  * This function adds advanced rule that forwards packets with
19  * VF's MAC address (src MAC) to the corresponding switchdev ctrl VSI queue.
20  */
21 int
22 ice_eswitch_add_vf_mac_rule(struct ice_pf *pf, struct ice_vf *vf, const u8 *mac)
23 {
24 	struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
25 	struct ice_adv_rule_info rule_info = { 0 };
26 	struct ice_adv_lkup_elem *list;
27 	struct ice_hw *hw = &pf->hw;
28 	const u16 lkups_cnt = 1;
29 	int err;
30 
31 	list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC);
32 	if (!list)
33 		return -ENOMEM;
34 
35 	list[0].type = ICE_MAC_OFOS;
36 	ether_addr_copy(list[0].h_u.eth_hdr.src_addr, mac);
37 	eth_broadcast_addr(list[0].m_u.eth_hdr.src_addr);
38 
39 	rule_info.sw_act.flag |= ICE_FLTR_TX;
40 	rule_info.sw_act.vsi_handle = ctrl_vsi->idx;
41 	rule_info.sw_act.fltr_act = ICE_FWD_TO_Q;
42 	rule_info.rx = false;
43 	rule_info.sw_act.fwd_id.q_id = hw->func_caps.common_cap.rxq_first_id +
44 				       ctrl_vsi->rxq_map[vf->vf_id];
45 	rule_info.flags_info.act |= ICE_SINGLE_ACT_LB_ENABLE;
46 	rule_info.flags_info.act_valid = true;
47 	rule_info.tun_type = ICE_SW_TUN_AND_NON_TUN;
48 
49 	err = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info,
50 			       vf->repr->mac_rule);
51 	if (err)
52 		dev_err(ice_pf_to_dev(pf), "Unable to add VF mac rule in switchdev mode for VF %d",
53 			vf->vf_id);
54 	else
55 		vf->repr->rule_added = true;
56 
57 	kfree(list);
58 	return err;
59 }
60 
61 /**
62  * ice_eswitch_replay_vf_mac_rule - replay adv rule with VF's MAC
63  * @vf: pointer to vF struct
64  *
65  * This function replays VF's MAC rule after reset.
66  */
67 void ice_eswitch_replay_vf_mac_rule(struct ice_vf *vf)
68 {
69 	int err;
70 
71 	if (!ice_is_switchdev_running(vf->pf))
72 		return;
73 
74 	if (is_valid_ether_addr(vf->hw_lan_addr)) {
75 		err = ice_eswitch_add_vf_mac_rule(vf->pf, vf,
76 						  vf->hw_lan_addr);
77 		if (err) {
78 			dev_err(ice_pf_to_dev(vf->pf), "Failed to add MAC %pM for VF %d\n, error %d\n",
79 				vf->hw_lan_addr, vf->vf_id, err);
80 			return;
81 		}
82 		vf->num_mac++;
83 
84 		ether_addr_copy(vf->dev_lan_addr, vf->hw_lan_addr);
85 	}
86 }
87 
88 /**
89  * ice_eswitch_del_vf_mac_rule - delete adv rule with VF's MAC
90  * @vf: pointer to the VF struct
91  *
92  * Delete the advanced rule that was used to forward packets with the VF's MAC
93  * address (src MAC) to the corresponding switchdev ctrl VSI queue.
94  */
95 void ice_eswitch_del_vf_mac_rule(struct ice_vf *vf)
96 {
97 	if (!ice_is_switchdev_running(vf->pf))
98 		return;
99 
100 	if (!vf->repr->rule_added)
101 		return;
102 
103 	ice_rem_adv_rule_by_id(&vf->pf->hw, vf->repr->mac_rule);
104 	vf->repr->rule_added = false;
105 }
106 
107 /**
108  * ice_eswitch_setup_env - configure switchdev HW filters
109  * @pf: pointer to PF struct
110  *
111  * This function adds HW filters configuration specific for switchdev
112  * mode.
113  */
114 static int ice_eswitch_setup_env(struct ice_pf *pf)
115 {
116 	struct ice_vsi *uplink_vsi = pf->switchdev.uplink_vsi;
117 	struct net_device *uplink_netdev = uplink_vsi->netdev;
118 	struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
119 	struct ice_vsi_vlan_ops *vlan_ops;
120 	bool rule_added = false;
121 
122 	vlan_ops = ice_get_compat_vsi_vlan_ops(ctrl_vsi);
123 	if (vlan_ops->dis_stripping(ctrl_vsi))
124 		return -ENODEV;
125 
126 	ice_remove_vsi_fltr(&pf->hw, uplink_vsi->idx);
127 
128 	netif_addr_lock_bh(uplink_netdev);
129 	__dev_uc_unsync(uplink_netdev, NULL);
130 	__dev_mc_unsync(uplink_netdev, NULL);
131 	netif_addr_unlock_bh(uplink_netdev);
132 
133 	if (ice_vsi_add_vlan_zero(uplink_vsi))
134 		goto err_def_rx;
135 
136 	if (!ice_is_dflt_vsi_in_use(uplink_vsi->port_info)) {
137 		if (ice_set_dflt_vsi(uplink_vsi))
138 			goto err_def_rx;
139 		rule_added = true;
140 	}
141 
142 	if (ice_vsi_update_security(uplink_vsi, ice_vsi_ctx_set_allow_override))
143 		goto err_override_uplink;
144 
145 	if (ice_vsi_update_security(ctrl_vsi, ice_vsi_ctx_set_allow_override))
146 		goto err_override_control;
147 
148 	return 0;
149 
150 err_override_control:
151 	ice_vsi_update_security(uplink_vsi, ice_vsi_ctx_clear_allow_override);
152 err_override_uplink:
153 	if (rule_added)
154 		ice_clear_dflt_vsi(uplink_vsi);
155 err_def_rx:
156 	ice_fltr_add_mac_and_broadcast(uplink_vsi,
157 				       uplink_vsi->port_info->mac.perm_addr,
158 				       ICE_FWD_TO_VSI);
159 	return -ENODEV;
160 }
161 
162 /**
163  * ice_eswitch_remap_rings_to_vectors - reconfigure rings of switchdev ctrl VSI
164  * @pf: pointer to PF struct
165  *
166  * In switchdev number of allocated Tx/Rx rings is equal.
167  *
168  * This function fills q_vectors structures associated with representor and
169  * move each ring pairs to port representor netdevs. Each port representor
170  * will have dedicated 1 Tx/Rx ring pair, so number of rings pair is equal to
171  * number of VFs.
172  */
173 static void ice_eswitch_remap_rings_to_vectors(struct ice_pf *pf)
174 {
175 	struct ice_vsi *vsi = pf->switchdev.control_vsi;
176 	int q_id;
177 
178 	ice_for_each_txq(vsi, q_id) {
179 		struct ice_q_vector *q_vector;
180 		struct ice_tx_ring *tx_ring;
181 		struct ice_rx_ring *rx_ring;
182 		struct ice_repr *repr;
183 		struct ice_vf *vf;
184 
185 		vf = ice_get_vf_by_id(pf, q_id);
186 		if (WARN_ON(!vf))
187 			continue;
188 
189 		repr = vf->repr;
190 		q_vector = repr->q_vector;
191 		tx_ring = vsi->tx_rings[q_id];
192 		rx_ring = vsi->rx_rings[q_id];
193 
194 		q_vector->vsi = vsi;
195 		q_vector->reg_idx = vsi->q_vectors[0]->reg_idx;
196 
197 		q_vector->num_ring_tx = 1;
198 		q_vector->tx.tx_ring = tx_ring;
199 		tx_ring->q_vector = q_vector;
200 		tx_ring->next = NULL;
201 		tx_ring->netdev = repr->netdev;
202 		/* In switchdev mode, from OS stack perspective, there is only
203 		 * one queue for given netdev, so it needs to be indexed as 0.
204 		 */
205 		tx_ring->q_index = 0;
206 
207 		q_vector->num_ring_rx = 1;
208 		q_vector->rx.rx_ring = rx_ring;
209 		rx_ring->q_vector = q_vector;
210 		rx_ring->next = NULL;
211 		rx_ring->netdev = repr->netdev;
212 
213 		ice_put_vf(vf);
214 	}
215 }
216 
217 /**
218  * ice_eswitch_release_reprs - clear PR VSIs configuration
219  * @pf: poiner to PF struct
220  * @ctrl_vsi: pointer to switchdev control VSI
221  */
222 static void
223 ice_eswitch_release_reprs(struct ice_pf *pf, struct ice_vsi *ctrl_vsi)
224 {
225 	struct ice_vf *vf;
226 	unsigned int bkt;
227 
228 	lockdep_assert_held(&pf->vfs.table_lock);
229 
230 	ice_for_each_vf(pf, bkt, vf) {
231 		struct ice_vsi *vsi = vf->repr->src_vsi;
232 
233 		/* Skip VFs that aren't configured */
234 		if (!vf->repr->dst)
235 			continue;
236 
237 		ice_vsi_update_security(vsi, ice_vsi_ctx_set_antispoof);
238 		metadata_dst_free(vf->repr->dst);
239 		vf->repr->dst = NULL;
240 		ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr,
241 					       ICE_FWD_TO_VSI);
242 
243 		netif_napi_del(&vf->repr->q_vector->napi);
244 	}
245 }
246 
247 /**
248  * ice_eswitch_setup_reprs - configure port reprs to run in switchdev mode
249  * @pf: pointer to PF struct
250  */
251 static int ice_eswitch_setup_reprs(struct ice_pf *pf)
252 {
253 	struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
254 	int max_vsi_num = 0;
255 	struct ice_vf *vf;
256 	unsigned int bkt;
257 
258 	lockdep_assert_held(&pf->vfs.table_lock);
259 
260 	ice_for_each_vf(pf, bkt, vf) {
261 		struct ice_vsi *vsi = vf->repr->src_vsi;
262 
263 		ice_remove_vsi_fltr(&pf->hw, vsi->idx);
264 		vf->repr->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX,
265 						   GFP_KERNEL);
266 		if (!vf->repr->dst) {
267 			ice_fltr_add_mac_and_broadcast(vsi,
268 						       vf->hw_lan_addr,
269 						       ICE_FWD_TO_VSI);
270 			goto err;
271 		}
272 
273 		if (ice_vsi_update_security(vsi, ice_vsi_ctx_clear_antispoof)) {
274 			ice_fltr_add_mac_and_broadcast(vsi,
275 						       vf->hw_lan_addr,
276 						       ICE_FWD_TO_VSI);
277 			metadata_dst_free(vf->repr->dst);
278 			vf->repr->dst = NULL;
279 			goto err;
280 		}
281 
282 		if (ice_vsi_add_vlan_zero(vsi)) {
283 			ice_fltr_add_mac_and_broadcast(vsi,
284 						       vf->hw_lan_addr,
285 						       ICE_FWD_TO_VSI);
286 			metadata_dst_free(vf->repr->dst);
287 			vf->repr->dst = NULL;
288 			ice_vsi_update_security(vsi, ice_vsi_ctx_set_antispoof);
289 			goto err;
290 		}
291 
292 		if (max_vsi_num < vsi->vsi_num)
293 			max_vsi_num = vsi->vsi_num;
294 
295 		netif_napi_add(vf->repr->netdev, &vf->repr->q_vector->napi,
296 			       ice_napi_poll);
297 
298 		netif_keep_dst(vf->repr->netdev);
299 	}
300 
301 	ice_for_each_vf(pf, bkt, vf) {
302 		struct ice_repr *repr = vf->repr;
303 		struct ice_vsi *vsi = repr->src_vsi;
304 		struct metadata_dst *dst;
305 
306 		dst = repr->dst;
307 		dst->u.port_info.port_id = vsi->vsi_num;
308 		dst->u.port_info.lower_dev = repr->netdev;
309 		ice_repr_set_traffic_vsi(repr, ctrl_vsi);
310 	}
311 
312 	return 0;
313 
314 err:
315 	ice_eswitch_release_reprs(pf, ctrl_vsi);
316 
317 	return -ENODEV;
318 }
319 
320 /**
321  * ice_eswitch_update_repr - reconfigure VF port representor
322  * @vsi: VF VSI for which port representor is configured
323  */
324 void ice_eswitch_update_repr(struct ice_vsi *vsi)
325 {
326 	struct ice_pf *pf = vsi->back;
327 	struct ice_repr *repr;
328 	struct ice_vf *vf;
329 	int ret;
330 
331 	if (!ice_is_switchdev_running(pf))
332 		return;
333 
334 	vf = vsi->vf;
335 	repr = vf->repr;
336 	repr->src_vsi = vsi;
337 	repr->dst->u.port_info.port_id = vsi->vsi_num;
338 
339 	ret = ice_vsi_update_security(vsi, ice_vsi_ctx_clear_antispoof);
340 	if (ret) {
341 		ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr, ICE_FWD_TO_VSI);
342 		dev_err(ice_pf_to_dev(pf), "Failed to update VF %d port representor",
343 			vsi->vf->vf_id);
344 	}
345 }
346 
347 /**
348  * ice_eswitch_port_start_xmit - callback for packets transmit
349  * @skb: send buffer
350  * @netdev: network interface device structure
351  *
352  * Returns NETDEV_TX_OK if sent, else an error code
353  */
354 netdev_tx_t
355 ice_eswitch_port_start_xmit(struct sk_buff *skb, struct net_device *netdev)
356 {
357 	struct ice_netdev_priv *np;
358 	struct ice_repr *repr;
359 	struct ice_vsi *vsi;
360 
361 	np = netdev_priv(netdev);
362 	vsi = np->vsi;
363 
364 	if (ice_is_reset_in_progress(vsi->back->state) ||
365 	    test_bit(ICE_VF_DIS, vsi->back->state))
366 		return NETDEV_TX_BUSY;
367 
368 	repr = ice_netdev_to_repr(netdev);
369 	skb_dst_drop(skb);
370 	dst_hold((struct dst_entry *)repr->dst);
371 	skb_dst_set(skb, (struct dst_entry *)repr->dst);
372 	skb->queue_mapping = repr->vf->vf_id;
373 
374 	return ice_start_xmit(skb, netdev);
375 }
376 
377 /**
378  * ice_eswitch_set_target_vsi - set switchdev context in Tx context descriptor
379  * @skb: pointer to send buffer
380  * @off: pointer to offload struct
381  */
382 void
383 ice_eswitch_set_target_vsi(struct sk_buff *skb,
384 			   struct ice_tx_offload_params *off)
385 {
386 	struct metadata_dst *dst = skb_metadata_dst(skb);
387 	u64 cd_cmd, dst_vsi;
388 
389 	if (!dst) {
390 		cd_cmd = ICE_TX_CTX_DESC_SWTCH_UPLINK << ICE_TXD_CTX_QW1_CMD_S;
391 		off->cd_qw1 |= (cd_cmd | ICE_TX_DESC_DTYPE_CTX);
392 	} else {
393 		cd_cmd = ICE_TX_CTX_DESC_SWTCH_VSI << ICE_TXD_CTX_QW1_CMD_S;
394 		dst_vsi = ((u64)dst->u.port_info.port_id <<
395 			   ICE_TXD_CTX_QW1_VSI_S) & ICE_TXD_CTX_QW1_VSI_M;
396 		off->cd_qw1 = cd_cmd | dst_vsi | ICE_TX_DESC_DTYPE_CTX;
397 	}
398 }
399 
400 /**
401  * ice_eswitch_release_env - clear switchdev HW filters
402  * @pf: pointer to PF struct
403  *
404  * This function removes HW filters configuration specific for switchdev
405  * mode and restores default legacy mode settings.
406  */
407 static void ice_eswitch_release_env(struct ice_pf *pf)
408 {
409 	struct ice_vsi *uplink_vsi = pf->switchdev.uplink_vsi;
410 	struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
411 
412 	ice_vsi_update_security(ctrl_vsi, ice_vsi_ctx_clear_allow_override);
413 	ice_vsi_update_security(uplink_vsi, ice_vsi_ctx_clear_allow_override);
414 	ice_clear_dflt_vsi(uplink_vsi);
415 	ice_fltr_add_mac_and_broadcast(uplink_vsi,
416 				       uplink_vsi->port_info->mac.perm_addr,
417 				       ICE_FWD_TO_VSI);
418 }
419 
420 /**
421  * ice_eswitch_vsi_setup - configure switchdev control VSI
422  * @pf: pointer to PF structure
423  * @pi: pointer to port_info structure
424  */
425 static struct ice_vsi *
426 ice_eswitch_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi)
427 {
428 	struct ice_vsi_cfg_params params = {};
429 
430 	params.type = ICE_VSI_SWITCHDEV_CTRL;
431 	params.pi = pi;
432 	params.flags = ICE_VSI_FLAG_INIT;
433 
434 	return ice_vsi_setup(pf, &params);
435 }
436 
437 /**
438  * ice_eswitch_napi_del - remove NAPI handle for all port representors
439  * @pf: pointer to PF structure
440  */
441 static void ice_eswitch_napi_del(struct ice_pf *pf)
442 {
443 	struct ice_vf *vf;
444 	unsigned int bkt;
445 
446 	lockdep_assert_held(&pf->vfs.table_lock);
447 
448 	ice_for_each_vf(pf, bkt, vf)
449 		netif_napi_del(&vf->repr->q_vector->napi);
450 }
451 
452 /**
453  * ice_eswitch_napi_enable - enable NAPI for all port representors
454  * @pf: pointer to PF structure
455  */
456 static void ice_eswitch_napi_enable(struct ice_pf *pf)
457 {
458 	struct ice_vf *vf;
459 	unsigned int bkt;
460 
461 	lockdep_assert_held(&pf->vfs.table_lock);
462 
463 	ice_for_each_vf(pf, bkt, vf)
464 		napi_enable(&vf->repr->q_vector->napi);
465 }
466 
467 /**
468  * ice_eswitch_napi_disable - disable NAPI for all port representors
469  * @pf: pointer to PF structure
470  */
471 static void ice_eswitch_napi_disable(struct ice_pf *pf)
472 {
473 	struct ice_vf *vf;
474 	unsigned int bkt;
475 
476 	lockdep_assert_held(&pf->vfs.table_lock);
477 
478 	ice_for_each_vf(pf, bkt, vf)
479 		napi_disable(&vf->repr->q_vector->napi);
480 }
481 
482 /**
483  * ice_eswitch_enable_switchdev - configure eswitch in switchdev mode
484  * @pf: pointer to PF structure
485  */
486 static int ice_eswitch_enable_switchdev(struct ice_pf *pf)
487 {
488 	struct ice_vsi *ctrl_vsi;
489 
490 	pf->switchdev.control_vsi = ice_eswitch_vsi_setup(pf, pf->hw.port_info);
491 	if (!pf->switchdev.control_vsi)
492 		return -ENODEV;
493 
494 	ctrl_vsi = pf->switchdev.control_vsi;
495 	pf->switchdev.uplink_vsi = ice_get_main_vsi(pf);
496 	if (!pf->switchdev.uplink_vsi)
497 		goto err_vsi;
498 
499 	if (ice_eswitch_setup_env(pf))
500 		goto err_vsi;
501 
502 	if (ice_repr_add_for_all_vfs(pf))
503 		goto err_repr_add;
504 
505 	if (ice_eswitch_setup_reprs(pf))
506 		goto err_setup_reprs;
507 
508 	ice_eswitch_remap_rings_to_vectors(pf);
509 
510 	if (ice_vsi_open(ctrl_vsi))
511 		goto err_setup_reprs;
512 
513 	ice_eswitch_napi_enable(pf);
514 
515 	return 0;
516 
517 err_setup_reprs:
518 	ice_repr_rem_from_all_vfs(pf);
519 err_repr_add:
520 	ice_eswitch_release_env(pf);
521 err_vsi:
522 	ice_vsi_release(ctrl_vsi);
523 	return -ENODEV;
524 }
525 
526 /**
527  * ice_eswitch_disable_switchdev - disable switchdev resources
528  * @pf: pointer to PF structure
529  */
530 static void ice_eswitch_disable_switchdev(struct ice_pf *pf)
531 {
532 	struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
533 
534 	ice_eswitch_napi_disable(pf);
535 	ice_eswitch_release_env(pf);
536 	ice_rem_adv_rule_for_vsi(&pf->hw, ctrl_vsi->idx);
537 	ice_eswitch_release_reprs(pf, ctrl_vsi);
538 	ice_vsi_release(ctrl_vsi);
539 	ice_repr_rem_from_all_vfs(pf);
540 }
541 
542 /**
543  * ice_eswitch_mode_set - set new eswitch mode
544  * @devlink: pointer to devlink structure
545  * @mode: eswitch mode to switch to
546  * @extack: pointer to extack structure
547  */
548 int
549 ice_eswitch_mode_set(struct devlink *devlink, u16 mode,
550 		     struct netlink_ext_ack *extack)
551 {
552 	struct ice_pf *pf = devlink_priv(devlink);
553 
554 	if (pf->eswitch_mode == mode)
555 		return 0;
556 
557 	if (ice_has_vfs(pf)) {
558 		dev_info(ice_pf_to_dev(pf), "Changing eswitch mode is allowed only if there is no VFs created");
559 		NL_SET_ERR_MSG_MOD(extack, "Changing eswitch mode is allowed only if there is no VFs created");
560 		return -EOPNOTSUPP;
561 	}
562 
563 	switch (mode) {
564 	case DEVLINK_ESWITCH_MODE_LEGACY:
565 		dev_info(ice_pf_to_dev(pf), "PF %d changed eswitch mode to legacy",
566 			 pf->hw.pf_id);
567 		NL_SET_ERR_MSG_MOD(extack, "Changed eswitch mode to legacy");
568 		break;
569 	case DEVLINK_ESWITCH_MODE_SWITCHDEV:
570 	{
571 		dev_info(ice_pf_to_dev(pf), "PF %d changed eswitch mode to switchdev",
572 			 pf->hw.pf_id);
573 		NL_SET_ERR_MSG_MOD(extack, "Changed eswitch mode to switchdev");
574 		break;
575 	}
576 	default:
577 		NL_SET_ERR_MSG_MOD(extack, "Unknown eswitch mode");
578 		return -EINVAL;
579 	}
580 
581 	pf->eswitch_mode = mode;
582 	return 0;
583 }
584 
585 /**
586  * ice_eswitch_mode_get - get current eswitch mode
587  * @devlink: pointer to devlink structure
588  * @mode: output parameter for current eswitch mode
589  */
590 int ice_eswitch_mode_get(struct devlink *devlink, u16 *mode)
591 {
592 	struct ice_pf *pf = devlink_priv(devlink);
593 
594 	*mode = pf->eswitch_mode;
595 	return 0;
596 }
597 
598 /**
599  * ice_is_eswitch_mode_switchdev - check if eswitch mode is set to switchdev
600  * @pf: pointer to PF structure
601  *
602  * Returns true if eswitch mode is set to DEVLINK_ESWITCH_MODE_SWITCHDEV,
603  * false otherwise.
604  */
605 bool ice_is_eswitch_mode_switchdev(struct ice_pf *pf)
606 {
607 	return pf->eswitch_mode == DEVLINK_ESWITCH_MODE_SWITCHDEV;
608 }
609 
610 /**
611  * ice_eswitch_release - cleanup eswitch
612  * @pf: pointer to PF structure
613  */
614 void ice_eswitch_release(struct ice_pf *pf)
615 {
616 	if (pf->eswitch_mode == DEVLINK_ESWITCH_MODE_LEGACY)
617 		return;
618 
619 	ice_eswitch_disable_switchdev(pf);
620 	pf->switchdev.is_running = false;
621 }
622 
623 /**
624  * ice_eswitch_configure - configure eswitch
625  * @pf: pointer to PF structure
626  */
627 int ice_eswitch_configure(struct ice_pf *pf)
628 {
629 	int status;
630 
631 	if (pf->eswitch_mode == DEVLINK_ESWITCH_MODE_LEGACY || pf->switchdev.is_running)
632 		return 0;
633 
634 	status = ice_eswitch_enable_switchdev(pf);
635 	if (status)
636 		return status;
637 
638 	pf->switchdev.is_running = true;
639 	return 0;
640 }
641 
642 /**
643  * ice_eswitch_start_all_tx_queues - start Tx queues of all port representors
644  * @pf: pointer to PF structure
645  */
646 static void ice_eswitch_start_all_tx_queues(struct ice_pf *pf)
647 {
648 	struct ice_vf *vf;
649 	unsigned int bkt;
650 
651 	lockdep_assert_held(&pf->vfs.table_lock);
652 
653 	if (test_bit(ICE_DOWN, pf->state))
654 		return;
655 
656 	ice_for_each_vf(pf, bkt, vf) {
657 		if (vf->repr)
658 			ice_repr_start_tx_queues(vf->repr);
659 	}
660 }
661 
662 /**
663  * ice_eswitch_stop_all_tx_queues - stop Tx queues of all port representors
664  * @pf: pointer to PF structure
665  */
666 void ice_eswitch_stop_all_tx_queues(struct ice_pf *pf)
667 {
668 	struct ice_vf *vf;
669 	unsigned int bkt;
670 
671 	lockdep_assert_held(&pf->vfs.table_lock);
672 
673 	if (test_bit(ICE_DOWN, pf->state))
674 		return;
675 
676 	ice_for_each_vf(pf, bkt, vf) {
677 		if (vf->repr)
678 			ice_repr_stop_tx_queues(vf->repr);
679 	}
680 }
681 
682 /**
683  * ice_eswitch_rebuild - rebuild eswitch
684  * @pf: pointer to PF structure
685  */
686 int ice_eswitch_rebuild(struct ice_pf *pf)
687 {
688 	struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
689 	int status;
690 
691 	ice_eswitch_napi_disable(pf);
692 	ice_eswitch_napi_del(pf);
693 
694 	status = ice_eswitch_setup_env(pf);
695 	if (status)
696 		return status;
697 
698 	status = ice_eswitch_setup_reprs(pf);
699 	if (status)
700 		return status;
701 
702 	ice_eswitch_remap_rings_to_vectors(pf);
703 
704 	ice_replay_tc_fltrs(pf);
705 
706 	status = ice_vsi_open(ctrl_vsi);
707 	if (status)
708 		return status;
709 
710 	ice_eswitch_napi_enable(pf);
711 	ice_eswitch_start_all_tx_queues(pf);
712 
713 	return 0;
714 }
715