net: s390: convert to hw_features

options.large_send was easy to get rid of. options.checksum_type has deeper
roots so is left for later cleanup.

Signed-off-by: Michał Mirosław <mirq-linux@rere.qmqm.pl>
Signed-off-by: David S. Miller <davem@davemloft.net>

3 files changed, 52 insertions, 107 deletions

diff --git a/drivers/s390/net/qeth_core.h b/drivers/s390/net/qeth_core.h
index af3f7b095647..8d6146a107d9 100644
--- a/drivers/s390/net/qeth_core.h
+++ b/drivers/s390/net/qeth_core.h
@@ -407,12 +407,6 @@ struct qeth_qdio_q {
         int next_buf_to_init;
 } __attribute__ ((aligned(256)));
 
-/* possible types of qeth large_send support */
-enum qeth_large_send_types {
-        QETH_LARGE_SEND_NO,
-        QETH_LARGE_SEND_TSO,
-};
-
 struct qeth_qdio_out_buffer {
         struct qdio_buffer *buffer;
         atomic_t state;
@@ -651,7 +645,6 @@ struct qeth_card_options {
         int fake_broadcast;
         int add_hhlen;
         int layer2;
-        enum qeth_large_send_types large_send;
         int performance_stats;
         int rx_sg_cb;
         enum qeth_ipa_isolation_modes isolation;
diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c
index 142e5f6ef4f3..1496661507ea 100644
--- a/drivers/s390/net/qeth_l3_main.c
+++ b/drivers/s390/net/qeth_l3_main.c
@@ -43,33 +43,6 @@ 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_IP_CSUM;
-                } else {
-                        card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
-                                        NETIF_F_IP_CSUM);
-                        card->options.large_send = QETH_LARGE_SEND_NO;
-                        rc = -EOPNOTSUPP;
-                }
-        } else {
-                card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG |
-                                        NETIF_F_IP_CSUM);
-                card->options.large_send = QETH_LARGE_SEND_NO;
-        }
-        return rc;
-}
-
 static int qeth_l3_isxdigit(char *buf)
 {
         while (*buf) {
@@ -1485,6 +1458,7 @@ int qeth_l3_set_rx_csum(struct qeth_card *card,
                         if (rc)
                                 return -EIO;
                 }
+                card->dev->features |= NETIF_F_RXCSUM;
         } else {
                 if (csum_type == HW_CHECKSUMMING) {
                         if (card->state != CARD_STATE_DOWN) {
@@ -1496,6 +1470,7 @@ int qeth_l3_set_rx_csum(struct qeth_card *card,
                                         return -EIO;
                         }
                 }
+                card->dev->features &= ~NETIF_F_RXCSUM;
         }
         card->options.checksum_type = csum_type;
         return rc;
@@ -1580,10 +1555,8 @@ static int qeth_l3_start_ipa_tso(struct qeth_card *card)
                         dev_info(&card->gdev->dev,
                                 "Outbound TSO enabled\n");
         }
-        if (rc && (card->options.large_send == QETH_LARGE_SEND_TSO)) {
-                card->options.large_send = QETH_LARGE_SEND_NO;
-                card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG);
-        }
+        if (rc)
+                card->dev->features &= ~NETIF_F_TSO;
         return rc;
 }
 
@@ -3024,7 +2997,7 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
         struct qeth_qdio_out_q *queue = card->qdio.out_qs
                 [qeth_get_priority_queue(card, skb, ipv, cast_type)];
         int tx_bytes = skb->len;
-        enum qeth_large_send_types large_send = QETH_LARGE_SEND_NO;
+        bool large_send;
         int data_offset = -1;
         int nr_frags;
 
@@ -3046,8 +3019,7 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 card->perf_stats.outbound_start_time = qeth_get_micros();
         }
 
