ice_eswitch.c

  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_eswitch_br.h"
  8#include "ice_fltr.h"
  9#include "ice_repr.h"
 10#include "devlink/devlink.h"
 11#include "ice_tc_lib.h"
 12
 13/**
 14 * ice_eswitch_setup_env - configure eswitch HW filters
 15 * @pf: pointer to PF struct
 16 *
 17 * This function adds HW filters configuration specific for switchdev
 18 * mode.
 19 */
 20static int ice_eswitch_setup_env(struct ice_pf *pf)
 21{
 22	struct ice_vsi *uplink_vsi = pf->eswitch.uplink_vsi;
 23	struct net_device *netdev = uplink_vsi->netdev;
 24	bool if_running = netif_running(netdev);
 25	struct ice_vsi_vlan_ops *vlan_ops;
 26
 27	if (if_running && !test_and_set_bit(ICE_VSI_DOWN, uplink_vsi->state))
 28		if (ice_down(uplink_vsi))
 29			return -ENODEV;
 30
 31	ice_remove_vsi_fltr(&pf->hw, uplink_vsi->idx);
 32	ice_vsi_cfg_sw_lldp(uplink_vsi, true, false);
 33
 34	netif_addr_lock_bh(netdev);
 35	__dev_uc_unsync(netdev, NULL);
 36	__dev_mc_unsync(netdev, NULL);
 37	netif_addr_unlock_bh(netdev);
 38
 39	if (ice_vsi_add_vlan_zero(uplink_vsi))
 40		goto err_vlan_zero;
 41
 42	if (ice_set_dflt_vsi(uplink_vsi))
 43		goto err_def_rx;
 44
 45	if (ice_cfg_dflt_vsi(uplink_vsi->port_info, uplink_vsi->idx, true,
 46			     ICE_FLTR_TX))
 47		goto err_def_tx;
 48
 49	vlan_ops = ice_get_compat_vsi_vlan_ops(uplink_vsi);
 50	if (vlan_ops->dis_rx_filtering(uplink_vsi))
 51		goto err_vlan_filtering;
 52
 53	if (ice_vsi_update_local_lb(uplink_vsi, true))
 54		goto err_override_local_lb;
 55
 56	if (if_running && ice_up(uplink_vsi))
 57		goto err_up;
 58
 59	return 0;
 60
 61err_up:
 62	ice_vsi_update_local_lb(uplink_vsi, false);
 63err_override_local_lb:
 64	vlan_ops->ena_rx_filtering(uplink_vsi);
 65err_vlan_filtering:
 66	ice_cfg_dflt_vsi(uplink_vsi->port_info, uplink_vsi->idx, false,
 67			 ICE_FLTR_TX);
 68err_def_tx:
 69	ice_cfg_dflt_vsi(uplink_vsi->port_info, uplink_vsi->idx, false,
 70			 ICE_FLTR_RX);
 71err_def_rx:
 72	ice_vsi_del_vlan_zero(uplink_vsi);
 73err_vlan_zero:
 74	ice_fltr_add_mac_and_broadcast(uplink_vsi,
 75				       uplink_vsi->port_info->mac.perm_addr,
 76				       ICE_FWD_TO_VSI);
 77	if (if_running)
 78		ice_up(uplink_vsi);
 79
 80	return -ENODEV;
 81}
 82
 83/**
 84 * ice_eswitch_release_repr - clear PR VSI configuration
 85 * @pf: poiner to PF struct
 86 * @repr: pointer to PR
 87 */
 88static void
 89ice_eswitch_release_repr(struct ice_pf *pf, struct ice_repr *repr)
 90{
 91	struct ice_vsi *vsi = repr->src_vsi;
 92
 93	/* Skip representors that aren't configured */
 94	if (!repr->dst)
 95		return;
 96
 97	ice_vsi_update_security(vsi, ice_vsi_ctx_set_antispoof);
 98	metadata_dst_free(repr->dst);
 99	repr->dst = NULL;
100	ice_fltr_add_mac_and_broadcast(vsi, repr->parent_mac,
101				       ICE_FWD_TO_VSI);
102}
103
104/**
105 * ice_eswitch_setup_repr - configure PR to run in switchdev mode
106 * @pf: pointer to PF struct
107 * @repr: pointer to PR struct
108 */
109static int ice_eswitch_setup_repr(struct ice_pf *pf, struct ice_repr *repr)
110{
111	struct ice_vsi *uplink_vsi = pf->eswitch.uplink_vsi;
112	struct ice_vsi *vsi = repr->src_vsi;
113	struct metadata_dst *dst;
114
115	repr->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX,
116				       GFP_KERNEL);
117	if (!repr->dst)
118		return -ENOMEM;
119
120	netif_keep_dst(uplink_vsi->netdev);
121
122	dst = repr->dst;
123	dst->u.port_info.port_id = vsi->vsi_num;
124	dst->u.port_info.lower_dev = uplink_vsi->netdev;
125
126	return 0;
127}
128
129/**
130 * ice_eswitch_cfg_vsi - configure VSI to work in slow-path
131 * @vsi: VSI structure of representee
132 * @mac: representee MAC
133 *
134 * Return: 0 on success, non-zero on error.
135 */
136int ice_eswitch_cfg_vsi(struct ice_vsi *vsi, const u8 *mac)
137{
138	int err;
139
140	ice_remove_vsi_fltr(&vsi->back->hw, vsi->idx);
141
142	err = ice_vsi_update_security(vsi, ice_vsi_ctx_clear_antispoof);
143	if (err)
144		goto err_update_security;
145
146	err = ice_vsi_add_vlan_zero(vsi);
147	if (err)
148		goto err_vlan_zero;
149
150	return 0;
151
152err_vlan_zero:
153	ice_vsi_update_security(vsi, ice_vsi_ctx_set_antispoof);
154err_update_security:
155	ice_fltr_add_mac_and_broadcast(vsi, mac, ICE_FWD_TO_VSI);
156
157	return err;
158}
159
160/**
161 * ice_eswitch_decfg_vsi - unroll changes done to VSI for switchdev
162 * @vsi: VSI structure of representee
163 * @mac: representee MAC
164 */
165void ice_eswitch_decfg_vsi(struct ice_vsi *vsi, const u8 *mac)
166{
167	ice_vsi_update_security(vsi, ice_vsi_ctx_set_antispoof);
168	ice_fltr_add_mac_and_broadcast(vsi, mac, ICE_FWD_TO_VSI);
169}
170
171/**
172 * ice_eswitch_update_repr - reconfigure port representor
173 * @repr_id: representor ID
174 * @vsi: VSI for which port representor is configured
175 */
176void ice_eswitch_update_repr(unsigned long *repr_id, struct ice_vsi *vsi)
177{
178	struct ice_pf *pf = vsi->back;
179	struct ice_repr *repr;
180	int err;
181
182	if (!ice_is_switchdev_running(pf))
183		return;
184
185	repr = xa_load(&pf->eswitch.reprs, *repr_id);
186	if (!repr)
187		return;
188
189	repr->src_vsi = vsi;
190	repr->dst->u.port_info.port_id = vsi->vsi_num;
191
192	if (repr->br_port)
193		repr->br_port->vsi = vsi;
194
195	err = ice_eswitch_cfg_vsi(vsi, repr->parent_mac);
196	if (err)
197		dev_err(ice_pf_to_dev(pf), "Failed to update VSI of port representor %d",
198			repr->id);
199
200	/* The VSI number is different, reload the PR with new id */
201	if (repr->id != vsi->vsi_num) {
202		xa_erase(&pf->eswitch.reprs, repr->id);
203		repr->id = vsi->vsi_num;
204		if (xa_insert(&pf->eswitch.reprs, repr->id, repr, GFP_KERNEL))
205			dev_err(ice_pf_to_dev(pf), "Failed to reload port representor %d",
206				repr->id);
207		*repr_id = repr->id;
208	}
209}
210
211/**
212 * ice_eswitch_port_start_xmit - callback for packets transmit
213 * @skb: send buffer
214 * @netdev: network interface device structure
215 *
216 * Returns NETDEV_TX_OK if sent, else an error code
217 */
218netdev_tx_t
219ice_eswitch_port_start_xmit(struct sk_buff *skb, struct net_device *netdev)
220{
221	struct ice_repr *repr = ice_netdev_to_repr(netdev);
222	unsigned int len = skb->len;
223	int ret;
224
225	skb_dst_drop(skb);
226	dst_hold((struct dst_entry *)repr->dst);
227	skb_dst_set(skb, (struct dst_entry *)repr->dst);
228	skb->dev = repr->dst->u.port_info.lower_dev;
229
230	ret = dev_queue_xmit(skb);
231	ice_repr_inc_tx_stats(repr, len, ret);
232
233	return ret;
234}
235
236/**
237 * ice_eswitch_set_target_vsi - set eswitch context in Tx context descriptor
238 * @skb: pointer to send buffer
239 * @off: pointer to offload struct
240 */
241void
242ice_eswitch_set_target_vsi(struct sk_buff *skb,
243			   struct ice_tx_offload_params *off)
244{
245	struct metadata_dst *dst = skb_metadata_dst(skb);
246	u64 cd_cmd, dst_vsi;
247
248	if (!dst) {
249		struct ethhdr *eth = (struct ethhdr *)skb_mac_header(skb);
250
251		if (unlikely(eth->h_proto == htons(ETH_P_LLDP)))
252			return;
253		cd_cmd = ICE_TX_CTX_DESC_SWTCH_UPLINK << ICE_TXD_CTX_QW1_CMD_S;
254		off->cd_qw1 |= (cd_cmd | ICE_TX_DESC_DTYPE_CTX);
255	} else {
256		cd_cmd = ICE_TX_CTX_DESC_SWTCH_VSI << ICE_TXD_CTX_QW1_CMD_S;
257		dst_vsi = FIELD_PREP(ICE_TXD_CTX_QW1_VSI_M,
258				     dst->u.port_info.port_id);
259		off->cd_qw1 = cd_cmd | dst_vsi | ICE_TX_DESC_DTYPE_CTX;
260	}
261}
262
263/**
264 * ice_eswitch_release_env - clear eswitch HW filters
265 * @pf: pointer to PF struct
266 *
267 * This function removes HW filters configuration specific for switchdev
268 * mode and restores default legacy mode settings.
269 */
270static void ice_eswitch_release_env(struct ice_pf *pf)
271{
272	struct ice_vsi *uplink_vsi = pf->eswitch.uplink_vsi;
273	struct ice_vsi_vlan_ops *vlan_ops;
274
275	vlan_ops = ice_get_compat_vsi_vlan_ops(uplink_vsi);
276
277	ice_vsi_update_local_lb(uplink_vsi, false);
278	vlan_ops->ena_rx_filtering(uplink_vsi);
279	ice_cfg_dflt_vsi(uplink_vsi->port_info, uplink_vsi->idx, false,
280			 ICE_FLTR_TX);
281	ice_cfg_dflt_vsi(uplink_vsi->port_info, uplink_vsi->idx, false,
282			 ICE_FLTR_RX);
283	ice_fltr_add_mac_and_broadcast(uplink_vsi,
284				       uplink_vsi->port_info->mac.perm_addr,
285				       ICE_FWD_TO_VSI);
286	ice_vsi_cfg_sw_lldp(uplink_vsi, true, true);
287}
288
289/**
290 * ice_eswitch_enable_switchdev - configure eswitch in switchdev mode
291 * @pf: pointer to PF structure
292 */
293static int ice_eswitch_enable_switchdev(struct ice_pf *pf)
294{
295	struct ice_vsi *uplink_vsi;
296
297	uplink_vsi = ice_get_main_vsi(pf);
298	if (!uplink_vsi)
299		return -ENODEV;
300
301	if (netif_is_any_bridge_port(uplink_vsi->netdev)) {
302		dev_err(ice_pf_to_dev(pf),
303			"Uplink port cannot be a bridge port\n");
304		return -EINVAL;
305	}
306
307	pf->eswitch.uplink_vsi = uplink_vsi;
308
309	if (ice_eswitch_setup_env(pf))
310		return -ENODEV;
311
312	if (ice_eswitch_br_offloads_init(pf))
313		goto err_br_offloads;
314
315	pf->eswitch.is_running = true;
316
317	return 0;
318
319err_br_offloads:
320	ice_eswitch_release_env(pf);
321	return -ENODEV;
322}
323
324/**
325 * ice_eswitch_disable_switchdev - disable eswitch resources
326 * @pf: pointer to PF structure
327 */
328static void ice_eswitch_disable_switchdev(struct ice_pf *pf)
329{
330	ice_eswitch_br_offloads_deinit(pf);
331	ice_eswitch_release_env(pf);
332
333	pf->eswitch.is_running = false;
334}
335
336/**
337 * ice_eswitch_mode_set - set new eswitch mode
338 * @devlink: pointer to devlink structure
339 * @mode: eswitch mode to switch to
340 * @extack: pointer to extack structure
341 */
342int
343ice_eswitch_mode_set(struct devlink *devlink, u16 mode,
344		     struct netlink_ext_ack *extack)
345{
346	struct ice_pf *pf = devlink_priv(devlink);
347
348	if (pf->eswitch_mode == mode)
349		return 0;
350
351	if (ice_has_vfs(pf)) {
352		dev_info(ice_pf_to_dev(pf), "Changing eswitch mode is allowed only if there is no VFs created");
353		NL_SET_ERR_MSG_MOD(extack, "Changing eswitch mode is allowed only if there is no VFs created");
354		return -EOPNOTSUPP;
355	}
356
357	switch (mode) {
358	case DEVLINK_ESWITCH_MODE_LEGACY:
359		dev_info(ice_pf_to_dev(pf), "PF %d changed eswitch mode to legacy",
360			 pf->hw.pf_id);
361		xa_destroy(&pf->eswitch.reprs);
362		NL_SET_ERR_MSG_MOD(extack, "Changed eswitch mode to legacy");
363		break;
364	case DEVLINK_ESWITCH_MODE_SWITCHDEV:
365	{
366		if (ice_is_adq_active(pf)) {
367			dev_err(ice_pf_to_dev(pf), "Couldn't change eswitch mode to switchdev - ADQ is active. Delete ADQ configs and try again, e.g. tc qdisc del dev $PF root");
368			NL_SET_ERR_MSG_MOD(extack, "Couldn't change eswitch mode to switchdev - ADQ is active. Delete ADQ configs and try again, e.g. tc qdisc del dev $PF root");
369			return -EOPNOTSUPP;
370		}
371
372		dev_info(ice_pf_to_dev(pf), "PF %d changed eswitch mode to switchdev",
373			 pf->hw.pf_id);
374		xa_init(&pf->eswitch.reprs);
375		NL_SET_ERR_MSG_MOD(extack, "Changed eswitch mode to switchdev");
376		break;
377	}
378	default:
379		NL_SET_ERR_MSG_MOD(extack, "Unknown eswitch mode");
380		return -EINVAL;
381	}
382
383	pf->eswitch_mode = mode;
384	return 0;
385}
386
387/**
388 * ice_eswitch_mode_get - get current eswitch mode
389 * @devlink: pointer to devlink structure
390 * @mode: output parameter for current eswitch mode
391 */
392int ice_eswitch_mode_get(struct devlink *devlink, u16 *mode)
393{
394	struct ice_pf *pf = devlink_priv(devlink);
395
396	*mode = pf->eswitch_mode;
397	return 0;
398}
399
400/**
401 * ice_is_eswitch_mode_switchdev - check if eswitch mode is set to switchdev
402 * @pf: pointer to PF structure
403 *
404 * Returns true if eswitch mode is set to DEVLINK_ESWITCH_MODE_SWITCHDEV,
405 * false otherwise.
406 */
407bool ice_is_eswitch_mode_switchdev(struct ice_pf *pf)
408{
409	return pf->eswitch_mode == DEVLINK_ESWITCH_MODE_SWITCHDEV;
410}
411
412/**
413 * ice_eswitch_start_all_tx_queues - start Tx queues of all port representors
414 * @pf: pointer to PF structure
415 */
416static void ice_eswitch_start_all_tx_queues(struct ice_pf *pf)
417{
418	struct ice_repr *repr;
419	unsigned long id;
420
421	if (test_bit(ICE_DOWN, pf->state))
422		return;
423
424	xa_for_each(&pf->eswitch.reprs, id, repr)
425		ice_repr_start_tx_queues(repr);
426}
427
428/**
429 * ice_eswitch_stop_all_tx_queues - stop Tx queues of all port representors
430 * @pf: pointer to PF structure
431 */
432void ice_eswitch_stop_all_tx_queues(struct ice_pf *pf)
433{
434	struct ice_repr *repr;
435	unsigned long id;
436
437	if (test_bit(ICE_DOWN, pf->state))
438		return;
439
440	xa_for_each(&pf->eswitch.reprs, id, repr)
441		ice_repr_stop_tx_queues(repr);
442}
443
444static void ice_eswitch_stop_reprs(struct ice_pf *pf)
445{
446	ice_eswitch_stop_all_tx_queues(pf);
447}
448
449static void ice_eswitch_start_reprs(struct ice_pf *pf)
450{
451	ice_eswitch_start_all_tx_queues(pf);
452}
453
454static int
455ice_eswitch_attach(struct ice_pf *pf, struct ice_repr *repr, unsigned long *id)
456{
457	int err;
458
459	if (pf->eswitch_mode == DEVLINK_ESWITCH_MODE_LEGACY)
460		return 0;
461
462	if (xa_empty(&pf->eswitch.reprs)) {
463		err = ice_eswitch_enable_switchdev(pf);
464		if (err)
465			return err;
466	}
467
468	ice_eswitch_stop_reprs(pf);
469
470	err = repr->ops.add(repr);
471	if (err)
472		goto err_create_repr;
473
474	err = ice_eswitch_setup_repr(pf, repr);
475	if (err)
476		goto err_setup_repr;
477
478	err = xa_insert(&pf->eswitch.reprs, repr->id, repr, GFP_KERNEL);
479	if (err)
480		goto err_xa_alloc;
481
482	*id = repr->id;
483
484	ice_eswitch_start_reprs(pf);
485
486	return 0;
487
488err_xa_alloc:
489	ice_eswitch_release_repr(pf, repr);
490err_setup_repr:
491	repr->ops.rem(repr);
492err_create_repr:
493	if (xa_empty(&pf->eswitch.reprs))
494		ice_eswitch_disable_switchdev(pf);
495	ice_eswitch_start_reprs(pf);
496
497	return err;
498}
499
500/**
501 * ice_eswitch_attach_vf - attach VF to a eswitch
502 * @pf: pointer to PF structure
503 * @vf: pointer to VF structure to be attached
504 *
505 * During attaching port representor for VF is created.
506 *
507 * Return: zero on success or an error code on failure.
508 */
509int ice_eswitch_attach_vf(struct ice_pf *pf, struct ice_vf *vf)
510{
511	struct devlink *devlink = priv_to_devlink(pf);
512	struct ice_repr *repr;
513	int err;
514
515	if (!ice_is_eswitch_mode_switchdev(pf))
516		return 0;
517
518	repr = ice_repr_create_vf(vf);
519	if (IS_ERR(repr))
520		return PTR_ERR(repr);
521
522	devl_lock(devlink);
523	err = ice_eswitch_attach(pf, repr, &vf->repr_id);
524	if (err)
525		ice_repr_destroy(repr);
526	devl_unlock(devlink);
527
528	return err;
529}
530
531/**
532 * ice_eswitch_attach_sf - attach SF to a eswitch
533 * @pf: pointer to PF structure
534 * @sf: pointer to SF structure to be attached
535 *
536 * During attaching port representor for SF is created.
537 *
538 * Return: zero on success or an error code on failure.
539 */
540int ice_eswitch_attach_sf(struct ice_pf *pf, struct ice_dynamic_port *sf)
541{
542	struct ice_repr *repr = ice_repr_create_sf(sf);
543	int err;
544
545	if (IS_ERR(repr))
546		return PTR_ERR(repr);
547
548	err = ice_eswitch_attach(pf, repr, &sf->repr_id);
549	if (err)
550		ice_repr_destroy(repr);
551
552	return err;
553}
554
555static void ice_eswitch_detach(struct ice_pf *pf, struct ice_repr *repr)
556{
557	ice_eswitch_stop_reprs(pf);
558	repr->ops.rem(repr);
559
560	xa_erase(&pf->eswitch.reprs, repr->id);
561
562	if (xa_empty(&pf->eswitch.reprs))
563		ice_eswitch_disable_switchdev(pf);
564
565	ice_eswitch_release_repr(pf, repr);
566	ice_repr_destroy(repr);
567
568	if (xa_empty(&pf->eswitch.reprs)) {
569		struct devlink *devlink = priv_to_devlink(pf);
570
571		/* since all port representors are destroyed, there is
572		 * no point in keeping the nodes
573		 */
574		ice_devlink_rate_clear_tx_topology(ice_get_main_vsi(pf));
575		devl_rate_nodes_destroy(devlink);
576	} else {
577		ice_eswitch_start_reprs(pf);
578	}
579}
580
581/**
582 * ice_eswitch_detach_vf - detach VF from a eswitch
583 * @pf: pointer to PF structure
584 * @vf: pointer to VF structure to be detached
585 */
586void ice_eswitch_detach_vf(struct ice_pf *pf, struct ice_vf *vf)
587{
588	struct ice_repr *repr = xa_load(&pf->eswitch.reprs, vf->repr_id);
589	struct devlink *devlink = priv_to_devlink(pf);
590
591	if (!repr)
592		return;
593
594	devl_lock(devlink);
595	ice_eswitch_detach(pf, repr);
596	devl_unlock(devlink);
597}
598
599/**
600 * ice_eswitch_detach_sf - detach SF from a eswitch
601 * @pf: pointer to PF structure
602 * @sf: pointer to SF structure to be detached
603 */
604void ice_eswitch_detach_sf(struct ice_pf *pf, struct ice_dynamic_port *sf)
605{
606	struct ice_repr *repr = xa_load(&pf->eswitch.reprs, sf->repr_id);
607
608	if (!repr)
609		return;
610
611	ice_eswitch_detach(pf, repr);
612}
613
614/**
615 * ice_eswitch_get_target - get netdev based on src_vsi from descriptor
616 * @rx_ring: ring used to receive the packet
617 * @rx_desc: descriptor used to get src_vsi value
618 *
619 * Get src_vsi value from descriptor and load correct representor. If it isn't
620 * found return rx_ring->netdev.
621 */
622struct net_device *ice_eswitch_get_target(struct ice_rx_ring *rx_ring,
623					  union ice_32b_rx_flex_desc *rx_desc)
624{
625	struct ice_eswitch *eswitch = &rx_ring->vsi->back->eswitch;
626	struct ice_32b_rx_flex_desc_nic_2 *desc;
627	struct ice_repr *repr;
628
629	desc = (struct ice_32b_rx_flex_desc_nic_2 *)rx_desc;
630	repr = xa_load(&eswitch->reprs, le16_to_cpu(desc->src_vsi));
631	if (!repr)
632		return rx_ring->netdev;
633
634	return repr->netdev;
635}