drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c

   1 /* Broadcom NetXtreme-C/E network driver.
   2  *
   3  * Copyright (c) 2016-2017 Broadcom Limited
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation.
   8  */
   9 #include <linux/pci.h>
  10 #include <linux/netdevice.h>
  11 #include <linux/etherdevice.h>
  12 #include <linux/rtnetlink.h>
  13 #include <linux/jhash.h>
  14 #include <net/pkt_cls.h>
  15
  16 #include "bnxt_hsi.h"
  17 #include "bnxt.h"
  18 #include "bnxt_vfr.h"
  19 #include "bnxt_tc.h"
  20
  21 #ifdef CONFIG_BNXT_SRIOV
  22
  23 #define CFA_HANDLE_INVALID              0xffff
  24 #define VF_IDX_INVALID                  0xffff
  25
  26 static int hwrm_cfa_vfr_alloc(struct bnxt *bp, u16 vf_idx,
  27                               u16 *tx_cfa_action, u16 *rx_cfa_code)
  28 {
  29         struct hwrm_cfa_vfr_alloc_output *resp = bp->hwrm_cmd_resp_addr;
  30         struct hwrm_cfa_vfr_alloc_input req = { 0 };
  31         int rc;
  32
  33         bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_CFA_VFR_ALLOC, -1, -1);
  34         req.vf_id = cpu_to_le16(vf_idx);
  35         sprintf(req.vfr_name, "vfr%d", vf_idx);
  36
  37         mutex_lock(&bp->hwrm_cmd_lock);
  38         rc = _hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
  39         if (!rc) {
  40                 *tx_cfa_action = le16_to_cpu(resp->tx_cfa_action);
  41                 *rx_cfa_code = le16_to_cpu(resp->rx_cfa_code);
  42                 netdev_dbg(bp->dev, "tx_cfa_action=0x%x, rx_cfa_code=0x%x",
  43                            *tx_cfa_action, *rx_cfa_code);
  44         } else {
  45                 netdev_info(bp->dev, "%s error rc=%d", __func__, rc);
  46         }
  47
  48         mutex_unlock(&bp->hwrm_cmd_lock);
  49         return rc;
  50 }
  51
  52 static int hwrm_cfa_vfr_free(struct bnxt *bp, u16 vf_idx)
  53 {
  54         struct hwrm_cfa_vfr_free_input req = { 0 };
  55         int rc;
  56
  57         bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_CFA_VFR_FREE, -1, -1);
  58         sprintf(req.vfr_name, "vfr%d", vf_idx);
  59
  60         rc = hwrm_send_message(bp, &req, sizeof(req), HWRM_CMD_TIMEOUT);
  61         if (rc)
  62                 netdev_info(bp->dev, "%s error rc=%d", __func__, rc);
  63         return rc;
  64 }
  65
  66 static int bnxt_vf_rep_open(struct net_device *dev)
  67 {
  68         struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
  69         struct bnxt *bp = vf_rep->bp;
  70
  71         /* Enable link and TX only if the parent PF is open. */
  72         if (netif_running(bp->dev)) {
  73                 netif_carrier_on(dev);
  74                 netif_tx_start_all_queues(dev);
  75         }
  76         return 0;
  77 }
  78
  79 static int bnxt_vf_rep_close(struct net_device *dev)
  80 {
  81         netif_carrier_off(dev);
  82         netif_tx_disable(dev);
  83
  84         return 0;
  85 }
  86
  87 static netdev_tx_t bnxt_vf_rep_xmit(struct sk_buff *skb,
  88                                     struct net_device *dev)
  89 {
  90         struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
  91         int rc, len = skb->len;
  92
  93         skb_dst_drop(skb);
  94         dst_hold((struct dst_entry *)vf_rep->dst);
  95         skb_dst_set(skb, (struct dst_entry *)vf_rep->dst);
  96         skb->dev = vf_rep->dst->u.port_info.lower_dev;
  97
  98         rc = dev_queue_xmit(skb);
  99         if (!rc) {
 100                 vf_rep->tx_stats.packets++;
 101                 vf_rep->tx_stats.bytes += len;
 102         }
 103         return rc;
 104 }
 105
 106 static void
 107 bnxt_vf_rep_get_stats64(struct net_device *dev,
 108                         struct rtnl_link_stats64 *stats)
 109 {
 110         struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
 111
 112         stats->rx_packets = vf_rep->rx_stats.packets;
 113         stats->rx_bytes = vf_rep->rx_stats.bytes;
 114         stats->tx_packets = vf_rep->tx_stats.packets;
 115         stats->tx_bytes = vf_rep->tx_stats.bytes;
 116 }
 117
 118 static int bnxt_vf_rep_setup_tc(struct net_device *dev, enum tc_setup_type type,
 119                                 void *type_data)
 120 {
 121         struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
 122         struct bnxt *bp = vf_rep->bp;
 123         int vf_fid = bp->pf.vf[vf_rep->vf_idx].fw_fid;
 124
 125         switch (type) {
 126         case TC_SETUP_CLSFLOWER:
 127                 return bnxt_tc_setup_flower(bp, vf_fid, type_data);
 128         default:
 129                 return -EOPNOTSUPP;
 130         }
 131 }
 132
 133 struct net_device *bnxt_get_vf_rep(struct bnxt *bp, u16 cfa_code)
 134 {
 135         u16 vf_idx;
 136
 137         if (cfa_code && bp->cfa_code_map && BNXT_PF(bp)) {
 138                 vf_idx = bp->cfa_code_map[cfa_code];
 139                 if (vf_idx != VF_IDX_INVALID)
 140                         return bp->vf_reps[vf_idx]->dev;
 141         }
 142         return NULL;
 143 }
 144
 145 void bnxt_vf_rep_rx(struct bnxt *bp, struct sk_buff *skb)
 146 {
 147         struct bnxt_vf_rep *vf_rep = netdev_priv(skb->dev);
 148         struct bnxt_vf_rep_stats *rx_stats;
 149
 150         rx_stats = &vf_rep->rx_stats;
 151         vf_rep->rx_stats.bytes += skb->len;
 152         vf_rep->rx_stats.packets++;
 153
 154         netif_receive_skb(skb);
 155 }
 156
 157 static int bnxt_vf_rep_get_phys_port_name(struct net_device *dev, char *buf,
 158                                           size_t len)
 159 {
 160         struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
 161         struct pci_dev *pf_pdev = vf_rep->bp->pdev;
 162         int rc;
 163
 164         rc = snprintf(buf, len, "pf%dvf%d", PCI_FUNC(pf_pdev->devfn),
 165                       vf_rep->vf_idx);
 166         if (rc >= len)
 167                 return -EOPNOTSUPP;
 168         return 0;
 169 }
 170
 171 static void bnxt_vf_rep_get_drvinfo(struct net_device *dev,
 172                                     struct ethtool_drvinfo *info)
 173 {
 174         strlcpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
 175         strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
 176 }
 177
 178 static int bnxt_vf_rep_port_attr_get(struct net_device *dev,
 179                                      struct switchdev_attr *attr)
 180 {
 181         struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
 182
 183         /* as only PORT_PARENT_ID is supported currently use common code
 184          * between PF and VF-rep for now.
 185          */
 186         return bnxt_port_attr_get(vf_rep->bp, attr);
 187 }
 188
 189 static const struct switchdev_ops bnxt_vf_rep_switchdev_ops = {
 190         .switchdev_port_attr_get        = bnxt_vf_rep_port_attr_get
 191 };
 192
 193 static const struct ethtool_ops bnxt_vf_rep_ethtool_ops = {
 194         .get_drvinfo            = bnxt_vf_rep_get_drvinfo
 195 };
 196
 197 static const struct net_device_ops bnxt_vf_rep_netdev_ops = {
 198         .ndo_open               = bnxt_vf_rep_open,
 199         .ndo_stop               = bnxt_vf_rep_close,
 200         .ndo_start_xmit         = bnxt_vf_rep_xmit,
 201         .ndo_get_stats64        = bnxt_vf_rep_get_stats64,
 202         .ndo_setup_tc           = bnxt_vf_rep_setup_tc,
 203         .ndo_get_phys_port_name = bnxt_vf_rep_get_phys_port_name
 204 };
 205
 206 /* Called when the parent PF interface is closed:
 207  * As the mode transition from SWITCHDEV to LEGACY
 208  * happens under the rtnl_lock() this routine is safe
 209  * under the rtnl_lock()
 210  */
 211 void bnxt_vf_reps_close(struct bnxt *bp)
 212 {
 213         struct bnxt_vf_rep *vf_rep;
 214         u16 num_vfs, i;
 215
 216         if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
 217                 return;
 218
 219         num_vfs = pci_num_vf(bp->pdev);
 220         for (i = 0; i < num_vfs; i++) {
 221                 vf_rep = bp->vf_reps[i];
 222                 if (netif_running(vf_rep->dev))
 223                         bnxt_vf_rep_close(vf_rep->dev);
 224         }
 225 }
 226
 227 /* Called when the parent PF interface is opened (re-opened):
 228  * As the mode transition from SWITCHDEV to LEGACY
 229  * happen under the rtnl_lock() this routine is safe
 230  * under the rtnl_lock()
 231  */
 232 void bnxt_vf_reps_open(struct bnxt *bp)
 233 {
 234         int i;
 235
 236         if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
 237                 return;
 238
 239         for (i = 0; i < pci_num_vf(bp->pdev); i++)
 240                 bnxt_vf_rep_open(bp->vf_reps[i]->dev);
 241 }
 242
 243 static void __bnxt_vf_reps_destroy(struct bnxt *bp)
 244 {
 245         u16 num_vfs = pci_num_vf(bp->pdev);
 246         struct bnxt_vf_rep *vf_rep;
 247         int i;
 248
 249         for (i = 0; i < num_vfs; i++) {
 250                 vf_rep = bp->vf_reps[i];
 251                 if (vf_rep) {
 252                         dst_release((struct dst_entry *)vf_rep->dst);
 253
 254                         if (vf_rep->tx_cfa_action != CFA_HANDLE_INVALID)
 255                                 hwrm_cfa_vfr_free(bp, vf_rep->vf_idx);
 256
 257                         if (vf_rep->dev) {
 258                                 /* if register_netdev failed, then netdev_ops
 259                                  * would have been set to NULL
 260                                  */
 261                                 if (vf_rep->dev->netdev_ops)
 262                                         unregister_netdev(vf_rep->dev);
 263                                 free_netdev(vf_rep->dev);
 264                         }
 265                 }
 266         }
 267
 268         kfree(bp->vf_reps);
 269         bp->vf_reps = NULL;
 270 }
 271
 272 void bnxt_vf_reps_destroy(struct bnxt *bp)
 273 {
 274         bool closed = false;
 275
 276         if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
 277                 return;
 278
 279         if (!bp->vf_reps)
 280                 return;
 281
 282         /* Ensure that parent PF's and VF-reps' RX/TX has been quiesced
 283          * before proceeding with VF-rep cleanup.
 284          */
 285         rtnl_lock();
 286         if (netif_running(bp->dev)) {
 287                 bnxt_close_nic(bp, false, false);
 288                 closed = true;
 289         }
 290         /* un-publish cfa_code_map so that RX path can't see it anymore */
 291         kfree(bp->cfa_code_map);
 292         bp->cfa_code_map = NULL;
 293         bp->eswitch_mode = DEVLINK_ESWITCH_MODE_LEGACY;
 294
 295         if (closed)
 296                 bnxt_open_nic(bp, false, false);
 297         rtnl_unlock();
 298
 299         /* Need to call vf_reps_destroy() outside of rntl_lock
 300          * as unregister_netdev takes rtnl_lock
 301          */
 302         __bnxt_vf_reps_destroy(bp);
 303 }
 304
 305 /* Use the OUI of the PF's perm addr and report the same mac addr
 306  * for the same VF-rep each time
 307  */
 308 static void bnxt_vf_rep_eth_addr_gen(u8 *src_mac, u16 vf_idx, u8 *mac)
 309 {
 310         u32 addr;
 311
 312         ether_addr_copy(mac, src_mac);
 313
 314         addr = jhash(src_mac, ETH_ALEN, 0) + vf_idx;
 315         mac[3] = (u8)(addr & 0xFF);
 316         mac[4] = (u8)((addr >> 8) & 0xFF);
 317         mac[5] = (u8)((addr >> 16) & 0xFF);
 318 }
 319
 320 static void bnxt_vf_rep_netdev_init(struct bnxt *bp, struct bnxt_vf_rep *vf_rep,
 321                                     struct net_device *dev)
 322 {
 323         struct net_device *pf_dev = bp->dev;
 324
 325         dev->netdev_ops = &bnxt_vf_rep_netdev_ops;
 326         dev->ethtool_ops = &bnxt_vf_rep_ethtool_ops;
 327         SWITCHDEV_SET_OPS(dev, &bnxt_vf_rep_switchdev_ops);
 328         /* Just inherit all the featues of the parent PF as the VF-R
 329          * uses the RX/TX rings of the parent PF
 330          */
 331         dev->hw_features = pf_dev->hw_features;
 332         dev->gso_partial_features = pf_dev->gso_partial_features;
 333         dev->vlan_features = pf_dev->vlan_features;
 334         dev->hw_enc_features = pf_dev->hw_enc_features;
 335         dev->features |= pf_dev->features;
 336         bnxt_vf_rep_eth_addr_gen(bp->pf.mac_addr, vf_rep->vf_idx,
 337                                  dev->perm_addr);
 338         ether_addr_copy(dev->dev_addr, dev->perm_addr);
 339 }
 340
 341 static int bnxt_vf_reps_create(struct bnxt *bp)
 342 {
 343         u16 *cfa_code_map = NULL, num_vfs = pci_num_vf(bp->pdev);
 344         struct bnxt_vf_rep *vf_rep;
 345         struct net_device *dev;
 346         int rc, i;
 347
 348         bp->vf_reps = kcalloc(num_vfs, sizeof(vf_rep), GFP_KERNEL);
 349         if (!bp->vf_reps)
 350                 return -ENOMEM;
 351
 352         /* storage for cfa_code to vf-idx mapping */
 353         cfa_code_map = kmalloc(sizeof(*bp->cfa_code_map) * MAX_CFA_CODE,
 354                                GFP_KERNEL);
 355         if (!cfa_code_map) {
 356                 rc = -ENOMEM;
 357                 goto err;
 358         }
 359         for (i = 0; i < MAX_CFA_CODE; i++)
 360                 cfa_code_map[i] = VF_IDX_INVALID;
 361
 362         for (i = 0; i < num_vfs; i++) {
 363                 dev = alloc_etherdev(sizeof(*vf_rep));
 364                 if (!dev) {
 365                         rc = -ENOMEM;
 366                         goto err;
 367                 }
 368
 369                 vf_rep = netdev_priv(dev);
 370                 bp->vf_reps[i] = vf_rep;
 371                 vf_rep->dev = dev;
 372                 vf_rep->bp = bp;
 373                 vf_rep->vf_idx = i;
 374                 vf_rep->tx_cfa_action = CFA_HANDLE_INVALID;
 375
 376                 /* get cfa handles from FW */
 377                 rc = hwrm_cfa_vfr_alloc(bp, vf_rep->vf_idx,
 378                                         &vf_rep->tx_cfa_action,
 379                                         &vf_rep->rx_cfa_code);
 380                 if (rc) {
 381                         rc = -ENOLINK;
 382                         goto err;
 383                 }
 384                 cfa_code_map[vf_rep->rx_cfa_code] = vf_rep->vf_idx;
 385
 386                 vf_rep->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX,
 387                                                  GFP_KERNEL);
 388                 if (!vf_rep->dst) {
 389                         rc = -ENOMEM;
 390                         goto err;
 391                 }
 392                 /* only cfa_action is needed to mux a packet while TXing */
 393                 vf_rep->dst->u.port_info.port_id = vf_rep->tx_cfa_action;
 394                 vf_rep->dst->u.port_info.lower_dev = bp->dev;
 395
 396                 bnxt_vf_rep_netdev_init(bp, vf_rep, dev);
 397                 rc = register_netdev(dev);
 398                 if (rc) {
 399                         /* no need for unregister_netdev in cleanup */
 400                         dev->netdev_ops = NULL;
 401                         goto err;
 402                 }
 403         }
 404
 405         /* publish cfa_code_map only after all VF-reps have been initialized */
 406         bp->cfa_code_map = cfa_code_map;
 407         bp->eswitch_mode = DEVLINK_ESWITCH_MODE_SWITCHDEV;
 408         netif_keep_dst(bp->dev);
 409         return 0;
 410
 411 err:
 412         netdev_info(bp->dev, "%s error=%d", __func__, rc);
 413         kfree(cfa_code_map);
 414         __bnxt_vf_reps_destroy(bp);
 415         return rc;
 416 }
 417
 418 /* Devlink related routines */
 419 static int bnxt_dl_eswitch_mode_get(struct devlink *devlink, u16 *mode)
 420 {
 421         struct bnxt *bp = bnxt_get_bp_from_dl(devlink);
 422
 423         *mode = bp->eswitch_mode;
 424         return 0;
 425 }
 426
 427 static int bnxt_dl_eswitch_mode_set(struct devlink *devlink, u16 mode)
 428 {
 429         struct bnxt *bp = bnxt_get_bp_from_dl(devlink);
 430         int rc = 0;
 431
 432         mutex_lock(&bp->sriov_lock);
 433         if (bp->eswitch_mode == mode) {
 434                 netdev_info(bp->dev, "already in %s eswitch mode",
 435                             mode == DEVLINK_ESWITCH_MODE_LEGACY ?
 436                             "legacy" : "switchdev");
 437                 rc = -EINVAL;
 438                 goto done;
 439         }
 440
 441         switch (mode) {
 442         case DEVLINK_ESWITCH_MODE_LEGACY:
 443                 bnxt_vf_reps_destroy(bp);
 444                 break;
 445
 446         case DEVLINK_ESWITCH_MODE_SWITCHDEV:
 447                 if (pci_num_vf(bp->pdev) == 0) {
 448                         netdev_info(bp->dev,
 449                                     "Enable VFs before setting switchdev mode");
 450                         rc = -EPERM;
 451                         goto done;
 452                 }
 453                 rc = bnxt_vf_reps_create(bp);
 454                 break;
 455
 456         default:
 457                 rc = -EINVAL;
 458                 goto done;
 459         }
 460 done:
 461         mutex_unlock(&bp->sriov_lock);
 462         return rc;
 463 }
 464
 465 static const struct devlink_ops bnxt_dl_ops = {
 466         .eswitch_mode_set = bnxt_dl_eswitch_mode_set,
 467         .eswitch_mode_get = bnxt_dl_eswitch_mode_get
 468 };
 469
 470 int bnxt_dl_register(struct bnxt *bp)
 471 {
 472         struct devlink *dl;
 473         int rc;
 474
 475         if (!pci_find_ext_capability(bp->pdev, PCI_EXT_CAP_ID_SRIOV))
 476                 return 0;
 477
 478         if (bp->hwrm_spec_code < 0x10800) {
 479                 netdev_warn(bp->dev, "Firmware does not support SR-IOV E-Switch SWITCHDEV mode.\n");
 480                 return -ENOTSUPP;
 481         }
 482
 483         dl = devlink_alloc(&bnxt_dl_ops, sizeof(struct bnxt_dl));
 484         if (!dl) {
 485                 netdev_warn(bp->dev, "devlink_alloc failed");
 486                 return -ENOMEM;
 487         }
 488
 489         bnxt_link_bp_to_dl(bp, dl);
 490         bp->eswitch_mode = DEVLINK_ESWITCH_MODE_LEGACY;
 491         rc = devlink_register(dl, &bp->pdev->dev);
 492         if (rc) {
 493                 bnxt_link_bp_to_dl(bp, NULL);
 494                 devlink_free(dl);
 495                 netdev_warn(bp->dev, "devlink_register failed. rc=%d", rc);
 496                 return rc;
 497         }
 498
 499         return 0;
 500 }
 501
 502 void bnxt_dl_unregister(struct bnxt *bp)
 503 {
 504         struct devlink *dl = bp->dl;
 505
 506         if (!dl)
 507                 return;
 508
 509         devlink_unregister(dl);
 510         devlink_free(dl);
 511 }
 512
 513 #endif