1// SPDX-License-Identifier: GPL-2.0
2/* Copyright (C) 2019-2021, Intel Corporation. */
3
4#include "ice.h"
5#include "ice_eswitch.h"
6#include "ice_devlink.h"
7#include "ice_sriov.h"
8#include "ice_tc_lib.h"
9#include "ice_dcb_lib.h"
10
11/**
12 * ice_repr_get_sw_port_id - get port ID associated with representor
13 * @repr: pointer to port representor
14 */
15static int ice_repr_get_sw_port_id(struct ice_repr *repr)
16{
17 return repr->vf->pf->hw.port_info->lport;
18}
19
20/**
21 * ice_repr_get_phys_port_name - get phys port name
22 * @netdev: pointer to port representor netdev
23 * @buf: write here port name
24 * @len: max length of buf
25 */
26static int
27ice_repr_get_phys_port_name(struct net_device *netdev, char *buf, size_t len)
28{
29 struct ice_netdev_priv *np = netdev_priv(dev: netdev);
30 struct ice_repr *repr = np->repr;
31 int res;
32
33 /* Devlink port is registered and devlink core is taking care of name formatting. */
34 if (repr->vf->devlink_port.devlink)
35 return -EOPNOTSUPP;
36
37 res = snprintf(buf, size: len, fmt: "pf%dvfr%d", ice_repr_get_sw_port_id(repr),
38 repr->vf->vf_id);
39 if (res <= 0)
40 return -EOPNOTSUPP;
41 return 0;
42}
43
44/**
45 * ice_repr_get_stats64 - get VF stats for VFPR use
46 * @netdev: pointer to port representor netdev
47 * @stats: pointer to struct where stats can be stored
48 */
49static void
50ice_repr_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats)
51{
52 struct ice_netdev_priv *np = netdev_priv(dev: netdev);
53 struct ice_eth_stats *eth_stats;
54 struct ice_vsi *vsi;
55
56 if (ice_is_vf_disabled(vf: np->repr->vf))
57 return;
58 vsi = np->repr->src_vsi;
59
60 ice_update_vsi_stats(vsi);
61 eth_stats = &vsi->eth_stats;
62
63 stats->tx_packets = eth_stats->tx_unicast + eth_stats->tx_broadcast +
64 eth_stats->tx_multicast;
65 stats->rx_packets = eth_stats->rx_unicast + eth_stats->rx_broadcast +
66 eth_stats->rx_multicast;
67 stats->tx_bytes = eth_stats->tx_bytes;
68 stats->rx_bytes = eth_stats->rx_bytes;
69 stats->multicast = eth_stats->rx_multicast;
70 stats->tx_errors = eth_stats->tx_errors;
71 stats->tx_dropped = eth_stats->tx_discards;
72 stats->rx_dropped = eth_stats->rx_discards;
73}
74
75/**
76 * ice_netdev_to_repr - Get port representor for given netdevice
77 * @netdev: pointer to port representor netdev
78 */
79struct ice_repr *ice_netdev_to_repr(struct net_device *netdev)
80{
81 struct ice_netdev_priv *np = netdev_priv(dev: netdev);
82
83 return np->repr;
84}
85
86/**
87 * ice_repr_open - Enable port representor's network interface
88 * @netdev: network interface device structure
89 *
90 * The open entry point is called when a port representor's network
91 * interface is made active by the system (IFF_UP). Corresponding
92 * VF is notified about link status change.
93 *
94 * Returns 0 on success
95 */
96static int ice_repr_open(struct net_device *netdev)
97{
98 struct ice_repr *repr = ice_netdev_to_repr(netdev);
99 struct ice_vf *vf;
100
101 vf = repr->vf;
102 vf->link_forced = true;
103 vf->link_up = true;
104 ice_vc_notify_vf_link_state(vf);
105
106 netif_carrier_on(dev: netdev);
107 netif_tx_start_all_queues(dev: netdev);
108
109 return 0;
110}
111
112/**
113 * ice_repr_stop - Disable port representor's network interface
114 * @netdev: network interface device structure
115 *
116 * The stop entry point is called when a port representor's network
117 * interface is de-activated by the system. Corresponding
118 * VF is notified about link status change.
119 *
120 * Returns 0 on success
121 */
122static int ice_repr_stop(struct net_device *netdev)
123{
124 struct ice_repr *repr = ice_netdev_to_repr(netdev);
125 struct ice_vf *vf;
126
127 vf = repr->vf;
128 vf->link_forced = true;
129 vf->link_up = false;
130 ice_vc_notify_vf_link_state(vf);
131
132 netif_carrier_off(dev: netdev);
133 netif_tx_stop_all_queues(dev: netdev);
134
135 return 0;
136}
137
138/**
139 * ice_repr_sp_stats64 - get slow path stats for port representor
140 * @dev: network interface device structure
141 * @stats: netlink stats structure
142 *
143 * RX/TX stats are being swapped here to be consistent with VF stats. In slow
144 * path, port representor receives data when the corresponding VF is sending it
145 * (and vice versa), TX and RX bytes/packets are effectively swapped on port
146 * representor.
147 */
148static int
149ice_repr_sp_stats64(const struct net_device *dev,
150 struct rtnl_link_stats64 *stats)
151{
152 struct ice_netdev_priv *np = netdev_priv(dev);
153 int vf_id = np->repr->vf->vf_id;
154 struct ice_tx_ring *tx_ring;
155 struct ice_rx_ring *rx_ring;
156 u64 pkts, bytes;
157
158 tx_ring = np->vsi->tx_rings[vf_id];
159 ice_fetch_u64_stats_per_ring(syncp: &tx_ring->ring_stats->syncp,
160 stats: tx_ring->ring_stats->stats,
161 pkts: &pkts, bytes: &bytes);
162 stats->rx_packets = pkts;
163 stats->rx_bytes = bytes;
164
165 rx_ring = np->vsi->rx_rings[vf_id];
166 ice_fetch_u64_stats_per_ring(syncp: &rx_ring->ring_stats->syncp,
167 stats: rx_ring->ring_stats->stats,
168 pkts: &pkts, bytes: &bytes);
169 stats->tx_packets = pkts;
170 stats->tx_bytes = bytes;
171 stats->tx_dropped = rx_ring->ring_stats->rx_stats.alloc_page_failed +
172 rx_ring->ring_stats->rx_stats.alloc_buf_failed;
173
174 return 0;
175}
176
177static bool
178ice_repr_ndo_has_offload_stats(const struct net_device *dev, int attr_id)
179{
180 return attr_id == IFLA_OFFLOAD_XSTATS_CPU_HIT;
181}
182
183static int
184ice_repr_ndo_get_offload_stats(int attr_id, const struct net_device *dev,
185 void *sp)
186{
187 if (attr_id == IFLA_OFFLOAD_XSTATS_CPU_HIT)
188 return ice_repr_sp_stats64(dev, stats: (struct rtnl_link_stats64 *)sp);
189
190 return -EINVAL;
191}
192
193static int
194ice_repr_setup_tc_cls_flower(struct ice_repr *repr,
195 struct flow_cls_offload *flower)
196{
197 switch (flower->command) {
198 case FLOW_CLS_REPLACE:
199 return ice_add_cls_flower(netdev: repr->netdev, vsi: repr->src_vsi, cls_flower: flower);
200 case FLOW_CLS_DESTROY:
201 return ice_del_cls_flower(vsi: repr->src_vsi, cls_flower: flower);
202 default:
203 return -EINVAL;
204 }
205}
206
207static int
208ice_repr_setup_tc_block_cb(enum tc_setup_type type, void *type_data,
209 void *cb_priv)
210{
211 struct flow_cls_offload *flower = (struct flow_cls_offload *)type_data;
212 struct ice_netdev_priv *np = (struct ice_netdev_priv *)cb_priv;
213
214 switch (type) {
215 case TC_SETUP_CLSFLOWER:
216 return ice_repr_setup_tc_cls_flower(repr: np->repr, flower);
217 default:
218 return -EOPNOTSUPP;
219 }
220}
221
222static LIST_HEAD(ice_repr_block_cb_list);
223
224static int
225ice_repr_setup_tc(struct net_device *netdev, enum tc_setup_type type,
226 void *type_data)
227{
228 struct ice_netdev_priv *np = netdev_priv(dev: netdev);
229
230 switch (type) {
231 case TC_SETUP_BLOCK:
232 return flow_block_cb_setup_simple(f: (struct flow_block_offload *)
233 type_data,
234 driver_list: &ice_repr_block_cb_list,
235 cb: ice_repr_setup_tc_block_cb,
236 cb_ident: np, cb_priv: np, ingress_only: true);
237 default:
238 return -EOPNOTSUPP;
239 }
240}
241
242static const struct net_device_ops ice_repr_netdev_ops = {
243 .ndo_get_phys_port_name = ice_repr_get_phys_port_name,
244 .ndo_get_stats64 = ice_repr_get_stats64,
245 .ndo_open = ice_repr_open,
246 .ndo_stop = ice_repr_stop,
247 .ndo_start_xmit = ice_eswitch_port_start_xmit,
248 .ndo_setup_tc = ice_repr_setup_tc,
249 .ndo_has_offload_stats = ice_repr_ndo_has_offload_stats,
250 .ndo_get_offload_stats = ice_repr_ndo_get_offload_stats,
251};
252
253/**
254 * ice_is_port_repr_netdev - Check if a given netdevice is a port representor netdev
255 * @netdev: pointer to netdev
256 */
257bool ice_is_port_repr_netdev(const struct net_device *netdev)
258{
259 return netdev && (netdev->netdev_ops == &ice_repr_netdev_ops);
260}
261
262/**
263 * ice_repr_reg_netdev - register port representor netdev
264 * @netdev: pointer to port representor netdev
265 */
266static int
267ice_repr_reg_netdev(struct net_device *netdev)
268{
269 eth_hw_addr_random(dev: netdev);
270 netdev->netdev_ops = &ice_repr_netdev_ops;
271 ice_set_ethtool_repr_ops(netdev);
272
273 netdev->hw_features |= NETIF_F_HW_TC;
274
275 netif_carrier_off(dev: netdev);
276 netif_tx_stop_all_queues(dev: netdev);
277
278 return register_netdev(dev: netdev);
279}
280
281/**
282 * ice_repr_add - add representor for VF
283 * @vf: pointer to VF structure
284 */
285static int ice_repr_add(struct ice_vf *vf)
286{
287 struct ice_q_vector *q_vector;
288 struct ice_netdev_priv *np;
289 struct ice_repr *repr;
290 struct ice_vsi *vsi;
291 int err;
292
293 vsi = ice_get_vf_vsi(vf);
294 if (!vsi)
295 return -EINVAL;
296
297 repr = kzalloc(size: sizeof(*repr), GFP_KERNEL);
298 if (!repr)
299 return -ENOMEM;
300
301 repr->netdev = alloc_etherdev(sizeof(struct ice_netdev_priv));
302 if (!repr->netdev) {
303 err = -ENOMEM;
304 goto err_alloc;
305 }
306
307 repr->src_vsi = vsi;
308 repr->vf = vf;
309 vf->repr = repr;
310 np = netdev_priv(dev: repr->netdev);
311 np->repr = repr;
312
313 q_vector = kzalloc(size: sizeof(*q_vector), GFP_KERNEL);
314 if (!q_vector) {
315 err = -ENOMEM;
316 goto err_alloc_q_vector;
317 }
318 repr->q_vector = q_vector;
319
320 err = ice_devlink_create_vf_port(vf);
321 if (err)
322 goto err_devlink;
323
324 repr->netdev->min_mtu = ETH_MIN_MTU;
325 repr->netdev->max_mtu = ICE_MAX_MTU;
326
327 SET_NETDEV_DEV(repr->netdev, ice_pf_to_dev(vf->pf));
328 SET_NETDEV_DEVLINK_PORT(repr->netdev, &vf->devlink_port);
329 err = ice_repr_reg_netdev(netdev: repr->netdev);
330 if (err)
331 goto err_netdev;
332
333 ice_virtchnl_set_repr_ops(vf);
334
335 return 0;
336
337err_netdev:
338 ice_devlink_destroy_vf_port(vf);
339err_devlink:
340 kfree(objp: repr->q_vector);
341 vf->repr->q_vector = NULL;
342err_alloc_q_vector:
343 free_netdev(dev: repr->netdev);
344 repr->netdev = NULL;
345err_alloc:
346 kfree(objp: repr);
347 vf->repr = NULL;
348 return err;
349}
350
351/**
352 * ice_repr_rem - remove representor from VF
353 * @vf: pointer to VF structure
354 */
355static void ice_repr_rem(struct ice_vf *vf)
356{
357 if (!vf->repr)
358 return;
359
360 kfree(objp: vf->repr->q_vector);
361 vf->repr->q_vector = NULL;
362 unregister_netdev(dev: vf->repr->netdev);
363 ice_devlink_destroy_vf_port(vf);
364 free_netdev(dev: vf->repr->netdev);
365 vf->repr->netdev = NULL;
366 kfree(objp: vf->repr);
367 vf->repr = NULL;
368
369 ice_virtchnl_set_dflt_ops(vf);
370}
371
372/**
373 * ice_repr_rem_from_all_vfs - remove port representor for all VFs
374 * @pf: pointer to PF structure
375 */
376void ice_repr_rem_from_all_vfs(struct ice_pf *pf)
377{
378 struct devlink *devlink;
379 struct ice_vf *vf;
380 unsigned int bkt;
381
382 lockdep_assert_held(&pf->vfs.table_lock);
383
384 ice_for_each_vf(pf, bkt, vf)
385 ice_repr_rem(vf);
386
387 /* since all port representors are destroyed, there is
388 * no point in keeping the nodes
389 */
390 devlink = priv_to_devlink(priv: pf);
391 devl_lock(devlink);
392 devl_rate_nodes_destroy(devlink);
393 devl_unlock(devlink);
394}
395
396/**
397 * ice_repr_add_for_all_vfs - add port representor for all VFs
398 * @pf: pointer to PF structure
399 */
400int ice_repr_add_for_all_vfs(struct ice_pf *pf)
401{
402 struct devlink *devlink;
403 struct ice_vf *vf;
404 unsigned int bkt;
405 int err;
406
407 lockdep_assert_held(&pf->vfs.table_lock);
408
409 ice_for_each_vf(pf, bkt, vf) {
410 err = ice_repr_add(vf);
411 if (err)
412 goto err;
413 }
414
415 /* only export if ADQ and DCB disabled */
416 if (ice_is_adq_active(pf) || ice_is_dcb_active(pf))
417 return 0;
418
419 devlink = priv_to_devlink(priv: pf);
420 ice_devlink_rate_init_tx_topology(devlink, vsi: ice_get_main_vsi(pf));
421
422 return 0;
423
424err:
425 ice_repr_rem_from_all_vfs(pf);
426
427 return err;
428}
429
430/**
431 * ice_repr_start_tx_queues - start Tx queues of port representor
432 * @repr: pointer to repr structure
433 */
434void ice_repr_start_tx_queues(struct ice_repr *repr)
435{
436 netif_carrier_on(dev: repr->netdev);
437 netif_tx_start_all_queues(dev: repr->netdev);
438}
439
440/**
441 * ice_repr_stop_tx_queues - stop Tx queues of port representor
442 * @repr: pointer to repr structure
443 */
444void ice_repr_stop_tx_queues(struct ice_repr *repr)
445{
446 netif_carrier_off(dev: repr->netdev);
447 netif_tx_stop_all_queues(dev: repr->netdev);
448}
449
450/**
451 * ice_repr_set_traffic_vsi - set traffic VSI for port representor
452 * @repr: repr on with VSI will be set
453 * @vsi: pointer to VSI that will be used by port representor to pass traffic
454 */
455void ice_repr_set_traffic_vsi(struct ice_repr *repr, struct ice_vsi *vsi)
456{
457 struct ice_netdev_priv *np = netdev_priv(dev: repr->netdev);
458
459 np->vsi = vsi;
460}
461

source code of linux/drivers/net/ethernet/intel/ice/ice_repr.c