1 /* 2 * Copyright (C) 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 #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> 40 41 #include "main.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" 50 #include "./cmsg.h" 51 52 #define NFP_FLOWER_ALLOWED_VER 0x0001000000010000UL 53 54 static const char *nfp_flower_extra_cap(struct nfp_app *app, struct nfp_net *nn) 55 { 56 return "FLOWER"; 57 } 58 59 static enum devlink_eswitch_mode eswitch_mode_get(struct nfp_app *app) 60 { 61 return DEVLINK_ESWITCH_MODE_SWITCHDEV; 62 } 63 64 static enum nfp_repr_type 65 nfp_flower_repr_get_type_and_port(struct nfp_app *app, u32 port_id, u8 *port) 66 { 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, 70 port_id); 71 return NFP_REPR_TYPE_PHYS_PORT; 72 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; 78 else 79 return NFP_REPR_TYPE_VF; 80 } 81 82 return NFP_FLOWER_CMSG_PORT_TYPE_UNSPEC; 83 } 84 85 static struct net_device * 86 nfp_flower_repr_get(struct nfp_app *app, u32 port_id) 87 { 88 enum nfp_repr_type repr_type; 89 struct nfp_reprs *reprs; 90 u8 port = 0; 91 92 repr_type = nfp_flower_repr_get_type_and_port(app, port_id, &port); 93 94 reprs = rcu_dereference(app->reprs[repr_type]); 95 if (!reprs) 96 return NULL; 97 98 if (port >= reprs->num_reprs) 99 return NULL; 100 101 return reprs->reprs[port]; 102 } 103 104 static int 105 nfp_flower_repr_netdev_open(struct nfp_app *app, struct nfp_repr *repr) 106 { 107 int err; 108 109 err = nfp_flower_cmsg_portmod(repr, true); 110 if (err) 111 return err; 112 113 netif_carrier_on(repr->netdev); 114 netif_tx_wake_all_queues(repr->netdev); 115 116 return 0; 117 } 118 119 static int 120 nfp_flower_repr_netdev_stop(struct nfp_app *app, struct nfp_repr *repr) 121 { 122 netif_carrier_off(repr->netdev); 123 netif_tx_disable(repr->netdev); 124 125 return nfp_flower_cmsg_portmod(repr, false); 126 } 127 128 static void nfp_flower_sriov_disable(struct nfp_app *app) 129 { 130 struct nfp_flower_priv *priv = app->priv; 131 132 if (!priv->nn) 133 return; 134 135 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_VF); 136 } 137 138 static int 139 nfp_flower_spawn_vnic_reprs(struct nfp_app *app, 140 enum nfp_flower_cmsg_port_vnic_type vnic_type, 141 enum nfp_repr_type repr_type, unsigned int cnt) 142 { 143 u8 nfp_pcie = nfp_cppcore_pcie_unit(app->pf->cpp); 144 struct nfp_flower_priv *priv = app->priv; 145 struct nfp_reprs *reprs, *old_reprs; 146 enum nfp_port_type port_type; 147 const u8 queue = 0; 148 int i, err; 149 150 port_type = repr_type == NFP_REPR_TYPE_PF ? NFP_PORT_PF_PORT : 151 NFP_PORT_VF_PORT; 152 153 reprs = nfp_reprs_alloc(cnt); 154 if (!reprs) 155 return -ENOMEM; 156 157 for (i = 0; i < cnt; i++) { 158 struct nfp_port *port; 159 u32 port_id; 160 161 reprs->reprs[i] = nfp_repr_alloc(app); 162 if (!reprs->reprs[i]) { 163 err = -ENOMEM; 164 goto err_reprs_clean; 165 } 166 167 /* For now we only support 1 PF */ 168 WARN_ON(repr_type == NFP_REPR_TYPE_PF && i); 169 170 port = nfp_port_alloc(app, port_type, reprs->reprs[i]); 171 if (repr_type == NFP_REPR_TYPE_PF) { 172 port->pf_id = i; 173 port->vnic = priv->nn->dp.ctrl_bar; 174 } else { 175 port->pf_id = 0; 176 port->vf_id = i; 177 port->vnic = 178 app->pf->vf_cfg_mem + i * NFP_NET_CFG_BAR_SZ; 179 } 180 181 eth_hw_addr_random(reprs->reprs[i]); 182 183 port_id = nfp_flower_cmsg_pcie_port(nfp_pcie, vnic_type, 184 i, queue); 185 err = nfp_repr_init(app, reprs->reprs[i], 186 port_id, port, priv->nn->dp.netdev); 187 if (err) { 188 nfp_port_free(port); 189 goto err_reprs_clean; 190 } 191 192 nfp_info(app->cpp, "%s%d Representor(%s) created\n", 193 repr_type == NFP_REPR_TYPE_PF ? "PF" : "VF", i, 194 reprs->reprs[i]->name); 195 } 196 197 old_reprs = nfp_app_reprs_set(app, repr_type, reprs); 198 if (IS_ERR(old_reprs)) { 199 err = PTR_ERR(old_reprs); 200 goto err_reprs_clean; 201 } 202 203 return 0; 204 err_reprs_clean: 205 nfp_reprs_clean_and_free(reprs); 206 return err; 207 } 208 209 static int nfp_flower_sriov_enable(struct nfp_app *app, int num_vfs) 210 { 211 struct nfp_flower_priv *priv = app->priv; 212 213 if (!priv->nn) 214 return 0; 215 216 return nfp_flower_spawn_vnic_reprs(app, 217 NFP_FLOWER_CMSG_PORT_VNIC_TYPE_VF, 218 NFP_REPR_TYPE_VF, num_vfs); 219 } 220 221 static int 222 nfp_flower_spawn_phy_reprs(struct nfp_app *app, struct nfp_flower_priv *priv) 223 { 224 struct nfp_eth_table *eth_tbl = app->pf->eth_tbl; 225 struct nfp_reprs *reprs, *old_reprs; 226 struct sk_buff *ctrl_skb; 227 unsigned int i; 228 int err; 229 230 ctrl_skb = nfp_flower_cmsg_mac_repr_start(app, eth_tbl->count); 231 if (!ctrl_skb) 232 return -ENOMEM; 233 234 reprs = nfp_reprs_alloc(eth_tbl->max_index + 1); 235 if (!reprs) { 236 err = -ENOMEM; 237 goto err_free_ctrl_skb; 238 } 239 240 for (i = 0; i < eth_tbl->count; i++) { 241 unsigned int phys_port = eth_tbl->ports[i].index; 242 struct nfp_port *port; 243 u32 cmsg_port_id; 244 245 reprs->reprs[phys_port] = nfp_repr_alloc(app); 246 if (!reprs->reprs[phys_port]) { 247 err = -ENOMEM; 248 goto err_reprs_clean; 249 } 250 251 port = nfp_port_alloc(app, NFP_PORT_PHYS_PORT, 252 reprs->reprs[phys_port]); 253 if (IS_ERR(port)) { 254 err = PTR_ERR(port); 255 goto err_reprs_clean; 256 } 257 err = nfp_port_init_phy_port(app->pf, app, port, i); 258 if (err) { 259 nfp_port_free(port); 260 goto err_reprs_clean; 261 } 262 263 SET_NETDEV_DEV(reprs->reprs[phys_port], &priv->nn->pdev->dev); 264 nfp_net_get_mac_addr(app->pf, port); 265 266 cmsg_port_id = nfp_flower_cmsg_phys_port(phys_port); 267 err = nfp_repr_init(app, reprs->reprs[phys_port], 268 cmsg_port_id, port, priv->nn->dp.netdev); 269 if (err) { 270 nfp_port_free(port); 271 goto err_reprs_clean; 272 } 273 274 nfp_flower_cmsg_mac_repr_add(ctrl_skb, i, 275 eth_tbl->ports[i].nbi, 276 eth_tbl->ports[i].base, 277 phys_port); 278 279 nfp_info(app->cpp, "Phys Port %d Representor(%s) created\n", 280 phys_port, reprs->reprs[phys_port]->name); 281 } 282 283 old_reprs = nfp_app_reprs_set(app, NFP_REPR_TYPE_PHYS_PORT, reprs); 284 if (IS_ERR(old_reprs)) { 285 err = PTR_ERR(old_reprs); 286 goto err_reprs_clean; 287 } 288 289 /* The MAC_REPR control message should be sent after the MAC 290 * representors are registered using nfp_app_reprs_set(). This is 291 * because the firmware may respond with control messages for the 292 * MAC representors, f.e. to provide the driver with information 293 * about their state, and without registration the driver will drop 294 * any such messages. 295 */ 296 nfp_ctrl_tx(app->ctrl, ctrl_skb); 297 298 return 0; 299 err_reprs_clean: 300 nfp_reprs_clean_and_free(reprs); 301 err_free_ctrl_skb: 302 kfree_skb(ctrl_skb); 303 return err; 304 } 305 306 static int nfp_flower_vnic_alloc(struct nfp_app *app, struct nfp_net *nn, 307 unsigned int id) 308 { 309 if (id > 0) { 310 nfp_warn(app->cpp, "FlowerNIC doesn't support more than one data vNIC\n"); 311 goto err_invalid_port; 312 } 313 314 eth_hw_addr_random(nn->dp.netdev); 315 netif_keep_dst(nn->dp.netdev); 316 317 return 0; 318 319 err_invalid_port: 320 nn->port = nfp_port_alloc(app, NFP_PORT_INVALID, nn->dp.netdev); 321 return PTR_ERR_OR_ZERO(nn->port); 322 } 323 324 static void nfp_flower_vnic_clean(struct nfp_app *app, struct nfp_net *nn) 325 { 326 struct nfp_flower_priv *priv = app->priv; 327 328 if (app->pf->num_vfs) 329 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_VF); 330 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF); 331 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT); 332 333 priv->nn = NULL; 334 } 335 336 static int nfp_flower_vnic_init(struct nfp_app *app, struct nfp_net *nn) 337 { 338 struct nfp_flower_priv *priv = app->priv; 339 int err; 340 341 priv->nn = nn; 342 343 err = nfp_flower_spawn_phy_reprs(app, app->priv); 344 if (err) 345 goto err_clear_nn; 346 347 err = nfp_flower_spawn_vnic_reprs(app, 348 NFP_FLOWER_CMSG_PORT_VNIC_TYPE_PF, 349 NFP_REPR_TYPE_PF, 1); 350 if (err) 351 goto err_destroy_reprs_phy; 352 353 if (app->pf->num_vfs) { 354 err = nfp_flower_spawn_vnic_reprs(app, 355 NFP_FLOWER_CMSG_PORT_VNIC_TYPE_VF, 356 NFP_REPR_TYPE_VF, 357 app->pf->num_vfs); 358 if (err) 359 goto err_destroy_reprs_pf; 360 } 361 362 return 0; 363 364 err_destroy_reprs_pf: 365 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF); 366 err_destroy_reprs_phy: 367 nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT); 368 err_clear_nn: 369 priv->nn = NULL; 370 return err; 371 } 372 373 static int nfp_flower_init(struct nfp_app *app) 374 { 375 const struct nfp_pf *pf = app->pf; 376 struct nfp_flower_priv *app_priv; 377 u64 version; 378 int err; 379 380 if (!pf->eth_tbl) { 381 nfp_warn(app->cpp, "FlowerNIC requires eth table\n"); 382 return -EINVAL; 383 } 384 385 if (!pf->mac_stats_bar) { 386 nfp_warn(app->cpp, "FlowerNIC requires mac_stats BAR\n"); 387 return -EINVAL; 388 } 389 390 if (!pf->vf_cfg_bar) { 391 nfp_warn(app->cpp, "FlowerNIC requires vf_cfg BAR\n"); 392 return -EINVAL; 393 } 394 395 version = nfp_rtsym_read_le(app->pf->rtbl, "hw_flower_version", &err); 396 if (err) { 397 nfp_warn(app->cpp, "FlowerNIC requires hw_flower_version memory symbol\n"); 398 return err; 399 } 400 401 /* We need to ensure hardware has enough flower capabilities. */ 402 if (version != NFP_FLOWER_ALLOWED_VER) { 403 nfp_warn(app->cpp, "FlowerNIC: unsupported firmware version\n"); 404 return -EINVAL; 405 } 406 407 app_priv = vzalloc(sizeof(struct nfp_flower_priv)); 408 if (!app_priv) 409 return -ENOMEM; 410 411 app->priv = app_priv; 412 app_priv->app = app; 413 skb_queue_head_init(&app_priv->cmsg_skbs); 414 INIT_WORK(&app_priv->cmsg_work, nfp_flower_cmsg_process_rx); 415 416 err = nfp_flower_metadata_init(app); 417 if (err) 418 goto err_free_app_priv; 419 420 return 0; 421 422 err_free_app_priv: 423 vfree(app->priv); 424 return err; 425 } 426 427 static void nfp_flower_clean(struct nfp_app *app) 428 { 429 struct nfp_flower_priv *app_priv = app->priv; 430 431 skb_queue_purge(&app_priv->cmsg_skbs); 432 flush_work(&app_priv->cmsg_work); 433 434 nfp_flower_metadata_cleanup(app); 435 vfree(app->priv); 436 app->priv = NULL; 437 } 438 439 const struct nfp_app_type app_flower = { 440 .id = NFP_APP_FLOWER_NIC, 441 .name = "flower", 442 .ctrl_has_meta = true, 443 444 .extra_cap = nfp_flower_extra_cap, 445 446 .init = nfp_flower_init, 447 .clean = nfp_flower_clean, 448 449 .vnic_alloc = nfp_flower_vnic_alloc, 450 .vnic_init = nfp_flower_vnic_init, 451 .vnic_clean = nfp_flower_vnic_clean, 452 453 .repr_open = nfp_flower_repr_netdev_open, 454 .repr_stop = nfp_flower_repr_netdev_stop, 455 456 .ctrl_msg_rx = nfp_flower_cmsg_rx, 457 458 .sriov_enable = nfp_flower_sriov_enable, 459 .sriov_disable = nfp_flower_sriov_disable, 460 461 .eswitch_mode_get = eswitch_mode_get, 462 .repr_get = nfp_flower_repr_get, 463 464 .setup_tc = nfp_flower_setup_tc, 465 }; 466