1 files changed, 124 insertions, 190 deletions

diff --git a/drivers/net/s2io.c b/drivers/net/s2io.c
index 18bc5b718bbb..df0d2c8ecc09 100644
--- a/drivers/net/s2io.c
+++ b/drivers/net/s2io.c
@@ -38,8 +38,6 @@
  * Tx descriptors that can be associated with each corresponding FIFO.
  * intr_type: This defines the type of interrupt. The values can be 0(INTA),
  *     2(MSI_X). Default value is '2(MSI_X)'
- * lro: Specifies whether to enable Large Receive Offload (LRO) or not.
- *     Possible values '1' for enable '0' for disable. Default is '0'
  * lro_max_pkts: This parameter defines maximum number of packets can be
  *     aggregated as a single large packet
  * napi: This parameter used to enable/disable NAPI (polling Rx)
@@ -80,6 +78,7 @@
 #include <linux/uaccess.h>
 #include <linux/io.h>
 #include <linux/slab.h>
+#include <linux/prefetch.h>
 #include <net/tcp.h>
 
 #include <asm/system.h>
@@ -90,14 +89,14 @@
 #include "s2io.h"
 #include "s2io-regs.h"
 
-#define DRV_VERSION "2.0.26.26"
+#define DRV_VERSION "2.0.26.28"
 
 /* S2io Driver name & version. */
-static char s2io_driver_name[] = "Neterion";
-static char s2io_driver_version[] = DRV_VERSION;
+static const char s2io_driver_name[] = "Neterion";
+static const char s2io_driver_version[] = DRV_VERSION;
 
