linux/drivers/net/ethernet/broadcom/bnxt/bnxt_vfr.c
<<
>>
Prefs
   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_hwrm.h"
  19#include "bnxt_vfr.h"
  20#include "bnxt_devlink.h"
  21#include "bnxt_tc.h"
  22
  23#ifdef CONFIG_BNXT_SRIOV
  24
  25#define CFA_HANDLE_INVALID              0xffff
  26#define VF_IDX_INVALID                  0xffff
  27
  28static int hwrm_cfa_vfr_alloc(struct bnxt *bp, u16 vf_idx,
  29                              u16 *tx_cfa_action, u16 *rx_cfa_code)
  30{
  31        struct hwrm_cfa_vfr_alloc_output *resp;
  32        struct hwrm_cfa_vfr_alloc_input *req;
  33        int rc;
  34
  35        rc = hwrm_req_init(bp, req, HWRM_CFA_VFR_ALLOC);
  36        if (!rc) {
  37                req->vf_id = cpu_to_le16(vf_idx);
  38                sprintf(req->vfr_name, "vfr%d", vf_idx);
  39
  40                resp = hwrm_req_hold(bp, req);
  41                rc = hwrm_req_send(bp, req);
  42                if (!rc) {
  43                        *tx_cfa_action = le16_to_cpu(resp->tx_cfa_action);
  44                        *rx_cfa_code = le16_to_cpu(resp->rx_cfa_code);
  45                        netdev_dbg(bp->dev, "tx_cfa_action=0x%x, rx_cfa_code=0x%x",
  46                                   *tx_cfa_action, *rx_cfa_code);
  47                }
  48                hwrm_req_drop(bp, req);
  49        }
  50        if (rc)
  51                netdev_info(bp->dev, "%s error rc=%d\n", __func__, rc);
  52        return rc;
  53}
  54
  55static int hwrm_cfa_vfr_free(struct bnxt *bp, u16 vf_idx)
  56{
  57        struct hwrm_cfa_vfr_free_input *req;
  58        int rc;
  59
  60        rc = hwrm_req_init(bp, req, HWRM_CFA_VFR_FREE);
  61        if (!rc) {
  62                sprintf(req->vfr_name, "vfr%d", vf_idx);
  63                rc = hwrm_req_send(bp, req);
  64        }
  65        if (rc)
  66                netdev_info(bp->dev, "%s error rc=%d\n", __func__, rc);
  67        return rc;
  68}
  69
  70static int bnxt_hwrm_vfr_qcfg(struct bnxt *bp, struct bnxt_vf_rep *vf_rep,
  71                              u16 *max_mtu)
  72{
  73        struct hwrm_func_qcfg_output *resp;
  74        struct hwrm_func_qcfg_input *req;
  75        u16 mtu;
  76        int rc;
  77
  78        rc = hwrm_req_init(bp, req, HWRM_FUNC_QCFG);
  79        if (rc)
  80                return rc;
  81
  82        req->fid = cpu_to_le16(bp->pf.vf[vf_rep->vf_idx].fw_fid);
  83        resp = hwrm_req_hold(bp, req);
  84        rc = hwrm_req_send(bp, req);
  85        if (!rc) {
  86                mtu = le16_to_cpu(resp->max_mtu_configured);
  87                if (!mtu)
  88                        *max_mtu = BNXT_MAX_MTU;
  89                else
  90                        *max_mtu = mtu;
  91        }
  92        hwrm_req_drop(bp, req);
  93        return rc;
  94}
  95
  96static int bnxt_vf_rep_open(struct net_device *dev)
  97{
  98        struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
  99        struct bnxt *bp = vf_rep->bp;
 100
 101        /* Enable link and TX only if the parent PF is open. */
 102        if (netif_running(bp->dev)) {
 103                netif_carrier_on(dev);
 104                netif_tx_start_all_queues(dev);
 105        }
 106        return 0;
 107}
 108
 109static int bnxt_vf_rep_close(struct net_device *dev)
 110{
 111        netif_carrier_off(dev);
 112        netif_tx_disable(dev);
 113
 114        return 0;
 115}
 116
 117static netdev_tx_t bnxt_vf_rep_xmit(struct sk_buff *skb,
 118                                    struct net_device *dev)
 119{
 120        struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
 121        int rc, len = skb->len;
 122
 123        skb_dst_drop(skb);
 124        dst_hold((struct dst_entry *)vf_rep->dst);
 125        skb_dst_set(skb, (struct dst_entry *)vf_rep->dst);
 126        skb->dev = vf_rep->dst->u.port_info.lower_dev;
 127
 128        rc = dev_queue_xmit(skb);
 129        if (!rc) {
 130                vf_rep->tx_stats.packets++;
 131                vf_rep->tx_stats.bytes += len;
 132        }
 133        return rc;
 134}
 135
 136static void
 137bnxt_vf_rep_get_stats64(struct net_device *dev,
 138                        struct rtnl_link_stats64 *stats)
 139{
 140        struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
 141
 142        stats->rx_packets = vf_rep->rx_stats.packets;
 143        stats->rx_bytes = vf_rep->rx_stats.bytes;
 144        stats->tx_packets = vf_rep->tx_stats.packets;
 145        stats->tx_bytes = vf_rep->tx_stats.bytes;
 146}
 147
 148static int bnxt_vf_rep_setup_tc_block_cb(enum tc_setup_type type,
 149                                         void *type_data,
 150                                         void *cb_priv)
 151{
 152        struct bnxt_vf_rep *vf_rep = cb_priv;
 153        struct bnxt *bp = vf_rep->bp;
 154        int vf_fid = bp->pf.vf[vf_rep->vf_idx].fw_fid;
 155
 156        if (!bnxt_tc_flower_enabled(vf_rep->bp) ||
 157            !tc_cls_can_offload_and_chain0(bp->dev, type_data))
 158                return -EOPNOTSUPP;
 159
 160        switch (type) {
 161        case TC_SETUP_CLSFLOWER:
 162                return bnxt_tc_setup_flower(bp, vf_fid, type_data);
 163        default:
 164                return -EOPNOTSUPP;
 165        }
 166}
 167
 168static LIST_HEAD(bnxt_vf_block_cb_list);
 169
 170static int bnxt_vf_rep_setup_tc(struct net_device *dev, enum tc_setup_type type,
 171                                void *type_data)
 172{
 173        struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
 174
 175        switch (type) {
 176        case TC_SETUP_BLOCK:
 177                return flow_block_cb_setup_simple(type_data,
 178                                                  &bnxt_vf_block_cb_list,
 179                                                  bnxt_vf_rep_setup_tc_block_cb,
 180                                                  vf_rep, vf_rep, true);
 181        default:
 182                return -EOPNOTSUPP;
 183        }
 184}
 185
 186struct net_device *bnxt_get_vf_rep(struct bnxt *bp, u16 cfa_code)
 187{
 188        u16 vf_idx;
 189
 190        if (cfa_code && bp->cfa_code_map && BNXT_PF(bp)) {
 191                vf_idx = bp->cfa_code_map[cfa_code];
 192                if (vf_idx != VF_IDX_INVALID)
 193                        return bp->vf_reps[vf_idx]->dev;
 194        }
 195        return NULL;
 196}
 197
 198void bnxt_vf_rep_rx(struct bnxt *bp, struct sk_buff *skb)
 199{
 200        struct bnxt_vf_rep *vf_rep = netdev_priv(skb->dev);
 201
 202        vf_rep->rx_stats.bytes += skb->len;
 203        vf_rep->rx_stats.packets++;
 204
 205        netif_receive_skb(skb);
 206}
 207
 208static int bnxt_vf_rep_get_phys_port_name(struct net_device *dev, char *buf,
 209                                          size_t len)
 210{
 211        struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
 212        struct pci_dev *pf_pdev = vf_rep->bp->pdev;
 213        int rc;
 214
 215        rc = snprintf(buf, len, "pf%dvf%d", PCI_FUNC(pf_pdev->devfn),
 216                      vf_rep->vf_idx);
 217        if (rc >= len)
 218                return -EOPNOTSUPP;
 219        return 0;
 220}
 221
 222static void bnxt_vf_rep_get_drvinfo(struct net_device *dev,
 223                                    struct ethtool_drvinfo *info)
 224{
 225        strlcpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
 226}
 227
 228static int bnxt_vf_rep_get_port_parent_id(struct net_device *dev,
 229                                          struct netdev_phys_item_id *ppid)
 230{
 231        struct bnxt_vf_rep *vf_rep = netdev_priv(dev);
 232
 233        /* as only PORT_PARENT_ID is supported currently use common code
 234         * between PF and VF-rep for now.
 235         */
 236        return bnxt_get_port_parent_id(vf_rep->bp->dev, ppid);
 237}
 238
 239static const struct ethtool_ops bnxt_vf_rep_ethtool_ops = {
 240        .get_drvinfo            = bnxt_vf_rep_get_drvinfo
 241};
 242
 243static const struct net_device_ops bnxt_vf_rep_netdev_ops = {
 244        .ndo_open               = bnxt_vf_rep_open,
 245        .ndo_stop               = bnxt_vf_rep_close,
 246        .ndo_start_xmit         = bnxt_vf_rep_xmit,
 247        .ndo_get_stats64        = bnxt_vf_rep_get_stats64,
 248        .ndo_setup_tc           = bnxt_vf_rep_setup_tc,
 249        .ndo_get_port_parent_id = bnxt_vf_rep_get_port_parent_id,
 250        .ndo_get_phys_port_name = bnxt_vf_rep_get_phys_port_name
 251};
 252
 253bool bnxt_dev_is_vf_rep(struct net_device *dev)
 254{
 255        return dev->netdev_ops == &bnxt_vf_rep_netdev_ops;
 256}
 257
 258/* Called when the parent PF interface is closed:
 259 * As the mode transition from SWITCHDEV to LEGACY
 260 * happens under the rtnl_lock() this routine is safe
 261 * under the rtnl_lock()
 262 */
 263void bnxt_vf_reps_close(struct bnxt *bp)
 264{
 265        struct bnxt_vf_rep *vf_rep;
 266        u16 num_vfs, i;
 267
 268        if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
 269                return;
 270
 271        num_vfs = pci_num_vf(bp->pdev);
 272        for (i = 0; i < num_vfs; i++) {
 273                vf_rep = bp->vf_reps[i];
 274                if (netif_running(vf_rep->dev))
 275                        bnxt_vf_rep_close(vf_rep->dev);
 276        }
 277}
 278
 279/* Called when the parent PF interface is opened (re-opened):
 280 * As the mode transition from SWITCHDEV to LEGACY
 281 * happen under the rtnl_lock() this routine is safe
 282 * under the rtnl_lock()
 283 */
 284void bnxt_vf_reps_open(struct bnxt *bp)
 285{
 286        int i;
 287
 288        if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
 289                return;
 290
 291        for (i = 0; i < pci_num_vf(bp->pdev); i++) {
 292                /* Open the VF-Rep only if it is allocated in the FW */
 293                if (bp->vf_reps[i]->tx_cfa_action != CFA_HANDLE_INVALID)
 294                        bnxt_vf_rep_open(bp->vf_reps[i]->dev);
 295        }
 296}
 297
 298static void __bnxt_free_one_vf_rep(struct bnxt *bp, struct bnxt_vf_rep *vf_rep)
 299{
 300        if (!vf_rep)
 301                return;
 302
 303        if (vf_rep->dst) {
 304                dst_release((struct dst_entry *)vf_rep->dst);
 305                vf_rep->dst = NULL;
 306        }
 307        if (vf_rep->tx_cfa_action != CFA_HANDLE_INVALID) {
 308                hwrm_cfa_vfr_free(bp, vf_rep->vf_idx);
 309                vf_rep->tx_cfa_action = CFA_HANDLE_INVALID;
 310        }
 311}
 312
 313static void __bnxt_vf_reps_destroy(struct bnxt *bp)
 314{
 315        u16 num_vfs = pci_num_vf(bp->pdev);
 316        struct bnxt_vf_rep *vf_rep;
 317        int i;
 318
 319        for (i = 0; i < num_vfs; i++) {
 320                vf_rep = bp->vf_reps[i];
 321                if (vf_rep) {
 322                        __bnxt_free_one_vf_rep(bp, vf_rep);
 323                        if (vf_rep->dev) {
 324                                /* if register_netdev failed, then netdev_ops
 325                                 * would have been set to NULL
 326                                 */
 327                                if (vf_rep->dev->netdev_ops)
 328                                        unregister_netdev(vf_rep->dev);
 329                                free_netdev(vf_rep->dev);
 330                        }
 331                }
 332        }
 333
 334        kfree(bp->vf_reps);
 335        bp->vf_reps = NULL;
 336}
 337
 338void bnxt_vf_reps_destroy(struct bnxt *bp)
 339{
 340        bool closed = false;
 341
 342        if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
 343                return;
 344
 345        if (!bp->vf_reps)
 346                return;
 347
 348        /* Ensure that parent PF's and VF-reps' RX/TX has been quiesced
 349         * before proceeding with VF-rep cleanup.
 350         */
 351        rtnl_lock();
 352        if (netif_running(bp->dev)) {
 353                bnxt_close_nic(bp, false, false);
 354                closed = true;
 355        }
 356        /* un-publish cfa_code_map so that RX path can't see it anymore */
 357        kfree(bp->cfa_code_map);
 358        bp->cfa_code_map = NULL;
 359        bp->eswitch_mode = DEVLINK_ESWITCH_MODE_LEGACY;
 360
 361        if (closed)
 362                bnxt_open_nic(bp, false, false);
 363        rtnl_unlock();
 364
 365        /* Need to call vf_reps_destroy() outside of rntl_lock
 366         * as unregister_netdev takes rtnl_lock
 367         */
 368        __bnxt_vf_reps_destroy(bp);
 369}
 370
 371/* Free the VF-Reps in firmware, during firmware hot-reset processing.
 372 * Note that the VF-Rep netdevs are still active (not unregistered) during
 373 * this process. As the mode transition from SWITCHDEV to LEGACY happens
 374 * under the rtnl_lock() this routine is safe under the rtnl_lock().
 375 */
 376void bnxt_vf_reps_free(struct bnxt *bp)
 377{
 378        u16 num_vfs = pci_num_vf(bp->pdev);
 379        int i;
 380
 381        if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
 382                return;
 383
 384        for (i = 0; i < num_vfs; i++)
 385                __bnxt_free_one_vf_rep(bp, bp->vf_reps[i]);
 386}
 387
 388static int bnxt_alloc_vf_rep(struct bnxt *bp, struct bnxt_vf_rep *vf_rep,
 389                             u16 *cfa_code_map)
 390{
 391        /* get cfa handles from FW */
 392        if (hwrm_cfa_vfr_alloc(bp, vf_rep->vf_idx, &vf_rep->tx_cfa_action,
 393                               &vf_rep->rx_cfa_code))
 394                return -ENOLINK;
 395
 396        cfa_code_map[vf_rep->rx_cfa_code] = vf_rep->vf_idx;
 397        vf_rep->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX, GFP_KERNEL);
 398        if (!vf_rep->dst)
 399                return -ENOMEM;
 400
 401        /* only cfa_action is needed to mux a packet while TXing */
 402        vf_rep->dst->u.port_info.port_id = vf_rep->tx_cfa_action;
 403        vf_rep->dst->u.port_info.lower_dev = bp->dev;
 404
 405        return 0;
 406}
 407
 408/* Allocate the VF-Reps in firmware, during firmware hot-reset processing.
 409 * Note that the VF-Rep netdevs are still active (not unregistered) during
 410 * this process. As the mode transition from SWITCHDEV to LEGACY happens
 411 * under the rtnl_lock() this routine is safe under the rtnl_lock().
 412 */
 413int bnxt_vf_reps_alloc(struct bnxt *bp)
 414{
 415        u16 *cfa_code_map = bp->cfa_code_map, num_vfs = pci_num_vf(bp->pdev);
 416        struct bnxt_vf_rep *vf_rep;
 417        int rc, i;
 418
 419        if (bp->eswitch_mode != DEVLINK_ESWITCH_MODE_SWITCHDEV)
 420                return 0;
 421
 422        if (!cfa_code_map)
 423                return -EINVAL;
 424
 425        for (i = 0; i < MAX_CFA_CODE; i++)
 426                cfa_code_map[i] = VF_IDX_INVALID;
 427
 428        for (i = 0; i < num_vfs; i++) {
 429                vf_rep = bp->vf_reps[i];
 430                vf_rep->vf_idx = i;
 431
 432                rc = bnxt_alloc_vf_rep(bp, vf_rep, cfa_code_map);
 433                if (rc)
 434                        goto err;
 435        }
 436
 437        return 0;
 438
 439err:
 440        netdev_info(bp->dev, "%s error=%d\n", __func__, rc);
 441        bnxt_vf_reps_free(bp);
 442        return rc;
 443}
 444
 445/* Use the OUI of the PF's perm addr and report the same mac addr
 446 * for the same VF-rep each time
 447 */
 448static void bnxt_vf_rep_eth_addr_gen(u8 *src_mac, u16 vf_idx, u8 *mac)
 449{
 450        u32 addr;
 451
 452        ether_addr_copy(mac, src_mac);
 453
 454        addr = jhash(src_mac, ETH_ALEN, 0) + vf_idx;
 455        mac[3] = (u8)(addr & 0xFF);
 456        mac[4] = (u8)((addr >> 8) & 0xFF);
 457        mac[5] = (u8)((addr >> 16) & 0xFF);
 458}
 459
 460static void bnxt_vf_rep_netdev_init(struct bnxt *bp, struct bnxt_vf_rep *vf_rep,
 461                                    struct net_device *dev)
 462{
 463        struct net_device *pf_dev = bp->dev;
 464        u16 max_mtu;
 465
 466        dev->netdev_ops = &bnxt_vf_rep_netdev_ops;
 467        dev->ethtool_ops = &bnxt_vf_rep_ethtool_ops;
 468        /* Just inherit all the featues of the parent PF as the VF-R
 469         * uses the RX/TX rings of the parent PF
 470         */
 471        dev->hw_features = pf_dev->hw_features;
 472        dev->gso_partial_features = pf_dev->gso_partial_features;
 473        dev->vlan_features = pf_dev->vlan_features;
 474        dev->hw_enc_features = pf_dev->hw_enc_features;
 475        dev->features |= pf_dev->features;
 476        bnxt_vf_rep_eth_addr_gen(bp->pf.mac_addr, vf_rep->vf_idx,
 477                                 dev->perm_addr);
 478        eth_hw_addr_set(dev, dev->perm_addr);
 479        /* Set VF-Rep's max-mtu to the corresponding VF's max-mtu */
 480        if (!bnxt_hwrm_vfr_qcfg(bp, vf_rep, &max_mtu))
 481                dev->max_mtu = max_mtu;
 482        dev->min_mtu = ETH_ZLEN;
 483}
 484
 485static int bnxt_vf_reps_create(struct bnxt *bp)
 486{
 487        u16 *cfa_code_map = NULL, num_vfs = pci_num_vf(bp->pdev);
 488        struct bnxt_vf_rep *vf_rep;
 489        struct net_device *dev;
 490        int rc, i;
 491
 492        if (!(bp->flags & BNXT_FLAG_DSN_VALID))
 493                return -ENODEV;
 494
 495        bp->vf_reps = kcalloc(num_vfs, sizeof(vf_rep), GFP_KERNEL);
 496        if (!bp->vf_reps)
 497                return -ENOMEM;
 498
 499        /* storage for cfa_code to vf-idx mapping */
 500        cfa_code_map = kmalloc_array(MAX_CFA_CODE, sizeof(*bp->cfa_code_map),
 501                                     GFP_KERNEL);
 502        if (!cfa_code_map) {
 503                rc = -ENOMEM;
 504                goto err;
 505        }
 506        for (i = 0; i < MAX_CFA_CODE; i++)
 507                cfa_code_map[i] = VF_IDX_INVALID;
 508
 509        for (i = 0; i < num_vfs; i++) {
 510                dev = alloc_etherdev(sizeof(*vf_rep));
 511                if (!dev) {
 512                        rc = -ENOMEM;
 513                        goto err;
 514                }
 515
 516                vf_rep = netdev_priv(dev);
 517                bp->vf_reps[i] = vf_rep;
 518                vf_rep->dev = dev;
 519                vf_rep->bp = bp;
 520                vf_rep->vf_idx = i;
 521                vf_rep->tx_cfa_action = CFA_HANDLE_INVALID;
 522
 523                rc = bnxt_alloc_vf_rep(bp, vf_rep, cfa_code_map);
 524                if (rc)
 525                        goto err;
 526
 527                bnxt_vf_rep_netdev_init(bp, vf_rep, dev);
 528                rc = register_netdev(dev);
 529                if (rc) {
 530                        /* no need for unregister_netdev in cleanup */
 531                        dev->netdev_ops = NULL;
 532                        goto err;
 533                }
 534        }
 535
 536        /* publish cfa_code_map only after all VF-reps have been initialized */
 537        bp->cfa_code_map = cfa_code_map;
 538        bp->eswitch_mode = DEVLINK_ESWITCH_MODE_SWITCHDEV;
 539        netif_keep_dst(bp->dev);
 540        return 0;
 541
 542err:
 543        netdev_info(bp->dev, "%s error=%d\n", __func__, rc);
 544        kfree(cfa_code_map);
 545        __bnxt_vf_reps_destroy(bp);
 546        return rc;
 547}
 548
 549/* Devlink related routines */
 550int bnxt_dl_eswitch_mode_get(struct devlink *devlink, u16 *mode)
 551{
 552        struct bnxt *bp = bnxt_get_bp_from_dl(devlink);
 553
 554        *mode = bp->eswitch_mode;
 555        return 0;
 556}
 557
 558int bnxt_dl_eswitch_mode_set(struct devlink *devlink, u16 mode,
 559                             struct netlink_ext_ack *extack)
 560{
 561        struct bnxt *bp = bnxt_get_bp_from_dl(devlink);
 562        int rc = 0;
 563
 564        mutex_lock(&bp->sriov_lock);
 565        if (bp->eswitch_mode == mode) {
 566                netdev_info(bp->dev, "already in %s eswitch mode\n",
 567                            mode == DEVLINK_ESWITCH_MODE_LEGACY ?
 568                            "legacy" : "switchdev");
 569                rc = -EINVAL;
 570                goto done;
 571        }
 572
 573        switch (mode) {
 574        case DEVLINK_ESWITCH_MODE_LEGACY:
 575                bnxt_vf_reps_destroy(bp);
 576                break;
 577
 578        case DEVLINK_ESWITCH_MODE_SWITCHDEV:
 579                if (bp->hwrm_spec_code < 0x10803) {
 580                        netdev_warn(bp->dev, "FW does not support SRIOV E-Switch SWITCHDEV mode\n");
 581                        rc = -ENOTSUPP;
 582                        goto done;
 583                }
 584
 585                if (pci_num_vf(bp->pdev) == 0) {
 586                        netdev_info(bp->dev, "Enable VFs before setting switchdev mode\n");
 587                        rc = -EPERM;
 588                        goto done;
 589                }
 590                rc = bnxt_vf_reps_create(bp);
 591                break;
 592
 593        default:
 594                rc = -EINVAL;
 595                goto done;
 596        }
 597done:
 598        mutex_unlock(&bp->sriov_lock);
 599        return rc;
 600}
 601
 602#endif
 603