2 * Copyright (C) 2017 Netronome Systems, Inc.
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.
9 * The BSD 2-Clause License:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * 1. Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
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.
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
34 #include <linux/etherdevice.h>
35 #include <linux/pci.h>
36 #include <linux/skbuff.h>
37 #include <linux/vmalloc.h>
38 #include <net/devlink.h>
39 #include <net/dst_metadata.h>
42 #include "../nfpcore/nfp_cpp.h"
43 #include "../nfpcore/nfp_nffw.h"
44 #include "../nfpcore/nfp_nsp.h"
45 #include "../nfp_app.h"
46 #include "../nfp_main.h"
47 #include "../nfp_net.h"
48 #include "../nfp_net_repr.h"
49 #include "../nfp_port.h"
52 #define NFP_FLOWER_ALLOWED_VER 0x0001000000010000UL
54 static const char *nfp_flower_extra_cap(struct nfp_app *app, struct nfp_net *nn)
59 static enum devlink_eswitch_mode eswitch_mode_get(struct nfp_app *app)
61 return DEVLINK_ESWITCH_MODE_SWITCHDEV;
64 static enum nfp_repr_type
65 nfp_flower_repr_get_type_and_port(struct nfp_app *app, u32 port_id, u8 *port)
67 switch (FIELD_GET(NFP_FLOWER_CMSG_PORT_TYPE, port_id)) {
68 case NFP_FLOWER_CMSG_PORT_TYPE_PHYS_PORT:
69 *port = FIELD_GET(NFP_FLOWER_CMSG_PORT_PHYS_PORT_NUM,
71 return NFP_REPR_TYPE_PHYS_PORT;
73 case NFP_FLOWER_CMSG_PORT_TYPE_PCIE_PORT:
74 *port = FIELD_GET(NFP_FLOWER_CMSG_PORT_VNIC, port_id);
75 if (FIELD_GET(NFP_FLOWER_CMSG_PORT_VNIC_TYPE, port_id) ==
76 NFP_FLOWER_CMSG_PORT_VNIC_TYPE_PF)
77 return NFP_REPR_TYPE_PF;
79 return NFP_REPR_TYPE_VF;
82 return __NFP_REPR_TYPE_MAX;
85 static struct net_device *
86 nfp_flower_repr_get(struct nfp_app *app, u32 port_id)
88 enum nfp_repr_type repr_type;
89 struct nfp_reprs *reprs;
92 repr_type = nfp_flower_repr_get_type_and_port(app, port_id, &port);
93 if (repr_type > NFP_REPR_TYPE_MAX)
96 reprs = rcu_dereference(app->reprs[repr_type]);
100 if (port >= reprs->num_reprs)
103 return reprs->reprs[port];
107 nfp_flower_repr_netdev_open(struct nfp_app *app, struct nfp_repr *repr)
111 err = nfp_flower_cmsg_portmod(repr, true);
115 netif_carrier_on(repr->netdev);
116 netif_tx_wake_all_queues(repr->netdev);
122 nfp_flower_repr_netdev_stop(struct nfp_app *app, struct nfp_repr *repr)
124 netif_carrier_off(repr->netdev);
125 netif_tx_disable(repr->netdev);
127 return nfp_flower_cmsg_portmod(repr, false);
130 static void nfp_flower_sriov_disable(struct nfp_app *app)
132 struct nfp_flower_priv *priv = app->priv;
137 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_VF);
141 nfp_flower_spawn_vnic_reprs(struct nfp_app *app,
142 enum nfp_flower_cmsg_port_vnic_type vnic_type,
143 enum nfp_repr_type repr_type, unsigned int cnt)
145 u8 nfp_pcie = nfp_cppcore_pcie_unit(app->pf->cpp);
146 struct nfp_flower_priv *priv = app->priv;
147 struct nfp_reprs *reprs, *old_reprs;
148 enum nfp_port_type port_type;
152 port_type = repr_type == NFP_REPR_TYPE_PF ? NFP_PORT_PF_PORT :
155 reprs = nfp_reprs_alloc(cnt);
159 for (i = 0; i < cnt; i++) {
160 struct nfp_port *port;
163 reprs->reprs[i] = nfp_repr_alloc(app);
164 if (!reprs->reprs[i]) {
166 goto err_reprs_clean;
169 /* For now we only support 1 PF */
170 WARN_ON(repr_type == NFP_REPR_TYPE_PF && i);
172 port = nfp_port_alloc(app, port_type, reprs->reprs[i]);
173 if (repr_type == NFP_REPR_TYPE_PF) {
175 port->vnic = priv->nn->dp.ctrl_bar;
180 app->pf->vf_cfg_mem + i * NFP_NET_CFG_BAR_SZ;
183 eth_hw_addr_random(reprs->reprs[i]);
185 port_id = nfp_flower_cmsg_pcie_port(nfp_pcie, vnic_type,
187 err = nfp_repr_init(app, reprs->reprs[i],
188 port_id, port, priv->nn->dp.netdev);
191 goto err_reprs_clean;
194 nfp_info(app->cpp, "%s%d Representor(%s) created\n",
195 repr_type == NFP_REPR_TYPE_PF ? "PF" : "VF", i,
196 reprs->reprs[i]->name);
199 old_reprs = nfp_app_reprs_set(app, repr_type, reprs);
200 if (IS_ERR(old_reprs)) {
201 err = PTR_ERR(old_reprs);
202 goto err_reprs_clean;
207 nfp_reprs_clean_and_free(reprs);
211 static int nfp_flower_sriov_enable(struct nfp_app *app, int num_vfs)
213 struct nfp_flower_priv *priv = app->priv;
218 return nfp_flower_spawn_vnic_reprs(app,
219 NFP_FLOWER_CMSG_PORT_VNIC_TYPE_VF,
220 NFP_REPR_TYPE_VF, num_vfs);
224 nfp_flower_spawn_phy_reprs(struct nfp_app *app, struct nfp_flower_priv *priv)
226 struct nfp_eth_table *eth_tbl = app->pf->eth_tbl;
227 struct nfp_reprs *reprs, *old_reprs;
228 struct sk_buff *ctrl_skb;
232 ctrl_skb = nfp_flower_cmsg_mac_repr_start(app, eth_tbl->count);
236 reprs = nfp_reprs_alloc(eth_tbl->max_index + 1);
239 goto err_free_ctrl_skb;
242 for (i = 0; i < eth_tbl->count; i++) {
243 unsigned int phys_port = eth_tbl->ports[i].index;
244 struct nfp_port *port;
247 reprs->reprs[phys_port] = nfp_repr_alloc(app);
248 if (!reprs->reprs[phys_port]) {
250 goto err_reprs_clean;
253 port = nfp_port_alloc(app, NFP_PORT_PHYS_PORT,
254 reprs->reprs[phys_port]);
257 goto err_reprs_clean;
259 err = nfp_port_init_phy_port(app->pf, app, port, i);
262 goto err_reprs_clean;
265 SET_NETDEV_DEV(reprs->reprs[phys_port], &priv->nn->pdev->dev);
266 nfp_net_get_mac_addr(app->pf, port);
268 cmsg_port_id = nfp_flower_cmsg_phys_port(phys_port);
269 err = nfp_repr_init(app, reprs->reprs[phys_port],
270 cmsg_port_id, port, priv->nn->dp.netdev);
273 goto err_reprs_clean;
276 nfp_flower_cmsg_mac_repr_add(ctrl_skb, i,
277 eth_tbl->ports[i].nbi,
278 eth_tbl->ports[i].base,
281 nfp_info(app->cpp, "Phys Port %d Representor(%s) created\n",
282 phys_port, reprs->reprs[phys_port]->name);
285 old_reprs = nfp_app_reprs_set(app, NFP_REPR_TYPE_PHYS_PORT, reprs);
286 if (IS_ERR(old_reprs)) {
287 err = PTR_ERR(old_reprs);
288 goto err_reprs_clean;
291 /* The MAC_REPR control message should be sent after the MAC
292 * representors are registered using nfp_app_reprs_set(). This is
293 * because the firmware may respond with control messages for the
294 * MAC representors, f.e. to provide the driver with information
295 * about their state, and without registration the driver will drop
298 nfp_ctrl_tx(app->ctrl, ctrl_skb);
302 nfp_reprs_clean_and_free(reprs);
308 static int nfp_flower_vnic_alloc(struct nfp_app *app, struct nfp_net *nn,
312 nfp_warn(app->cpp, "FlowerNIC doesn't support more than one data vNIC\n");
313 goto err_invalid_port;
316 eth_hw_addr_random(nn->dp.netdev);
317 netif_keep_dst(nn->dp.netdev);
322 nn->port = nfp_port_alloc(app, NFP_PORT_INVALID, nn->dp.netdev);
323 return PTR_ERR_OR_ZERO(nn->port);
326 static void nfp_flower_vnic_clean(struct nfp_app *app, struct nfp_net *nn)
328 struct nfp_flower_priv *priv = app->priv;
330 if (app->pf->num_vfs)
331 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_VF);
332 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF);
333 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);
338 static int nfp_flower_vnic_init(struct nfp_app *app, struct nfp_net *nn)
340 struct nfp_flower_priv *priv = app->priv;
345 err = nfp_flower_spawn_phy_reprs(app, app->priv);
349 err = nfp_flower_spawn_vnic_reprs(app,
350 NFP_FLOWER_CMSG_PORT_VNIC_TYPE_PF,
351 NFP_REPR_TYPE_PF, 1);
353 goto err_destroy_reprs_phy;
355 if (app->pf->num_vfs) {
356 err = nfp_flower_spawn_vnic_reprs(app,
357 NFP_FLOWER_CMSG_PORT_VNIC_TYPE_VF,
361 goto err_destroy_reprs_pf;
366 err_destroy_reprs_pf:
367 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF);
368 err_destroy_reprs_phy:
369 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);
375 static int nfp_flower_init(struct nfp_app *app)
377 const struct nfp_pf *pf = app->pf;
378 struct nfp_flower_priv *app_priv;
383 nfp_warn(app->cpp, "FlowerNIC requires eth table\n");
387 if (!pf->mac_stats_bar) {
388 nfp_warn(app->cpp, "FlowerNIC requires mac_stats BAR\n");
392 if (!pf->vf_cfg_bar) {
393 nfp_warn(app->cpp, "FlowerNIC requires vf_cfg BAR\n");
397 version = nfp_rtsym_read_le(app->pf->rtbl, "hw_flower_version", &err);
399 nfp_warn(app->cpp, "FlowerNIC requires hw_flower_version memory symbol\n");
403 /* We need to ensure hardware has enough flower capabilities. */
404 if (version != NFP_FLOWER_ALLOWED_VER) {
405 nfp_warn(app->cpp, "FlowerNIC: unsupported firmware version\n");
409 app_priv = vzalloc(sizeof(struct nfp_flower_priv));
413 app->priv = app_priv;
415 skb_queue_head_init(&app_priv->cmsg_skbs);
416 INIT_WORK(&app_priv->cmsg_work, nfp_flower_cmsg_process_rx);
418 err = nfp_flower_metadata_init(app);
420 goto err_free_app_priv;
429 static void nfp_flower_clean(struct nfp_app *app)
431 struct nfp_flower_priv *app_priv = app->priv;
433 skb_queue_purge(&app_priv->cmsg_skbs);
434 flush_work(&app_priv->cmsg_work);
436 nfp_flower_metadata_cleanup(app);
441 const struct nfp_app_type app_flower = {
442 .id = NFP_APP_FLOWER_NIC,
444 .ctrl_has_meta = true,
446 .extra_cap = nfp_flower_extra_cap,
448 .init = nfp_flower_init,
449 .clean = nfp_flower_clean,
451 .vnic_alloc = nfp_flower_vnic_alloc,
452 .vnic_init = nfp_flower_vnic_init,
453 .vnic_clean = nfp_flower_vnic_clean,
455 .repr_open = nfp_flower_repr_netdev_open,
456 .repr_stop = nfp_flower_repr_netdev_stop,
458 .ctrl_msg_rx = nfp_flower_cmsg_rx,
460 .sriov_enable = nfp_flower_sriov_enable,
461 .sriov_disable = nfp_flower_sriov_disable,
463 .eswitch_mode_get = eswitch_mode_get,
464 .repr_get = nfp_flower_repr_get,
466 .setup_tc = nfp_flower_setup_tc,