F:    drivers/net/ethernet/rdc/r6040.c
  
  RDS - RELIABLE DATAGRAM SOCKETS
 -M:    Chien Yen <chien.yen@oracle.com>
 +M:    Santosh Shilimkar <santosh.shilimkar@oracle.com>
 +L:    netdev@vger.kernel.org
 +L:    linux-rdma@vger.kernel.org
  L:    rds-devel@oss.oracle.com (moderated for non-subscribers)
 +W:    https://oss.oracle.com/projects/rds/
  S:    Supported
  F:    net/rds/
 +F:    Documentation/networking/rds.txt
  
+ RDMAVT - RDMA verbs software
+ M:    Dennis Dalessandro <dennis.dalessandro@intel.com>
+ L:    linux-rdma@vger.kernel.org
+ S:    Supported
+ F:    drivers/infiniband/sw/rdmavt
+ 
  READ-COPY UPDATE (RCU)
  M:    "Paul E. McKenney" <paulmck@linux.vnet.ibm.com>
  M:    Josh Triplett <josh@joshtriplett.org>
 
        vxlan_get_rx_port(netdev);
  #endif
  #ifdef CONFIG_I40E_GENEVE
 -      geneve_get_rx_port(netdev);
 +      if (pf->flags & I40E_FLAG_GENEVE_OFFLOAD_CAPABLE)
 +              geneve_get_rx_port(netdev);
  #endif
  
+       i40e_notify_client_of_netdev_open(vsi);
+ 
        return 0;
  }
  
        if (pf->vsi[pf->lan_vsi])
                i40e_vsi_release(pf->vsi[pf->lan_vsi]);
  
+       /* remove attached clients */
+       ret_code = i40e_lan_del_device(pf);
+       if (ret_code) {
+               dev_warn(&pdev->dev, "Failed to delete client device: %d\n",
+                        ret_code);
+       }
+ 
        /* shutdown and destroy the HMC */
 -      if (pf->hw.hmc.hmc_obj) {
 -              ret_code = i40e_shutdown_lan_hmc(&pf->hw);
 +      if (hw->hmc.hmc_obj) {
 +              ret_code = i40e_shutdown_lan_hmc(hw);
                if (ret_code)
                        dev_warn(&pdev->dev,
                                 "Failed to destroy the HMC resources: %d\n",
 
        ppd = ppd_from_ibp(ibp);
  
        memset(rsp, 0, sizeof(*rsp));
-       rsp->port_number = (u8)port_num;
+       rsp->port_number = port_num;
+ 
+       pma_get_opa_port_ectrs(ibdev, rsp, port_num);
  
-       rsp->port_rcv_constraint_errors =
-               cpu_to_be64(read_port_cntr(ppd, C_SW_RCV_CSTR_ERR,
-                                          CNTR_INVALID_VL));
-       /* port_rcv_switch_relay_errors is 0 for HFIs */
-       rsp->port_xmit_discards =
-               cpu_to_be64(read_port_cntr(ppd, C_SW_XMIT_DSCD,
-                                               CNTR_INVALID_VL));
        rsp->port_rcv_remote_physical_errors =
                cpu_to_be64(read_dev_cntr(dd, C_DC_RMT_PHY_ERR,
-                                               CNTR_INVALID_VL));
-       tmp = read_dev_cntr(dd, C_DC_RX_REPLAY, CNTR_INVALID_VL);
-       tmp2 = tmp + read_dev_cntr(dd, C_DC_TX_REPLAY, CNTR_INVALID_VL);
-       if (tmp2 < tmp) {
-               /* overflow/wrapped */
-               rsp->local_link_integrity_errors = cpu_to_be64(~0);
-       } else {
-               rsp->local_link_integrity_errors = cpu_to_be64(tmp2);
-       }
-       tmp = read_dev_cntr(dd, C_DC_SEQ_CRC_CNT, CNTR_INVALID_VL);
-       tmp2 = tmp + read_dev_cntr(dd, C_DC_REINIT_FROM_PEER_CNT,
-                                       CNTR_INVALID_VL);
-       if (tmp2 > (u32)UINT_MAX || tmp2 < tmp) {
-               /* overflow/wrapped */
-               rsp->link_error_recovery = cpu_to_be32(~0);
-       } else {
-               rsp->link_error_recovery = cpu_to_be32(tmp2);
-       }
-       rsp->port_xmit_constraint_errors =
-               cpu_to_be64(read_port_cntr(ppd, C_SW_XMIT_CSTR_ERR,
-                                          CNTR_INVALID_VL));
-       rsp->excessive_buffer_overruns =
-               cpu_to_be64(read_dev_cntr(dd, C_RCV_OVF, CNTR_INVALID_VL));
+                                         CNTR_INVALID_VL));
        rsp->fm_config_errors =
                cpu_to_be64(read_dev_cntr(dd, C_DC_FM_CFG_ERR,
-                                               CNTR_INVALID_VL));
-       rsp->link_downed = cpu_to_be32(read_port_cntr(ppd, C_SW_LINK_DOWN,
-                                               CNTR_INVALID_VL));
+                                         CNTR_INVALID_VL));
        tmp = read_dev_cntr(dd, C_DC_UNC_ERR, CNTR_INVALID_VL);
