Loading...
1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2/* Copyright (C) 2015-2018 Netronome Systems, Inc. */
3
4/*
5 * nfp_net_main.c
6 * Netronome network device driver: Main entry point
7 * Authors: Jakub Kicinski <jakub.kicinski@netronome.com>
8 * Alejandro Lucero <alejandro.lucero@netronome.com>
9 * Jason McMullan <jason.mcmullan@netronome.com>
10 * Rolf Neugebauer <rolf.neugebauer@netronome.com>
11 */
12
13#include <linux/etherdevice.h>
14#include <linux/kernel.h>
15#include <linux/init.h>
16#include <linux/lockdep.h>
17#include <linux/pci.h>
18#include <linux/pci_regs.h>
19#include <linux/random.h>
20#include <linux/rtnetlink.h>
21
22#include "nfpcore/nfp.h"
23#include "nfpcore/nfp_cpp.h"
24#include "nfpcore/nfp_dev.h"
25#include "nfpcore/nfp_nffw.h"
26#include "nfpcore/nfp_nsp.h"
27#include "nfpcore/nfp6000_pcie.h"
28#include "nfp_app.h"
29#include "nfp_net_ctrl.h"
30#include "nfp_net_sriov.h"
31#include "nfp_net.h"
32#include "nfp_main.h"
33#include "nfp_port.h"
34
35#define NFP_PF_CSR_SLICE_SIZE (32 * 1024)
36
37/**
38 * nfp_net_get_mac_addr() - Get the MAC address.
39 * @pf: NFP PF handle
40 * @netdev: net_device to set MAC address on
41 * @port: NFP port structure
42 *
43 * First try to get the MAC address from NSP ETH table. If that
44 * fails generate a random address.
45 */
46void
47nfp_net_get_mac_addr(struct nfp_pf *pf, struct net_device *netdev,
48 struct nfp_port *port)
49{
50 struct nfp_eth_table_port *eth_port;
51
52 eth_port = __nfp_port_get_eth_port(port);
53 if (!eth_port) {
54 eth_hw_addr_random(netdev);
55 return;
56 }
57
58 eth_hw_addr_set(netdev, eth_port->mac_addr);
59 ether_addr_copy(netdev->perm_addr, eth_port->mac_addr);
60}
61
62static struct nfp_eth_table_port *
63nfp_net_find_port(struct nfp_eth_table *eth_tbl, unsigned int index)
64{
65 int i;
66
67 for (i = 0; eth_tbl && i < eth_tbl->count; i++)
68 if (eth_tbl->ports[i].index == index)
69 return ð_tbl->ports[i];
70
71 return NULL;
72}
73
74static int nfp_net_pf_get_num_ports(struct nfp_pf *pf)
75{
76 return nfp_pf_rtsym_read_optional(pf, "nfd_cfg_pf%u_num_ports", 1);
77}
78
79static void nfp_net_pf_free_vnic(struct nfp_pf *pf, struct nfp_net *nn)
80{
81 if (nfp_net_is_data_vnic(nn))
82 nfp_app_vnic_free(pf->app, nn);
83 nfp_port_free(nn->port);
84 list_del(&nn->vnic_list);
85 pf->num_vnics--;
86 nfp_net_free(nn);
87}
88
89static void nfp_net_pf_free_vnics(struct nfp_pf *pf)
90{
91 struct nfp_net *nn, *next;
92
93 list_for_each_entry_safe(nn, next, &pf->vnics, vnic_list)
94 if (nfp_net_is_data_vnic(nn))
95 nfp_net_pf_free_vnic(pf, nn);
96}
97
98static struct nfp_net *
99nfp_net_pf_alloc_vnic(struct nfp_pf *pf, bool needs_netdev,
100 void __iomem *ctrl_bar, void __iomem *qc_bar,
101 int stride, unsigned int id)
102{
103 u32 tx_base, rx_base, n_tx_rings, n_rx_rings;
104 struct nfp_net *nn;
105 int err;
106
107 tx_base = readl(ctrl_bar + NFP_NET_CFG_START_TXQ);
108 rx_base = readl(ctrl_bar + NFP_NET_CFG_START_RXQ);
109 n_tx_rings = readl(ctrl_bar + NFP_NET_CFG_MAX_TXRINGS);
110 n_rx_rings = readl(ctrl_bar + NFP_NET_CFG_MAX_RXRINGS);
111
112 /* Allocate and initialise the vNIC */
113 nn = nfp_net_alloc(pf->pdev, pf->dev_info, ctrl_bar, needs_netdev,
114 n_tx_rings, n_rx_rings);
115 if (IS_ERR(nn))
116 return nn;
117
118 nn->app = pf->app;
119 nn->tx_bar = qc_bar + tx_base * NFP_QCP_QUEUE_ADDR_SZ;
120 nn->rx_bar = qc_bar + rx_base * NFP_QCP_QUEUE_ADDR_SZ;
121 nn->dp.is_vf = 0;
122 nn->stride_rx = stride;
123 nn->stride_tx = stride;
124
125 if (needs_netdev) {
126 err = nfp_app_vnic_alloc(pf->app, nn, id);
127 if (err) {
128 nfp_net_free(nn);
129 return ERR_PTR(err);
130 }
131 }
132
133 pf->num_vnics++;
134 list_add_tail(&nn->vnic_list, &pf->vnics);
135
136 return nn;
137}
138
139static int
140nfp_net_pf_init_vnic(struct nfp_pf *pf, struct nfp_net *nn, unsigned int id)
141{
142 int err;
143
144 nn->id = id;
145
146 if (nn->port) {
147 err = nfp_devlink_port_register(pf->app, nn->port);
148 if (err)
149 return err;
150 }
151
152 err = nfp_net_init(nn);
153 if (err)
154 goto err_devlink_port_clean;
155
156 nfp_net_debugfs_vnic_add(nn, pf->ddir);
157
158 nfp_net_info(nn);
159
160 if (nfp_net_is_data_vnic(nn)) {
161 err = nfp_app_vnic_init(pf->app, nn);
162 if (err)
163 goto err_debugfs_vnic_clean;
164 }
165
166 return 0;
167
168err_debugfs_vnic_clean:
169 nfp_net_debugfs_dir_clean(&nn->debugfs_dir);
170 nfp_net_clean(nn);
171err_devlink_port_clean:
172 if (nn->port)
173 nfp_devlink_port_unregister(nn->port);
174 return err;
175}
176
177static int
178nfp_net_pf_alloc_vnics(struct nfp_pf *pf, void __iomem *ctrl_bar,
179 void __iomem *qc_bar, int stride)
180{
181 struct nfp_net *nn;
182 unsigned int i;
183 int err;
184
185 for (i = 0; i < pf->max_data_vnics; i++) {
186 nn = nfp_net_pf_alloc_vnic(pf, true, ctrl_bar, qc_bar,
187 stride, i);
188 if (IS_ERR(nn)) {
189 err = PTR_ERR(nn);
190 goto err_free_prev;
191 }
192
193 if (nn->port)
194 nn->port->link_cb = nfp_net_refresh_port_table;
195
196 ctrl_bar += NFP_PF_CSR_SLICE_SIZE;
197
198 /* Kill the vNIC if app init marked it as invalid */
199 if (nn->port && nn->port->type == NFP_PORT_INVALID)
200 nfp_net_pf_free_vnic(pf, nn);
201 }
202
203 if (list_empty(&pf->vnics))
204 return -ENODEV;
205
206 return 0;
207
208err_free_prev:
209 nfp_net_pf_free_vnics(pf);
210 return err;
211}
212
213static void nfp_net_pf_clean_vnic(struct nfp_pf *pf, struct nfp_net *nn)
214{
215 if (nfp_net_is_data_vnic(nn))
216 nfp_app_vnic_clean(pf->app, nn);
217 nfp_net_debugfs_dir_clean(&nn->debugfs_dir);
218 nfp_net_clean(nn);
219 if (nn->port)
220 nfp_devlink_port_unregister(nn->port);
221}
222
223static int nfp_net_pf_alloc_irqs(struct nfp_pf *pf)
224{
225 unsigned int wanted_irqs, num_irqs, vnics_left, irqs_left;
226 struct nfp_net *nn;
227
228 /* Get MSI-X vectors */
229 wanted_irqs = 0;
230 list_for_each_entry(nn, &pf->vnics, vnic_list)
231 wanted_irqs += NFP_NET_NON_Q_VECTORS + nn->dp.num_r_vecs;
232 pf->irq_entries = kcalloc(wanted_irqs, sizeof(*pf->irq_entries),
233 GFP_KERNEL);
234 if (!pf->irq_entries)
235 return -ENOMEM;
236
237 num_irqs = nfp_net_irqs_alloc(pf->pdev, pf->irq_entries,
238 NFP_NET_MIN_VNIC_IRQS * pf->num_vnics,
239 wanted_irqs);
240 if (!num_irqs) {
241 nfp_warn(pf->cpp, "Unable to allocate MSI-X vectors\n");
242 kfree(pf->irq_entries);
243 return -ENOMEM;
244 }
245
246 /* Distribute IRQs to vNICs */
247 irqs_left = num_irqs;
248 vnics_left = pf->num_vnics;
249 list_for_each_entry(nn, &pf->vnics, vnic_list) {
250 unsigned int n;
251
252 n = min(NFP_NET_NON_Q_VECTORS + nn->dp.num_r_vecs,
253 DIV_ROUND_UP(irqs_left, vnics_left));
254 nfp_net_irqs_assign(nn, &pf->irq_entries[num_irqs - irqs_left],
255 n);
256 irqs_left -= n;
257 vnics_left--;
258 }
259
260 return 0;
261}
262
263static void nfp_net_pf_free_irqs(struct nfp_pf *pf)
264{
265 nfp_net_irqs_disable(pf->pdev);
266 kfree(pf->irq_entries);
267}
268
269static int nfp_net_pf_init_vnics(struct nfp_pf *pf)
270{
271 struct nfp_net *nn;
272 unsigned int id;
273 int err;
274
275 /* Finish vNIC init and register */
276 id = 0;
277 list_for_each_entry(nn, &pf->vnics, vnic_list) {
278 if (!nfp_net_is_data_vnic(nn))
279 continue;
280 err = nfp_net_pf_init_vnic(pf, nn, id);
281 if (err)
282 goto err_prev_deinit;
283
284 id++;
285 }
286
287 return 0;
288
289err_prev_deinit:
290 list_for_each_entry_continue_reverse(nn, &pf->vnics, vnic_list)
291 if (nfp_net_is_data_vnic(nn))
292 nfp_net_pf_clean_vnic(pf, nn);
293 return err;
294}
295
296static int
297nfp_net_pf_app_init(struct nfp_pf *pf, u8 __iomem *qc_bar, unsigned int stride)
298{
299 struct devlink *devlink = priv_to_devlink(pf);
300 u8 __iomem *ctrl_bar;
301 int err;
302
303 pf->app = nfp_app_alloc(pf, nfp_net_pf_get_app_id(pf));
304 if (IS_ERR(pf->app))
305 return PTR_ERR(pf->app);
306
307 devl_lock(devlink);
308 err = nfp_app_init(pf->app);
309 devl_unlock(devlink);
310 if (err)
311 goto err_free;
312
313 if (!nfp_app_needs_ctrl_vnic(pf->app))
314 return 0;
315
316 ctrl_bar = nfp_pf_map_rtsym(pf, "net.ctrl", "_pf%u_net_ctrl_bar",
317 NFP_PF_CSR_SLICE_SIZE, &pf->ctrl_vnic_bar);
318 if (IS_ERR(ctrl_bar)) {
319 nfp_err(pf->cpp, "Failed to find ctrl vNIC memory symbol\n");
320 err = PTR_ERR(ctrl_bar);
321 goto err_app_clean;
322 }
323
324 pf->ctrl_vnic = nfp_net_pf_alloc_vnic(pf, false, ctrl_bar, qc_bar,
325 stride, 0);
326 if (IS_ERR(pf->ctrl_vnic)) {
327 err = PTR_ERR(pf->ctrl_vnic);
328 goto err_unmap;
329 }
330
331 return 0;
332
333err_unmap:
334 nfp_cpp_area_release_free(pf->ctrl_vnic_bar);
335err_app_clean:
336 devl_lock(devlink);
337 nfp_app_clean(pf->app);
338 devl_unlock(devlink);
339err_free:
340 nfp_app_free(pf->app);
341 pf->app = NULL;
342 return err;
343}
344
345static void nfp_net_pf_app_clean(struct nfp_pf *pf)
346{
347 struct devlink *devlink = priv_to_devlink(pf);
348
349 if (pf->ctrl_vnic) {
350 nfp_net_pf_free_vnic(pf, pf->ctrl_vnic);
351 nfp_cpp_area_release_free(pf->ctrl_vnic_bar);
352 }
353
354 devl_lock(devlink);
355 nfp_app_clean(pf->app);
356 devl_unlock(devlink);
357
358 nfp_app_free(pf->app);
359 pf->app = NULL;
360}
361
362static int nfp_net_pf_app_start_ctrl(struct nfp_pf *pf)
363{
364 int err;
365
366 if (!pf->ctrl_vnic)
367 return 0;
368 err = nfp_net_pf_init_vnic(pf, pf->ctrl_vnic, 0);
369 if (err)
370 return err;
371
372 err = nfp_ctrl_open(pf->ctrl_vnic);
373 if (err)
374 goto err_clean_ctrl;
375
376 return 0;
377
378err_clean_ctrl:
379 nfp_net_pf_clean_vnic(pf, pf->ctrl_vnic);
380 return err;
381}
382
383static void nfp_net_pf_app_stop_ctrl(struct nfp_pf *pf)
384{
385 if (!pf->ctrl_vnic)
386 return;
387 nfp_ctrl_close(pf->ctrl_vnic);
388 nfp_net_pf_clean_vnic(pf, pf->ctrl_vnic);
389}
390
391static int nfp_net_pf_app_start(struct nfp_pf *pf)
392{
393 int err;
394
395 err = nfp_net_pf_app_start_ctrl(pf);
396 if (err)
397 return err;
398
399 err = nfp_app_start(pf->app, pf->ctrl_vnic);
400 if (err)
401 goto err_ctrl_stop;
402
403 if (pf->num_vfs) {
404 err = nfp_app_sriov_enable(pf->app, pf->num_vfs);
405 if (err)
406 goto err_app_stop;
407 }
408
409 return 0;
410
411err_app_stop:
412 nfp_app_stop(pf->app);
413err_ctrl_stop:
414 nfp_net_pf_app_stop_ctrl(pf);
415 return err;
416}
417
418static void nfp_net_pf_app_stop(struct nfp_pf *pf)
419{
420 if (pf->num_vfs)
421 nfp_app_sriov_disable(pf->app);
422 nfp_app_stop(pf->app);
423 nfp_net_pf_app_stop_ctrl(pf);
424}
425
426static void nfp_net_pci_unmap_mem(struct nfp_pf *pf)
427{
428 if (pf->vfcfg_tbl2_area)
429 nfp_cpp_area_release_free(pf->vfcfg_tbl2_area);
430 if (pf->vf_cfg_bar)
431 nfp_cpp_area_release_free(pf->vf_cfg_bar);
432 if (pf->mac_stats_bar)
433 nfp_cpp_area_release_free(pf->mac_stats_bar);
434 nfp_cpp_area_release_free(pf->qc_area);
435 nfp_cpp_area_release_free(pf->data_vnic_bar);
436}
437
438static int nfp_net_pci_map_mem(struct nfp_pf *pf)
439{
440 u32 min_size, cpp_id;
441 u8 __iomem *mem;
442 int err;
443
444 min_size = pf->max_data_vnics * NFP_PF_CSR_SLICE_SIZE;
445 mem = nfp_pf_map_rtsym(pf, "net.bar0", "_pf%d_net_bar0",
446 min_size, &pf->data_vnic_bar);
447 if (IS_ERR(mem)) {
448 nfp_err(pf->cpp, "Failed to find data vNIC memory symbol\n");
449 return PTR_ERR(mem);
450 }
451
452 if (pf->eth_tbl) {
453 min_size = NFP_MAC_STATS_SIZE * (pf->eth_tbl->max_index + 1);
454 pf->mac_stats_mem = nfp_rtsym_map(pf->rtbl, "_mac_stats",
455 "net.macstats", min_size,
456 &pf->mac_stats_bar);
457 if (IS_ERR(pf->mac_stats_mem)) {
458 if (PTR_ERR(pf->mac_stats_mem) != -ENOENT) {
459 err = PTR_ERR(pf->mac_stats_mem);
460 goto err_unmap_ctrl;
461 }
462 pf->mac_stats_mem = NULL;
463 }
464 }
465
466 pf->vf_cfg_mem = nfp_pf_map_rtsym(pf, "net.vfcfg", "_pf%d_net_vf_bar",
467 NFP_NET_CFG_BAR_SZ * pf->limit_vfs,
468 &pf->vf_cfg_bar);
469 if (IS_ERR(pf->vf_cfg_mem)) {
470 if (PTR_ERR(pf->vf_cfg_mem) != -ENOENT) {
471 err = PTR_ERR(pf->vf_cfg_mem);
472 goto err_unmap_mac_stats;
473 }
474 pf->vf_cfg_mem = NULL;
475 }
476
477 min_size = NFP_NET_VF_CFG_SZ * pf->limit_vfs + NFP_NET_VF_CFG_MB_SZ;
478 pf->vfcfg_tbl2 = nfp_pf_map_rtsym(pf, "net.vfcfg_tbl2",
479 "_pf%d_net_vf_cfg2",
480 min_size, &pf->vfcfg_tbl2_area);
481 if (IS_ERR(pf->vfcfg_tbl2)) {
482 if (PTR_ERR(pf->vfcfg_tbl2) != -ENOENT) {
483 err = PTR_ERR(pf->vfcfg_tbl2);
484 goto err_unmap_vf_cfg;
485 }
486 pf->vfcfg_tbl2 = NULL;
487 }
488
489 cpp_id = NFP_CPP_ISLAND_ID(0, NFP_CPP_ACTION_RW, 0, 0);
490 mem = nfp_cpp_map_area(pf->cpp, "net.qc", cpp_id,
491 nfp_qcp_queue_offset(pf->dev_info, 0),
492 pf->dev_info->qc_area_sz, &pf->qc_area);
493 if (IS_ERR(mem)) {
494 nfp_err(pf->cpp, "Failed to map Queue Controller area.\n");
495 err = PTR_ERR(mem);
496 goto err_unmap_vfcfg_tbl2;
497 }
498
499 return 0;
500
501err_unmap_vfcfg_tbl2:
502 if (pf->vfcfg_tbl2_area)
503 nfp_cpp_area_release_free(pf->vfcfg_tbl2_area);
504err_unmap_vf_cfg:
505 if (pf->vf_cfg_bar)
506 nfp_cpp_area_release_free(pf->vf_cfg_bar);
507err_unmap_mac_stats:
508 if (pf->mac_stats_bar)
509 nfp_cpp_area_release_free(pf->mac_stats_bar);
510err_unmap_ctrl:
511 nfp_cpp_area_release_free(pf->data_vnic_bar);
512 return err;
513}
514
515static const unsigned int lr_to_speed[] = {
516 [NFP_NET_CFG_STS_LINK_RATE_UNSUPPORTED] = 0,
517 [NFP_NET_CFG_STS_LINK_RATE_UNKNOWN] = SPEED_UNKNOWN,
518 [NFP_NET_CFG_STS_LINK_RATE_1G] = SPEED_1000,
519 [NFP_NET_CFG_STS_LINK_RATE_10G] = SPEED_10000,
520 [NFP_NET_CFG_STS_LINK_RATE_25G] = SPEED_25000,
521 [NFP_NET_CFG_STS_LINK_RATE_40G] = SPEED_40000,
522 [NFP_NET_CFG_STS_LINK_RATE_50G] = SPEED_50000,
523 [NFP_NET_CFG_STS_LINK_RATE_100G] = SPEED_100000,
524};
525
526unsigned int nfp_net_lr2speed(unsigned int linkrate)
527{
528 if (linkrate < ARRAY_SIZE(lr_to_speed))
529 return lr_to_speed[linkrate];
530
531 return SPEED_UNKNOWN;
532}
533
534unsigned int nfp_net_speed2lr(unsigned int speed)
535{
536 int i;
537
538 for (i = 0; i < ARRAY_SIZE(lr_to_speed); i++) {
539 if (speed == lr_to_speed[i])
540 return i;
541 }
542
543 return NFP_NET_CFG_STS_LINK_RATE_UNKNOWN;
544}
545
546static void nfp_net_notify_port_speed(struct nfp_port *port)
547{
548 struct net_device *netdev = port->netdev;
549 struct nfp_net *nn;
550 u16 sts;
551
552 if (!nfp_netdev_is_nfp_net(netdev))
553 return;
554
555 nn = netdev_priv(netdev);
556 sts = nn_readw(nn, NFP_NET_CFG_STS);
557
558 if (!(sts & NFP_NET_CFG_STS_LINK)) {
559 nn_writew(nn, NFP_NET_CFG_STS_NSP_LINK_RATE, NFP_NET_CFG_STS_LINK_RATE_UNKNOWN);
560 return;
561 }
562
563 nn_writew(nn, NFP_NET_CFG_STS_NSP_LINK_RATE, nfp_net_speed2lr(port->eth_port->speed));
564}
565
566static int
567nfp_net_eth_port_update(struct nfp_cpp *cpp, struct nfp_port *port,
568 struct nfp_eth_table *eth_table)
569{
570 struct nfp_eth_table_port *eth_port;
571
572 ASSERT_RTNL();
573
574 eth_port = nfp_net_find_port(eth_table, port->eth_id);
575 if (!eth_port) {
576 set_bit(NFP_PORT_CHANGED, &port->flags);
577 nfp_warn(cpp, "Warning: port #%d not present after reconfig\n",
578 port->eth_id);
579 return -EIO;
580 }
581 if (eth_port->override_changed) {
582 nfp_warn(cpp, "Port #%d config changed, unregistering. Driver reload required before port will be operational again.\n", port->eth_id);
583 port->type = NFP_PORT_INVALID;
584 }
585
586 memcpy(port->eth_port, eth_port, sizeof(*eth_port));
587 nfp_net_notify_port_speed(port);
588
589 return 0;
590}
591
592int nfp_net_refresh_port_table_sync(struct nfp_pf *pf)
593{
594 struct devlink *devlink = priv_to_devlink(pf);
595 struct nfp_eth_table *eth_table;
596 struct nfp_net *nn, *next;
597 struct nfp_port *port;
598 int err;
599
600 devl_assert_locked(devlink);
601
602 /* Check for nfp_net_pci_remove() racing against us */
603 if (list_empty(&pf->vnics))
604 return 0;
605
606 /* Update state of all ports */
607 rtnl_lock();
608 list_for_each_entry(port, &pf->ports, port_list)
609 clear_bit(NFP_PORT_CHANGED, &port->flags);
610
611 eth_table = nfp_eth_read_ports(pf->cpp);
612 if (!eth_table) {
613 list_for_each_entry(port, &pf->ports, port_list)
614 if (__nfp_port_get_eth_port(port))
615 set_bit(NFP_PORT_CHANGED, &port->flags);
616 rtnl_unlock();
617 nfp_err(pf->cpp, "Error refreshing port config!\n");
618 return -EIO;
619 }
620
621 list_for_each_entry(port, &pf->ports, port_list)
622 if (__nfp_port_get_eth_port(port))
623 nfp_net_eth_port_update(pf->cpp, port, eth_table);
624 rtnl_unlock();
625
626 kfree(eth_table);
627
628 /* Resync repr state. This may cause reprs to be removed. */
629 err = nfp_reprs_resync_phys_ports(pf->app);
630 if (err)
631 return err;
632
633 /* Shoot off the ports which became invalid */
634 list_for_each_entry_safe(nn, next, &pf->vnics, vnic_list) {
635 if (!nn->port || nn->port->type != NFP_PORT_INVALID)
636 continue;
637
638 nfp_net_pf_clean_vnic(pf, nn);
639 nfp_net_pf_free_vnic(pf, nn);
640 }
641
642 return 0;
643}
644
645static void nfp_net_refresh_vnics(struct work_struct *work)
646{
647 struct nfp_pf *pf = container_of(work, struct nfp_pf,
648 port_refresh_work);
649 struct devlink *devlink = priv_to_devlink(pf);
650
651 devl_lock(devlink);
652 nfp_net_refresh_port_table_sync(pf);
653 devl_unlock(devlink);
654}
655
656void nfp_net_refresh_port_table(struct nfp_port *port)
657{
658 struct nfp_pf *pf = port->app->pf;
659
660 set_bit(NFP_PORT_CHANGED, &port->flags);
661
662 queue_work(pf->wq, &pf->port_refresh_work);
663}
664
665int nfp_net_refresh_eth_port(struct nfp_port *port)
666{
667 struct nfp_cpp *cpp = port->app->cpp;
668 struct nfp_eth_table *eth_table;
669 int ret;
670
671 clear_bit(NFP_PORT_CHANGED, &port->flags);
672
673 eth_table = nfp_eth_read_ports(cpp);
674 if (!eth_table) {
675 set_bit(NFP_PORT_CHANGED, &port->flags);
676 nfp_err(cpp, "Error refreshing port state table!\n");
677 return -EIO;
678 }
679
680 ret = nfp_net_eth_port_update(cpp, port, eth_table);
681
682 kfree(eth_table);
683
684 return ret;
685}
686
687/*
688 * PCI device functions
689 */
690int nfp_net_pci_probe(struct nfp_pf *pf)
691{
692 struct devlink *devlink = priv_to_devlink(pf);
693 struct nfp_net_fw_version fw_ver;
694 u8 __iomem *ctrl_bar, *qc_bar;
695 int stride;
696 int err;
697
698 INIT_WORK(&pf->port_refresh_work, nfp_net_refresh_vnics);
699
700 if (!pf->rtbl) {
701 nfp_err(pf->cpp, "No %s, giving up.\n",
702 pf->fw_loaded ? "symbol table" : "firmware found");
703 return -EINVAL;
704 }
705
706 pf->max_data_vnics = nfp_net_pf_get_num_ports(pf);
707 if ((int)pf->max_data_vnics < 0)
708 return pf->max_data_vnics;
709
710 err = nfp_net_pci_map_mem(pf);
711 if (err)
712 return err;
713
714 ctrl_bar = nfp_cpp_area_iomem(pf->data_vnic_bar);
715 qc_bar = nfp_cpp_area_iomem(pf->qc_area);
716 if (!ctrl_bar || !qc_bar) {
717 err = -EIO;
718 goto err_unmap;
719 }
720
721 nfp_net_get_fw_version(&fw_ver, ctrl_bar);
722 if (fw_ver.extend & NFP_NET_CFG_VERSION_RESERVED_MASK ||
723 fw_ver.class != NFP_NET_CFG_VERSION_CLASS_GENERIC) {
724 nfp_err(pf->cpp, "Unknown Firmware ABI %d.%d.%d.%d\n",
725 fw_ver.extend, fw_ver.class,
726 fw_ver.major, fw_ver.minor);
727 err = -EINVAL;
728 goto err_unmap;
729 }
730
731 /* Determine stride */
732 if (nfp_net_fw_ver_eq(&fw_ver, 0, 0, 0, 1)) {
733 stride = 2;
734 nfp_warn(pf->cpp, "OBSOLETE Firmware detected - VF isolation not available\n");
735 } else {
736 switch (fw_ver.major) {
737 case 1 ... 5:
738 stride = 4;
739 break;
740 default:
741 nfp_err(pf->cpp, "Unsupported Firmware ABI %d.%d.%d.%d\n",
742 fw_ver.extend, fw_ver.class,
743 fw_ver.major, fw_ver.minor);
744 err = -EINVAL;
745 goto err_unmap;
746 }
747 }
748
749 err = nfp_net_pf_app_init(pf, qc_bar, stride);
750 if (err)
751 goto err_unmap;
752
753 err = nfp_shared_buf_register(pf);
754 if (err)
755 goto err_devlink_unreg;
756
757 devl_lock(devlink);
758 err = nfp_devlink_params_register(pf);
759 if (err)
760 goto err_shared_buf_unreg;
761
762 pf->ddir = nfp_net_debugfs_device_add(pf->pdev);
763
764 /* Allocate the vnics and do basic init */
765 err = nfp_net_pf_alloc_vnics(pf, ctrl_bar, qc_bar, stride);
766 if (err)
767 goto err_clean_ddir;
768
769 err = nfp_net_pf_alloc_irqs(pf);
770 if (err)
771 goto err_free_vnics;
772
773 err = nfp_net_pf_app_start(pf);
774 if (err)
775 goto err_free_irqs;
776
777 err = nfp_net_pf_init_vnics(pf);
778 if (err)
779 goto err_stop_app;
780
781 devl_unlock(devlink);
782 devlink_register(devlink);
783
784 return 0;
785
786err_stop_app:
787 nfp_net_pf_app_stop(pf);
788err_free_irqs:
789 nfp_net_pf_free_irqs(pf);
790err_free_vnics:
791 nfp_net_pf_free_vnics(pf);
792err_clean_ddir:
793 nfp_net_debugfs_dir_clean(&pf->ddir);
794 nfp_devlink_params_unregister(pf);
795err_shared_buf_unreg:
796 devl_unlock(devlink);
797 nfp_shared_buf_unregister(pf);
798err_devlink_unreg:
799 cancel_work_sync(&pf->port_refresh_work);
800 nfp_net_pf_app_clean(pf);
801err_unmap:
802 nfp_net_pci_unmap_mem(pf);
803 return err;
804}
805
806void nfp_net_pci_remove(struct nfp_pf *pf)
807{
808 struct devlink *devlink = priv_to_devlink(pf);
809 struct nfp_net *nn, *next;
810
811 devlink_unregister(priv_to_devlink(pf));
812 devl_lock(devlink);
813 list_for_each_entry_safe(nn, next, &pf->vnics, vnic_list) {
814 if (!nfp_net_is_data_vnic(nn))
815 continue;
816 nfp_net_pf_clean_vnic(pf, nn);
817 nfp_net_pf_free_vnic(pf, nn);
818 }
819
820 nfp_net_pf_app_stop(pf);
821 /* stop app first, to avoid double free of ctrl vNIC's ddir */
822 nfp_net_debugfs_dir_clean(&pf->ddir);
823
824 nfp_devlink_params_unregister(pf);
825
826 devl_unlock(devlink);
827
828 nfp_shared_buf_unregister(pf);
829
830 nfp_net_pf_free_irqs(pf);
831 nfp_net_pf_app_clean(pf);
832 nfp_net_pci_unmap_mem(pf);
833
834 cancel_work_sync(&pf->port_refresh_work);
835}
1/*
2 * Copyright (C) 2015-2017 Netronome Systems, Inc.
3 *
4 * This software is dual licensed under the GNU General License Version 2,
5 * June 1991 as shown in the file COPYING in the top-level directory of this
6 * source tree or the BSD 2-Clause License provided below. You have the
7 * option to license this software under the complete terms of either license.
8 *
9 * The BSD 2-Clause License:
10 *
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
13 * conditions are met:
14 *
15 * 1. Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer.
18 *
19 * 2. Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 * SOFTWARE.
32 */
33
34/*
35 * nfp_net_main.c
36 * Netronome network device driver: Main entry point
37 * Authors: Jakub Kicinski <jakub.kicinski@netronome.com>
38 * Alejandro Lucero <alejandro.lucero@netronome.com>
39 * Jason McMullan <jason.mcmullan@netronome.com>
40 * Rolf Neugebauer <rolf.neugebauer@netronome.com>
41 */
42
43#include <linux/etherdevice.h>
44#include <linux/kernel.h>
45#include <linux/init.h>
46#include <linux/lockdep.h>
47#include <linux/pci.h>
48#include <linux/pci_regs.h>
49#include <linux/msi.h>
50#include <linux/random.h>
51#include <linux/rtnetlink.h>
52
53#include "nfpcore/nfp.h"
54#include "nfpcore/nfp_cpp.h"
55#include "nfpcore/nfp_nffw.h"
56#include "nfpcore/nfp_nsp.h"
57#include "nfpcore/nfp6000_pcie.h"
58#include "nfp_app.h"
59#include "nfp_net_ctrl.h"
60#include "nfp_net_sriov.h"
61#include "nfp_net.h"
62#include "nfp_main.h"
63#include "nfp_port.h"
64
65#define NFP_PF_CSR_SLICE_SIZE (32 * 1024)
66
67/**
68 * nfp_net_get_mac_addr() - Get the MAC address.
69 * @pf: NFP PF handle
70 * @netdev: net_device to set MAC address on
71 * @port: NFP port structure
72 *
73 * First try to get the MAC address from NSP ETH table. If that
74 * fails generate a random address.
75 */
76void
77nfp_net_get_mac_addr(struct nfp_pf *pf, struct net_device *netdev,
78 struct nfp_port *port)
79{
80 struct nfp_eth_table_port *eth_port;
81
82 eth_port = __nfp_port_get_eth_port(port);
83 if (!eth_port) {
84 eth_hw_addr_random(netdev);
85 return;
86 }
87
88 ether_addr_copy(netdev->dev_addr, eth_port->mac_addr);
89 ether_addr_copy(netdev->perm_addr, eth_port->mac_addr);
90}
91
92static struct nfp_eth_table_port *
93nfp_net_find_port(struct nfp_eth_table *eth_tbl, unsigned int index)
94{
95 int i;
96
97 for (i = 0; eth_tbl && i < eth_tbl->count; i++)
98 if (eth_tbl->ports[i].index == index)
99 return ð_tbl->ports[i];
100
101 return NULL;
102}
103
104static int
105nfp_net_pf_rtsym_read_optional(struct nfp_pf *pf, const char *format,
106 unsigned int default_val)
107{
108 char name[256];
109 int err = 0;
110 u64 val;
111
112 snprintf(name, sizeof(name), format, nfp_cppcore_pcie_unit(pf->cpp));
113
114 val = nfp_rtsym_read_le(pf->rtbl, name, &err);
115 if (err) {
116 if (err == -ENOENT)
117 return default_val;
118 nfp_err(pf->cpp, "Unable to read symbol %s\n", name);
119 return err;
120 }
121
122 return val;
123}
124
125static int nfp_net_pf_get_num_ports(struct nfp_pf *pf)
126{
127 return nfp_net_pf_rtsym_read_optional(pf, "nfd_cfg_pf%u_num_ports", 1);
128}
129
130static int nfp_net_pf_get_app_id(struct nfp_pf *pf)
131{
132 return nfp_net_pf_rtsym_read_optional(pf, "_pf%u_net_app_id",
133 NFP_APP_CORE_NIC);
134}
135
136static u8 __iomem *
137nfp_net_pf_map_rtsym(struct nfp_pf *pf, const char *name, const char *sym_fmt,
138 unsigned int min_size, struct nfp_cpp_area **area)
139{
140 char pf_symbol[256];
141
142 snprintf(pf_symbol, sizeof(pf_symbol), sym_fmt,
143 nfp_cppcore_pcie_unit(pf->cpp));
144
145 return nfp_rtsym_map(pf->rtbl, pf_symbol, name, min_size, area);
146}
147
148static void nfp_net_pf_free_vnic(struct nfp_pf *pf, struct nfp_net *nn)
149{
150 if (nfp_net_is_data_vnic(nn))
151 nfp_app_vnic_free(pf->app, nn);
152 nfp_port_free(nn->port);
153 list_del(&nn->vnic_list);
154 pf->num_vnics--;
155 nfp_net_free(nn);
156}
157
158static void nfp_net_pf_free_vnics(struct nfp_pf *pf)
159{
160 struct nfp_net *nn, *next;
161
162 list_for_each_entry_safe(nn, next, &pf->vnics, vnic_list)
163 if (nfp_net_is_data_vnic(nn))
164 nfp_net_pf_free_vnic(pf, nn);
165}
166
167static struct nfp_net *
168nfp_net_pf_alloc_vnic(struct nfp_pf *pf, bool needs_netdev,
169 void __iomem *ctrl_bar, void __iomem *qc_bar,
170 int stride, unsigned int id)
171{
172 u32 tx_base, rx_base, n_tx_rings, n_rx_rings;
173 struct nfp_net *nn;
174 int err;
175
176 tx_base = readl(ctrl_bar + NFP_NET_CFG_START_TXQ);
177 rx_base = readl(ctrl_bar + NFP_NET_CFG_START_RXQ);
178 n_tx_rings = readl(ctrl_bar + NFP_NET_CFG_MAX_TXRINGS);
179 n_rx_rings = readl(ctrl_bar + NFP_NET_CFG_MAX_RXRINGS);
180
181 /* Allocate and initialise the vNIC */
182 nn = nfp_net_alloc(pf->pdev, needs_netdev, n_tx_rings, n_rx_rings);
183 if (IS_ERR(nn))
184 return nn;
185
186 nn->app = pf->app;
187 nfp_net_get_fw_version(&nn->fw_ver, ctrl_bar);
188 nn->dp.ctrl_bar = ctrl_bar;
189 nn->tx_bar = qc_bar + tx_base * NFP_QCP_QUEUE_ADDR_SZ;
190 nn->rx_bar = qc_bar + rx_base * NFP_QCP_QUEUE_ADDR_SZ;
191 nn->dp.is_vf = 0;
192 nn->stride_rx = stride;
193 nn->stride_tx = stride;
194
195 if (needs_netdev) {
196 err = nfp_app_vnic_alloc(pf->app, nn, id);
197 if (err) {
198 nfp_net_free(nn);
199 return ERR_PTR(err);
200 }
201 }
202
203 pf->num_vnics++;
204 list_add_tail(&nn->vnic_list, &pf->vnics);
205
206 return nn;
207}
208
209static int
210nfp_net_pf_init_vnic(struct nfp_pf *pf, struct nfp_net *nn, unsigned int id)
211{
212 int err;
213
214 err = nfp_net_init(nn);
215 if (err)
216 return err;
217
218 nfp_net_debugfs_vnic_add(nn, pf->ddir, id);
219
220 if (nn->port) {
221 err = nfp_devlink_port_register(pf->app, nn->port);
222 if (err)
223 goto err_dfs_clean;
224 }
225
226 nfp_net_info(nn);
227
228 if (nfp_net_is_data_vnic(nn)) {
229 err = nfp_app_vnic_init(pf->app, nn);
230 if (err)
231 goto err_devlink_port_clean;
232 }
233
234 return 0;
235
236err_devlink_port_clean:
237 if (nn->port)
238 nfp_devlink_port_unregister(nn->port);
239err_dfs_clean:
240 nfp_net_debugfs_dir_clean(&nn->debugfs_dir);
241 nfp_net_clean(nn);
242 return err;
243}
244
245static int
246nfp_net_pf_alloc_vnics(struct nfp_pf *pf, void __iomem *ctrl_bar,
247 void __iomem *qc_bar, int stride)
248{
249 struct nfp_net *nn;
250 unsigned int i;
251 int err;
252
253 for (i = 0; i < pf->max_data_vnics; i++) {
254 nn = nfp_net_pf_alloc_vnic(pf, true, ctrl_bar, qc_bar,
255 stride, i);
256 if (IS_ERR(nn)) {
257 err = PTR_ERR(nn);
258 goto err_free_prev;
259 }
260
261 ctrl_bar += NFP_PF_CSR_SLICE_SIZE;
262
263 /* Kill the vNIC if app init marked it as invalid */
264 if (nn->port && nn->port->type == NFP_PORT_INVALID) {
265 nfp_net_pf_free_vnic(pf, nn);
266 continue;
267 }
268 }
269
270 if (list_empty(&pf->vnics))
271 return -ENODEV;
272
273 return 0;
274
275err_free_prev:
276 nfp_net_pf_free_vnics(pf);
277 return err;
278}
279
280static void nfp_net_pf_clean_vnic(struct nfp_pf *pf, struct nfp_net *nn)
281{
282 if (nfp_net_is_data_vnic(nn))
283 nfp_app_vnic_clean(pf->app, nn);
284 if (nn->port)
285 nfp_devlink_port_unregister(nn->port);
286 nfp_net_debugfs_dir_clean(&nn->debugfs_dir);
287 nfp_net_clean(nn);
288}
289
290static int nfp_net_pf_alloc_irqs(struct nfp_pf *pf)
291{
292 unsigned int wanted_irqs, num_irqs, vnics_left, irqs_left;
293 struct nfp_net *nn;
294
295 /* Get MSI-X vectors */
296 wanted_irqs = 0;
297 list_for_each_entry(nn, &pf->vnics, vnic_list)
298 wanted_irqs += NFP_NET_NON_Q_VECTORS + nn->dp.num_r_vecs;
299 pf->irq_entries = kcalloc(wanted_irqs, sizeof(*pf->irq_entries),
300 GFP_KERNEL);
301 if (!pf->irq_entries)
302 return -ENOMEM;
303
304 num_irqs = nfp_net_irqs_alloc(pf->pdev, pf->irq_entries,
305 NFP_NET_MIN_VNIC_IRQS * pf->num_vnics,
306 wanted_irqs);
307 if (!num_irqs) {
308 nfp_warn(pf->cpp, "Unable to allocate MSI-X vectors\n");
309 kfree(pf->irq_entries);
310 return -ENOMEM;
311 }
312
313 /* Distribute IRQs to vNICs */
314 irqs_left = num_irqs;
315 vnics_left = pf->num_vnics;
316 list_for_each_entry(nn, &pf->vnics, vnic_list) {
317 unsigned int n;
318
319 n = min(NFP_NET_NON_Q_VECTORS + nn->dp.num_r_vecs,
320 DIV_ROUND_UP(irqs_left, vnics_left));
321 nfp_net_irqs_assign(nn, &pf->irq_entries[num_irqs - irqs_left],
322 n);
323 irqs_left -= n;
324 vnics_left--;
325 }
326
327 return 0;
328}
329
330static void nfp_net_pf_free_irqs(struct nfp_pf *pf)
331{
332 nfp_net_irqs_disable(pf->pdev);
333 kfree(pf->irq_entries);
334}
335
336static int nfp_net_pf_init_vnics(struct nfp_pf *pf)
337{
338 struct nfp_net *nn;
339 unsigned int id;
340 int err;
341
342 /* Finish vNIC init and register */
343 id = 0;
344 list_for_each_entry(nn, &pf->vnics, vnic_list) {
345 if (!nfp_net_is_data_vnic(nn))
346 continue;
347 err = nfp_net_pf_init_vnic(pf, nn, id);
348 if (err)
349 goto err_prev_deinit;
350
351 id++;
352 }
353
354 return 0;
355
356err_prev_deinit:
357 list_for_each_entry_continue_reverse(nn, &pf->vnics, vnic_list)
358 if (nfp_net_is_data_vnic(nn))
359 nfp_net_pf_clean_vnic(pf, nn);
360 return err;
361}
362
363static int
364nfp_net_pf_app_init(struct nfp_pf *pf, u8 __iomem *qc_bar, unsigned int stride)
365{
366 u8 __iomem *ctrl_bar;
367 int err;
368
369 pf->app = nfp_app_alloc(pf, nfp_net_pf_get_app_id(pf));
370 if (IS_ERR(pf->app))
371 return PTR_ERR(pf->app);
372
373 mutex_lock(&pf->lock);
374 err = nfp_app_init(pf->app);
375 mutex_unlock(&pf->lock);
376 if (err)
377 goto err_free;
378
379 if (!nfp_app_needs_ctrl_vnic(pf->app))
380 return 0;
381
382 ctrl_bar = nfp_net_pf_map_rtsym(pf, "net.ctrl", "_pf%u_net_ctrl_bar",
383 NFP_PF_CSR_SLICE_SIZE,
384 &pf->ctrl_vnic_bar);
385 if (IS_ERR(ctrl_bar)) {
386 nfp_err(pf->cpp, "Failed to find ctrl vNIC memory symbol\n");
387 err = PTR_ERR(ctrl_bar);
388 goto err_app_clean;
389 }
390
391 pf->ctrl_vnic = nfp_net_pf_alloc_vnic(pf, false, ctrl_bar, qc_bar,
392 stride, 0);
393 if (IS_ERR(pf->ctrl_vnic)) {
394 err = PTR_ERR(pf->ctrl_vnic);
395 goto err_unmap;
396 }
397
398 return 0;
399
400err_unmap:
401 nfp_cpp_area_release_free(pf->ctrl_vnic_bar);
402err_app_clean:
403 mutex_lock(&pf->lock);
404 nfp_app_clean(pf->app);
405 mutex_unlock(&pf->lock);
406err_free:
407 nfp_app_free(pf->app);
408 pf->app = NULL;
409 return err;
410}
411
412static void nfp_net_pf_app_clean(struct nfp_pf *pf)
413{
414 if (pf->ctrl_vnic) {
415 nfp_net_pf_free_vnic(pf, pf->ctrl_vnic);
416 nfp_cpp_area_release_free(pf->ctrl_vnic_bar);
417 }
418
419 mutex_lock(&pf->lock);
420 nfp_app_clean(pf->app);
421 mutex_unlock(&pf->lock);
422
423 nfp_app_free(pf->app);
424 pf->app = NULL;
425}
426
427static int nfp_net_pf_app_start_ctrl(struct nfp_pf *pf)
428{
429 int err;
430
431 if (!pf->ctrl_vnic)
432 return 0;
433 err = nfp_net_pf_init_vnic(pf, pf->ctrl_vnic, 0);
434 if (err)
435 return err;
436
437 err = nfp_ctrl_open(pf->ctrl_vnic);
438 if (err)
439 goto err_clean_ctrl;
440
441 return 0;
442
443err_clean_ctrl:
444 nfp_net_pf_clean_vnic(pf, pf->ctrl_vnic);
445 return err;
446}
447
448static void nfp_net_pf_app_stop_ctrl(struct nfp_pf *pf)
449{
450 if (!pf->ctrl_vnic)
451 return;
452 nfp_ctrl_close(pf->ctrl_vnic);
453 nfp_net_pf_clean_vnic(pf, pf->ctrl_vnic);
454}
455
456static int nfp_net_pf_app_start(struct nfp_pf *pf)
457{
458 int err;
459
460 err = nfp_net_pf_app_start_ctrl(pf);
461 if (err)
462 return err;
463
464 err = nfp_app_start(pf->app, pf->ctrl_vnic);
465 if (err)
466 goto err_ctrl_stop;
467
468 if (pf->num_vfs) {
469 err = nfp_app_sriov_enable(pf->app, pf->num_vfs);
470 if (err)
471 goto err_app_stop;
472 }
473
474 return 0;
475
476err_app_stop:
477 nfp_app_stop(pf->app);
478err_ctrl_stop:
479 nfp_net_pf_app_stop_ctrl(pf);
480 return err;
481}
482
483static void nfp_net_pf_app_stop(struct nfp_pf *pf)
484{
485 if (pf->num_vfs)
486 nfp_app_sriov_disable(pf->app);
487 nfp_app_stop(pf->app);
488 nfp_net_pf_app_stop_ctrl(pf);
489}
490
491static void nfp_net_pci_unmap_mem(struct nfp_pf *pf)
492{
493 if (pf->vfcfg_tbl2_area)
494 nfp_cpp_area_release_free(pf->vfcfg_tbl2_area);
495 if (pf->vf_cfg_bar)
496 nfp_cpp_area_release_free(pf->vf_cfg_bar);
497 if (pf->mac_stats_bar)
498 nfp_cpp_area_release_free(pf->mac_stats_bar);
499 nfp_cpp_area_release_free(pf->qc_area);
500 nfp_cpp_area_release_free(pf->data_vnic_bar);
501}
502
503static int nfp_net_pci_map_mem(struct nfp_pf *pf)
504{
505 u8 __iomem *mem;
506 u32 min_size;
507 int err;
508
509 min_size = pf->max_data_vnics * NFP_PF_CSR_SLICE_SIZE;
510 mem = nfp_net_pf_map_rtsym(pf, "net.bar0", "_pf%d_net_bar0",
511 min_size, &pf->data_vnic_bar);
512 if (IS_ERR(mem)) {
513 nfp_err(pf->cpp, "Failed to find data vNIC memory symbol\n");
514 return PTR_ERR(mem);
515 }
516
517 if (pf->eth_tbl) {
518 min_size = NFP_MAC_STATS_SIZE * (pf->eth_tbl->max_index + 1);
519 pf->mac_stats_mem = nfp_rtsym_map(pf->rtbl, "_mac_stats",
520 "net.macstats", min_size,
521 &pf->mac_stats_bar);
522 if (IS_ERR(pf->mac_stats_mem)) {
523 if (PTR_ERR(pf->mac_stats_mem) != -ENOENT) {
524 err = PTR_ERR(pf->mac_stats_mem);
525 goto err_unmap_ctrl;
526 }
527 pf->mac_stats_mem = NULL;
528 }
529 }
530
531 pf->vf_cfg_mem = nfp_net_pf_map_rtsym(pf, "net.vfcfg",
532 "_pf%d_net_vf_bar",
533 NFP_NET_CFG_BAR_SZ *
534 pf->limit_vfs, &pf->vf_cfg_bar);
535 if (IS_ERR(pf->vf_cfg_mem)) {
536 if (PTR_ERR(pf->vf_cfg_mem) != -ENOENT) {
537 err = PTR_ERR(pf->vf_cfg_mem);
538 goto err_unmap_mac_stats;
539 }
540 pf->vf_cfg_mem = NULL;
541 }
542
543 min_size = NFP_NET_VF_CFG_SZ * pf->limit_vfs + NFP_NET_VF_CFG_MB_SZ;
544 pf->vfcfg_tbl2 = nfp_net_pf_map_rtsym(pf, "net.vfcfg_tbl2",
545 "_pf%d_net_vf_cfg2",
546 min_size, &pf->vfcfg_tbl2_area);
547 if (IS_ERR(pf->vfcfg_tbl2)) {
548 if (PTR_ERR(pf->vfcfg_tbl2) != -ENOENT) {
549 err = PTR_ERR(pf->vfcfg_tbl2);
550 goto err_unmap_vf_cfg;
551 }
552 pf->vfcfg_tbl2 = NULL;
553 }
554
555 mem = nfp_cpp_map_area(pf->cpp, "net.qc", 0, 0,
556 NFP_PCIE_QUEUE(0), NFP_QCP_QUEUE_AREA_SZ,
557 &pf->qc_area);
558 if (IS_ERR(mem)) {
559 nfp_err(pf->cpp, "Failed to map Queue Controller area.\n");
560 err = PTR_ERR(mem);
561 goto err_unmap_vfcfg_tbl2;
562 }
563
564 return 0;
565
566err_unmap_vfcfg_tbl2:
567 if (pf->vfcfg_tbl2_area)
568 nfp_cpp_area_release_free(pf->vfcfg_tbl2_area);
569err_unmap_vf_cfg:
570 if (pf->vf_cfg_bar)
571 nfp_cpp_area_release_free(pf->vf_cfg_bar);
572err_unmap_mac_stats:
573 if (pf->mac_stats_bar)
574 nfp_cpp_area_release_free(pf->mac_stats_bar);
575err_unmap_ctrl:
576 nfp_cpp_area_release_free(pf->data_vnic_bar);
577 return err;
578}
579
580static int
581nfp_net_eth_port_update(struct nfp_cpp *cpp, struct nfp_port *port,
582 struct nfp_eth_table *eth_table)
583{
584 struct nfp_eth_table_port *eth_port;
585
586 ASSERT_RTNL();
587
588 eth_port = nfp_net_find_port(eth_table, port->eth_id);
589 if (!eth_port) {
590 set_bit(NFP_PORT_CHANGED, &port->flags);
591 nfp_warn(cpp, "Warning: port #%d not present after reconfig\n",
592 port->eth_id);
593 return -EIO;
594 }
595 if (eth_port->override_changed) {
596 nfp_warn(cpp, "Port #%d config changed, unregistering. Driver reload required before port will be operational again.\n", port->eth_id);
597 port->type = NFP_PORT_INVALID;
598 }
599
600 memcpy(port->eth_port, eth_port, sizeof(*eth_port));
601
602 return 0;
603}
604
605int nfp_net_refresh_port_table_sync(struct nfp_pf *pf)
606{
607 struct nfp_eth_table *eth_table;
608 struct nfp_net *nn, *next;
609 struct nfp_port *port;
610 int err;
611
612 lockdep_assert_held(&pf->lock);
613
614 /* Check for nfp_net_pci_remove() racing against us */
615 if (list_empty(&pf->vnics))
616 return 0;
617
618 /* Update state of all ports */
619 rtnl_lock();
620 list_for_each_entry(port, &pf->ports, port_list)
621 clear_bit(NFP_PORT_CHANGED, &port->flags);
622
623 eth_table = nfp_eth_read_ports(pf->cpp);
624 if (!eth_table) {
625 list_for_each_entry(port, &pf->ports, port_list)
626 if (__nfp_port_get_eth_port(port))
627 set_bit(NFP_PORT_CHANGED, &port->flags);
628 rtnl_unlock();
629 nfp_err(pf->cpp, "Error refreshing port config!\n");
630 return -EIO;
631 }
632
633 list_for_each_entry(port, &pf->ports, port_list)
634 if (__nfp_port_get_eth_port(port))
635 nfp_net_eth_port_update(pf->cpp, port, eth_table);
636 rtnl_unlock();
637
638 kfree(eth_table);
639
640 /* Resync repr state. This may cause reprs to be removed. */
641 err = nfp_reprs_resync_phys_ports(pf->app);
642 if (err)
643 return err;
644
645 /* Shoot off the ports which became invalid */
646 list_for_each_entry_safe(nn, next, &pf->vnics, vnic_list) {
647 if (!nn->port || nn->port->type != NFP_PORT_INVALID)
648 continue;
649
650 nfp_net_pf_clean_vnic(pf, nn);
651 nfp_net_pf_free_vnic(pf, nn);
652 }
653
654 return 0;
655}
656
657static void nfp_net_refresh_vnics(struct work_struct *work)
658{
659 struct nfp_pf *pf = container_of(work, struct nfp_pf,
660 port_refresh_work);
661
662 mutex_lock(&pf->lock);
663 nfp_net_refresh_port_table_sync(pf);
664 mutex_unlock(&pf->lock);
665}
666
667void nfp_net_refresh_port_table(struct nfp_port *port)
668{
669 struct nfp_pf *pf = port->app->pf;
670
671 set_bit(NFP_PORT_CHANGED, &port->flags);
672
673 queue_work(pf->wq, &pf->port_refresh_work);
674}
675
676int nfp_net_refresh_eth_port(struct nfp_port *port)
677{
678 struct nfp_cpp *cpp = port->app->cpp;
679 struct nfp_eth_table *eth_table;
680 int ret;
681
682 clear_bit(NFP_PORT_CHANGED, &port->flags);
683
684 eth_table = nfp_eth_read_ports(cpp);
685 if (!eth_table) {
686 set_bit(NFP_PORT_CHANGED, &port->flags);
687 nfp_err(cpp, "Error refreshing port state table!\n");
688 return -EIO;
689 }
690
691 ret = nfp_net_eth_port_update(cpp, port, eth_table);
692
693 kfree(eth_table);
694
695 return ret;
696}
697
698/*
699 * PCI device functions
700 */
701int nfp_net_pci_probe(struct nfp_pf *pf)
702{
703 struct devlink *devlink = priv_to_devlink(pf);
704 struct nfp_net_fw_version fw_ver;
705 u8 __iomem *ctrl_bar, *qc_bar;
706 int stride;
707 int err;
708
709 INIT_WORK(&pf->port_refresh_work, nfp_net_refresh_vnics);
710
711 if (!pf->rtbl) {
712 nfp_err(pf->cpp, "No %s, giving up.\n",
713 pf->fw_loaded ? "symbol table" : "firmware found");
714 return -EINVAL;
715 }
716
717 pf->max_data_vnics = nfp_net_pf_get_num_ports(pf);
718 if ((int)pf->max_data_vnics < 0)
719 return pf->max_data_vnics;
720
721 err = nfp_net_pci_map_mem(pf);
722 if (err)
723 return err;
724
725 ctrl_bar = nfp_cpp_area_iomem(pf->data_vnic_bar);
726 qc_bar = nfp_cpp_area_iomem(pf->qc_area);
727 if (!ctrl_bar || !qc_bar) {
728 err = -EIO;
729 goto err_unmap;
730 }
731
732 nfp_net_get_fw_version(&fw_ver, ctrl_bar);
733 if (fw_ver.resv || fw_ver.class != NFP_NET_CFG_VERSION_CLASS_GENERIC) {
734 nfp_err(pf->cpp, "Unknown Firmware ABI %d.%d.%d.%d\n",
735 fw_ver.resv, fw_ver.class, fw_ver.major, fw_ver.minor);
736 err = -EINVAL;
737 goto err_unmap;
738 }
739
740 /* Determine stride */
741 if (nfp_net_fw_ver_eq(&fw_ver, 0, 0, 0, 1)) {
742 stride = 2;
743 nfp_warn(pf->cpp, "OBSOLETE Firmware detected - VF isolation not available\n");
744 } else {
745 switch (fw_ver.major) {
746 case 1 ... 5:
747 stride = 4;
748 break;
749 default:
750 nfp_err(pf->cpp, "Unsupported Firmware ABI %d.%d.%d.%d\n",
751 fw_ver.resv, fw_ver.class,
752 fw_ver.major, fw_ver.minor);
753 err = -EINVAL;
754 goto err_unmap;
755 }
756 }
757
758 err = nfp_net_pf_app_init(pf, qc_bar, stride);
759 if (err)
760 goto err_unmap;
761
762 err = devlink_register(devlink, &pf->pdev->dev);
763 if (err)
764 goto err_app_clean;
765
766 mutex_lock(&pf->lock);
767 pf->ddir = nfp_net_debugfs_device_add(pf->pdev);
768
769 /* Allocate the vnics and do basic init */
770 err = nfp_net_pf_alloc_vnics(pf, ctrl_bar, qc_bar, stride);
771 if (err)
772 goto err_clean_ddir;
773
774 err = nfp_net_pf_alloc_irqs(pf);
775 if (err)
776 goto err_free_vnics;
777
778 err = nfp_net_pf_app_start(pf);
779 if (err)
780 goto err_free_irqs;
781
782 err = nfp_net_pf_init_vnics(pf);
783 if (err)
784 goto err_stop_app;
785
786 mutex_unlock(&pf->lock);
787
788 return 0;
789
790err_stop_app:
791 nfp_net_pf_app_stop(pf);
792err_free_irqs:
793 nfp_net_pf_free_irqs(pf);
794err_free_vnics:
795 nfp_net_pf_free_vnics(pf);
796err_clean_ddir:
797 nfp_net_debugfs_dir_clean(&pf->ddir);
798 mutex_unlock(&pf->lock);
799 cancel_work_sync(&pf->port_refresh_work);
800 devlink_unregister(devlink);
801err_app_clean:
802 nfp_net_pf_app_clean(pf);
803err_unmap:
804 nfp_net_pci_unmap_mem(pf);
805 return err;
806}
807
808void nfp_net_pci_remove(struct nfp_pf *pf)
809{
810 struct nfp_net *nn, *next;
811
812 mutex_lock(&pf->lock);
813 list_for_each_entry_safe(nn, next, &pf->vnics, vnic_list) {
814 if (!nfp_net_is_data_vnic(nn))
815 continue;
816 nfp_net_pf_clean_vnic(pf, nn);
817 nfp_net_pf_free_vnic(pf, nn);
818 }
819
820 nfp_net_pf_app_stop(pf);
821 /* stop app first, to avoid double free of ctrl vNIC's ddir */
822 nfp_net_debugfs_dir_clean(&pf->ddir);
823
824 mutex_unlock(&pf->lock);
825
826 devlink_unregister(priv_to_devlink(pf));
827
828 nfp_net_pf_free_irqs(pf);
829 nfp_net_pf_app_clean(pf);
830 nfp_net_pci_unmap_mem(pf);
831
832 cancel_work_sync(&pf->port_refresh_work);
833}