705 lines
20 KiB
C
705 lines
20 KiB
C
/*
|
|
* Copyright (C) 2005 - 2008 ServerEngines
|
|
* All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License version 2
|
|
* as published by the Free Software Foundation. The full GNU General
|
|
* Public License is included in this distribution in the file called COPYING.
|
|
*
|
|
* Contact Information:
|
|
* linux-drivers@serverengines.com
|
|
*
|
|
* ServerEngines
|
|
* 209 N. Fair Oaks Ave
|
|
* Sunnyvale, CA 94085
|
|
*/
|
|
/*
|
|
* be_netif.c
|
|
*
|
|
* This file contains various entry points of drivers seen by tcp/ip stack.
|
|
*/
|
|
|
|
#include <linux/if_vlan.h>
|
|
#include <linux/in.h>
|
|
#include "benet.h"
|
|
#include <linux/ip.h>
|
|
#include <linux/inet_lro.h>
|
|
|
|
/* Strings to print Link properties */
|
|
static const char *link_speed[] = {
|
|
"Invalid link Speed Value",
|
|
"10 Mbps",
|
|
"100 Mbps",
|
|
"1 Gbps",
|
|
"10 Gbps"
|
|
};
|
|
|
|
static const char *link_duplex[] = {
|
|
"Invalid Duplex Value",
|
|
"Half Duplex",
|
|
"Full Duplex"
|
|
};
|
|
|
|
static const char *link_state[] = {
|
|
"",
|
|
"(active)"
|
|
};
|
|
|
|
void be_print_link_info(struct BE_LINK_STATUS *lnk_status)
|
|
{
|
|
u16 si, di, ai;
|
|
|
|
/* Port 0 */
|
|
if (lnk_status->mac0_speed && lnk_status->mac0_duplex) {
|
|
/* Port is up and running */
|
|
si = (lnk_status->mac0_speed < 5) ? lnk_status->mac0_speed : 0;
|
|
di = (lnk_status->mac0_duplex < 3) ?
|
|
lnk_status->mac0_duplex : 0;
|
|
ai = (lnk_status->active_port == 0) ? 1 : 0;
|
|
printk(KERN_INFO "PortNo. 0: Speed - %s %s %s\n",
|
|
link_speed[si], link_duplex[di], link_state[ai]);
|
|
} else
|
|
printk(KERN_INFO "PortNo. 0: Down\n");
|
|
|
|
/* Port 1 */
|
|
if (lnk_status->mac1_speed && lnk_status->mac1_duplex) {
|
|
/* Port is up and running */
|
|
si = (lnk_status->mac1_speed < 5) ? lnk_status->mac1_speed : 0;
|
|
di = (lnk_status->mac1_duplex < 3) ?
|
|
lnk_status->mac1_duplex : 0;
|
|
ai = (lnk_status->active_port == 0) ? 1 : 0;
|
|
printk(KERN_INFO "PortNo. 1: Speed - %s %s %s\n",
|
|
link_speed[si], link_duplex[di], link_state[ai]);
|
|
} else
|
|
printk(KERN_INFO "PortNo. 1: Down\n");
|
|
|
|
return;
|
|
}
|
|
|
|
static int
|
|
be_get_frag_header(struct skb_frag_struct *frag, void **mac_hdr,
|
|
void **ip_hdr, void **tcpudp_hdr,
|
|
u64 *hdr_flags, void *priv)
|
|
{
|
|
struct ethhdr *eh;
|
|
struct vlan_ethhdr *veh;
|
|
struct iphdr *iph;
|
|
u8 *va = page_address(frag->page) + frag->page_offset;
|
|
unsigned long ll_hlen;
|
|
|
|
/* find the mac header, abort if not IPv4 */
|
|
|
|
prefetch(va);
|
|
eh = (struct ethhdr *)va;
|
|
*mac_hdr = eh;
|
|
ll_hlen = ETH_HLEN;
|
|
if (eh->h_proto != htons(ETH_P_IP)) {
|
|
if (eh->h_proto == htons(ETH_P_8021Q)) {
|
|
veh = (struct vlan_ethhdr *)va;
|
|
if (veh->h_vlan_encapsulated_proto != htons(ETH_P_IP))
|
|
return -1;
|
|
|
|
ll_hlen += VLAN_HLEN;
|
|
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
*hdr_flags = LRO_IPV4;
|
|
|
|
iph = (struct iphdr *)(va + ll_hlen);
|
|
*ip_hdr = iph;
|
|
if (iph->protocol != IPPROTO_TCP)
|
|
return -1;
|
|
*hdr_flags |= LRO_TCP;
|
|
*tcpudp_hdr = (u8 *) (*ip_hdr) + (iph->ihl << 2);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int benet_open(struct net_device *netdev)
|
|
{
|
|
struct be_net_object *pnob = netdev_priv(netdev);
|
|
struct be_adapter *adapter = pnob->adapter;
|
|
struct net_lro_mgr *lro_mgr;
|
|
|
|
if (adapter->dev_state < BE_DEV_STATE_INIT)
|
|
return -EAGAIN;
|
|
|
|
lro_mgr = &pnob->lro_mgr;
|
|
lro_mgr->dev = netdev;
|
|
|
|
lro_mgr->features = LRO_F_NAPI;
|
|
lro_mgr->ip_summed = CHECKSUM_UNNECESSARY;
|
|
lro_mgr->ip_summed_aggr = CHECKSUM_UNNECESSARY;
|
|
lro_mgr->max_desc = BE_MAX_LRO_DESCRIPTORS;
|
|
lro_mgr->lro_arr = pnob->lro_desc;
|
|
lro_mgr->get_frag_header = be_get_frag_header;
|
|
lro_mgr->max_aggr = adapter->max_rx_coal;
|
|
lro_mgr->frag_align_pad = 2;
|
|
if (lro_mgr->max_aggr > MAX_SKB_FRAGS)
|
|
lro_mgr->max_aggr = MAX_SKB_FRAGS;
|
|
|
|
adapter->max_rx_coal = BE_LRO_MAX_PKTS;
|
|
|
|
be_update_link_status(adapter);
|
|
|
|
/*
|
|
* Set carrier on only if Physical Link up
|
|
* Either of the port link status up signifies this
|
|
*/
|
|
if ((adapter->port0_link_sts == BE_PORT_LINK_UP) ||
|
|
(adapter->port1_link_sts == BE_PORT_LINK_UP)) {
|
|
netif_start_queue(netdev);
|
|
netif_carrier_on(netdev);
|
|
}
|
|
|
|
adapter->dev_state = BE_DEV_STATE_OPEN;
|
|
napi_enable(&pnob->napi);
|
|
be_enable_intr(pnob);
|
|
be_enable_eq_intr(pnob);
|
|
/*
|
|
* RX completion queue may be in dis-armed state. Arm it.
|
|
*/
|
|
be_notify_cmpl(pnob, 0, pnob->rx_cq_id, 1);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int benet_close(struct net_device *netdev)
|
|
{
|
|
struct be_net_object *pnob = netdev_priv(netdev);
|
|
struct be_adapter *adapter = pnob->adapter;
|
|
|
|
netif_stop_queue(netdev);
|
|
synchronize_irq(netdev->irq);
|
|
|
|
be_wait_nic_tx_cmplx_cmpl(pnob);
|
|
adapter->dev_state = BE_DEV_STATE_INIT;
|
|
netif_carrier_off(netdev);
|
|
|
|
adapter->port0_link_sts = BE_PORT_LINK_DOWN;
|
|
adapter->port1_link_sts = BE_PORT_LINK_DOWN;
|
|
be_disable_intr(pnob);
|
|
be_disable_eq_intr(pnob);
|
|
napi_disable(&pnob->napi);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Setting a Mac Address for BE
|
|
* Takes netdev and a void pointer as arguments.
|
|
* The pointer holds the new addres to be used.
|
|
*/
|
|
static int benet_set_mac_addr(struct net_device *netdev, void *p)
|
|
{
|
|
struct sockaddr *addr = p;
|
|
struct be_net_object *pnob = netdev_priv(netdev);
|
|
|
|
memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
|
|
be_rxf_mac_address_read_write(&pnob->fn_obj, 0, 0, false, true, false,
|
|
netdev->dev_addr, NULL, NULL);
|
|
/*
|
|
* Since we are doing Active-Passive failover, both
|
|
* ports should have matching MAC addresses everytime.
|
|
*/
|
|
be_rxf_mac_address_read_write(&pnob->fn_obj, 1, 0, false, true, false,
|
|
netdev->dev_addr, NULL, NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void be_get_stats_timer_handler(unsigned long context)
|
|
{
|
|
struct be_timer_ctxt *ctxt = (struct be_timer_ctxt *)context;
|
|
|
|
if (atomic_read(&ctxt->get_stat_flag)) {
|
|
atomic_dec(&ctxt->get_stat_flag);
|
|
up((void *)ctxt->get_stat_sem_addr);
|
|
}
|
|
del_timer(&ctxt->get_stats_timer);
|
|
return;
|
|
}
|
|
|
|
void be_get_stat_cb(void *context, int status,
|
|
struct MCC_WRB_AMAP *optional_wrb)
|
|
{
|
|
struct be_timer_ctxt *ctxt = (struct be_timer_ctxt *)context;
|
|
/*
|
|
* just up the semaphore if the get_stat_flag
|
|
* reads 1. so that the waiter can continue.
|
|
* If it is 0, then it was handled by the timer handler.
|
|
*/
|
|
del_timer(&ctxt->get_stats_timer);
|
|
if (atomic_read(&ctxt->get_stat_flag)) {
|
|
atomic_dec(&ctxt->get_stat_flag);
|
|
up((void *)ctxt->get_stat_sem_addr);
|
|
}
|
|
}
|
|
|
|
struct net_device_stats *benet_get_stats(struct net_device *dev)
|
|
{
|
|
struct be_net_object *pnob = netdev_priv(dev);
|
|
struct be_adapter *adapter = pnob->adapter;
|
|
u64 pa;
|
|
struct be_timer_ctxt *ctxt = &adapter->timer_ctxt;
|
|
|
|
if (adapter->dev_state != BE_DEV_STATE_OPEN) {
|
|
/* Return previously read stats */
|
|
return &(adapter->benet_stats);
|
|
}
|
|
/* Get Physical Addr */
|
|
pa = pci_map_single(adapter->pdev, adapter->eth_statsp,
|
|
sizeof(struct FWCMD_ETH_GET_STATISTICS),
|
|
PCI_DMA_FROMDEVICE);
|
|
ctxt->get_stat_sem_addr = (unsigned long)&adapter->get_eth_stat_sem;
|
|
atomic_inc(&ctxt->get_stat_flag);
|
|
|
|
be_rxf_query_eth_statistics(&pnob->fn_obj, adapter->eth_statsp,
|
|
cpu_to_le64(pa), be_get_stat_cb, ctxt,
|
|
NULL);
|
|
|
|
ctxt->get_stats_timer.data = (unsigned long)ctxt;
|
|
mod_timer(&ctxt->get_stats_timer, (jiffies + (HZ * 2)));
|
|
down((void *)ctxt->get_stat_sem_addr); /* callback will unblock us */
|
|
|
|
/* Adding port0 and port1 stats. */
|
|
adapter->benet_stats.rx_packets =
|
|
adapter->eth_statsp->params.response.p0recvdtotalframes +
|
|
adapter->eth_statsp->params.response.p1recvdtotalframes;
|
|
adapter->benet_stats.tx_packets =
|
|
adapter->eth_statsp->params.response.p0xmitunicastframes +
|
|
adapter->eth_statsp->params.response.p1xmitunicastframes;
|
|
adapter->benet_stats.tx_bytes =
|
|
adapter->eth_statsp->params.response.p0xmitbyteslsd +
|
|
adapter->eth_statsp->params.response.p1xmitbyteslsd;
|
|
adapter->benet_stats.rx_errors =
|
|
adapter->eth_statsp->params.response.p0crcerrors +
|
|
adapter->eth_statsp->params.response.p1crcerrors;
|
|
adapter->benet_stats.rx_errors +=
|
|
adapter->eth_statsp->params.response.p0alignmentsymerrs +
|
|
adapter->eth_statsp->params.response.p1alignmentsymerrs;
|
|
adapter->benet_stats.rx_errors +=
|
|
adapter->eth_statsp->params.response.p0inrangelenerrors +
|
|
adapter->eth_statsp->params.response.p1inrangelenerrors;
|
|
adapter->benet_stats.rx_bytes =
|
|
adapter->eth_statsp->params.response.p0recvdtotalbytesLSD +
|
|
adapter->eth_statsp->params.response.p1recvdtotalbytesLSD;
|
|
adapter->benet_stats.rx_crc_errors =
|
|
adapter->eth_statsp->params.response.p0crcerrors +
|
|
adapter->eth_statsp->params.response.p1crcerrors;
|
|
|
|
adapter->benet_stats.tx_packets +=
|
|
adapter->eth_statsp->params.response.p0xmitmulticastframes +
|
|
adapter->eth_statsp->params.response.p1xmitmulticastframes;
|
|
adapter->benet_stats.tx_packets +=
|
|
adapter->eth_statsp->params.response.p0xmitbroadcastframes +
|
|
adapter->eth_statsp->params.response.p1xmitbroadcastframes;
|
|
adapter->benet_stats.tx_errors = 0;
|
|
|
|
adapter->benet_stats.multicast =
|
|
adapter->eth_statsp->params.response.p0xmitmulticastframes +
|
|
adapter->eth_statsp->params.response.p1xmitmulticastframes;
|
|
|
|
adapter->benet_stats.rx_fifo_errors =
|
|
adapter->eth_statsp->params.response.p0rxfifooverflowdropped +
|
|
adapter->eth_statsp->params.response.p1rxfifooverflowdropped;
|
|
adapter->benet_stats.rx_frame_errors =
|
|
adapter->eth_statsp->params.response.p0alignmentsymerrs +
|
|
adapter->eth_statsp->params.response.p1alignmentsymerrs;
|
|
adapter->benet_stats.rx_length_errors =
|
|
adapter->eth_statsp->params.response.p0inrangelenerrors +
|
|
adapter->eth_statsp->params.response.p1inrangelenerrors;
|
|
adapter->benet_stats.rx_length_errors +=
|
|
adapter->eth_statsp->params.response.p0outrangeerrors +
|
|
adapter->eth_statsp->params.response.p1outrangeerrors;
|
|
adapter->benet_stats.rx_length_errors +=
|
|
adapter->eth_statsp->params.response.p0frametoolongerrors +
|
|
adapter->eth_statsp->params.response.p1frametoolongerrors;
|
|
|
|
pci_unmap_single(adapter->pdev, (ulong) adapter->eth_statsp,
|
|
sizeof(struct FWCMD_ETH_GET_STATISTICS),
|
|
PCI_DMA_FROMDEVICE);
|
|
return &(adapter->benet_stats);
|
|
|
|
}
|
|
|
|
static void be_start_tx(struct be_net_object *pnob, u32 nposted)
|
|
{
|
|
#define CSR_ETH_MAX_SQPOSTS 255
|
|
struct SQ_DB_AMAP sqdb;
|
|
|
|
sqdb.dw[0] = 0;
|
|
|
|
AMAP_SET_BITS_PTR(SQ_DB, cid, &sqdb, pnob->tx_q_id);
|
|
while (nposted) {
|
|
if (nposted > CSR_ETH_MAX_SQPOSTS) {
|
|
AMAP_SET_BITS_PTR(SQ_DB, numPosted, &sqdb,
|
|
CSR_ETH_MAX_SQPOSTS);
|
|
nposted -= CSR_ETH_MAX_SQPOSTS;
|
|
} else {
|
|
AMAP_SET_BITS_PTR(SQ_DB, numPosted, &sqdb, nposted);
|
|
nposted = 0;
|
|
}
|
|
PD_WRITE(&pnob->fn_obj, etx_sq_db, sqdb.dw[0]);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
static void update_tx_rate(struct be_adapter *adapter)
|
|
{
|
|
/* update the rate once in two seconds */
|
|
if ((jiffies - adapter->eth_tx_jiffies) > 2 * (HZ)) {
|
|
u32 r;
|
|
r = adapter->eth_tx_bytes /
|
|
((jiffies - adapter->eth_tx_jiffies) / (HZ));
|
|
r = (r / 1000000); /* M bytes/s */
|
|
adapter->be_stat.bes_eth_tx_rate = (r * 8); /* M bits/s */
|
|
adapter->eth_tx_jiffies = jiffies;
|
|
adapter->eth_tx_bytes = 0;
|
|
}
|
|
}
|
|
|
|
static int wrb_cnt_in_skb(struct sk_buff *skb)
|
|
{
|
|
int cnt = 0;
|
|
while (skb) {
|
|
if (skb->len > skb->data_len)
|
|
cnt++;
|
|
cnt += skb_shinfo(skb)->nr_frags;
|
|
skb = skb_shinfo(skb)->frag_list;
|
|
}
|
|
BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT);
|
|
return cnt;
|
|
}
|
|
|
|
static void wrb_fill(struct ETH_WRB_AMAP *wrb, u64 addr, int len)
|
|
{
|
|
AMAP_SET_BITS_PTR(ETH_WRB, frag_pa_hi, wrb, addr >> 32);
|
|
AMAP_SET_BITS_PTR(ETH_WRB, frag_pa_lo, wrb, addr & 0xFFFFFFFF);
|
|
AMAP_SET_BITS_PTR(ETH_WRB, frag_len, wrb, len);
|
|
}
|
|
|
|
static void wrb_fill_extra(struct ETH_WRB_AMAP *wrb, struct sk_buff *skb,
|
|
struct be_net_object *pnob)
|
|
{
|
|
wrb->dw[2] = wrb->dw[3] = 0;
|
|
AMAP_SET_BITS_PTR(ETH_WRB, crc, wrb, 1);
|
|
if (skb_shinfo(skb)->gso_segs > 1 && skb_shinfo(skb)->gso_size) {
|
|
AMAP_SET_BITS_PTR(ETH_WRB, lso, wrb, 1);
|
|
AMAP_SET_BITS_PTR(ETH_WRB, lso_mss, wrb,
|
|
skb_shinfo(skb)->gso_size);
|
|
} else if (skb->ip_summed == CHECKSUM_PARTIAL) {
|
|
u8 proto = ((struct iphdr *)ip_hdr(skb))->protocol;
|
|
if (proto == IPPROTO_TCP)
|
|
AMAP_SET_BITS_PTR(ETH_WRB, tcpcs, wrb, 1);
|
|
else if (proto == IPPROTO_UDP)
|
|
AMAP_SET_BITS_PTR(ETH_WRB, udpcs, wrb, 1);
|
|
}
|
|
if (pnob->vlan_grp && vlan_tx_tag_present(skb)) {
|
|
AMAP_SET_BITS_PTR(ETH_WRB, vlan, wrb, 1);
|
|
AMAP_SET_BITS_PTR(ETH_WRB, vlan_tag, wrb, vlan_tx_tag_get(skb));
|
|
}
|
|
}
|
|
|
|
static inline void wrb_copy_extra(struct ETH_WRB_AMAP *to,
|
|
struct ETH_WRB_AMAP *from)
|
|
{
|
|
|
|
to->dw[2] = from->dw[2];
|
|
to->dw[3] = from->dw[3];
|
|
}
|
|
|
|
/* Returns the actual count of wrbs used including a possible dummy */
|
|
static int copy_skb_to_txq(struct be_net_object *pnob, struct sk_buff *skb,
|
|
u32 wrb_cnt, u32 *copied)
|
|
{
|
|
u64 busaddr;
|
|
struct ETH_WRB_AMAP *wrb = NULL, *first = NULL;
|
|
u32 i;
|
|
bool dummy = true;
|
|
struct pci_dev *pdev = pnob->adapter->pdev;
|
|
|
|
if (wrb_cnt & 1)
|
|
wrb_cnt++;
|
|
else
|
|
dummy = false;
|
|
|
|
atomic_add(wrb_cnt, &pnob->tx_q_used);
|
|
|
|
while (skb) {
|
|
if (skb->len > skb->data_len) {
|
|
int len = skb->len - skb->data_len;
|
|
busaddr = pci_map_single(pdev, skb->data, len,
|
|
PCI_DMA_TODEVICE);
|
|
busaddr = cpu_to_le64(busaddr);
|
|
wrb = &pnob->tx_q[pnob->tx_q_hd];
|
|
if (first == NULL) {
|
|
wrb_fill_extra(wrb, skb, pnob);
|
|
first = wrb;
|
|
} else {
|
|
wrb_copy_extra(wrb, first);
|
|
}
|
|
wrb_fill(wrb, busaddr, len);
|
|
be_adv_txq_hd(pnob);
|
|
*copied += len;
|
|
}
|
|
|
|
for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
|
|
struct skb_frag_struct *frag =
|
|
&skb_shinfo(skb)->frags[i];
|
|
busaddr = pci_map_page(pdev, frag->page,
|
|
frag->page_offset, frag->size,
|
|
PCI_DMA_TODEVICE);
|
|
busaddr = cpu_to_le64(busaddr);
|
|
wrb = &pnob->tx_q[pnob->tx_q_hd];
|
|
if (first == NULL) {
|
|
wrb_fill_extra(wrb, skb, pnob);
|
|
first = wrb;
|
|
} else {
|
|
wrb_copy_extra(wrb, first);
|
|
}
|
|
wrb_fill(wrb, busaddr, frag->size);
|
|
be_adv_txq_hd(pnob);
|
|
*copied += frag->size;
|
|
}
|
|
skb = skb_shinfo(skb)->frag_list;
|
|
}
|
|
|
|
if (dummy) {
|
|
wrb = &pnob->tx_q[pnob->tx_q_hd];
|
|
BUG_ON(first == NULL);
|
|
wrb_copy_extra(wrb, first);
|
|
wrb_fill(wrb, 0, 0);
|
|
be_adv_txq_hd(pnob);
|
|
}
|
|
AMAP_SET_BITS_PTR(ETH_WRB, complete, wrb, 1);
|
|
AMAP_SET_BITS_PTR(ETH_WRB, last, wrb, 1);
|
|
return wrb_cnt;
|
|
}
|
|
|
|
/* For each skb transmitted, tx_ctxt stores the num of wrbs in the
|
|
* start index and skb pointer in the end index
|
|
*/
|
|
static inline void be_tx_wrb_info_remember(struct be_net_object *pnob,
|
|
struct sk_buff *skb, int wrb_cnt,
|
|
u32 start)
|
|
{
|
|
*(u32 *) (&pnob->tx_ctxt[start]) = wrb_cnt;
|
|
index_adv(&start, wrb_cnt - 1, pnob->tx_q_len);
|
|
pnob->tx_ctxt[start] = skb;
|
|
}
|
|
|
|
static int benet_xmit(struct sk_buff *skb, struct net_device *netdev)
|
|
{
|
|
struct be_net_object *pnob = netdev_priv(netdev);
|
|
struct be_adapter *adapter = pnob->adapter;
|
|
u32 wrb_cnt, copied = 0;
|
|
u32 start = pnob->tx_q_hd;
|
|
|
|
adapter->be_stat.bes_tx_reqs++;
|
|
|
|
wrb_cnt = wrb_cnt_in_skb(skb);
|
|
spin_lock_bh(&adapter->txq_lock);
|
|
if ((pnob->tx_q_len - 2 - atomic_read(&pnob->tx_q_used)) <= wrb_cnt) {
|
|
netif_stop_queue(pnob->netdev);
|
|
spin_unlock_bh(&adapter->txq_lock);
|
|
adapter->be_stat.bes_tx_fails++;
|
|
return NETDEV_TX_BUSY;
|
|
}
|
|
spin_unlock_bh(&adapter->txq_lock);
|
|
|
|
wrb_cnt = copy_skb_to_txq(pnob, skb, wrb_cnt, &copied);
|
|
be_tx_wrb_info_remember(pnob, skb, wrb_cnt, start);
|
|
|
|
be_start_tx(pnob, wrb_cnt);
|
|
|
|
adapter->eth_tx_bytes += copied;
|
|
adapter->be_stat.bes_tx_wrbs += wrb_cnt;
|
|
update_tx_rate(adapter);
|
|
netdev->trans_start = jiffies;
|
|
|
|
return NETDEV_TX_OK;
|
|
}
|
|
|
|
/*
|
|
* This is the driver entry point to change the mtu of the device
|
|
* Returns 0 for success and errno for failure.
|
|
*/
|
|
static int benet_change_mtu(struct net_device *netdev, int new_mtu)
|
|
{
|
|
/*
|
|
* BE supports jumbo frame size upto 9000 bytes including the link layer
|
|
* header. Considering the different variants of frame formats possible
|
|
* like VLAN, SNAP/LLC, the maximum possible value for MTU is 8974 bytes
|
|
*/
|
|
|
|
if (new_mtu < (ETH_ZLEN + ETH_FCS_LEN) || (new_mtu > BE_MAX_MTU)) {
|
|
dev_info(&netdev->dev, "Invalid MTU requested. "
|
|
"Must be between %d and %d bytes\n",
|
|
(ETH_ZLEN + ETH_FCS_LEN), BE_MAX_MTU);
|
|
return -EINVAL;
|
|
}
|
|
dev_info(&netdev->dev, "MTU changed from %d to %d\n",
|
|
netdev->mtu, new_mtu);
|
|
netdev->mtu = new_mtu;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* This is the driver entry point to register a vlan with the device
|
|
*/
|
|
static void benet_vlan_register(struct net_device *netdev,
|
|
struct vlan_group *grp)
|
|
{
|
|
struct be_net_object *pnob = netdev_priv(netdev);
|
|
|
|
be_disable_eq_intr(pnob);
|
|
pnob->vlan_grp = grp;
|
|
pnob->num_vlans = 0;
|
|
be_enable_eq_intr(pnob);
|
|
}
|
|
|
|
/*
|
|
* This is the driver entry point to add a vlan vlan_id
|
|
* with the device netdev
|
|
*/
|
|
static void benet_vlan_add_vid(struct net_device *netdev, u16 vlan_id)
|
|
{
|
|
struct be_net_object *pnob = netdev_priv(netdev);
|
|
|
|
if (pnob->num_vlans == (BE_NUM_VLAN_SUPPORTED - 1)) {
|
|
/* no way to return an error */
|
|
dev_info(&netdev->dev,
|
|
"BladeEngine: Cannot configure more than %d Vlans\n",
|
|
BE_NUM_VLAN_SUPPORTED);
|
|
return;
|
|
}
|
|
/* The new vlan tag will be in the slot indicated by num_vlans. */
|
|
pnob->vlan_tag[pnob->num_vlans++] = vlan_id;
|
|
be_rxf_vlan_config(&pnob->fn_obj, false, pnob->num_vlans,
|
|
pnob->vlan_tag, NULL, NULL, NULL);
|
|
}
|
|
|
|
/*
|
|
* This is the driver entry point to remove a vlan vlan_id
|
|
* with the device netdev
|
|
*/
|
|
static void benet_vlan_rem_vid(struct net_device *netdev, u16 vlan_id)
|
|
{
|
|
struct be_net_object *pnob = netdev_priv(netdev);
|
|
|
|
u32 i, value;
|
|
|
|
/*
|
|
* In Blade Engine, we support 32 vlan tag filters across both ports.
|
|
* To program a vlan tag, the RXF_RTPR_CSR register is used.
|
|
* Each 32-bit value of RXF_RTDR_CSR can address 2 vlan tag entries.
|
|
* The Vlan table is of depth 16. thus we support 32 tags.
|
|
*/
|
|
|
|
value = vlan_id | VLAN_VALID_BIT;
|
|
for (i = 0; i < BE_NUM_VLAN_SUPPORTED; i++) {
|
|
if (pnob->vlan_tag[i] == vlan_id)
|
|
break;
|
|
}
|
|
|
|
if (i == BE_NUM_VLAN_SUPPORTED)
|
|
return;
|
|
/* Now compact the vlan tag array by removing hole created. */
|
|
while ((i + 1) < BE_NUM_VLAN_SUPPORTED) {
|
|
pnob->vlan_tag[i] = pnob->vlan_tag[i + 1];
|
|
i++;
|
|
}
|
|
if ((i + 1) == BE_NUM_VLAN_SUPPORTED)
|
|
pnob->vlan_tag[i] = (u16) 0x0;
|
|
pnob->num_vlans--;
|
|
be_rxf_vlan_config(&pnob->fn_obj, false, pnob->num_vlans,
|
|
pnob->vlan_tag, NULL, NULL, NULL);
|
|
}
|
|
|
|
/*
|
|
* This function is called to program multicast
|
|
* address in the multicast filter of the ASIC.
|
|
*/
|
|
static void be_set_multicast_filter(struct net_device *netdev)
|
|
{
|
|
struct be_net_object *pnob = netdev_priv(netdev);
|
|
struct dev_mc_list *mc_ptr;
|
|
u8 mac_addr[32][ETH_ALEN];
|
|
int i;
|
|
|
|
if (netdev->flags & IFF_ALLMULTI) {
|
|
/* set BE in Multicast promiscuous */
|
|
be_rxf_multicast_config(&pnob->fn_obj, true, 0, NULL, NULL,
|
|
NULL, NULL);
|
|
return;
|
|
}
|
|
|
|
for (mc_ptr = netdev->mc_list, i = 0; mc_ptr;
|
|
mc_ptr = mc_ptr->next, i++) {
|
|
memcpy(&mac_addr[i][0], mc_ptr->dmi_addr, ETH_ALEN);
|
|
}
|
|
|
|
/* reset the promiscuous mode also. */
|
|
be_rxf_multicast_config(&pnob->fn_obj, false, i,
|
|
&mac_addr[0][0], NULL, NULL, NULL);
|
|
}
|
|
|
|
/*
|
|
* This is the driver entry point to set multicast list
|
|
* with the device netdev. This function will be used to
|
|
* set promiscuous mode or multicast promiscuous mode
|
|
* or multicast mode....
|
|
*/
|
|
static void benet_set_multicast_list(struct net_device *netdev)
|
|
{
|
|
struct be_net_object *pnob = netdev_priv(netdev);
|
|
|
|
if (netdev->flags & IFF_PROMISC) {
|
|
be_rxf_promiscuous(&pnob->fn_obj, 1, 1, NULL, NULL, NULL);
|
|
} else {
|
|
be_rxf_promiscuous(&pnob->fn_obj, 0, 0, NULL, NULL, NULL);
|
|
be_set_multicast_filter(netdev);
|
|
}
|
|
}
|
|
|
|
int benet_init(struct net_device *netdev)
|
|
{
|
|
struct be_net_object *pnob = netdev_priv(netdev);
|
|
struct be_adapter *adapter = pnob->adapter;
|
|
|
|
ether_setup(netdev);
|
|
|
|
netdev->open = &benet_open;
|
|
netdev->stop = &benet_close;
|
|
netdev->hard_start_xmit = &benet_xmit;
|
|
|
|
netdev->get_stats = &benet_get_stats;
|
|
|
|
netdev->set_multicast_list = &benet_set_multicast_list;
|
|
|
|
netdev->change_mtu = &benet_change_mtu;
|
|
netdev->set_mac_address = &benet_set_mac_addr;
|
|
|
|
netdev->vlan_rx_register = benet_vlan_register;
|
|
netdev->vlan_rx_add_vid = benet_vlan_add_vid;
|
|
netdev->vlan_rx_kill_vid = benet_vlan_rem_vid;
|
|
|
|
netdev->features =
|
|
NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_RX | NETIF_F_TSO |
|
|
NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER | NETIF_F_IP_CSUM;
|
|
|
|
netdev->flags |= IFF_MULTICAST;
|
|
|
|
/* If device is DAC Capable, set the HIGHDMA flag for netdevice. */
|
|
if (adapter->dma_64bit_cap)
|
|
netdev->features |= NETIF_F_HIGHDMA;
|
|
|
|
SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);
|
|
return 0;
|
|
}
|