+ 
        rsp->uncorrectable_errors = tmp < 0x100 ? (tmp & 0xff) : 0xff;
  
 -      vlinfo = (struct _vls_ectrs *)&rsp->vls[0];
 +      vlinfo = &rsp->vls[0];
        vfi = 0;
        vl_select_mask = be32_to_cpu(req->vl_select_mask);
        for_each_set_bit(vl, (unsigned long *)&(vl_select_mask),
 
                void __iomem *send;             /* SOP end */
                void __iomem *xend;
  
-               /* calculate the end of data or end of block, whichever
-                  comes first */
+               /*
+                * calculate the end of data or end of block, whichever
+                * comes first
+                */
                send = pbuf->start + PIO_BLOCK_SIZE;
 -              xend = send < dend ? send : dend;
 +              xend = min(send, dend);
  
                /* shift up to SOP=1 space */
                dest += SOP_DISTANCE;
                void __iomem *send;             /* SOP end */
                void __iomem *xend;
  
-               /* calculate the end of data or end of block, whichever
-                  comes first */
+               /*
+                * calculate the end of data or end of block, whichever
+                * comes first
+                */
                send = pbuf->start + PIO_BLOCK_SIZE;
 -              xend = send < dend ? send : dend;
 +              xend = min(send, dend);
  
                /* shift up to SOP=1 space */
                dest += SOP_DISTANCE;
 
        [IFLA_VF_RSS_QUERY_EN]  = { .len = sizeof(struct ifla_vf_rss_query_en) },
        [IFLA_VF_STATS]         = { .type = NLA_NESTED },
        [IFLA_VF_TRUST]         = { .len = sizeof(struct ifla_vf_trust) },
+       [IFLA_VF_IB_NODE_GUID]  = { .len = sizeof(struct ifla_vf_guid) },
+       [IFLA_VF_IB_PORT_GUID]  = { .len = sizeof(struct ifla_vf_guid) },
  };
  
 -static const struct nla_policy ifla_vf_stats_policy[IFLA_VF_STATS_MAX + 1] = {
 -      [IFLA_VF_STATS_RX_PACKETS]      = { .type = NLA_U64 },
 -      [IFLA_VF_STATS_TX_PACKETS]      = { .type = NLA_U64 },
 -      [IFLA_VF_STATS_RX_BYTES]        = { .type = NLA_U64 },
 -      [IFLA_VF_STATS_TX_BYTES]        = { .type = NLA_U64 },
 -      [IFLA_VF_STATS_BROADCAST]       = { .type = NLA_U64 },
 -      [IFLA_VF_STATS_MULTICAST]       = { .type = NLA_U64 },
 -};
 -
  static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = {
        [IFLA_PORT_VF]          = { .type = NLA_U32 },
        [IFLA_PORT_PROFILE]     = { .type = NLA_STRING,