-static int rxd_size[2] = {32, 48};
-static int rxd_count[2] = {127, 85};
+static const int rxd_size[2] = {32, 48};
+static const int rxd_count[2] = {127, 85};
 
 static inline int RXD_IS_UP2DT(struct RxD_t *rxdp)
 {
@@ -496,8 +495,6 @@ S2IO_PARM_INT(rxsync_frequency, 3);
 /* Interrupt type. Values can be 0(INTA), 2(MSI_X) */
 S2IO_PARM_INT(intr_type, 2);
 /* Large receive offload feature */
-static unsigned int lro_enable = 1;
-module_param_named(lro, lro_enable, uint, 0);
 
 /* Max pkts to be aggregated by LRO at one time. If not specified,
  * aggregation happens until we hit max IP pkt size(64K)
@@ -2248,13 +2245,12 @@ static int verify_xena_quiescence(struct s2io_nic *sp)
 static void fix_mac_address(struct s2io_nic *sp)
 {
         struct XENA_dev_config __iomem *bar0 = sp->bar0;
-        u64 val64;
         int i = 0;
 
         while (fix_mac[i] != END_SIGN) {
                 writeq(fix_mac[i++], &bar0->gpio_control);
                 udelay(10);
-                val64 = readq(&bar0->gpio_control);
+                (void) readq(&bar0->gpio_control);
         }
 }
 
@@ -2357,7 +2353,7 @@ static int start_nic(struct s2io_nic *nic)
 
         if (s2io_link_fault_indication(nic) == MAC_RMAC_ERR_TIMER) {
                 /*
-                 * Dont see link state interrupts initally on some switches,
+                 * Dont see link state interrupts initially on some switches,
                  * so directly scheduling the link state task here.
                  */
                 schedule_work(&nic->set_link_task);
@@ -2731,7 +2727,6 @@ static void free_rxd_blk(struct s2io_nic *sp, int ring_no, int blk)
         int j;
         struct sk_buff *skb;
         struct RxD_t *rxdp;
-        struct buffAdd *ba;
         struct RxD1 *rxdp1;
         struct RxD3 *rxdp3;
         struct mac_info *mac_control = &sp->mac_control;
@@ -2755,7 +2750,6 @@ static void free_rxd_blk(struct s2io_nic *sp, int ring_no, int blk)
                         memset(rxdp, 0, sizeof(struct RxD1));
                 } else if (sp->rxd_mode == RXD_MODE_3B) {
                         rxdp3 = (struct RxD3 *)rxdp;
-                        ba = &mac_control->rings[ring_no].ba[blk][j];
                         pci_unmap_single(sp->pdev,
                                          (dma_addr_t)rxdp3->Buffer0_ptr,
                                          BUF0_LEN,
@@ -3567,7 +3561,7 @@ static void s2io_reset(struct s2io_nic *sp)
         }
 
         /*
-         * Clear spurious ECC interrupts that would have occured on
+         * Clear spurious ECC interrupts that would have occurred on
          * XFRAME II cards after reset.
          */
         if (sp->device_type == XFRAME_II_DEVICE) {
@@ -3602,10 +3596,12 @@ static int s2io_set_swapper(struct s2io_nic *sp)
         val64 = readq(&bar0->pif_rd_swapper_fb);
         if (val64 != 0x0123456789ABCDEFULL) {
                 int i = 0;
-                u64 value[] = { 0xC30000C3C30000C3ULL,   /* FE=1, SE=1 */
-                                0x8100008181000081ULL,  /* FE=1, SE=0 */
-                                0x4200004242000042ULL,  /* FE=0, SE=1 */
-                                0};                     /* FE=0, SE=0 */
+                static const u64 value[] = {
+                        0xC30000C3C30000C3ULL,  /* FE=1, SE=1 */
+                        0x8100008181000081ULL,  /* FE=1, SE=0 */
+                        0x4200004242000042ULL,  /* FE=0, SE=1 */
+                        0                       /* FE=0, SE=0 */
+                };
 
                 while (i < 4) {
                         writeq(value[i], &bar0->swapper_ctrl);
@@ -3631,10 +3627,12 @@ static int s2io_set_swapper(struct s2io_nic *sp)
 
         if (val64 != valt) {
                 int i = 0;
-                u64 value[] = { 0x00C3C30000C3C300ULL,  /* FE=1, SE=1 */
-                                0x0081810000818100ULL,  /* FE=1, SE=0 */
-                                0x0042420000424200ULL,  /* FE=0, SE=1 */
-                                0};                     /* FE=0, SE=0 */
+                static const u64 value[] = {
+                        0x00C3C30000C3C300ULL,  /* FE=1, SE=1 */
+                        0x0081810000818100ULL,  /* FE=1, SE=0 */
+                        0x0042420000424200ULL,  /* FE=0, SE=1 */
+                        0                       /* FE=0, SE=0 */
+                };
 
                 while (i < 4) {
                         writeq((value[i] | valr), &bar0->swapper_ctrl);
@@ -4065,7 +4063,7 @@ static int s2io_close(struct net_device *dev)
  *  Description :
  *  This function is the Tx entry point of the driver. S2IO NIC supports
  *  certain protocol assist features on Tx side, namely  CSO, S/G, LSO.
- *  NOTE: when device cant queue the pkt,just the trans_start variable will
+ *  NOTE: when device can't queue the pkt,just the trans_start variable will
  *  not be upadted.
  *  Return value:
  *  0 on success & 1 on failure.
@@ -4105,7 +4103,7 @@ static netdev_tx_t s2io_xmit(struct sk_buff *skb, struct net_device *dev)
         }
 
         queue = 0;
-        if (sp->vlgrp && vlan_tx_tag_present(skb))
+        if (vlan_tx_tag_present(skb))
                 vlan_tag = vlan_tx_tag_get(skb);
         if (sp->config.tx_steering_type == TX_DEFAULT_STEERING) {
                 if (skb->protocol == htons(ETH_P_IP)) {
@@ -5124,8 +5122,6 @@ static void s2io_set_multicast(struct net_device *dev)
                 /* Create the new Rx filter list and update the same in H/W. */
                 i = 0;
                 netdev_for_each_mc_addr(ha, dev) {
-                        memcpy(sp->usr_addrs[i].addr, ha->addr,
-                               ETH_ALEN);
                         mac_addr = 0;
                         for (j = 0; j < ETH_ALEN; j++) {
                                 mac_addr |= ha->addr[j];
@@ -5385,7 +5381,7 @@ static int s2io_ethtool_sset(struct net_device *dev,
 {
         struct s2io_nic *sp = netdev_priv(dev);
         if ((info->autoneg == AUTONEG_ENABLE) ||
-            (info->speed != SPEED_10000) ||
+            (ethtool_cmd_speed(info) != SPEED_10000) ||
             (info->duplex != DUPLEX_FULL))
                 return -EINVAL;
         else {
@@ -5419,10 +5415,10 @@ static int s2io_ethtool_gset(struct net_device *dev, struct ethtool_cmd *info)
         info->transceiver = XCVR_EXTERNAL;
 
         if (netif_carrier_ok(sp->dev)) {
-                info->speed = 10000;
+                ethtool_cmd_speed_set(info, SPEED_10000);
                 info->duplex = DUPLEX_FULL;
         } else {
-                info->speed = -1;
+                ethtool_cmd_speed_set(info, -1);
                 info->duplex = -1;
         }
 
@@ -5486,83 +5482,79 @@ static void s2io_ethtool_gregs(struct net_device *dev,
         }
 }
 
-/**
- *  s2io_phy_id  - timer function that alternates adapter LED.
- *  @data : address of the private member of the device structure, which
- *  is a pointer to the s2io_nic structure, provided as an u32.
- * Description: This is actually the timer function that alternates the
- * adapter LED bit of the adapter control bit to set/reset every time on
- * invocation. The timer is set for 1/2 a second, hence tha NIC blinks
- *  once every second.
+/*
+ *  s2io_set_led - control NIC led
  */
-static void s2io_phy_id(unsigned long data)
+static void s2io_set_led(struct s2io_nic *sp, bool on)
 {
-        struct s2io_nic *sp = (struct s2io_nic *)data;
         struct XENA_dev_config __iomem *bar0 = sp->bar0;
-        u64 val64 = 0;
-        u16 subid;
+        u16 subid = sp->pdev->subsystem_device;
+        u64 val64;
 
-        subid = sp->pdev->subsystem_device;
         if ((sp->device_type == XFRAME_II_DEVICE) ||
             ((subid & 0xFF) >= 0x07)) {
                 val64 = readq(&bar0->gpio_control);
-                val64 ^= GPIO_CTRL_GPIO_0;
+                if (on)
+                        val64 |= GPIO_CTRL_GPIO_0;
+                else
+                        val64 &= ~GPIO_CTRL_GPIO_0;
+
                 writeq(val64, &bar0->gpio_control);
         } else {
                 val64 = readq(&bar0->adapter_control);
-                val64 ^= ADAPTER_LED_ON;
+                if (on)
+                        val64 |= ADAPTER_LED_ON;
+                else
+                        val64 &= ~ADAPTER_LED_ON;
+
                 writeq(val64, &bar0->adapter_control);
         }
 
-        mod_timer(&sp->id_timer, jiffies + HZ / 2);
 }
 
 /**
- * s2io_ethtool_idnic - To physically identify the nic on the system.
- * @sp : private member of the device structure, which is a pointer to the
- * s2io_nic structure.
- * @id : pointer to the structure with identification parameters given by
- * ethtool.
+ * s2io_ethtool_set_led - To physically identify the nic on the system.
+ * @dev : network device
+ * @state: led setting
+ *
  * Description: Used to physically identify the NIC on the system.
  * The Link LED will blink for a time specified by the user for
  * identification.
  * NOTE: The Link has to be Up to be able to blink the LED. Hence
  * identification is possible only if it's link is up.
- * Return value:
- * int , returns 0 on success
  */
 
-static int s2io_ethtool_idnic(struct net_device *dev, u32 data)
+static int s2io_ethtool_set_led(struct net_device *dev,
+                                enum ethtool_phys_id_state state)
 {
-        u64 val64 = 0, last_gpio_ctrl_val;
         struct s2io_nic *sp = netdev_priv(dev);
         struct XENA_dev_config __iomem *bar0 = sp->bar0;
-        u16 subid;
+        u16 subid = sp->pdev->subsystem_device;
 
-        subid = sp->pdev->subsystem_device;
-        last_gpio_ctrl_val = readq(&bar0->gpio_control);
         if ((sp->device_type == XFRAME_I_DEVICE) && ((subid & 0xFF) < 0x07)) {
-                val64 = readq(&bar0->adapter_control);
+                u64 val64 = readq(&bar0->adapter_control);
                 if (!(val64 & ADAPTER_CNTL_EN)) {
                         pr_err("Adapter Link down, cannot blink LED\n");
-                        return -EFAULT;
+                        return -EAGAIN;
                 }
         }
-        if (sp->id_timer.function == NULL) {
-                init_timer(&sp->id_timer);
-                sp->id_timer.function = s2io_phy_id;
-                sp->id_timer.data = (unsigned long)sp;
-        }
-        mod_timer(&sp->id_timer, jiffies);
-        if (data)
-                msleep_interruptible(data * HZ);
-        else
-                msleep_interruptible(MAX_FLICKER_TIME);
-        del_timer_sync(&sp->id_timer);
 
-        if (CARDS_WITH_FAULTY_LINK_INDICATORS(sp->device_type, subid)) {
-                writeq(last_gpio_ctrl_val, &bar0->gpio_control);
-                last_gpio_ctrl_val = readq(&bar0->gpio_control);
+        switch (state) {
+        case ETHTOOL_ID_ACTIVE:
+                sp->adapt_ctrl_org = readq(&bar0->gpio_control);
+                return 1;       /* cycle on/off once per second */
+
+        case ETHTOOL_ID_ON:
+                s2io_set_led(sp, true);
+                break;
+
+        case ETHTOOL_ID_OFF:
+                s2io_set_led(sp, false);
+                break;
+
+        case ETHTOOL_ID_INACTIVE:
+                if (CARDS_WITH_FAULTY_LINK_INDICATORS(sp->device_type, subid))
+                        writeq(sp->adapt_ctrl_org, &bar0->gpio_control);
         }
 
         return 0;
@@ -5574,30 +5566,27 @@ static void s2io_ethtool_gringparam(struct net_device *dev,
         struct s2io_nic *sp = netdev_priv(dev);
         int i, tx_desc_count = 0, rx_desc_count = 0;
 
-        if (sp->rxd_mode == RXD_MODE_1)
+        if (sp->rxd_mode == RXD_MODE_1) {
                 ering->rx_max_pending = MAX_RX_DESC_1;
-        else if (sp->rxd_mode == RXD_MODE_3B)
+                ering->rx_jumbo_max_pending = MAX_RX_DESC_1;
+        } else {
                 ering->rx_max_pending = MAX_RX_DESC_2;
+                ering->rx_jumbo_max_pending = MAX_RX_DESC_2;
+        }
 
+        ering->rx_mini_max_pending = 0;
         ering->tx_max_pending = MAX_TX_DESC;
-        for (i = 0 ; i < sp->config.tx_fifo_num ; i++)
-                tx_desc_count += sp->config.tx_cfg[i].fifo_len;
 
-        DBG_PRINT(INFO_DBG, "max txds: %d\n", sp->config.max_txds);
-        ering->tx_pending = tx_desc_count;
-        rx_desc_count = 0;
-        for (i = 0 ; i < sp->config.rx_ring_num ; i++)
+        for (i = 0; i < sp->config.rx_ring_num; i++)
                 rx_desc_count += sp->config.rx_cfg[i].num_rxd;
-
         ering->rx_pending = rx_desc_count;
-
-        ering->rx_mini_max_pending = 0;
-        ering->rx_mini_pending = 0;
-        if (sp->rxd_mode == RXD_MODE_1)
-                ering->rx_jumbo_max_pending = MAX_RX_DESC_1;
-        else if (sp->rxd_mode == RXD_MODE_3B)
-                ering->rx_jumbo_max_pending = MAX_RX_DESC_2;
         ering->rx_jumbo_pending = rx_desc_count;
+        ering->rx_mini_pending = 0;
+
+        for (i = 0; i < sp->config.tx_fifo_num; i++)
+                tx_desc_count += sp->config.tx_cfg[i].fifo_len;
+        ering->tx_pending = tx_desc_count;
+        DBG_PRINT(INFO_DBG, "max txds: %d\n", sp->config.max_txds);
 }
 
 /**
@@ -6630,25 +6619,6 @@ static int s2io_ethtool_get_regs_len(struct net_device *dev)
 }
 
 
-static u32 s2io_ethtool_get_rx_csum(struct net_device *dev)
-{
-        struct s2io_nic *sp = netdev_priv(dev);
-
-        return sp->rx_csum;
-}
-
-static int s2io_ethtool_set_rx_csum(struct net_device *dev, u32 data)
-{
-        struct s2io_nic *sp = netdev_priv(dev);
-
-        if (data)
-                sp->rx_csum = 1;
-        else
-                sp->rx_csum = 0;
-
-        return 0;
-}
-
 static int s2io_get_eeprom_len(struct net_device *dev)
 {
         return XENA_EEPROM_SPACE;
@@ -6700,65 +6670,27 @@ static void s2io_ethtool_get_strings(struct net_device *dev,
         }
 }
 
-static int s2io_ethtool_op_set_tx_csum(struct net_device *dev, u32 data)
-{
-        if (data)
-                dev->features |= NETIF_F_IP_CSUM;
-        else
-                dev->features &= ~NETIF_F_IP_CSUM;
-
-        return 0;
-}
-
-static u32 s2io_ethtool_op_get_tso(struct net_device *dev)
-{
-        return (dev->features & NETIF_F_TSO) != 0;
-}
-
-static int s2io_ethtool_op_set_tso(struct net_device *dev, u32 data)
-{
-        if (data)
-                dev->features |= (NETIF_F_TSO | NETIF_F_TSO6);
-        else
-                dev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6);
-
-        return 0;
-}
-
-static int s2io_ethtool_set_flags(struct net_device *dev, u32 data)
+static int s2io_set_features(struct net_device *dev, u32 features)
 {
         struct s2io_nic *sp = netdev_priv(dev);
-        int rc = 0;
-        int changed = 0;
-
-        if (data & ~ETH_FLAG_LRO)
-                return -EINVAL;
-
-        if (data & ETH_FLAG_LRO) {
-                if (lro_enable) {
-                        if (!(dev->features & NETIF_F_LRO)) {
-                                dev->features |= NETIF_F_LRO;
-                                changed = 1;
-                        }
-                } else
-                        rc = -EINVAL;
-        } else if (dev->features & NETIF_F_LRO) {
-                dev->features &= ~NETIF_F_LRO;
-                changed = 1;
-        }
+        u32 changed = (features ^ dev->features) & NETIF_F_LRO;
 
         if (changed && netif_running(dev)) {
+                int rc;
+
                 s2io_stop_all_tx_queue(sp);
                 s2io_card_down(sp);
-                sp->lro = !!(dev->features & NETIF_F_LRO);
+                dev->features = features;
                 rc = s2io_card_up(sp);
                 if (rc)
                         s2io_reset(sp);
                 else
                         s2io_start_all_tx_queue(sp);
+
+                return rc ? rc : 1;
         }
 
-        return rc;
+        return 0;
 }
 
 static const struct ethtool_ops netdev_ethtool_ops = {
@@ -6774,18 +6706,9 @@ static const struct ethtool_ops netdev_ethtool_ops = {
         .get_ringparam = s2io_ethtool_gringparam,
         .get_pauseparam = s2io_ethtool_getpause_data,
         .set_pauseparam = s2io_ethtool_setpause_data,
-        .get_rx_csum = s2io_ethtool_get_rx_csum,
-        .set_rx_csum = s2io_ethtool_set_rx_csum,
-        .set_tx_csum = s2io_ethtool_op_set_tx_csum,
-        .set_flags = s2io_ethtool_set_flags,
-        .get_flags = ethtool_op_get_flags,
-        .set_sg = ethtool_op_set_sg,
-        .get_tso = s2io_ethtool_op_get_tso,
-        .set_tso = s2io_ethtool_op_set_tso,
-        .set_ufo = ethtool_op_set_ufo,
         .self_test = s2io_ethtool_test,
         .get_strings = s2io_ethtool_get_strings,
-        .phys_id = s2io_ethtool_idnic,
+        .set_phys_id = s2io_ethtool_set_led,
         .get_ethtool_stats = s2io_get_ethtool_stats,
         .get_sset_count = s2io_get_sset_count,
 };
@@ -7240,7 +7163,7 @@ static void do_s2io_card_down(struct s2io_nic *sp, int do_io)
                 /* As per the HW requirement we need to replenish the
                  * receive buffer to avoid the ring bump. Since there is
                  * no intention of processing the Rx frame at this pointwe are
-                 * just settting the ownership bit of rxd in Each Rx
+                 * just setting the ownership bit of rxd in Each Rx
                  * ring to HW and set the appropriate buffer size
                  * based on the ring mode
                  */
@@ -7307,7 +7230,7 @@ static int s2io_card_up(struct s2io_nic *sp)
                 struct ring_info *ring = &mac_control->rings[i];
 
                 ring->mtu = dev->mtu;
-                ring->lro = sp->lro;
+                ring->lro = !!(dev->features & NETIF_F_LRO);
                 ret = fill_rx_buffers(sp, ring, 1);
                 if (ret) {
                         DBG_PRINT(ERR_DBG, "%s: Out of memory in Open\n",
@@ -7341,7 +7264,7 @@ static int s2io_card_up(struct s2io_nic *sp)
         /* Setting its receive mode */
         s2io_set_multicast(dev);
 
-        if (sp->lro) {
+        if (dev->features & NETIF_F_LRO) {
                 /* Initialize max aggregatable pkts per session based on MTU */
                 sp->lro_max_aggr_per_sess = ((1<<16) - 1) / dev->mtu;
                 /* Check if we can use (if specified) user provided value */
@@ -7554,7 +7477,7 @@ static int rx_osm_handler(struct ring_info *ring_data, struct RxD_t * rxdp)
         if ((rxdp->Control_1 & TCP_OR_UDP_FRAME) &&
             ((!ring_data->lro) ||
              (ring_data->lro && (!(rxdp->Control_1 & RXD_FRAME_IP_FRAG)))) &&
-            (sp->rx_csum)) {
+            (dev->features & NETIF_F_RXCSUM)) {
                 l3_csum = RXD_GET_L3_CKSUM(rxdp->Control_1);
                 l4_csum = RXD_GET_L4_CKSUM(rxdp->Control_1);
                 if ((l3_csum == L3_CKSUM_OK) && (l4_csum == L4_CKSUM_OK)) {
@@ -7565,7 +7488,7 @@ static int rx_osm_handler(struct ring_info *ring_data, struct RxD_t * rxdp)
                          */
                         skb->ip_summed = CHECKSUM_UNNECESSARY;
                         if (ring_data->lro) {
-                                u32 tcp_len;
+                                u32 tcp_len = 0;
                                 u8 *tcp;
                                 int ret = 0;
 
@@ -7613,10 +7536,10 @@ static int rx_osm_handler(struct ring_info *ring_data, struct RxD_t * rxdp)
                          * Packet with erroneous checksum, let the
                          * upper layers deal with it.
                          */
-                        skb->ip_summed = CHECKSUM_NONE;
+                        skb_checksum_none_assert(skb);
                 }
         } else
-                skb->ip_summed = CHECKSUM_NONE;
+                skb_checksum_none_assert(skb);
 
         swstats->mem_freed += skb->truesize;
 send_up:
@@ -7702,6 +7625,8 @@ static void s2io_init_pci(struct s2io_nic *sp)
 static int s2io_verify_parm(struct pci_dev *pdev, u8 *dev_intr_type,
                             u8 *dev_multiq)
 {
+        int i;
+
         if ((tx_fifo_num > MAX_TX_FIFOS) || (tx_fifo_num < 1)) {
                 DBG_PRINT(ERR_DBG, "Requested number of tx fifos "
                           "(%d) not supported\n", tx_fifo_num);
@@ -7760,6 +7685,15 @@ static int s2io_verify_parm(struct pci_dev *pdev, u8 *dev_intr_type,
                 DBG_PRINT(ERR_DBG, "Defaulting to 1-buffer mode\n");
                 rx_ring_mode = 1;
         }
+
+        for (i = 0; i < MAX_RX_RINGS; i++)
+                if (rx_ring_sz[i] > MAX_RX_BLOCKS_PER_RING) {
+                        DBG_PRINT(ERR_DBG, "Requested rx ring size not "
+                                  "supported\nDefaulting to %d\n",
+                                  MAX_RX_BLOCKS_PER_RING);
+                        rx_ring_sz[i] = MAX_RX_BLOCKS_PER_RING;
+                }
+
         return SUCCESS;
 }
 
@@ -7804,6 +7738,7 @@ static const struct net_device_ops s2io_netdev_ops = {
         .ndo_do_ioctl           = s2io_ioctl,
         .ndo_set_mac_address    = s2io_set_mac_addr,
         .ndo_change_mtu         = s2io_change_mtu,
+        .ndo_set_features       = s2io_set_features,
         .ndo_vlan_rx_register   = s2io_vlan_rx_register,
         .ndo_vlan_rx_kill_vid   = s2io_vlan_rx_kill_vid,
         .ndo_tx_timeout         = s2io_tx_watchdog,
@@ -7911,7 +7846,6 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
         else
                 sp->device_type = XFRAME_I_DEVICE;
 
-        sp->lro = lro_enable;
 
         /* Initialize some PCI/PCI-X fields of the NIC. */
         s2io_init_pci(sp);
@@ -8046,18 +7980,18 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
         /*  Driver entry points */
         dev->netdev_ops = &s2io_netdev_ops;
         SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
-        dev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
-        if (lro_enable)
-                dev->features |= NETIF_F_LRO;
-        dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
+        dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM |
+                NETIF_F_TSO | NETIF_F_TSO6 |
+                NETIF_F_RXCSUM | NETIF_F_LRO;
+        dev->features |= dev->hw_features |
+                NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
+        if (sp->device_type & XFRAME_II_DEVICE) {
+                dev->hw_features |= NETIF_F_UFO;
+                if (ufo)
+                        dev->features |= NETIF_F_UFO;
+        }
         if (sp->high_dma_flag == true)
                 dev->features |= NETIF_F_HIGHDMA;
-        dev->features |= NETIF_F_TSO;
-        dev->features |= NETIF_F_TSO6;
-        if ((sp->device_type & XFRAME_II_DEVICE) && (ufo))  {
-                dev->features |= NETIF_F_UFO;
-                dev->features |= NETIF_F_HW_CSUM;
-        }
         dev->watchdog_timeo = WATCH_DOG_TIMEOUT;
         INIT_WORK(&sp->rst_timer_task, s2io_restart_nic);
         INIT_WORK(&sp->set_link_task, s2io_set_link);
@@ -8283,9 +8217,8 @@ s2io_init_nic(struct pci_dev *pdev, const struct pci_device_id *pre)
                           dev->name);
         }
 
-        if (sp->lro)
-                DBG_PRINT(ERR_DBG, "%s: Large receive offload enabled\n",
-                          dev->name);
+        DBG_PRINT(ERR_DBG, "%s: Large receive offload enabled\n",
+                  dev->name);
         if (ufo)
                 DBG_PRINT(ERR_DBG,
                           "%s: UDP Fragmentation Offload(UFO) enabled\n",
@@ -8334,8 +8267,7 @@ mem_alloc_failed:
 
 static void __devexit s2io_rem_nic(struct pci_dev *pdev)
 {
-        struct net_device *dev =
-                (struct net_device *)pci_get_drvdata(pdev);
+        struct net_device *dev = pci_get_drvdata(pdev);
         struct s2io_nic *sp;
 
         if (dev == NULL) {
@@ -8343,9 +8275,11 @@ static void __devexit s2io_rem_nic(struct pci_dev *pdev)
                 return;
         }
 
-        flush_scheduled_work();
-
         sp = netdev_priv(dev);
+
+        cancel_work_sync(&sp->rst_timer_task);
+        cancel_work_sync(&sp->set_link_task);
+
         unregister_netdev(dev);
 
         free_shared_mem(sp);