1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause)
2 /*
3 * Copyright (C) 2018 Netronome Systems, Inc.
4 *
5 * This software is dual licensed under the GNU General License Version 2,
6 * June 1991 as shown in the file COPYING in the top-level directory of this
7 * source tree or the BSD 2-Clause License provided below. You have the
8 * option to license this software under the complete terms of either license.
9 *
10 * The BSD 2-Clause License:
11 *
12 * Redistribution and use in source and binary forms, with or
13 * without modification, are permitted provided that the following
14 * conditions are met:
15 *
16 * 1. Redistributions of source code must retain the above
17 * copyright notice, this list of conditions and the following
18 * disclaimer.
19 *
20 * 2. Redistributions in binary form must reproduce the above
21 * copyright notice, this list of conditions and the following
22 * disclaimer in the documentation and/or other materials
23 * provided with the distribution.
24 *
25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32 * SOFTWARE.
33 */
34
35 #include <linux/bitfield.h>
36 #include <linux/etherdevice.h>
37 #include <linux/lockdep.h>
38 #include <linux/netdevice.h>
39 #include <linux/rcupdate.h>
40 #include <linux/slab.h>
41 #include <net/pkt_cls.h>
42 #include <net/pkt_sched.h>
43 #include <net/red.h>
44
45 #include "../nfpcore/nfp.h"
46 #include "../nfpcore/nfp_cpp.h"
47 #include "../nfpcore/nfp_nsp.h"
48 #include "../nfp_app.h"
49 #include "../nfp_main.h"
50 #include "../nfp_net.h"
51 #include "../nfp_net_repr.h"
52 #include "../nfp_port.h"
53 #include "main.h"
54
nfp_abm_portid(enum nfp_repr_type rtype,unsigned int id)55 static u32 nfp_abm_portid(enum nfp_repr_type rtype, unsigned int id)
56 {
57 return FIELD_PREP(NFP_ABM_PORTID_TYPE, rtype) |
58 FIELD_PREP(NFP_ABM_PORTID_ID, id);
59 }
60
61 static int
__nfp_abm_reset_root(struct net_device * netdev,struct nfp_abm_link * alink,u32 handle,unsigned int qs,u32 init_val)62 __nfp_abm_reset_root(struct net_device *netdev, struct nfp_abm_link *alink,
63 u32 handle, unsigned int qs, u32 init_val)
64 {
65 struct nfp_port *port = nfp_port_from_netdev(netdev);
66 int ret;
67
68 ret = nfp_abm_ctrl_set_all_q_lvls(alink, init_val);
69 memset(alink->qdiscs, 0, sizeof(*alink->qdiscs) * alink->num_qdiscs);
70
71 alink->parent = handle;
72 alink->num_qdiscs = qs;
73 port->tc_offload_cnt = qs;
74
75 return ret;
76 }
77
78 static void
nfp_abm_reset_root(struct net_device * netdev,struct nfp_abm_link * alink,u32 handle,unsigned int qs)79 nfp_abm_reset_root(struct net_device *netdev, struct nfp_abm_link *alink,
80 u32 handle, unsigned int qs)
81 {
82 __nfp_abm_reset_root(netdev, alink, handle, qs, ~0);
83 }
84
85 static int
nfp_abm_red_find(struct nfp_abm_link * alink,struct tc_red_qopt_offload * opt)86 nfp_abm_red_find(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt)
87 {
88 unsigned int i = TC_H_MIN(opt->parent) - 1;
89
90 if (opt->parent == TC_H_ROOT)
91 i = 0;
92 else if (TC_H_MAJ(alink->parent) == TC_H_MAJ(opt->parent))
93 i = TC_H_MIN(opt->parent) - 1;
94 else
95 return -EOPNOTSUPP;
96
97 if (i >= alink->num_qdiscs || opt->handle != alink->qdiscs[i].handle)
98 return -EOPNOTSUPP;
99
100 return i;
101 }
102
103 static void
nfp_abm_red_destroy(struct net_device * netdev,struct nfp_abm_link * alink,u32 handle)104 nfp_abm_red_destroy(struct net_device *netdev, struct nfp_abm_link *alink,
105 u32 handle)
106 {
107 unsigned int i;
108
109 for (i = 0; i < alink->num_qdiscs; i++)
110 if (handle == alink->qdiscs[i].handle)
111 break;
112 if (i == alink->num_qdiscs)
113 return;
114
115 if (alink->parent == TC_H_ROOT) {
116 nfp_abm_reset_root(netdev, alink, TC_H_ROOT, 0);
117 } else {
118 nfp_abm_ctrl_set_q_lvl(alink, i, ~0);
119 memset(&alink->qdiscs[i], 0, sizeof(*alink->qdiscs));
120 }
121 }
122
123 static int
nfp_abm_red_replace(struct net_device * netdev,struct nfp_abm_link * alink,struct tc_red_qopt_offload * opt)124 nfp_abm_red_replace(struct net_device *netdev, struct nfp_abm_link *alink,
125 struct tc_red_qopt_offload *opt)
126 {
127 bool existing;
128 int i, err;
129
130 i = nfp_abm_red_find(alink, opt);
131 existing = i >= 0;
132
133 if (opt->set.min != opt->set.max || !opt->set.is_ecn) {
134 nfp_warn(alink->abm->app->cpp,
135 "RED offload failed - unsupported parameters\n");
136 err = -EINVAL;
137 goto err_destroy;
138 }
139
140 if (existing) {
141 if (alink->parent == TC_H_ROOT)
142 err = nfp_abm_ctrl_set_all_q_lvls(alink, opt->set.min);
143 else
144 err = nfp_abm_ctrl_set_q_lvl(alink, i, opt->set.min);
145 if (err)
146 goto err_destroy;
147 return 0;
148 }
149
150 if (opt->parent == TC_H_ROOT) {
151 i = 0;
152 err = __nfp_abm_reset_root(netdev, alink, TC_H_ROOT, 1,
153 opt->set.min);
154 } else if (TC_H_MAJ(alink->parent) == TC_H_MAJ(opt->parent)) {
155 i = TC_H_MIN(opt->parent) - 1;
156 err = nfp_abm_ctrl_set_q_lvl(alink, i, opt->set.min);
157 } else {
158 return -EINVAL;
159 }
160 /* Set the handle to try full clean up, in case IO failed */
161 alink->qdiscs[i].handle = opt->handle;
162 if (err)
163 goto err_destroy;
164
165 if (opt->parent == TC_H_ROOT)
166 err = nfp_abm_ctrl_read_stats(alink, &alink->qdiscs[i].stats);
167 else
168 err = nfp_abm_ctrl_read_q_stats(alink, i,
169 &alink->qdiscs[i].stats);
170 if (err)
171 goto err_destroy;
172
173 if (opt->parent == TC_H_ROOT)
174 err = nfp_abm_ctrl_read_xstats(alink,
175 &alink->qdiscs[i].xstats);
176 else
177 err = nfp_abm_ctrl_read_q_xstats(alink, i,
178 &alink->qdiscs[i].xstats);
179 if (err)
180 goto err_destroy;
181
182 alink->qdiscs[i].stats.backlog_pkts = 0;
183 alink->qdiscs[i].stats.backlog_bytes = 0;
184
185 return 0;
186 err_destroy:
187 /* If the qdisc keeps on living, but we can't offload undo changes */
188 if (existing) {
189 opt->set.qstats->qlen -= alink->qdiscs[i].stats.backlog_pkts;
190 opt->set.qstats->backlog -=
191 alink->qdiscs[i].stats.backlog_bytes;
192 }
193 nfp_abm_red_destroy(netdev, alink, opt->handle);
194
195 return err;
196 }
197
198 static void
nfp_abm_update_stats(struct nfp_alink_stats * new,struct nfp_alink_stats * old,struct tc_qopt_offload_stats * stats)199 nfp_abm_update_stats(struct nfp_alink_stats *new, struct nfp_alink_stats *old,
200 struct tc_qopt_offload_stats *stats)
201 {
202 _bstats_update(stats->bstats, new->tx_bytes - old->tx_bytes,
203 new->tx_pkts - old->tx_pkts);
204 stats->qstats->qlen += new->backlog_pkts - old->backlog_pkts;
205 stats->qstats->backlog += new->backlog_bytes - old->backlog_bytes;
206 stats->qstats->overlimits += new->overlimits - old->overlimits;
207 stats->qstats->drops += new->drops - old->drops;
208 }
209
210 static int
nfp_abm_red_stats(struct nfp_abm_link * alink,struct tc_red_qopt_offload * opt)211 nfp_abm_red_stats(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt)
212 {
213 struct nfp_alink_stats *prev_stats;
214 struct nfp_alink_stats stats;
215 int i, err;
216
217 i = nfp_abm_red_find(alink, opt);
218 if (i < 0)
219 return i;
220 prev_stats = &alink->qdiscs[i].stats;
221
222 if (alink->parent == TC_H_ROOT)
223 err = nfp_abm_ctrl_read_stats(alink, &stats);
224 else
225 err = nfp_abm_ctrl_read_q_stats(alink, i, &stats);
226 if (err)
227 return err;
228
229 nfp_abm_update_stats(&stats, prev_stats, &opt->stats);
230
231 *prev_stats = stats;
232
233 return 0;
234 }
235
236 static int
nfp_abm_red_xstats(struct nfp_abm_link * alink,struct tc_red_qopt_offload * opt)237 nfp_abm_red_xstats(struct nfp_abm_link *alink, struct tc_red_qopt_offload *opt)
238 {
239 struct nfp_alink_xstats *prev_xstats;
240 struct nfp_alink_xstats xstats;
241 int i, err;
242
243 i = nfp_abm_red_find(alink, opt);
244 if (i < 0)
245 return i;
246 prev_xstats = &alink->qdiscs[i].xstats;
247
248 if (alink->parent == TC_H_ROOT)
249 err = nfp_abm_ctrl_read_xstats(alink, &xstats);
250 else
251 err = nfp_abm_ctrl_read_q_xstats(alink, i, &xstats);
252 if (err)
253 return err;
254
255 opt->xstats->forced_mark += xstats.ecn_marked - prev_xstats->ecn_marked;
256 opt->xstats->pdrop += xstats.pdrop - prev_xstats->pdrop;
257
258 *prev_xstats = xstats;
259
260 return 0;
261 }
262
263 static int
nfp_abm_setup_tc_red(struct net_device * netdev,struct nfp_abm_link * alink,struct tc_red_qopt_offload * opt)264 nfp_abm_setup_tc_red(struct net_device *netdev, struct nfp_abm_link *alink,
265 struct tc_red_qopt_offload *opt)
266 {
267 switch (opt->command) {
268 case TC_RED_REPLACE:
269 return nfp_abm_red_replace(netdev, alink, opt);
270 case TC_RED_DESTROY:
271 nfp_abm_red_destroy(netdev, alink, opt->handle);
272 return 0;
273 case TC_RED_STATS:
274 return nfp_abm_red_stats(alink, opt);
275 case TC_RED_XSTATS:
276 return nfp_abm_red_xstats(alink, opt);
277 default:
278 return -EOPNOTSUPP;
279 }
280 }
281
282 static int
nfp_abm_mq_stats(struct nfp_abm_link * alink,struct tc_mq_qopt_offload * opt)283 nfp_abm_mq_stats(struct nfp_abm_link *alink, struct tc_mq_qopt_offload *opt)
284 {
285 struct nfp_alink_stats stats;
286 unsigned int i;
287 int err;
288
289 for (i = 0; i < alink->num_qdiscs; i++) {
290 if (alink->qdiscs[i].handle == TC_H_UNSPEC)
291 continue;
292
293 err = nfp_abm_ctrl_read_q_stats(alink, i, &stats);
294 if (err)
295 return err;
296
297 nfp_abm_update_stats(&stats, &alink->qdiscs[i].stats,
298 &opt->stats);
299 }
300
301 return 0;
302 }
303
304 static int
nfp_abm_setup_tc_mq(struct net_device * netdev,struct nfp_abm_link * alink,struct tc_mq_qopt_offload * opt)305 nfp_abm_setup_tc_mq(struct net_device *netdev, struct nfp_abm_link *alink,
306 struct tc_mq_qopt_offload *opt)
307 {
308 switch (opt->command) {
309 case TC_MQ_CREATE:
310 nfp_abm_reset_root(netdev, alink, opt->handle,
311 alink->total_queues);
312 return 0;
313 case TC_MQ_DESTROY:
314 if (opt->handle == alink->parent)
315 nfp_abm_reset_root(netdev, alink, TC_H_ROOT, 0);
316 return 0;
317 case TC_MQ_STATS:
318 return nfp_abm_mq_stats(alink, opt);
319 default:
320 return -EOPNOTSUPP;
321 }
322 }
323
324 static int
nfp_abm_setup_tc(struct nfp_app * app,struct net_device * netdev,enum tc_setup_type type,void * type_data)325 nfp_abm_setup_tc(struct nfp_app *app, struct net_device *netdev,
326 enum tc_setup_type type, void *type_data)
327 {
328 struct nfp_repr *repr = netdev_priv(netdev);
329 struct nfp_port *port;
330
331 port = nfp_port_from_netdev(netdev);
332 if (!port || port->type != NFP_PORT_PF_PORT)
333 return -EOPNOTSUPP;
334
335 switch (type) {
336 case TC_SETUP_QDISC_MQ:
337 return nfp_abm_setup_tc_mq(netdev, repr->app_priv, type_data);
338 case TC_SETUP_QDISC_RED:
339 return nfp_abm_setup_tc_red(netdev, repr->app_priv, type_data);
340 default:
341 return -EOPNOTSUPP;
342 }
343 }
344
nfp_abm_repr_get(struct nfp_app * app,u32 port_id)345 static struct net_device *nfp_abm_repr_get(struct nfp_app *app, u32 port_id)
346 {
347 enum nfp_repr_type rtype;
348 struct nfp_reprs *reprs;
349 u8 port;
350
351 rtype = FIELD_GET(NFP_ABM_PORTID_TYPE, port_id);
352 port = FIELD_GET(NFP_ABM_PORTID_ID, port_id);
353
354 reprs = rcu_dereference(app->reprs[rtype]);
355 if (!reprs)
356 return NULL;
357
358 if (port >= reprs->num_reprs)
359 return NULL;
360
361 return rcu_dereference(reprs->reprs[port]);
362 }
363
364 static int
nfp_abm_spawn_repr(struct nfp_app * app,struct nfp_abm_link * alink,enum nfp_port_type ptype)365 nfp_abm_spawn_repr(struct nfp_app *app, struct nfp_abm_link *alink,
366 enum nfp_port_type ptype)
367 {
368 struct net_device *netdev;
369 enum nfp_repr_type rtype;
370 struct nfp_reprs *reprs;
371 struct nfp_repr *repr;
372 struct nfp_port *port;
373 unsigned int txqs;
374 int err;
375
376 if (ptype == NFP_PORT_PHYS_PORT) {
377 rtype = NFP_REPR_TYPE_PHYS_PORT;
378 txqs = 1;
379 } else {
380 rtype = NFP_REPR_TYPE_PF;
381 txqs = alink->vnic->max_rx_rings;
382 }
383
384 netdev = nfp_repr_alloc_mqs(app, txqs, 1);
385 if (!netdev)
386 return -ENOMEM;
387 repr = netdev_priv(netdev);
388 repr->app_priv = alink;
389
390 port = nfp_port_alloc(app, ptype, netdev);
391 if (IS_ERR(port)) {
392 err = PTR_ERR(port);
393 goto err_free_repr;
394 }
395
396 if (ptype == NFP_PORT_PHYS_PORT) {
397 port->eth_forced = true;
398 err = nfp_port_init_phy_port(app->pf, app, port, alink->id);
399 if (err)
400 goto err_free_port;
401 } else {
402 port->pf_id = alink->abm->pf_id;
403 port->pf_split = app->pf->max_data_vnics > 1;
404 port->pf_split_id = alink->id;
405 port->vnic = alink->vnic->dp.ctrl_bar;
406 }
407
408 SET_NETDEV_DEV(netdev, &alink->vnic->pdev->dev);
409 eth_hw_addr_random(netdev);
410
411 err = nfp_repr_init(app, netdev, nfp_abm_portid(rtype, alink->id),
412 port, alink->vnic->dp.netdev);
413 if (err)
414 goto err_free_port;
415
416 reprs = nfp_reprs_get_locked(app, rtype);
417 WARN(nfp_repr_get_locked(app, reprs, alink->id), "duplicate repr");
418 rcu_assign_pointer(reprs->reprs[alink->id], netdev);
419
420 nfp_info(app->cpp, "%s Port %d Representor(%s) created\n",
421 ptype == NFP_PORT_PF_PORT ? "PCIe" : "Phys",
422 alink->id, netdev->name);
423
424 return 0;
425
426 err_free_port:
427 nfp_port_free(port);
428 err_free_repr:
429 nfp_repr_free(netdev);
430 return err;
431 }
432
433 static void
nfp_abm_kill_repr(struct nfp_app * app,struct nfp_abm_link * alink,enum nfp_repr_type rtype)434 nfp_abm_kill_repr(struct nfp_app *app, struct nfp_abm_link *alink,
435 enum nfp_repr_type rtype)
436 {
437 struct net_device *netdev;
438 struct nfp_reprs *reprs;
439
440 reprs = nfp_reprs_get_locked(app, rtype);
441 netdev = nfp_repr_get_locked(app, reprs, alink->id);
442 if (!netdev)
443 return;
444 rcu_assign_pointer(reprs->reprs[alink->id], NULL);
445 synchronize_rcu();
446 /* Cast to make sure nfp_repr_clean_and_free() takes a nfp_repr */
447 nfp_repr_clean_and_free((struct nfp_repr *)netdev_priv(netdev));
448 }
449
450 static void
nfp_abm_kill_reprs(struct nfp_abm * abm,struct nfp_abm_link * alink)451 nfp_abm_kill_reprs(struct nfp_abm *abm, struct nfp_abm_link *alink)
452 {
453 nfp_abm_kill_repr(abm->app, alink, NFP_REPR_TYPE_PF);
454 nfp_abm_kill_repr(abm->app, alink, NFP_REPR_TYPE_PHYS_PORT);
455 }
456
nfp_abm_kill_reprs_all(struct nfp_abm * abm)457 static void nfp_abm_kill_reprs_all(struct nfp_abm *abm)
458 {
459 struct nfp_pf *pf = abm->app->pf;
460 struct nfp_net *nn;
461
462 list_for_each_entry(nn, &pf->vnics, vnic_list)
463 nfp_abm_kill_reprs(abm, (struct nfp_abm_link *)nn->app_priv);
464 }
465
nfp_abm_eswitch_mode_get(struct nfp_app * app)466 static enum devlink_eswitch_mode nfp_abm_eswitch_mode_get(struct nfp_app *app)
467 {
468 struct nfp_abm *abm = app->priv;
469
470 return abm->eswitch_mode;
471 }
472
nfp_abm_eswitch_set_legacy(struct nfp_abm * abm)473 static int nfp_abm_eswitch_set_legacy(struct nfp_abm *abm)
474 {
475 nfp_abm_kill_reprs_all(abm);
476 nfp_abm_ctrl_qm_disable(abm);
477
478 abm->eswitch_mode = DEVLINK_ESWITCH_MODE_LEGACY;
479 return 0;
480 }
481
nfp_abm_eswitch_clean_up(struct nfp_abm * abm)482 static void nfp_abm_eswitch_clean_up(struct nfp_abm *abm)
483 {
484 if (abm->eswitch_mode != DEVLINK_ESWITCH_MODE_LEGACY)
485 WARN_ON(nfp_abm_eswitch_set_legacy(abm));
486 }
487
nfp_abm_eswitch_set_switchdev(struct nfp_abm * abm)488 static int nfp_abm_eswitch_set_switchdev(struct nfp_abm *abm)
489 {
490 struct nfp_app *app = abm->app;
491 struct nfp_pf *pf = app->pf;
492 struct nfp_net *nn;
493 int err;
494
495 err = nfp_abm_ctrl_qm_enable(abm);
496 if (err)
497 return err;
498
499 list_for_each_entry(nn, &pf->vnics, vnic_list) {
500 struct nfp_abm_link *alink = nn->app_priv;
501
502 err = nfp_abm_spawn_repr(app, alink, NFP_PORT_PHYS_PORT);
503 if (err)
504 goto err_kill_all_reprs;
505
506 err = nfp_abm_spawn_repr(app, alink, NFP_PORT_PF_PORT);
507 if (err)
508 goto err_kill_all_reprs;
509 }
510
511 abm->eswitch_mode = DEVLINK_ESWITCH_MODE_SWITCHDEV;
512 return 0;
513
514 err_kill_all_reprs:
515 nfp_abm_kill_reprs_all(abm);
516 nfp_abm_ctrl_qm_disable(abm);
517 return err;
518 }
519
nfp_abm_eswitch_mode_set(struct nfp_app * app,u16 mode)520 static int nfp_abm_eswitch_mode_set(struct nfp_app *app, u16 mode)
521 {
522 struct nfp_abm *abm = app->priv;
523
524 if (abm->eswitch_mode == mode)
525 return 0;
526
527 switch (mode) {
528 case DEVLINK_ESWITCH_MODE_LEGACY:
529 return nfp_abm_eswitch_set_legacy(abm);
530 case DEVLINK_ESWITCH_MODE_SWITCHDEV:
531 return nfp_abm_eswitch_set_switchdev(abm);
532 default:
533 return -EINVAL;
534 }
535 }
536
537 static void
nfp_abm_vnic_set_mac(struct nfp_pf * pf,struct nfp_abm * abm,struct nfp_net * nn,unsigned int id)538 nfp_abm_vnic_set_mac(struct nfp_pf *pf, struct nfp_abm *abm, struct nfp_net *nn,
539 unsigned int id)
540 {
541 struct nfp_eth_table_port *eth_port = &pf->eth_tbl->ports[id];
542 u8 mac_addr[ETH_ALEN];
543 const char *mac_str;
544 char name[32];
545
546 if (id > pf->eth_tbl->count) {
547 nfp_warn(pf->cpp, "No entry for persistent MAC address\n");
548 eth_hw_addr_random(nn->dp.netdev);
549 return;
550 }
551
552 snprintf(name, sizeof(name), "eth%u.mac.pf%u",
553 eth_port->eth_index, abm->pf_id);
554
555 mac_str = nfp_hwinfo_lookup(pf->hwinfo, name);
556 if (!mac_str) {
557 nfp_warn(pf->cpp, "Can't lookup persistent MAC address (%s)\n",
558 name);
559 eth_hw_addr_random(nn->dp.netdev);
560 return;
561 }
562
563 if (sscanf(mac_str, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
564 &mac_addr[0], &mac_addr[1], &mac_addr[2],
565 &mac_addr[3], &mac_addr[4], &mac_addr[5]) != 6) {
566 nfp_warn(pf->cpp, "Can't parse persistent MAC address (%s)\n",
567 mac_str);
568 eth_hw_addr_random(nn->dp.netdev);
569 return;
570 }
571
572 ether_addr_copy(nn->dp.netdev->dev_addr, mac_addr);
573 ether_addr_copy(nn->dp.netdev->perm_addr, mac_addr);
574 }
575
576 static int
nfp_abm_vnic_alloc(struct nfp_app * app,struct nfp_net * nn,unsigned int id)577 nfp_abm_vnic_alloc(struct nfp_app *app, struct nfp_net *nn, unsigned int id)
578 {
579 struct nfp_eth_table_port *eth_port = &app->pf->eth_tbl->ports[id];
580 struct nfp_abm *abm = app->priv;
581 struct nfp_abm_link *alink;
582 int err;
583
584 alink = kzalloc(sizeof(*alink), GFP_KERNEL);
585 if (!alink)
586 return -ENOMEM;
587 nn->app_priv = alink;
588 alink->abm = abm;
589 alink->vnic = nn;
590 alink->id = id;
591 alink->parent = TC_H_ROOT;
592 alink->total_queues = alink->vnic->max_rx_rings;
593 alink->qdiscs = kvcalloc(alink->total_queues, sizeof(*alink->qdiscs),
594 GFP_KERNEL);
595 if (!alink->qdiscs) {
596 err = -ENOMEM;
597 goto err_free_alink;
598 }
599
600 /* This is a multi-host app, make sure MAC/PHY is up, but don't
601 * make the MAC/PHY state follow the state of any of the ports.
602 */
603 err = nfp_eth_set_configured(app->cpp, eth_port->index, true);
604 if (err < 0)
605 goto err_free_qdiscs;
606
607 netif_keep_dst(nn->dp.netdev);
608
609 nfp_abm_vnic_set_mac(app->pf, abm, nn, id);
610 nfp_abm_ctrl_read_params(alink);
611
612 return 0;
613
614 err_free_qdiscs:
615 kvfree(alink->qdiscs);
616 err_free_alink:
617 kfree(alink);
618 return err;
619 }
620
nfp_abm_vnic_free(struct nfp_app * app,struct nfp_net * nn)621 static void nfp_abm_vnic_free(struct nfp_app *app, struct nfp_net *nn)
622 {
623 struct nfp_abm_link *alink = nn->app_priv;
624
625 nfp_abm_kill_reprs(alink->abm, alink);
626 kvfree(alink->qdiscs);
627 kfree(alink);
628 }
629
630 static u64 *
nfp_abm_port_get_stats(struct nfp_app * app,struct nfp_port * port,u64 * data)631 nfp_abm_port_get_stats(struct nfp_app *app, struct nfp_port *port, u64 *data)
632 {
633 struct nfp_repr *repr = netdev_priv(port->netdev);
634 struct nfp_abm_link *alink;
635 unsigned int i;
636
637 if (port->type != NFP_PORT_PF_PORT)
638 return data;
639 alink = repr->app_priv;
640 for (i = 0; i < alink->vnic->dp.num_r_vecs; i++) {
641 *data++ = nfp_abm_ctrl_stat_non_sto(alink, i);
642 *data++ = nfp_abm_ctrl_stat_sto(alink, i);
643 }
644 return data;
645 }
646
647 static int
nfp_abm_port_get_stats_count(struct nfp_app * app,struct nfp_port * port)648 nfp_abm_port_get_stats_count(struct nfp_app *app, struct nfp_port *port)
649 {
650 struct nfp_repr *repr = netdev_priv(port->netdev);
651 struct nfp_abm_link *alink;
652
653 if (port->type != NFP_PORT_PF_PORT)
654 return 0;
655 alink = repr->app_priv;
656 return alink->vnic->dp.num_r_vecs * 2;
657 }
658
659 static u8 *
nfp_abm_port_get_stats_strings(struct nfp_app * app,struct nfp_port * port,u8 * data)660 nfp_abm_port_get_stats_strings(struct nfp_app *app, struct nfp_port *port,
661 u8 *data)
662 {
663 struct nfp_repr *repr = netdev_priv(port->netdev);
664 struct nfp_abm_link *alink;
665 unsigned int i;
666
667 if (port->type != NFP_PORT_PF_PORT)
668 return data;
669 alink = repr->app_priv;
670 for (i = 0; i < alink->vnic->dp.num_r_vecs; i++) {
671 data = nfp_pr_et(data, "q%u_no_wait", i);
672 data = nfp_pr_et(data, "q%u_delayed", i);
673 }
674 return data;
675 }
676
nfp_abm_init(struct nfp_app * app)677 static int nfp_abm_init(struct nfp_app *app)
678 {
679 struct nfp_pf *pf = app->pf;
680 struct nfp_reprs *reprs;
681 struct nfp_abm *abm;
682 int err;
683
684 if (!pf->eth_tbl) {
685 nfp_err(pf->cpp, "ABM NIC requires ETH table\n");
686 return -EINVAL;
687 }
688 if (pf->max_data_vnics != pf->eth_tbl->count) {
689 nfp_err(pf->cpp, "ETH entries don't match vNICs (%d vs %d)\n",
690 pf->max_data_vnics, pf->eth_tbl->count);
691 return -EINVAL;
692 }
693 if (!pf->mac_stats_bar) {
694 nfp_warn(app->cpp, "ABM NIC requires mac_stats symbol\n");
695 return -EINVAL;
696 }
697
698 abm = kzalloc(sizeof(*abm), GFP_KERNEL);
699 if (!abm)
700 return -ENOMEM;
701 app->priv = abm;
702 abm->app = app;
703
704 err = nfp_abm_ctrl_find_addrs(abm);
705 if (err)
706 goto err_free_abm;
707
708 /* We start in legacy mode, make sure advanced queuing is disabled */
709 err = nfp_abm_ctrl_qm_disable(abm);
710 if (err)
711 goto err_free_abm;
712
713 err = -ENOMEM;
714 reprs = nfp_reprs_alloc(pf->max_data_vnics);
715 if (!reprs)
716 goto err_free_abm;
717 RCU_INIT_POINTER(app->reprs[NFP_REPR_TYPE_PHYS_PORT], reprs);
718
719 reprs = nfp_reprs_alloc(pf->max_data_vnics);
720 if (!reprs)
721 goto err_free_phys;
722 RCU_INIT_POINTER(app->reprs[NFP_REPR_TYPE_PF], reprs);
723
724 return 0;
725
726 err_free_phys:
727 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);
728 err_free_abm:
729 kfree(abm);
730 app->priv = NULL;
731 return err;
732 }
733
nfp_abm_clean(struct nfp_app * app)734 static void nfp_abm_clean(struct nfp_app *app)
735 {
736 struct nfp_abm *abm = app->priv;
737
738 nfp_abm_eswitch_clean_up(abm);
739 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF);
740 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);
741 kfree(abm);
742 app->priv = NULL;
743 }
744
745 const struct nfp_app_type app_abm = {
746 .id = NFP_APP_ACTIVE_BUFFER_MGMT_NIC,
747 .name = "abm",
748
749 .init = nfp_abm_init,
750 .clean = nfp_abm_clean,
751
752 .vnic_alloc = nfp_abm_vnic_alloc,
753 .vnic_free = nfp_abm_vnic_free,
754
755 .port_get_stats = nfp_abm_port_get_stats,
756 .port_get_stats_count = nfp_abm_port_get_stats_count,
757 .port_get_stats_strings = nfp_abm_port_get_stats_strings,
758
759 .setup_tc = nfp_abm_setup_tc,
760
761 .eswitch_mode_get = nfp_abm_eswitch_mode_get,
762 .eswitch_mode_set = nfp_abm_eswitch_mode_set,
763
764 .repr_get = nfp_abm_repr_get,
765 };
766
