mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
657 lines
18 KiB
657 lines
18 KiB
/* |
|
* Copyright(c) 2017 - 2020 Intel Corporation. |
|
* |
|
* This file is provided under a dual BSD/GPLv2 license. When using or |
|
* redistributing this file, you may do so under either license. |
|
* |
|
* GPL LICENSE SUMMARY |
|
* |
|
* This program is free software; you can redistribute it and/or modify |
|
* it under the terms of version 2 of the GNU General Public License as |
|
* published by the Free Software Foundation. |
|
* |
|
* This program is distributed in the hope that it will be useful, but |
|
* WITHOUT ANY WARRANTY; without even the implied warranty of |
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
|
* General Public License for more details. |
|
* |
|
* BSD LICENSE |
|
* |
|
* Redistribution and use in source and binary forms, with or without |
|
* modification, are permitted provided that the following conditions |
|
* are met: |
|
* |
|
* - Redistributions of source code must retain the above copyright |
|
* notice, this list of conditions and the following disclaimer. |
|
* - Redistributions in binary form must reproduce the above copyright |
|
* notice, this list of conditions and the following disclaimer in |
|
* the documentation and/or other materials provided with the |
|
* distribution. |
|
* - Neither the name of Intel Corporation nor the names of its |
|
* contributors may be used to endorse or promote products derived |
|
* from this software without specific prior written permission. |
|
* |
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
|
* |
|
*/ |
|
|
|
/* |
|
* This file contains HFI1 support for VNIC functionality |
|
*/ |
|
|
|
#include <linux/io.h> |
|
#include <linux/if_vlan.h> |
|
|
|
#include "vnic.h" |
|
#include "netdev.h" |
|
|
|
#define HFI_TX_TIMEOUT_MS 1000 |
|
|
|
#define HFI1_VNIC_RCV_Q_SIZE 1024 |
|
|
|
#define HFI1_VNIC_UP 0 |
|
|
|
static DEFINE_SPINLOCK(vport_cntr_lock); |
|
|
|
#define SUM_GRP_COUNTERS(stats, qstats, x_grp) do { \ |
|
u64 *src64, *dst64; \ |
|
for (src64 = &qstats->x_grp.unicast, \ |
|
dst64 = &stats->x_grp.unicast; \ |
|
dst64 <= &stats->x_grp.s_1519_max;) { \ |
|
*dst64++ += *src64++; \ |
|
} \ |
|
} while (0) |
|
|
|
#define VNIC_MASK (0xFF) |
|
#define VNIC_ID(val) ((1ull << 24) | ((val) & VNIC_MASK)) |
|
|
|
/* hfi1_vnic_update_stats - update statistics */ |
|
static void hfi1_vnic_update_stats(struct hfi1_vnic_vport_info *vinfo, |
|
struct opa_vnic_stats *stats) |
|
{ |
|
struct net_device *netdev = vinfo->netdev; |
|
u8 i; |
|
|
|
/* add tx counters on different queues */ |
|
for (i = 0; i < vinfo->num_tx_q; i++) { |
|
struct opa_vnic_stats *qstats = &vinfo->stats[i]; |
|
struct rtnl_link_stats64 *qnstats = &vinfo->stats[i].netstats; |
|
|
|
stats->netstats.tx_fifo_errors += qnstats->tx_fifo_errors; |
|
stats->netstats.tx_carrier_errors += qnstats->tx_carrier_errors; |
|
stats->tx_drop_state += qstats->tx_drop_state; |
|
stats->tx_dlid_zero += qstats->tx_dlid_zero; |
|
|
|
SUM_GRP_COUNTERS(stats, qstats, tx_grp); |
|
stats->netstats.tx_packets += qnstats->tx_packets; |
|
stats->netstats.tx_bytes += qnstats->tx_bytes; |
|
} |
|
|
|
/* add rx counters on different queues */ |
|
for (i = 0; i < vinfo->num_rx_q; i++) { |
|
struct opa_vnic_stats *qstats = &vinfo->stats[i]; |
|
struct rtnl_link_stats64 *qnstats = &vinfo->stats[i].netstats; |
|
|
|
stats->netstats.rx_fifo_errors += qnstats->rx_fifo_errors; |
|
stats->netstats.rx_nohandler += qnstats->rx_nohandler; |
|
stats->rx_drop_state += qstats->rx_drop_state; |
|
stats->rx_oversize += qstats->rx_oversize; |
|
stats->rx_runt += qstats->rx_runt; |
|
|
|
SUM_GRP_COUNTERS(stats, qstats, rx_grp); |
|
stats->netstats.rx_packets += qnstats->rx_packets; |
|
stats->netstats.rx_bytes += qnstats->rx_bytes; |
|
} |
|
|
|
stats->netstats.tx_errors = stats->netstats.tx_fifo_errors + |
|
stats->netstats.tx_carrier_errors + |
|
stats->tx_drop_state + stats->tx_dlid_zero; |
|
stats->netstats.tx_dropped = stats->netstats.tx_errors; |
|
|
|
stats->netstats.rx_errors = stats->netstats.rx_fifo_errors + |
|
stats->netstats.rx_nohandler + |
|
stats->rx_drop_state + stats->rx_oversize + |
|
stats->rx_runt; |
|
stats->netstats.rx_dropped = stats->netstats.rx_errors; |
|
|
|
netdev->stats.tx_packets = stats->netstats.tx_packets; |
|
netdev->stats.tx_bytes = stats->netstats.tx_bytes; |
|
netdev->stats.tx_fifo_errors = stats->netstats.tx_fifo_errors; |
|
netdev->stats.tx_carrier_errors = stats->netstats.tx_carrier_errors; |
|
netdev->stats.tx_errors = stats->netstats.tx_errors; |
|
netdev->stats.tx_dropped = stats->netstats.tx_dropped; |
|
|
|
netdev->stats.rx_packets = stats->netstats.rx_packets; |
|
netdev->stats.rx_bytes = stats->netstats.rx_bytes; |
|
netdev->stats.rx_fifo_errors = stats->netstats.rx_fifo_errors; |
|
netdev->stats.multicast = stats->rx_grp.mcastbcast; |
|
netdev->stats.rx_length_errors = stats->rx_oversize + stats->rx_runt; |
|
netdev->stats.rx_errors = stats->netstats.rx_errors; |
|
netdev->stats.rx_dropped = stats->netstats.rx_dropped; |
|
} |
|
|
|
/* update_len_counters - update pkt's len histogram counters */ |
|
static inline void update_len_counters(struct opa_vnic_grp_stats *grp, |
|
int len) |
|
{ |
|
/* account for 4 byte FCS */ |
|
if (len >= 1515) |
|
grp->s_1519_max++; |
|
else if (len >= 1020) |
|
grp->s_1024_1518++; |
|
else if (len >= 508) |
|
grp->s_512_1023++; |
|
else if (len >= 252) |
|
grp->s_256_511++; |
|
else if (len >= 124) |
|
grp->s_128_255++; |
|
else if (len >= 61) |
|
grp->s_65_127++; |
|
else |
|
grp->s_64++; |
|
} |
|
|
|
/* hfi1_vnic_update_tx_counters - update transmit counters */ |
|
static void hfi1_vnic_update_tx_counters(struct hfi1_vnic_vport_info *vinfo, |
|
u8 q_idx, struct sk_buff *skb, int err) |
|
{ |
|
struct ethhdr *mac_hdr = (struct ethhdr *)skb_mac_header(skb); |
|
struct opa_vnic_stats *stats = &vinfo->stats[q_idx]; |
|
struct opa_vnic_grp_stats *tx_grp = &stats->tx_grp; |
|
u16 vlan_tci; |
|
|
|
stats->netstats.tx_packets++; |
|
stats->netstats.tx_bytes += skb->len + ETH_FCS_LEN; |
|
|
|
update_len_counters(tx_grp, skb->len); |
|
|
|
/* rest of the counts are for good packets only */ |
|
if (unlikely(err)) |
|
return; |
|
|
|
if (is_multicast_ether_addr(mac_hdr->h_dest)) |
|
tx_grp->mcastbcast++; |
|
else |
|
tx_grp->unicast++; |
|
|
|
if (!__vlan_get_tag(skb, &vlan_tci)) |
|
tx_grp->vlan++; |
|
else |
|
tx_grp->untagged++; |
|
} |
|
|
|
/* hfi1_vnic_update_rx_counters - update receive counters */ |
|
static void hfi1_vnic_update_rx_counters(struct hfi1_vnic_vport_info *vinfo, |
|
u8 q_idx, struct sk_buff *skb, int err) |
|
{ |
|
struct ethhdr *mac_hdr = (struct ethhdr *)skb->data; |
|
struct opa_vnic_stats *stats = &vinfo->stats[q_idx]; |
|
struct opa_vnic_grp_stats *rx_grp = &stats->rx_grp; |
|
u16 vlan_tci; |
|
|
|
stats->netstats.rx_packets++; |
|
stats->netstats.rx_bytes += skb->len + ETH_FCS_LEN; |
|
|
|
update_len_counters(rx_grp, skb->len); |
|
|
|
/* rest of the counts are for good packets only */ |
|
if (unlikely(err)) |
|
return; |
|
|
|
if (is_multicast_ether_addr(mac_hdr->h_dest)) |
|
rx_grp->mcastbcast++; |
|
else |
|
rx_grp->unicast++; |
|
|
|
if (!__vlan_get_tag(skb, &vlan_tci)) |
|
rx_grp->vlan++; |
|
else |
|
rx_grp->untagged++; |
|
} |
|
|
|
/* This function is overloaded for opa_vnic specific implementation */ |
|
static void hfi1_vnic_get_stats64(struct net_device *netdev, |
|
struct rtnl_link_stats64 *stats) |
|
{ |
|
struct opa_vnic_stats *vstats = (struct opa_vnic_stats *)stats; |
|
struct hfi1_vnic_vport_info *vinfo = opa_vnic_dev_priv(netdev); |
|
|
|
hfi1_vnic_update_stats(vinfo, vstats); |
|
} |
|
|
|
static u64 create_bypass_pbc(u32 vl, u32 dw_len) |
|
{ |
|
u64 pbc; |
|
|
|
pbc = ((u64)PBC_IHCRC_NONE << PBC_INSERT_HCRC_SHIFT) |
|
| PBC_INSERT_BYPASS_ICRC | PBC_CREDIT_RETURN |
|
| PBC_PACKET_BYPASS |
|
| ((vl & PBC_VL_MASK) << PBC_VL_SHIFT) |
|
| (dw_len & PBC_LENGTH_DWS_MASK) << PBC_LENGTH_DWS_SHIFT; |
|
|
|
return pbc; |
|
} |
|
|
|
/* hfi1_vnic_maybe_stop_tx - stop tx queue if required */ |
|
static void hfi1_vnic_maybe_stop_tx(struct hfi1_vnic_vport_info *vinfo, |
|
u8 q_idx) |
|
{ |
|
netif_stop_subqueue(vinfo->netdev, q_idx); |
|
if (!hfi1_vnic_sdma_write_avail(vinfo, q_idx)) |
|
return; |
|
|
|
netif_start_subqueue(vinfo->netdev, q_idx); |
|
} |
|
|
|
static netdev_tx_t hfi1_netdev_start_xmit(struct sk_buff *skb, |
|
struct net_device *netdev) |
|
{ |
|
struct hfi1_vnic_vport_info *vinfo = opa_vnic_dev_priv(netdev); |
|
u8 pad_len, q_idx = skb->queue_mapping; |
|
struct hfi1_devdata *dd = vinfo->dd; |
|
struct opa_vnic_skb_mdata *mdata; |
|
u32 pkt_len, total_len; |
|
int err = -EINVAL; |
|
u64 pbc; |
|
|
|
v_dbg("xmit: queue %d skb len %d\n", q_idx, skb->len); |
|
if (unlikely(!netif_oper_up(netdev))) { |
|
vinfo->stats[q_idx].tx_drop_state++; |
|
goto tx_finish; |
|
} |
|
|
|
/* take out meta data */ |
|
mdata = (struct opa_vnic_skb_mdata *)skb->data; |
|
skb_pull(skb, sizeof(*mdata)); |
|
if (unlikely(mdata->flags & OPA_VNIC_SKB_MDATA_ENCAP_ERR)) { |
|
vinfo->stats[q_idx].tx_dlid_zero++; |
|
goto tx_finish; |
|
} |
|
|
|
/* add tail padding (for 8 bytes size alignment) and icrc */ |
|
pad_len = -(skb->len + OPA_VNIC_ICRC_TAIL_LEN) & 0x7; |
|
pad_len += OPA_VNIC_ICRC_TAIL_LEN; |
|
|
|
/* |
|
* pkt_len is how much data we have to write, includes header and data. |
|
* total_len is length of the packet in Dwords plus the PBC should not |
|
* include the CRC. |
|
*/ |
|
pkt_len = (skb->len + pad_len) >> 2; |
|
total_len = pkt_len + 2; /* PBC + packet */ |
|
|
|
pbc = create_bypass_pbc(mdata->vl, total_len); |
|
|
|
skb_get(skb); |
|
v_dbg("pbc 0x%016llX len %d pad_len %d\n", pbc, skb->len, pad_len); |
|
err = dd->process_vnic_dma_send(dd, q_idx, vinfo, skb, pbc, pad_len); |
|
if (unlikely(err)) { |
|
if (err == -ENOMEM) |
|
vinfo->stats[q_idx].netstats.tx_fifo_errors++; |
|
else if (err != -EBUSY) |
|
vinfo->stats[q_idx].netstats.tx_carrier_errors++; |
|
} |
|
/* remove the header before updating tx counters */ |
|
skb_pull(skb, OPA_VNIC_HDR_LEN); |
|
|
|
if (unlikely(err == -EBUSY)) { |
|
hfi1_vnic_maybe_stop_tx(vinfo, q_idx); |
|
dev_kfree_skb_any(skb); |
|
return NETDEV_TX_BUSY; |
|
} |
|
|
|
tx_finish: |
|
/* update tx counters */ |
|
hfi1_vnic_update_tx_counters(vinfo, q_idx, skb, err); |
|
dev_kfree_skb_any(skb); |
|
return NETDEV_TX_OK; |
|
} |
|
|
|
static u16 hfi1_vnic_select_queue(struct net_device *netdev, |
|
struct sk_buff *skb, |
|
struct net_device *sb_dev) |
|
{ |
|
struct hfi1_vnic_vport_info *vinfo = opa_vnic_dev_priv(netdev); |
|
struct opa_vnic_skb_mdata *mdata; |
|
struct sdma_engine *sde; |
|
|
|
mdata = (struct opa_vnic_skb_mdata *)skb->data; |
|
sde = sdma_select_engine_vl(vinfo->dd, mdata->entropy, mdata->vl); |
|
return sde->this_idx; |
|
} |
|
|
|
/* hfi1_vnic_decap_skb - strip OPA header from the skb (ethernet) packet */ |
|
static inline int hfi1_vnic_decap_skb(struct hfi1_vnic_rx_queue *rxq, |
|
struct sk_buff *skb) |
|
{ |
|
struct hfi1_vnic_vport_info *vinfo = rxq->vinfo; |
|
int max_len = vinfo->netdev->mtu + VLAN_ETH_HLEN; |
|
int rc = -EFAULT; |
|
|
|
skb_pull(skb, OPA_VNIC_HDR_LEN); |
|
|
|
/* Validate Packet length */ |
|
if (unlikely(skb->len > max_len)) |
|
vinfo->stats[rxq->idx].rx_oversize++; |
|
else if (unlikely(skb->len < ETH_ZLEN)) |
|
vinfo->stats[rxq->idx].rx_runt++; |
|
else |
|
rc = 0; |
|
return rc; |
|
} |
|
|
|
static struct hfi1_vnic_vport_info *get_vnic_port(struct hfi1_devdata *dd, |
|
int vesw_id) |
|
{ |
|
int vnic_id = VNIC_ID(vesw_id); |
|
|
|
return hfi1_netdev_get_data(dd, vnic_id); |
|
} |
|
|
|
static struct hfi1_vnic_vport_info *get_first_vnic_port(struct hfi1_devdata *dd) |
|
{ |
|
struct hfi1_vnic_vport_info *vinfo; |
|
int next_id = VNIC_ID(0); |
|
|
|
vinfo = hfi1_netdev_get_first_data(dd, &next_id); |
|
|
|
if (next_id > VNIC_ID(VNIC_MASK)) |
|
return NULL; |
|
|
|
return vinfo; |
|
} |
|
|
|
void hfi1_vnic_bypass_rcv(struct hfi1_packet *packet) |
|
{ |
|
struct hfi1_devdata *dd = packet->rcd->dd; |
|
struct hfi1_vnic_vport_info *vinfo = NULL; |
|
struct hfi1_vnic_rx_queue *rxq; |
|
struct sk_buff *skb; |
|
int l4_type, vesw_id = -1, rc; |
|
u8 q_idx; |
|
unsigned char *pad_info; |
|
|
|
l4_type = hfi1_16B_get_l4(packet->ebuf); |
|
if (likely(l4_type == OPA_16B_L4_ETHR)) { |
|
vesw_id = HFI1_VNIC_GET_VESWID(packet->ebuf); |
|
vinfo = get_vnic_port(dd, vesw_id); |
|
|
|
/* |
|
* In case of invalid vesw id, count the error on |
|
* the first available vport. |
|
*/ |
|
if (unlikely(!vinfo)) { |
|
struct hfi1_vnic_vport_info *vinfo_tmp; |
|
|
|
vinfo_tmp = get_first_vnic_port(dd); |
|
if (vinfo_tmp) { |
|
spin_lock(&vport_cntr_lock); |
|
vinfo_tmp->stats[0].netstats.rx_nohandler++; |
|
spin_unlock(&vport_cntr_lock); |
|
} |
|
} |
|
} |
|
|
|
if (unlikely(!vinfo)) { |
|
dd_dev_warn(dd, "vnic rcv err: l4 %d vesw id %d ctx %d\n", |
|
l4_type, vesw_id, packet->rcd->ctxt); |
|
return; |
|
} |
|
|
|
q_idx = packet->rcd->vnic_q_idx; |
|
rxq = &vinfo->rxq[q_idx]; |
|
if (unlikely(!netif_oper_up(vinfo->netdev))) { |
|
vinfo->stats[q_idx].rx_drop_state++; |
|
return; |
|
} |
|
|
|
skb = netdev_alloc_skb(vinfo->netdev, packet->tlen); |
|
if (unlikely(!skb)) { |
|
vinfo->stats[q_idx].netstats.rx_fifo_errors++; |
|
return; |
|
} |
|
|
|
memcpy(skb->data, packet->ebuf, packet->tlen); |
|
skb_put(skb, packet->tlen); |
|
|
|
pad_info = skb->data + skb->len - 1; |
|
skb_trim(skb, (skb->len - OPA_VNIC_ICRC_TAIL_LEN - |
|
((*pad_info) & 0x7))); |
|
|
|
rc = hfi1_vnic_decap_skb(rxq, skb); |
|
|
|
/* update rx counters */ |
|
hfi1_vnic_update_rx_counters(vinfo, rxq->idx, skb, rc); |
|
if (unlikely(rc)) { |
|
dev_kfree_skb_any(skb); |
|
return; |
|
} |
|
|
|
skb_checksum_none_assert(skb); |
|
skb->protocol = eth_type_trans(skb, rxq->netdev); |
|
|
|
napi_gro_receive(&rxq->napi, skb); |
|
} |
|
|
|
static int hfi1_vnic_up(struct hfi1_vnic_vport_info *vinfo) |
|
{ |
|
struct hfi1_devdata *dd = vinfo->dd; |
|
struct net_device *netdev = vinfo->netdev; |
|
int rc; |
|
|
|
/* ensure virtual eth switch id is valid */ |
|
if (!vinfo->vesw_id) |
|
return -EINVAL; |
|
|
|
rc = hfi1_netdev_add_data(dd, VNIC_ID(vinfo->vesw_id), vinfo); |
|
if (rc < 0) |
|
return rc; |
|
|
|
rc = hfi1_netdev_rx_init(dd); |
|
if (rc) |
|
goto err_remove; |
|
|
|
netif_carrier_on(netdev); |
|
netif_tx_start_all_queues(netdev); |
|
set_bit(HFI1_VNIC_UP, &vinfo->flags); |
|
|
|
return 0; |
|
|
|
err_remove: |
|
hfi1_netdev_remove_data(dd, VNIC_ID(vinfo->vesw_id)); |
|
return rc; |
|
} |
|
|
|
static void hfi1_vnic_down(struct hfi1_vnic_vport_info *vinfo) |
|
{ |
|
struct hfi1_devdata *dd = vinfo->dd; |
|
|
|
clear_bit(HFI1_VNIC_UP, &vinfo->flags); |
|
netif_carrier_off(vinfo->netdev); |
|
netif_tx_disable(vinfo->netdev); |
|
hfi1_netdev_remove_data(dd, VNIC_ID(vinfo->vesw_id)); |
|
|
|
hfi1_netdev_rx_destroy(dd); |
|
} |
|
|
|
static int hfi1_netdev_open(struct net_device *netdev) |
|
{ |
|
struct hfi1_vnic_vport_info *vinfo = opa_vnic_dev_priv(netdev); |
|
int rc; |
|
|
|
mutex_lock(&vinfo->lock); |
|
rc = hfi1_vnic_up(vinfo); |
|
mutex_unlock(&vinfo->lock); |
|
return rc; |
|
} |
|
|
|
static int hfi1_netdev_close(struct net_device *netdev) |
|
{ |
|
struct hfi1_vnic_vport_info *vinfo = opa_vnic_dev_priv(netdev); |
|
|
|
mutex_lock(&vinfo->lock); |
|
if (test_bit(HFI1_VNIC_UP, &vinfo->flags)) |
|
hfi1_vnic_down(vinfo); |
|
mutex_unlock(&vinfo->lock); |
|
return 0; |
|
} |
|
|
|
static int hfi1_vnic_init(struct hfi1_vnic_vport_info *vinfo) |
|
{ |
|
struct hfi1_devdata *dd = vinfo->dd; |
|
int rc = 0; |
|
|
|
mutex_lock(&hfi1_mutex); |
|
if (!dd->vnic_num_vports) { |
|
rc = hfi1_vnic_txreq_init(dd); |
|
if (rc) |
|
goto txreq_fail; |
|
} |
|
|
|
rc = hfi1_netdev_rx_init(dd); |
|
if (rc) { |
|
dd_dev_err(dd, "Unable to initialize netdev contexts\n"); |
|
goto alloc_fail; |
|
} |
|
|
|
hfi1_init_vnic_rsm(dd); |
|
|
|
dd->vnic_num_vports++; |
|
hfi1_vnic_sdma_init(vinfo); |
|
|
|
alloc_fail: |
|
if (!dd->vnic_num_vports) |
|
hfi1_vnic_txreq_deinit(dd); |
|
txreq_fail: |
|
mutex_unlock(&hfi1_mutex); |
|
return rc; |
|
} |
|
|
|
static void hfi1_vnic_deinit(struct hfi1_vnic_vport_info *vinfo) |
|
{ |
|
struct hfi1_devdata *dd = vinfo->dd; |
|
|
|
mutex_lock(&hfi1_mutex); |
|
if (--dd->vnic_num_vports == 0) { |
|
hfi1_deinit_vnic_rsm(dd); |
|
hfi1_vnic_txreq_deinit(dd); |
|
} |
|
mutex_unlock(&hfi1_mutex); |
|
hfi1_netdev_rx_destroy(dd); |
|
} |
|
|
|
static void hfi1_vnic_set_vesw_id(struct net_device *netdev, int id) |
|
{ |
|
struct hfi1_vnic_vport_info *vinfo = opa_vnic_dev_priv(netdev); |
|
bool reopen = false; |
|
|
|
/* |
|
* If vesw_id is being changed, and if the vnic port is up, |
|
* reset the vnic port to ensure new vesw_id gets picked up |
|
*/ |
|
if (id != vinfo->vesw_id) { |
|
mutex_lock(&vinfo->lock); |
|
if (test_bit(HFI1_VNIC_UP, &vinfo->flags)) { |
|
hfi1_vnic_down(vinfo); |
|
reopen = true; |
|
} |
|
|
|
vinfo->vesw_id = id; |
|
if (reopen) |
|
hfi1_vnic_up(vinfo); |
|
|
|
mutex_unlock(&vinfo->lock); |
|
} |
|
} |
|
|
|
/* netdev ops */ |
|
static const struct net_device_ops hfi1_netdev_ops = { |
|
.ndo_open = hfi1_netdev_open, |
|
.ndo_stop = hfi1_netdev_close, |
|
.ndo_start_xmit = hfi1_netdev_start_xmit, |
|
.ndo_select_queue = hfi1_vnic_select_queue, |
|
.ndo_get_stats64 = hfi1_vnic_get_stats64, |
|
}; |
|
|
|
static void hfi1_vnic_free_rn(struct net_device *netdev) |
|
{ |
|
struct hfi1_vnic_vport_info *vinfo = opa_vnic_dev_priv(netdev); |
|
|
|
hfi1_vnic_deinit(vinfo); |
|
mutex_destroy(&vinfo->lock); |
|
free_netdev(netdev); |
|
} |
|
|
|
struct net_device *hfi1_vnic_alloc_rn(struct ib_device *device, |
|
u32 port_num, |
|
enum rdma_netdev_t type, |
|
const char *name, |
|
unsigned char name_assign_type, |
|
void (*setup)(struct net_device *)) |
|
{ |
|
struct hfi1_devdata *dd = dd_from_ibdev(device); |
|
struct hfi1_vnic_vport_info *vinfo; |
|
struct net_device *netdev; |
|
struct rdma_netdev *rn; |
|
int i, size, rc; |
|
|
|
if (!dd->num_netdev_contexts) |
|
return ERR_PTR(-ENOMEM); |
|
|
|
if (!port_num || (port_num > dd->num_pports)) |
|
return ERR_PTR(-EINVAL); |
|
|
|
if (type != RDMA_NETDEV_OPA_VNIC) |
|
return ERR_PTR(-EOPNOTSUPP); |
|
|
|
size = sizeof(struct opa_vnic_rdma_netdev) + sizeof(*vinfo); |
|
netdev = alloc_netdev_mqs(size, name, name_assign_type, setup, |
|
chip_sdma_engines(dd), |
|
dd->num_netdev_contexts); |
|
if (!netdev) |
|
return ERR_PTR(-ENOMEM); |
|
|
|
rn = netdev_priv(netdev); |
|
vinfo = opa_vnic_dev_priv(netdev); |
|
vinfo->dd = dd; |
|
vinfo->num_tx_q = chip_sdma_engines(dd); |
|
vinfo->num_rx_q = dd->num_netdev_contexts; |
|
vinfo->netdev = netdev; |
|
rn->free_rdma_netdev = hfi1_vnic_free_rn; |
|
rn->set_id = hfi1_vnic_set_vesw_id; |
|
|
|
netdev->features = NETIF_F_HIGHDMA | NETIF_F_SG; |
|
netdev->hw_features = netdev->features; |
|
netdev->vlan_features = netdev->features; |
|
netdev->watchdog_timeo = msecs_to_jiffies(HFI_TX_TIMEOUT_MS); |
|
netdev->netdev_ops = &hfi1_netdev_ops; |
|
mutex_init(&vinfo->lock); |
|
|
|
for (i = 0; i < vinfo->num_rx_q; i++) { |
|
struct hfi1_vnic_rx_queue *rxq = &vinfo->rxq[i]; |
|
|
|
rxq->idx = i; |
|
rxq->vinfo = vinfo; |
|
rxq->netdev = netdev; |
|
} |
|
|
|
rc = hfi1_vnic_init(vinfo); |
|
if (rc) |
|
goto init_fail; |
|
|
|
return netdev; |
|
init_fail: |
|
mutex_destroy(&vinfo->lock); |
|
free_netdev(netdev); |
|
return ERR_PTR(rc); |
|
}
|
|
|