-        if (skb_is_gso(skb))
-                large_send = card->options.large_send;
+        large_send = skb_is_gso(skb);
 
         if ((card->info.type == QETH_CARD_TYPE_IQD) && (!large_send) &&
             (skb_shinfo(skb)->nr_frags == 0)) {
@@ -3096,7 +3068,7 @@ 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) {
+        if (large_send) {
                 if (qeth_l3_tso_elements(new_skb) + 1 > 16) {
                         if (skb_linearize(new_skb))
                                 goto tx_drop;
@@ -3105,8 +3077,7 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 }
         }
 
-        if ((large_send == QETH_LARGE_SEND_TSO) &&
-            (cast_type == RTN_UNSPEC)) {
+        if (large_send && (cast_type == RTN_UNSPEC)) {
                 hdr = (struct qeth_hdr *)skb_push(new_skb,
                                                 sizeof(struct qeth_hdr_tso));
                 memset(hdr, 0, sizeof(struct qeth_hdr_tso));
@@ -3141,7 +3112,7 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
         if (card->info.type != QETH_CARD_TYPE_IQD) {
                 int len;
-                if (large_send == QETH_LARGE_SEND_TSO)
+                if (large_send)
                         len = ((unsigned long)tcp_hdr(new_skb) +
                                 tcp_hdr(new_skb)->doff * 4) -
                                 (unsigned long)new_skb->data;
@@ -3162,7 +3133,7 @@ static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
                 if (new_skb != skb)
                         dev_kfree_skb_any(skb);
                 if (card->options.performance_stats) {
-                        if (large_send != QETH_LARGE_SEND_NO) {
+                        if (large_send) {
                                 card->perf_stats.large_send_bytes += tx_bytes;
                                 card->perf_stats.large_send_cnt++;
                         }
@@ -3248,65 +3219,40 @@ static int qeth_l3_stop(struct net_device *dev)
         return 0;
 }
 
-static u32 qeth_l3_ethtool_get_rx_csum(struct net_device *dev)
+static u32 qeth_l3_fix_features(struct net_device *dev, u32 features)
 {
         struct qeth_card *card = dev->ml_priv;
 
-        return (card->options.checksum_type == HW_CHECKSUMMING);
+        if (!qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM))
+                features &= ~NETIF_F_IP_CSUM;
+        if (!qeth_is_supported(card, IPA_OUTBOUND_TSO))
+                features &= ~NETIF_F_TSO;
+        if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM))
+                features &= ~NETIF_F_RXCSUM;
+
+        return features;
 }
 
-static int qeth_l3_ethtool_set_rx_csum(struct net_device *dev, u32 data)
+static int qeth_l3_set_features(struct net_device *dev, u32 features)
 {
-        struct qeth_card *card = dev->ml_priv;
         enum qeth_checksum_types csum_type;
+        struct qeth_card *card = dev->ml_priv;
+        u32 changed = dev->features ^ features;
 
-        if (data)
+        if (!(changed & NETIF_F_RXCSUM))
+                return 0;
+
+        if (features & NETIF_F_RXCSUM)
                 csum_type = HW_CHECKSUMMING;
         else
                 csum_type = SW_CHECKSUMMING;
 
+        dev->features = features ^ NETIF_F_RXCSUM;
         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) {
-                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 rc;
-}
-
-static int qeth_l3_ethtool_set_tx_csum(struct net_device *dev, u32 data)
-{
-        struct qeth_card *card = dev->ml_priv;
-
-        if (data) {
-                if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM))
-                        dev->features |= NETIF_F_IP_CSUM;
-                else
-                        return -EPERM;
-        } else
-                dev->features &= ~NETIF_F_IP_CSUM;
-
-        return 0;
-}
-
 static const struct ethtool_ops qeth_l3_ethtool_ops = {
         .get_link = ethtool_op_get_link,
-        .get_tx_csum = ethtool_op_get_tx_csum,
-        .set_tx_csum = qeth_l3_ethtool_set_tx_csum,
-        .get_rx_csum = qeth_l3_ethtool_get_rx_csum,
-        .set_rx_csum = qeth_l3_ethtool_set_rx_csum,
-        .get_sg      = ethtool_op_get_sg,
-        .set_sg      = ethtool_op_set_sg,
-        .get_tso     = ethtool_op_get_tso,
-        .set_tso     = qeth_l3_ethtool_set_tso,
         .get_strings = qeth_core_get_strings,
         .get_ethtool_stats = qeth_core_get_ethtool_stats,
         .get_sset_count = qeth_core_get_sset_count,
@@ -3347,6 +3293,8 @@ static const struct net_device_ops qeth_l3_netdev_ops = {
         .ndo_set_multicast_list = qeth_l3_set_multicast_list,
         .ndo_do_ioctl           = qeth_l3_do_ioctl,
         .ndo_change_mtu         = qeth_change_mtu,
+        .ndo_fix_features       = qeth_l3_fix_features,
+        .ndo_set_features       = qeth_l3_set_features,
         .ndo_vlan_rx_register   = qeth_l3_vlan_rx_register,
         .ndo_vlan_rx_add_vid    = qeth_l3_vlan_rx_add_vid,
         .ndo_vlan_rx_kill_vid   = qeth_l3_vlan_rx_kill_vid,
@@ -3362,6 +3310,8 @@ static const struct net_device_ops qeth_l3_osa_netdev_ops = {
         .ndo_set_multicast_list = qeth_l3_set_multicast_list,
         .ndo_do_ioctl           = qeth_l3_do_ioctl,
         .ndo_change_mtu         = qeth_change_mtu,
+        .ndo_fix_features       = qeth_l3_fix_features,
+        .ndo_set_features       = qeth_l3_set_features,
         .ndo_vlan_rx_register   = qeth_l3_vlan_rx_register,
         .ndo_vlan_rx_add_vid    = qeth_l3_vlan_rx_add_vid,
         .ndo_vlan_rx_kill_vid   = qeth_l3_vlan_rx_kill_vid,
@@ -3392,8 +3342,6 @@ static int qeth_l3_setup_netdev(struct qeth_card *card)
                         if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
                                 card->dev->dev_id = card->info.unique_id &
                                                          0xffff;
-                        if (!card->info.guestlan)
-                                card->dev->features |= NETIF_F_GRO;
                 }
         } else if (card->info.type == QETH_CARD_TYPE_IQD) {
                 card->dev = alloc_netdev(0, "hsi%d", ether_setup);
@@ -3409,6 +3357,8 @@ static int qeth_l3_setup_netdev(struct qeth_card *card)
         card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
         card->dev->mtu = card->info.initial_mtu;
         SET_ETHTOOL_OPS(card->dev, &qeth_l3_ethtool_ops);
+        card->dev->hw_features = NETIF_F_SG | NETIF_F_RXCSUM |
+                NETIF_F_IP_CSUM | NETIF_F_TSO;
         card->dev->features |=  NETIF_F_HW_VLAN_TX |
                                 NETIF_F_HW_VLAN_RX |
                                 NETIF_F_HW_VLAN_FILTER;
@@ -3516,7 +3466,6 @@ contin:
                 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);
diff --git a/drivers/s390/net/qeth_l3_sys.c b/drivers/s390/net/qeth_l3_sys.c
index 67cfa68dcf1b..bf9f003e3a97 100644
--- a/drivers/s390/net/qeth_l3_sys.c
+++ b/drivers/s390/net/qeth_l3_sys.c
@@ -410,39 +410,42 @@ static ssize_t qeth_l3_dev_large_send_show(struct device *dev,
         if (!card)
                 return -EINVAL;
 
-        switch (card->options.large_send) {
-        case QETH_LARGE_SEND_NO:
+        if (!(card->dev->features & NETIF_F_TSO))
                 return sprintf(buf, "%s\n", "no");
-        case QETH_LARGE_SEND_TSO:
+        else
                 return sprintf(buf, "%s\n", "TSO");
-        default:
-                return sprintf(buf, "%s\n", "N/A");
-        }
 }
 
 static ssize_t qeth_l3_dev_large_send_store(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t count)
 {
-        struct qeth_card *card = dev_get_drvdata(dev);
-        enum qeth_large_send_types type;
-        int rc = 0;
+        struct qeth_card *card;
         char *tmp;
+        int enable;
 
         if (!card)
                 return -EINVAL;
         tmp = strsep((char **) &buf, "\n");
         if (!strcmp(tmp, "no"))
-                type = QETH_LARGE_SEND_NO;
+                enable = 0;
         else if (!strcmp(tmp, "TSO"))
-                type = QETH_LARGE_SEND_TSO;
+                enable = 1;
         else
                 return -EINVAL;
 
-        mutex_lock(&card->conf_mutex);
-        if (card->options.large_send != type)
-                rc = qeth_l3_set_large_send(card, type);
-        mutex_unlock(&card->conf_mutex);
-        return rc ? rc : count;
+        rtnl_lock();
+
+        card = dev_get_drvdata(dev);
+
+        if (enable)
+                card->dev->wanted_features |= NETIF_F_TSO;
+        else
+                card->dev->wanted_features &= ~NETIF_F_TSO;
+        netdev_update_features(card->dev);
+
+        rtnl_unlock();
+
+        return count;
 }
 
 static DEVICE_ATTR(large_send, 0644, qeth_l3_dev_large_send_show,