1 files changed, 259 insertions, 84 deletions

diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c
index 073b6d354915..fc6ca1da8b98 100644
--- a/drivers/s390/net/qeth_l3_main.c
+++ b/drivers/s390/net/qeth_l3_main.c
@@ -22,6 +22,7 @@
 #include <linux/ipv6.h>
 #include <linux/inetdevice.h>
 #include <linux/igmp.h>
+#include <linux/slab.h>
 
 #include <net/ip.h>
 #include <net/arp.h>
@@ -41,6 +42,32 @@ static int qeth_l3_deregister_addr_entry(struct qeth_card *,
 static int __qeth_l3_set_online(struct ccwgroup_device *, int);
 static int __qeth_l3_set_offline(struct ccwgroup_device *, int);
 
+int qeth_l3_set_large_send(struct qeth_card *card,
+                enum qeth_large_send_types type)
+{
+        int rc = 0;
+
+        card->options.large_send = type;
+        if (card->dev == NULL)
+                return 0;
+
+        if (card->options.large_send == QETH_LARGE_SEND_TSO) {
+                if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
+                        card->dev->features |= NETIF_F_TSO | NETIF_F_SG |
+                                        NETIF_F_HW_CSUM;
+                } else {
+                        card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
+                                        NETIF_F_HW_CSUM);
+                        card->options.large_send = QETH_LARGE_SEND_NO;
+                        rc = -EOPNOTSUPP;
+                }
+        } else {
+                card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
+                                        NETIF_F_HW_CSUM);
+                card->options.large_send = QETH_LARGE_SEND_NO;
+        }
+        return rc;
+}
 
 static int qeth_l3_isxdigit(char *buf)
 {
@@ -216,6 +243,8 @@ static int __qeth_l3_insert_ip_todo(struct qeth_card *card,
         struct qeth_ipaddr *tmp, *t;
         int found = 0;
 
+        if (card->options.sniffer)
+                return 0;
         list_for_each_entry_safe(tmp, t, card->ip_tbd_list, entry) {
                 if ((addr->type == QETH_IP_TYPE_DEL_ALL_MC) &&
                     (tmp->type == QETH_IP_TYPE_DEL_ALL_MC))
@@ -431,6 +460,8 @@ static void qeth_l3_set_ip_addr_list(struct qeth_card *card)
         QETH_DBF_TEXT(TRACE, 2, "sdiplist");
         QETH_DBF_HEX(TRACE, 2, &card, sizeof(void *));
 
+        if (card->options.sniffer)
+                return;
         spin_lock_irqsave(&card->ip_lock, flags);
         tbd_list = card->ip_tbd_list;
         card->ip_tbd_list = kmalloc(sizeof(struct list_head), GFP_ATOMIC);
@@ -469,7 +500,7 @@ static void qeth_l3_set_ip_addr_list(struct qeth_card *card)
                         spin_unlock_irqrestore(&card->ip_lock, flags);
                         rc = qeth_l3_deregister_addr_entry(card, addr);
                         spin_lock_irqsave(&card->ip_lock, flags);
-                        if (!rc || (rc == IPA_RC_PRIMARY_ALREADY_DEFINED))
+                        if (!rc || (rc == IPA_RC_IP_ADDRESS_NOT_DEFINED))
                                 kfree(addr);
                         else
                                 list_add_tail(&addr->entry, &card->ip_list);
@@ -487,6 +518,8 @@ static void qeth_l3_clear_ip_list(struct qeth_card *card, int clean,
         unsigned long flags;
 
         QETH_DBF_TEXT(TRACE, 4, "clearip");
+        if (recover && card->options.sniffer)
+                return;
         spin_lock_irqsave(&card->ip_lock, flags);
         /* clear todo list */
         list_for_each_entry_safe(addr, tmp, card->ip_tbd_list, entry) {
@@ -1439,6 +1472,35 @@ static int qeth_l3_send_checksum_command(struct qeth_card *card)
         return 0;
 }
 
+int qeth_l3_set_rx_csum(struct qeth_card *card,
+        enum qeth_checksum_types csum_type)
+{
+        int rc = 0;
+
+        if (card->options.checksum_type == HW_CHECKSUMMING) {
+                if ((csum_type != HW_CHECKSUMMING) &&
+                        (card->state != CARD_STATE_DOWN)) {
+                        rc = qeth_l3_send_simple_setassparms(card,
+                                IPA_INBOUND_CHECKSUM, IPA_CMD_ASS_STOP, 0);
+                        if (rc)
+                                return -EIO;
+                }
+        } else {
+                if (csum_type == HW_CHECKSUMMING) {
+                        if (card->state != CARD_STATE_DOWN) {
+                                if (!qeth_is_supported(card,
+                                    IPA_INBOUND_CHECKSUM))
+                                        return -EPERM;
+                                rc = qeth_l3_send_checksum_command(card);
+                                if (rc)
+                                        return -EIO;
+                        }
+                }
+        }
+        card->options.checksum_type = csum_type;
+        return rc;
+}
+
 static int qeth_l3_start_ipa_checksum(struct qeth_card *card)
 {
         int rc = 0;
@@ -1506,6 +1568,8 @@ static int qeth_l3_start_ipa_tso(struct qeth_card *card)
 static int qeth_l3_start_ipassists(struct qeth_card *card)
 {
         QETH_DBF_TEXT(TRACE, 3, "strtipas");
+
+        qeth_set_access_ctrl_online(card);      /* go on*/
         qeth_l3_start_ipa_arp_processing(card); /* go on*/
         qeth_l3_start_ipa_ip_fragmentation(card);       /* go on*/
         qeth_l3_start_ipa_source_mac(card);     /* go on*/
@@ -1617,6 +1681,80 @@ static int qeth_l3_get_unique_id(struct qeth_card *card)
         return rc;
 }
 
+static int
+qeth_diags_trace_cb(struct qeth_card *card, struct qeth_reply *reply,
+                            unsigned long data)
+{
+        struct qeth_ipa_cmd        *cmd;
+        __u16 rc;
+
+        QETH_DBF_TEXT(SETUP, 2, "diastrcb");
+
+        cmd = (struct qeth_ipa_cmd *)data;
+        rc = cmd->hdr.return_code;
+        if (rc)
+                QETH_DBF_TEXT_(TRACE, 2, "dxter%x", rc);
+        switch (cmd->data.diagass.action) {
+        case QETH_DIAGS_CMD_TRACE_QUERY:
+                break;
+        case QETH_DIAGS_CMD_TRACE_DISABLE:
+                switch (rc) {
+                case 0:
+                case IPA_RC_INVALID_SUBCMD:
+                        card->info.promisc_mode = SET_PROMISC_MODE_OFF;
+                        dev_info(&card->gdev->dev, "The HiperSockets network "
+                                "traffic analyzer is deactivated\n");
+                        break;
+                default:
+                        break;
+                }
+                break;
+        case QETH_DIAGS_CMD_TRACE_ENABLE:
+                switch (rc) {
+                case 0:
+                        card->info.promisc_mode = SET_PROMISC_MODE_ON;
+                        dev_info(&card->gdev->dev, "The HiperSockets network "
+                                "traffic analyzer is activated\n");
+                        break;
+                case IPA_RC_HARDWARE_AUTH_ERROR:
+                        dev_warn(&card->gdev->dev, "The device is not "
+                                "authorized to run as a HiperSockets network "
+                                "traffic analyzer\n");
+                        break;
+                case IPA_RC_TRACE_ALREADY_ACTIVE:
+                        dev_warn(&card->gdev->dev, "A HiperSockets "
+                                "network traffic analyzer is already "
+                                "active in the HiperSockets LAN\n");
+                        break;
+                default:
+                        break;
+                }
+                break;
+        default:
+                QETH_DBF_MESSAGE(2, "Unknown sniffer action (0x%04x) on %s\n",
+                        cmd->data.diagass.action, QETH_CARD_IFNAME(card));
+        }
+
+        return 0;
+}
+
+static int
+qeth_diags_trace(struct qeth_card *card, enum qeth_diags_trace_cmds diags_cmd)
+{
+        struct qeth_cmd_buffer *iob;
+        struct qeth_ipa_cmd    *cmd;
+
+        QETH_DBF_TEXT(SETUP, 2, "diagtrac");
+
+        iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SET_DIAG_ASS, 0);
+        cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
+        cmd->data.diagass.subcmd_len = 16;
+        cmd->data.diagass.subcmd = QETH_DIAGS_CMD_TRACE;
+        cmd->data.diagass.type = QETH_DIAGS_TYPE_HIPERSOCKET;
+        cmd->data.diagass.action = diags_cmd;
+        return qeth_send_ipa_cmd(card, iob, qeth_diags_trace_cb, NULL);
+}
+
 static void qeth_l3_get_mac_for_ipm(__u32 ipm, char *mac,
                                 struct net_device *dev)
 {
@@ -1894,7 +2032,10 @@ static inline __u16 qeth_l3_rebuild_skb(struct qeth_card *card,
                 case QETH_CAST_ANYCAST:
                 case QETH_CAST_NOCAST:
                 default:
-                        skb->pkt_type = PACKET_HOST;
+                        if (card->options.sniffer)
+                                skb->pkt_type = PACKET_OTHERHOST;
+                        else
+                                skb->pkt_type = PACKET_HOST;
                         memcpy(tg_addr, card->dev->dev_addr,
                                 card->dev->addr_len);
                 }
@@ -1950,7 +2091,6 @@ static void qeth_l3_process_inbound_buffer(struct qeth_card *card,
         int offset;
         __u16 vlan_tag = 0;
         unsigned int len;
-
         /* get first element of current buffer */
         element = (struct qdio_buffer_element *)&buf->buffer->element[0];
         offset = 0;
@@ -1969,7 +2109,7 @@ static void qeth_l3_process_inbound_buffer(struct qeth_card *card,
                 case QETH_HEADER_TYPE_LAYER3:
                         vlan_tag = qeth_l3_rebuild_skb(card, skb, hdr);
                         len = skb->len;
-                        if (vlan_tag)
+                        if (vlan_tag && !card->options.sniffer)
                                 if (card->vlangrp)
                                         vlan_hwaccel_rx(skb, card->vlangrp,
                                                 vlan_tag);
@@ -1980,6 +2120,16 @@ static void qeth_l3_process_inbound_buffer(struct qeth_card *card,
                         else
                                 netif_rx(skb);
                         break;
+                case QETH_HEADER_TYPE_LAYER2: /* for HiperSockets sniffer */
+                        skb->pkt_type = PACKET_HOST;
+                        skb->protocol = eth_type_trans(skb, skb->dev);
+                        if (card->options.checksum_type == NO_CHECKSUMMING)
+                                skb->ip_summed = CHECKSUM_UNNECESSARY;
+                        else
+                                skb->ip_summed = CHECKSUM_NONE;
+                        len = skb->len;
+                        netif_receive_skb(skb);
+                        break;
                 default:
                         dev_kfree_skb_any(skb);
                         QETH_DBF_TEXT(TRACE, 3, "inbunkno");
@@ -2061,17 +2211,18 @@ static int qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
         QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
 
         qeth_set_allowed_threads(card, 0, 1);
+        if (card->options.sniffer &&
+            (card->info.promisc_mode == SET_PROMISC_MODE_ON))
+                qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
         if (card->read.state == CH_STATE_UP &&
             card->write.state == CH_STATE_UP &&
             (card->state == CARD_STATE_UP)) {
                 if (recovery_mode)
                         qeth_l3_stop(card->dev);
                 else {
-                        if (card->dev) {
-                                rtnl_lock();
-                                dev_close(card->dev);
-                                rtnl_unlock();
-                        }
+                        rtnl_lock();
+                        dev_close(card->dev);
+                        rtnl_unlock();
                 }
                 if (!card->use_hard_stop) {
                         rc = qeth_send_stoplan(card);
@@ -2105,6 +2256,36 @@ static int qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
         return rc;
 }
 
+/*
+ * test for and Switch promiscuous mode (on or off)
+ *  either for guestlan or HiperSocket Sniffer
+ */
+static void
+qeth_l3_handle_promisc_mode(struct qeth_card *card)
+{
+        struct net_device *dev = card->dev;
+
+        if (((dev->flags & IFF_PROMISC) &&
+             (card->info.promisc_mode == SET_PROMISC_MODE_ON)) ||
+            (!(dev->flags & IFF_PROMISC) &&
+             (card->info.promisc_mode == SET_PROMISC_MODE_OFF)))
+                return;
+
+        if (card->info.guestlan) {              /* Guestlan trace */
+                if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
+                        qeth_setadp_promisc_mode(card);
+        } else if (card->options.sniffer &&     /* HiperSockets trace */
+                   qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) {
+                if (dev->flags & IFF_PROMISC) {
+                        QETH_DBF_TEXT(TRACE, 3, "+promisc");
+                        qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE);
+                } else {
+                        QETH_DBF_TEXT(TRACE, 3, "-promisc");
+                        qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
+                }
+        }
+}
+
 static void qeth_l3_set_multicast_list(struct net_device *dev)
 {
         struct qeth_card *card = dev->ml_priv;
@@ -2113,15 +2294,17 @@ static void qeth_l3_set_multicast_list(struct net_device *dev)
         if (qeth_threads_running(card, QETH_RECOVER_THREAD) &&
             (card->state != CARD_STATE_UP))
                 return;
-        qeth_l3_delete_mc_addresses(card);
-        qeth_l3_add_multicast_ipv4(card);
+        if (!card->options.sniffer) {
+                qeth_l3_delete_mc_addresses(card);
+                qeth_l3_add_multicast_ipv4(card);
 #ifdef CONFIG_QETH_IPV6
-        qeth_l3_add_multicast_ipv6(card);
+                qeth_l3_add_multicast_ipv6(card);
 #endif
-        qeth_l3_set_ip_addr_list(card);
-        if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
-                return;
-        qeth_setadp_promisc_mode(card);
+                qeth_l3_set_ip_addr_list(card);
+                if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
+                        return;
+        }
+        qeth_l3_handle_promisc_mode(card);
 }
 
 static const char *qeth_l3_arp_get_error_cause(int *rc)
@@ -2684,6 +2867,24 @@ static void qeth_tx_csum(struct sk_buff *skb)
         *(__sum16 *)(skb->data + offset) = csum_fold(csum);
 }
 
+static inline int qeth_l3_tso_elements(struct sk_buff *skb)
+{
+        unsigned long tcpd = (unsigned long)tcp_hdr(skb) +
+                tcp_hdr(skb)->doff * 4;
+        int tcpd_len = skb->len - (tcpd - (unsigned long)skb->data);
+        int elements = PFN_UP(tcpd + tcpd_len) - PFN_DOWN(tcpd);
+        elements += skb_shinfo(skb)->nr_frags;
+        return elements;
+}
+
+static inline int qeth_l3_tso_check(struct sk_buff *skb)
+{
+        int len = ((unsigned long)tcp_hdr(skb) + tcp_hdr(skb)->doff * 4) -
+                (unsigned long)skb->data;
+        return (((unsigned long)skb->data & PAGE_MASK) !=
+                (((unsigned long)skb->data + len) & PAGE_MASK));
+}
+
 static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
         int rc;
@@ -2702,9 +2903,8 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
         int data_offset = -1;
         int nr_frags;
 
-        if ((card->info.type == QETH_CARD_TYPE_IQD) &&
-            (skb->protocol != htons(ETH_P_IPV6)) &&
-            (skb->protocol != htons(ETH_P_IP)))
+        if (((card->info.type == QETH_CARD_TYPE_IQD) && (!ipv)) ||
+             card->options.sniffer)
                         goto tx_drop;
 
         if ((card->state != CARD_STATE_UP) || !card->lan_online) {
@@ -2750,14 +2950,14 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 if (data_offset < 0)
                         skb_pull(new_skb, ETH_HLEN);
         } else {
-                if (new_skb->protocol == htons(ETH_P_IP)) {
+                if (ipv == 4) {
                         if (card->dev->type == ARPHRD_IEEE802_TR)
                                 skb_pull(new_skb, TR_HLEN);
                         else
                                 skb_pull(new_skb, ETH_HLEN);
                 }
 
-                if (new_skb->protocol == ETH_P_IPV6 && card->vlangrp &&
+                if (ipv == 6 && card->vlangrp &&
                                 vlan_tx_tag_present(new_skb)) {
                         skb_push(new_skb, VLAN_HLEN);
                         skb_copy_to_linear_data(new_skb, new_skb->data + 4, 4);
@@ -2777,16 +2977,21 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
         /* fix hardware limitation: as long as we do not have sbal
          * chaining we can not send long frag lists
          */
-        if ((large_send == QETH_LARGE_SEND_TSO) &&
-            ((skb_shinfo(new_skb)->nr_frags + 2) > 16)) {
-                if (skb_linearize(new_skb))
-                        goto tx_drop;
+        if (large_send == QETH_LARGE_SEND_TSO) {
+                if (qeth_l3_tso_elements(new_skb) + 1 > 16) {
+                        if (skb_linearize(new_skb))
+                                goto tx_drop;
+                        if (card->options.performance_stats)
+                                card->perf_stats.tx_lin++;
+                }
         }
 
         if ((large_send == QETH_LARGE_SEND_TSO) &&
             (cast_type == RTN_UNSPEC)) {
                 hdr = (struct qeth_hdr *)skb_push(new_skb,
                                                 sizeof(struct qeth_hdr_tso));
+                if (qeth_l3_tso_check(new_skb))
+                        QETH_DBF_MESSAGE(2, "tso skb misaligned\n");
                 memset(hdr, 0, sizeof(struct qeth_hdr_tso));
                 qeth_l3_fill_header(card, hdr, new_skb, ipv, cast_type);
                 qeth_tso_fill_header(card, hdr, new_skb);
@@ -2903,46 +3108,28 @@ static u32 qeth_l3_ethtool_get_rx_csum(struct net_device *dev)
 static int qeth_l3_ethtool_set_rx_csum(struct net_device *dev, u32 data)
 {
         struct qeth_card *card = dev->ml_priv;
-        enum qeth_card_states old_state;
         enum qeth_checksum_types csum_type;
 
-        if ((card->state != CARD_STATE_UP) &&
-            (card->state != CARD_STATE_DOWN))
-                return -EPERM;
-
         if (data)
                 csum_type = HW_CHECKSUMMING;
         else
                 csum_type = SW_CHECKSUMMING;
 
-        if (card->options.checksum_type != csum_type) {
-                old_state = card->state;
-                if (card->state == CARD_STATE_UP)
-                        __qeth_l3_set_offline(card->gdev, 1);
-                card->options.checksum_type = csum_type;
-                if (old_state == CARD_STATE_UP)
-                        __qeth_l3_set_online(card->gdev, 1);
-        }
-        return 0;
+        return qeth_l3_set_rx_csum(card, csum_type);
 }
 
 static int qeth_l3_ethtool_set_tso(struct net_device *dev, u32 data)
 {
         struct qeth_card *card = dev->ml_priv;
+        int rc = 0;
 
         if (data) {
-                if (card->options.large_send == QETH_LARGE_SEND_NO) {
-                        if (card->info.type == QETH_CARD_TYPE_IQD)
-                                return -EPERM;
-                        else
-                                card->options.large_send = QETH_LARGE_SEND_TSO;
-                        dev->features |= NETIF_F_TSO;
-                }
+                rc = qeth_l3_set_large_send(card, QETH_LARGE_SEND_TSO);
         } else {
                 dev->features &= ~NETIF_F_TSO;
                 card->options.large_send = QETH_LARGE_SEND_NO;
         }
-        return 0;
+        return rc;
 }
 
 static const struct ethtool_ops qeth_l3_ethtool_ops = {
@@ -2957,7 +3144,7 @@ static const struct ethtool_ops qeth_l3_ethtool_ops = {
         .set_tso     = qeth_l3_ethtool_set_tso,
         .get_strings = qeth_core_get_strings,
         .get_ethtool_stats = qeth_core_get_ethtool_stats,
-        .get_stats_count = qeth_core_get_stats_count,
+        .get_sset_count = qeth_core_get_sset_count,
         .get_drvinfo = qeth_core_get_drvinfo,
         .get_settings = qeth_core_ethtool_get_settings,
 };
@@ -3058,6 +3245,7 @@ static int qeth_l3_setup_netdev(struct qeth_card *card)
                                 NETIF_F_HW_VLAN_RX |
                                 NETIF_F_HW_VLAN_FILTER;
         card->dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
+        card->dev->gso_max_size = 15 * PAGE_SIZE;
 
         SET_NETDEV_DEV(card->dev, &card->gdev->dev);
         return register_netdev(card->dev);
@@ -3092,7 +3280,7 @@ static void qeth_l3_qdio_input_handler(struct ccw_device *ccwdev,
                 index = i % QDIO_MAX_BUFFERS_PER_Q;
                 buffer = &card->qdio.in_q->bufs[index];
                 if (!(qdio_err &&
-                      qeth_check_qdio_errors(buffer->buffer,
+                      qeth_check_qdio_errors(card, buffer->buffer,
                                              qdio_err, "qinerr")))
                         qeth_l3_process_inbound_buffer(card, buffer, index);
                 /* clear buffer and give back to hardware */
@@ -3151,35 +3339,20 @@ static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
         QETH_DBF_TEXT(SETUP, 2, "setonlin");
         QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
 
-        qeth_set_allowed_threads(card, QETH_RECOVER_THREAD, 1);
-
         recover_flag = card->state;
-        rc = ccw_device_set_online(CARD_RDEV(card));
-        if (rc) {
-                QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
-                return -EIO;
-        }
-        rc = ccw_device_set_online(CARD_WDEV(card));
-        if (rc) {
-                QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
-                return -EIO;
-        }
-        rc = ccw_device_set_online(CARD_DDEV(card));
-        if (rc) {
-                QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
-                return -EIO;
-        }
-
         rc = qeth_core_hardsetup_card(card);
         if (rc) {
                 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
+                rc = -ENODEV;
                 goto out_remove;
         }
 
         qeth_l3_query_ipassists(card, QETH_PROT_IPV4);
 
-        if (!card->dev && qeth_l3_setup_netdev(card))
+        if (!card->dev && qeth_l3_setup_netdev(card)) {
+                rc = -ENODEV;
                 goto out_remove;
+        }
 
         card->state = CARD_STATE_HARDSETUP;
         qeth_print_status_message(card);
@@ -3196,28 +3369,32 @@ static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
                         card->lan_online = 0;
                         return 0;
                 }
+                rc = -ENODEV;
                 goto out_remove;
         } else
                 card->lan_online = 1;
-        qeth_set_large_send(card, card->options.large_send);
 
         rc = qeth_l3_setadapter_parms(card);
         if (rc)
                 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
-        rc = qeth_l3_start_ipassists(card);
-        if (rc)
-                QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
-        rc = qeth_l3_setrouting_v4(card);
-        if (rc)
-                QETH_DBF_TEXT_(SETUP, 2, "4err%d", rc);
-        rc = qeth_l3_setrouting_v6(card);
-        if (rc)
-                QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc);
+        if (!card->options.sniffer) {
+                rc = qeth_l3_start_ipassists(card);
+                if (rc)
+                        QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
+                qeth_l3_set_large_send(card, card->options.large_send);
+                rc = qeth_l3_setrouting_v4(card);
+                if (rc)
+                        QETH_DBF_TEXT_(SETUP, 2, "4err%d", rc);
+                rc = qeth_l3_setrouting_v6(card);
+                if (rc)
+                        QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc);
+        }
         netif_tx_disable(card->dev);
 
         rc = qeth_init_qdio_queues(card);
         if (rc) {
                 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
+                rc = -ENODEV;
                 goto out_remove;
         }
         card->state = CARD_STATE_SOFTSETUP;
@@ -3248,7 +3425,7 @@ out_remove:
                 card->state = CARD_STATE_RECOVER;
         else
                 card->state = CARD_STATE_DOWN;
-        return -ENODEV;
+        return rc;
 }
 
 static int qeth_l3_set_online(struct ccwgroup_device *gdev)
@@ -3358,11 +3535,9 @@ static int qeth_l3_pm_resume(struct ccwgroup_device *gdev)
         if (card->state == CARD_STATE_RECOVER) {
                 rc = __qeth_l3_set_online(card->gdev, 1);
                 if (rc) {
-                        if (card->dev) {
-                                rtnl_lock();
-                                dev_close(card->dev);
-                                rtnl_unlock();
-                        }
+                        rtnl_lock();
+                        dev_close(card->dev);
+                        rtnl_unlock();
                 }
         } else
                 rc = __qeth_l3_set_online(card->gdev, 0);