Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *    Copyright IBM Corp. 2007, 2009
0004  *    Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
0005  *       Frank Pavlic <fpavlic@de.ibm.com>,
0006  *       Thomas Spatzier <tspat@de.ibm.com>,
0007  *       Frank Blaschka <frank.blaschka@de.ibm.com>
0008  */
0009 
0010 #define KMSG_COMPONENT "qeth"
0011 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
0012 
0013 #include <linux/module.h>
0014 #include <linux/moduleparam.h>
0015 #include <linux/bitops.h>
0016 #include <linux/string.h>
0017 #include <linux/errno.h>
0018 #include <linux/kernel.h>
0019 #include <linux/etherdevice.h>
0020 #include <linux/ip.h>
0021 #include <linux/in.h>
0022 #include <linux/ipv6.h>
0023 #include <linux/inetdevice.h>
0024 #include <linux/igmp.h>
0025 #include <linux/slab.h>
0026 #include <linux/if_ether.h>
0027 #include <linux/if_vlan.h>
0028 #include <linux/skbuff.h>
0029 
0030 #include <net/ip.h>
0031 #include <net/arp.h>
0032 #include <net/route.h>
0033 #include <net/ipv6.h>
0034 #include <net/ip6_route.h>
0035 #include <net/iucv/af_iucv.h>
0036 #include <linux/hashtable.h>
0037 
0038 #include "qeth_l3.h"
0039 
0040 static int qeth_l3_register_addr_entry(struct qeth_card *,
0041         struct qeth_ipaddr *);
0042 static int qeth_l3_deregister_addr_entry(struct qeth_card *,
0043         struct qeth_ipaddr *);
0044 
0045 int qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto, const u8 *addr,
0046                  char *buf)
0047 {
0048     if (proto == QETH_PROT_IPV4)
0049         return sprintf(buf, "%pI4", addr);
0050     else
0051         return sprintf(buf, "%pI6", addr);
0052 }
0053 
0054 static struct qeth_ipaddr *qeth_l3_find_addr_by_ip(struct qeth_card *card,
0055                            struct qeth_ipaddr *query)
0056 {
0057     u32 key = qeth_l3_ipaddr_hash(query);
0058     struct qeth_ipaddr *addr;
0059 
0060     if (query->is_multicast) {
0061         hash_for_each_possible(card->rx_mode_addrs, addr, hnode, key)
0062             if (qeth_l3_addr_match_ip(addr, query))
0063                 return addr;
0064     } else {
0065         hash_for_each_possible(card->ip_htable,  addr, hnode, key)
0066             if (qeth_l3_addr_match_ip(addr, query))
0067                 return addr;
0068     }
0069     return NULL;
0070 }
0071 
0072 static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
0073 {
0074     int i, j;
0075     u8 octet;
0076 
0077     for (i = 0; i < len; ++i) {
0078         octet = addr[i];
0079         for (j = 7; j >= 0; --j) {
0080             bits[i*8 + j] = octet & 1;
0081             octet >>= 1;
0082         }
0083     }
0084 }
0085 
0086 static bool qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
0087                          struct qeth_ipaddr *addr)
0088 {
0089     struct qeth_ipato_entry *ipatoe;
0090     u8 addr_bits[128] = {0, };
0091     u8 ipatoe_bits[128] = {0, };
0092     int rc = 0;
0093 
0094     if (!card->ipato.enabled)
0095         return false;
0096     if (addr->type != QETH_IP_TYPE_NORMAL)
0097         return false;
0098 
0099     qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits,
0100                      (addr->proto == QETH_PROT_IPV4) ? 4 : 16);
0101     list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
0102         if (addr->proto != ipatoe->proto)
0103             continue;
0104         qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits,
0105                       (ipatoe->proto == QETH_PROT_IPV4) ?
0106                       4 : 16);
0107         rc = !memcmp(addr_bits, ipatoe_bits, ipatoe->mask_bits);
0108         if (rc)
0109             break;
0110     }
0111     /* invert? */
0112     if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
0113         rc = !rc;
0114     else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
0115         rc = !rc;
0116 
0117     return rc;
0118 }
0119 
0120 static int qeth_l3_delete_ip(struct qeth_card *card,
0121                  struct qeth_ipaddr *tmp_addr)
0122 {
0123     int rc = 0;
0124     struct qeth_ipaddr *addr;
0125 
0126     if (tmp_addr->type == QETH_IP_TYPE_RXIP)
0127         QETH_CARD_TEXT(card, 2, "delrxip");
0128     else if (tmp_addr->type == QETH_IP_TYPE_VIPA)
0129         QETH_CARD_TEXT(card, 2, "delvipa");
0130     else
0131         QETH_CARD_TEXT(card, 2, "delip");
0132 
0133     if (tmp_addr->proto == QETH_PROT_IPV4)
0134         QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
0135     else {
0136         QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
0137         QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
0138     }
0139 
0140     addr = qeth_l3_find_addr_by_ip(card, tmp_addr);
0141     if (!addr || !qeth_l3_addr_match_all(addr, tmp_addr))
0142         return -ENOENT;
0143 
0144     addr->ref_counter--;
0145     if (addr->type == QETH_IP_TYPE_NORMAL && addr->ref_counter > 0)
0146         return rc;
0147 
0148     if (qeth_card_hw_is_reachable(card))
0149         rc = qeth_l3_deregister_addr_entry(card, addr);
0150 
0151     hash_del(&addr->hnode);
0152     kfree(addr);
0153 
0154     return rc;
0155 }
0156 
0157 static int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
0158 {
0159     int rc = 0;
0160     struct qeth_ipaddr *addr;
0161     char buf[40];
0162 
0163     if (tmp_addr->type == QETH_IP_TYPE_RXIP)
0164         QETH_CARD_TEXT(card, 2, "addrxip");
0165     else if (tmp_addr->type == QETH_IP_TYPE_VIPA)
0166         QETH_CARD_TEXT(card, 2, "addvipa");
0167     else
0168         QETH_CARD_TEXT(card, 2, "addip");
0169 
0170     if (tmp_addr->proto == QETH_PROT_IPV4)
0171         QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
0172     else {
0173         QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
0174         QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
0175     }
0176 
0177     addr = qeth_l3_find_addr_by_ip(card, tmp_addr);
0178     if (addr) {
0179         if (tmp_addr->type != QETH_IP_TYPE_NORMAL)
0180             return -EADDRINUSE;
0181         if (qeth_l3_addr_match_all(addr, tmp_addr)) {
0182             addr->ref_counter++;
0183             return 0;
0184         }
0185         qeth_l3_ipaddr_to_string(tmp_addr->proto, (u8 *)&tmp_addr->u,
0186                      buf);
0187         dev_warn(&card->gdev->dev,
0188              "Registering IP address %s failed\n", buf);
0189         return -EADDRINUSE;
0190     } else {
0191         addr = kmemdup(tmp_addr, sizeof(*tmp_addr), GFP_KERNEL);
0192         if (!addr)
0193             return -ENOMEM;
0194 
0195         if (qeth_l3_is_addr_covered_by_ipato(card, addr)) {
0196             QETH_CARD_TEXT(card, 2, "tkovaddr");
0197             addr->ipato = 1;
0198         }
0199         hash_add(card->ip_htable, &addr->hnode,
0200                 qeth_l3_ipaddr_hash(addr));
0201 
0202         if (!qeth_card_hw_is_reachable(card)) {
0203             addr->disp_flag = QETH_DISP_ADDR_ADD;
0204             return 0;
0205         }
0206 
0207         rc = qeth_l3_register_addr_entry(card, addr);
0208 
0209         if (!rc || rc == -EADDRINUSE || rc == -ENETDOWN) {
0210             addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
0211         } else {
0212             hash_del(&addr->hnode);
0213             kfree(addr);
0214         }
0215     }
0216     return rc;
0217 }
0218 
0219 static int qeth_l3_modify_ip(struct qeth_card *card, struct qeth_ipaddr *addr,
0220                  bool add)
0221 {
0222     int rc;
0223 
0224     mutex_lock(&card->ip_lock);
0225     rc = add ? qeth_l3_add_ip(card, addr) : qeth_l3_delete_ip(card, addr);
0226     mutex_unlock(&card->ip_lock);
0227 
0228     return rc;
0229 }
0230 
0231 static void qeth_l3_drain_rx_mode_cache(struct qeth_card *card)
0232 {
0233     struct qeth_ipaddr *addr;
0234     struct hlist_node *tmp;
0235     int i;
0236 
0237     hash_for_each_safe(card->rx_mode_addrs, i, tmp, addr, hnode) {
0238         hash_del(&addr->hnode);
0239         kfree(addr);
0240     }
0241 }
0242 
0243 static void qeth_l3_clear_ip_htable(struct qeth_card *card, int recover)
0244 {
0245     struct qeth_ipaddr *addr;
0246     struct hlist_node *tmp;
0247     int i;
0248 
0249     QETH_CARD_TEXT(card, 4, "clearip");
0250 
0251     mutex_lock(&card->ip_lock);
0252 
0253     hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
0254         if (!recover) {
0255             hash_del(&addr->hnode);
0256             kfree(addr);
0257             continue;
0258         }
0259         addr->disp_flag = QETH_DISP_ADDR_ADD;
0260     }
0261 
0262     mutex_unlock(&card->ip_lock);
0263 }
0264 
0265 static void qeth_l3_recover_ip(struct qeth_card *card)
0266 {
0267     struct qeth_ipaddr *addr;
0268     struct hlist_node *tmp;
0269     int i;
0270     int rc;
0271 
0272     QETH_CARD_TEXT(card, 4, "recovrip");
0273 
0274     mutex_lock(&card->ip_lock);
0275 
0276     hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
0277         if (addr->disp_flag == QETH_DISP_ADDR_ADD) {
0278             rc = qeth_l3_register_addr_entry(card, addr);
0279 
0280             if (!rc) {
0281                 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
0282             } else {
0283                 hash_del(&addr->hnode);
0284                 kfree(addr);
0285             }
0286         }
0287     }
0288 
0289     mutex_unlock(&card->ip_lock);
0290 }
0291 
0292 static int qeth_l3_setdelip_cb(struct qeth_card *card, struct qeth_reply *reply,
0293                    unsigned long data)
0294 {
0295     struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
0296 
0297     switch (cmd->hdr.return_code) {
0298     case IPA_RC_SUCCESS:
0299         return 0;
0300     case IPA_RC_DUPLICATE_IP_ADDRESS:
0301         return -EADDRINUSE;
0302     case IPA_RC_MC_ADDR_NOT_FOUND:
0303         return -ENOENT;
0304     case IPA_RC_LAN_OFFLINE:
0305         return -ENETDOWN;
0306     default:
0307         return -EIO;
0308     }
0309 }
0310 
0311 static int qeth_l3_send_setdelmc(struct qeth_card *card,
0312                  struct qeth_ipaddr *addr,
0313                  enum qeth_ipa_cmds ipacmd)
0314 {
0315     struct qeth_cmd_buffer *iob;
0316     struct qeth_ipa_cmd *cmd;
0317 
0318     QETH_CARD_TEXT(card, 4, "setdelmc");
0319 
0320     iob = qeth_ipa_alloc_cmd(card, ipacmd, addr->proto,
0321                  IPA_DATA_SIZEOF(setdelipm));
0322     if (!iob)
0323         return -ENOMEM;
0324     cmd = __ipa_cmd(iob);
0325     if (addr->proto == QETH_PROT_IPV6) {
0326         cmd->data.setdelipm.ip = addr->u.a6.addr;
0327         ipv6_eth_mc_map(&addr->u.a6.addr, cmd->data.setdelipm.mac);
0328     } else {
0329         cmd->data.setdelipm.ip.s6_addr32[3] = addr->u.a4.addr;
0330         ip_eth_mc_map(addr->u.a4.addr, cmd->data.setdelipm.mac);
0331     }
0332 
0333     return qeth_send_ipa_cmd(card, iob, qeth_l3_setdelip_cb, NULL);
0334 }
0335 
0336 static void qeth_l3_set_ipv6_prefix(struct in6_addr *prefix, unsigned int len)
0337 {
0338     unsigned int i = 0;
0339 
0340     while (len && i < 4) {
0341         int mask_len = min_t(int, len, 32);
0342 
0343         prefix->s6_addr32[i] = inet_make_mask(mask_len);
0344         len -= mask_len;
0345         i++;
0346     }
0347 }
0348 
0349 static u32 qeth_l3_get_setdelip_flags(struct qeth_ipaddr *addr, bool set)
0350 {
0351     switch (addr->type) {
0352     case QETH_IP_TYPE_RXIP:
0353         return (set) ? QETH_IPA_SETIP_TAKEOVER_FLAG : 0;
0354     case QETH_IP_TYPE_VIPA:
0355         return (set) ? QETH_IPA_SETIP_VIPA_FLAG :
0356                    QETH_IPA_DELIP_VIPA_FLAG;
0357     default:
0358         return (set && addr->ipato) ? QETH_IPA_SETIP_TAKEOVER_FLAG : 0;
0359     }
0360 }
0361 
0362 static int qeth_l3_send_setdelip(struct qeth_card *card,
0363                  struct qeth_ipaddr *addr,
0364                  enum qeth_ipa_cmds ipacmd)
0365 {
0366     struct qeth_cmd_buffer *iob;
0367     struct qeth_ipa_cmd *cmd;
0368     u32 flags;
0369 
0370     QETH_CARD_TEXT(card, 4, "setdelip");
0371 
0372     iob = qeth_ipa_alloc_cmd(card, ipacmd, addr->proto,
0373                  IPA_DATA_SIZEOF(setdelip6));
0374     if (!iob)
0375         return -ENOMEM;
0376     cmd = __ipa_cmd(iob);
0377 
0378     flags = qeth_l3_get_setdelip_flags(addr, ipacmd == IPA_CMD_SETIP);
0379     QETH_CARD_TEXT_(card, 4, "flags%02X", flags);
0380 
0381     if (addr->proto == QETH_PROT_IPV6) {
0382         cmd->data.setdelip6.addr = addr->u.a6.addr;
0383         qeth_l3_set_ipv6_prefix(&cmd->data.setdelip6.prefix,
0384                     addr->u.a6.pfxlen);
0385         cmd->data.setdelip6.flags = flags;
0386     } else {
0387         cmd->data.setdelip4.addr = addr->u.a4.addr;
0388         cmd->data.setdelip4.mask = addr->u.a4.mask;
0389         cmd->data.setdelip4.flags = flags;
0390     }
0391 
0392     return qeth_send_ipa_cmd(card, iob, qeth_l3_setdelip_cb, NULL);
0393 }
0394 
0395 static int qeth_l3_send_setrouting(struct qeth_card *card,
0396     enum qeth_routing_types type, enum qeth_prot_versions prot)
0397 {
0398     int rc;
0399     struct qeth_ipa_cmd *cmd;
0400     struct qeth_cmd_buffer *iob;
0401 
0402     QETH_CARD_TEXT(card, 4, "setroutg");
0403     iob = qeth_ipa_alloc_cmd(card, IPA_CMD_SETRTG, prot,
0404                  IPA_DATA_SIZEOF(setrtg));
0405     if (!iob)
0406         return -ENOMEM;
0407     cmd = __ipa_cmd(iob);
0408     cmd->data.setrtg.type = (type);
0409     rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
0410 
0411     return rc;
0412 }
0413 
0414 static int qeth_l3_correct_routing_type(struct qeth_card *card,
0415         enum qeth_routing_types *type, enum qeth_prot_versions prot)
0416 {
0417     if (IS_IQD(card)) {
0418         switch (*type) {
0419         case NO_ROUTER:
0420         case PRIMARY_CONNECTOR:
0421         case SECONDARY_CONNECTOR:
0422         case MULTICAST_ROUTER:
0423             return 0;
0424         default:
0425             goto out_inval;
0426         }
0427     } else {
0428         switch (*type) {
0429         case NO_ROUTER:
0430         case PRIMARY_ROUTER:
0431         case SECONDARY_ROUTER:
0432             return 0;
0433         case MULTICAST_ROUTER:
0434             if (qeth_is_ipafunc_supported(card, prot,
0435                               IPA_OSA_MC_ROUTER))
0436                 return 0;
0437             goto out_inval;
0438         default:
0439             goto out_inval;
0440         }
0441     }
0442 out_inval:
0443     *type = NO_ROUTER;
0444     return -EINVAL;
0445 }
0446 
0447 int qeth_l3_setrouting_v4(struct qeth_card *card)
0448 {
0449     int rc;
0450 
0451     QETH_CARD_TEXT(card, 3, "setrtg4");
0452 
0453     rc = qeth_l3_correct_routing_type(card, &card->options.route4.type,
0454                   QETH_PROT_IPV4);
0455     if (rc)
0456         return rc;
0457 
0458     rc = qeth_l3_send_setrouting(card, card->options.route4.type,
0459                   QETH_PROT_IPV4);
0460     if (rc) {
0461         card->options.route4.type = NO_ROUTER;
0462         QETH_DBF_MESSAGE(2, "Error (%#06x) while setting routing type on device %x. Type set to 'no router'.\n",
0463                  rc, CARD_DEVID(card));
0464     }
0465     return rc;
0466 }
0467 
0468 int qeth_l3_setrouting_v6(struct qeth_card *card)
0469 {
0470     int rc = 0;
0471 
0472     QETH_CARD_TEXT(card, 3, "setrtg6");
0473 
0474     if (!qeth_is_supported(card, IPA_IPV6))
0475         return 0;
0476     rc = qeth_l3_correct_routing_type(card, &card->options.route6.type,
0477                   QETH_PROT_IPV6);
0478     if (rc)
0479         return rc;
0480 
0481     rc = qeth_l3_send_setrouting(card, card->options.route6.type,
0482                   QETH_PROT_IPV6);
0483     if (rc) {
0484         card->options.route6.type = NO_ROUTER;
0485         QETH_DBF_MESSAGE(2, "Error (%#06x) while setting routing type on device %x. Type set to 'no router'.\n",
0486                  rc, CARD_DEVID(card));
0487     }
0488     return rc;
0489 }
0490 
0491 /*
0492  * IP address takeover related functions
0493  */
0494 
0495 /*
0496  * qeth_l3_update_ipato() - Update 'takeover' property, for all NORMAL IPs.
0497  *
0498  * Caller must hold ip_lock.
0499  */
0500 void qeth_l3_update_ipato(struct qeth_card *card)
0501 {
0502     struct qeth_ipaddr *addr;
0503     unsigned int i;
0504 
0505     hash_for_each(card->ip_htable, i, addr, hnode) {
0506         if (addr->type != QETH_IP_TYPE_NORMAL)
0507             continue;
0508         addr->ipato = qeth_l3_is_addr_covered_by_ipato(card, addr);
0509     }
0510 }
0511 
0512 static void qeth_l3_clear_ipato_list(struct qeth_card *card)
0513 {
0514     struct qeth_ipato_entry *ipatoe, *tmp;
0515 
0516     mutex_lock(&card->ip_lock);
0517 
0518     list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
0519         list_del(&ipatoe->entry);
0520         kfree(ipatoe);
0521     }
0522 
0523     qeth_l3_update_ipato(card);
0524     mutex_unlock(&card->ip_lock);
0525 }
0526 
0527 int qeth_l3_add_ipato_entry(struct qeth_card *card,
0528                 struct qeth_ipato_entry *new)
0529 {
0530     struct qeth_ipato_entry *ipatoe;
0531     int rc = 0;
0532 
0533     QETH_CARD_TEXT(card, 2, "addipato");
0534 
0535     mutex_lock(&card->ip_lock);
0536 
0537     list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
0538         if (ipatoe->proto != new->proto)
0539             continue;
0540         if (!memcmp(ipatoe->addr, new->addr,
0541                 (ipatoe->proto == QETH_PROT_IPV4) ? 4 : 16) &&
0542             (ipatoe->mask_bits == new->mask_bits)) {
0543             rc = -EEXIST;
0544             break;
0545         }
0546     }
0547 
0548     if (!rc) {
0549         list_add_tail(&new->entry, &card->ipato.entries);
0550         qeth_l3_update_ipato(card);
0551     }
0552 
0553     mutex_unlock(&card->ip_lock);
0554 
0555     return rc;
0556 }
0557 
0558 int qeth_l3_del_ipato_entry(struct qeth_card *card,
0559                 enum qeth_prot_versions proto, u8 *addr,
0560                 unsigned int mask_bits)
0561 {
0562     struct qeth_ipato_entry *ipatoe, *tmp;
0563     int rc = -ENOENT;
0564 
0565     QETH_CARD_TEXT(card, 2, "delipato");
0566 
0567     mutex_lock(&card->ip_lock);
0568 
0569     list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
0570         if (ipatoe->proto != proto)
0571             continue;
0572         if (!memcmp(ipatoe->addr, addr,
0573                 (proto == QETH_PROT_IPV4) ? 4 : 16) &&
0574             (ipatoe->mask_bits == mask_bits)) {
0575             list_del(&ipatoe->entry);
0576             qeth_l3_update_ipato(card);
0577             kfree(ipatoe);
0578             rc = 0;
0579         }
0580     }
0581 
0582     mutex_unlock(&card->ip_lock);
0583 
0584     return rc;
0585 }
0586 
0587 int qeth_l3_modify_rxip_vipa(struct qeth_card *card, bool add, const u8 *ip,
0588                  enum qeth_ip_types type,
0589                  enum qeth_prot_versions proto)
0590 {
0591     struct qeth_ipaddr addr;
0592 
0593     qeth_l3_init_ipaddr(&addr, type, proto);
0594     if (proto == QETH_PROT_IPV4)
0595         memcpy(&addr.u.a4.addr, ip, 4);
0596     else
0597         memcpy(&addr.u.a6.addr, ip, 16);
0598 
0599     return qeth_l3_modify_ip(card, &addr, add);
0600 }
0601 
0602 int qeth_l3_modify_hsuid(struct qeth_card *card, bool add)
0603 {
0604     struct qeth_ipaddr addr;
0605     unsigned int i;
0606 
0607     qeth_l3_init_ipaddr(&addr, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV6);
0608     addr.u.a6.addr.s6_addr[0] = 0xfe;
0609     addr.u.a6.addr.s6_addr[1] = 0x80;
0610     for (i = 0; i < 8; i++)
0611         addr.u.a6.addr.s6_addr[8+i] = card->options.hsuid[i];
0612 
0613     return qeth_l3_modify_ip(card, &addr, add);
0614 }
0615 
0616 static int qeth_l3_register_addr_entry(struct qeth_card *card,
0617                 struct qeth_ipaddr *addr)
0618 {
0619     char buf[50];
0620     int rc = 0;
0621     int cnt = 3;
0622 
0623     if (card->options.sniffer)
0624         return 0;
0625 
0626     if (addr->proto == QETH_PROT_IPV4) {
0627         QETH_CARD_TEXT(card, 2, "setaddr4");
0628         QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
0629     } else if (addr->proto == QETH_PROT_IPV6) {
0630         QETH_CARD_TEXT(card, 2, "setaddr6");
0631         QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
0632         QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
0633     } else {
0634         QETH_CARD_TEXT(card, 2, "setaddr?");
0635         QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
0636     }
0637     do {
0638         if (addr->is_multicast)
0639             rc =  qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
0640         else
0641             rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP);
0642         if (rc)
0643             QETH_CARD_TEXT(card, 2, "failed");
0644     } while ((--cnt > 0) && rc);
0645     if (rc) {
0646         QETH_CARD_TEXT(card, 2, "FAILED");
0647         qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
0648         dev_warn(&card->gdev->dev,
0649             "Registering IP address %s failed\n", buf);
0650     }
0651     return rc;
0652 }
0653 
0654 static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
0655                         struct qeth_ipaddr *addr)
0656 {
0657     int rc = 0;
0658 
0659     if (card->options.sniffer)
0660         return 0;
0661 
0662     if (addr->proto == QETH_PROT_IPV4) {
0663         QETH_CARD_TEXT(card, 2, "deladdr4");
0664         QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
0665     } else if (addr->proto == QETH_PROT_IPV6) {
0666         QETH_CARD_TEXT(card, 2, "deladdr6");
0667         QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
0668         QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
0669     } else {
0670         QETH_CARD_TEXT(card, 2, "deladdr?");
0671         QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
0672     }
0673     if (addr->is_multicast)
0674         rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
0675     else
0676         rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP);
0677     if (rc)
0678         QETH_CARD_TEXT(card, 2, "failed");
0679 
0680     return rc;
0681 }
0682 
0683 static int qeth_l3_setadapter_parms(struct qeth_card *card)
0684 {
0685     int rc = 0;
0686 
0687     QETH_CARD_TEXT(card, 2, "setadprm");
0688 
0689     if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
0690         rc = qeth_setadpparms_change_macaddr(card);
0691         if (rc)
0692             dev_warn(&card->gdev->dev, "Reading the adapter MAC"
0693                 " address failed\n");
0694     }
0695 
0696     return rc;
0697 }
0698 
0699 static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
0700 {
0701     int rc;
0702 
0703     QETH_CARD_TEXT(card, 3, "ipaarp");
0704 
0705     if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
0706         dev_info(&card->gdev->dev,
0707              "ARP processing not supported on %s!\n",
0708              netdev_name(card->dev));
0709         return 0;
0710     }
0711     rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
0712                       IPA_CMD_ASS_START, NULL);
0713     if (rc) {
0714         dev_warn(&card->gdev->dev,
0715              "Starting ARP processing support for %s failed\n",
0716              netdev_name(card->dev));
0717     }
0718     return rc;
0719 }
0720 
0721 static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
0722 {
0723     int rc;
0724 
0725     QETH_CARD_TEXT(card, 3, "stsrcmac");
0726 
0727     if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
0728         dev_info(&card->gdev->dev,
0729              "Inbound source MAC-address not supported on %s\n",
0730              netdev_name(card->dev));
0731         return -EOPNOTSUPP;
0732     }
0733 
0734     rc = qeth_send_simple_setassparms(card, IPA_SOURCE_MAC,
0735                       IPA_CMD_ASS_START, NULL);
0736     if (rc)
0737         dev_warn(&card->gdev->dev,
0738              "Starting source MAC-address support for %s failed\n",
0739              netdev_name(card->dev));
0740     return rc;
0741 }
0742 
0743 static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
0744 {
0745     int rc = 0;
0746 
0747     QETH_CARD_TEXT(card, 3, "strtvlan");
0748 
0749     if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
0750         dev_info(&card->gdev->dev,
0751              "VLAN not supported on %s\n", netdev_name(card->dev));
0752         return -EOPNOTSUPP;
0753     }
0754 
0755     rc = qeth_send_simple_setassparms(card, IPA_VLAN_PRIO,
0756                       IPA_CMD_ASS_START, NULL);
0757     if (rc) {
0758         dev_warn(&card->gdev->dev,
0759              "Starting VLAN support for %s failed\n",
0760              netdev_name(card->dev));
0761     } else {
0762         dev_info(&card->gdev->dev, "VLAN enabled\n");
0763     }
0764     return rc;
0765 }
0766 
0767 static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
0768 {
0769     int rc;
0770 
0771     QETH_CARD_TEXT(card, 3, "stmcast");
0772 
0773     if (!qeth_is_supported(card, IPA_MULTICASTING)) {
0774         dev_info(&card->gdev->dev,
0775              "Multicast not supported on %s\n",
0776              netdev_name(card->dev));
0777         return -EOPNOTSUPP;
0778     }
0779 
0780     rc = qeth_send_simple_setassparms(card, IPA_MULTICASTING,
0781                       IPA_CMD_ASS_START, NULL);
0782     if (rc) {
0783         dev_warn(&card->gdev->dev,
0784              "Starting multicast support for %s failed\n",
0785              netdev_name(card->dev));
0786     } else {
0787         dev_info(&card->gdev->dev, "Multicast enabled\n");
0788         card->dev->flags |= IFF_MULTICAST;
0789     }
0790     return rc;
0791 }
0792 
0793 static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
0794 {
0795     u32 ipv6_data = 3;
0796     int rc;
0797 
0798     QETH_CARD_TEXT(card, 3, "softipv6");
0799 
0800     if (IS_IQD(card))
0801         goto out;
0802 
0803     rc = qeth_send_simple_setassparms(card, IPA_IPV6, IPA_CMD_ASS_START,
0804                       &ipv6_data);
0805     if (rc) {
0806         dev_err(&card->gdev->dev,
0807             "Activating IPv6 support for %s failed\n",
0808             netdev_name(card->dev));
0809         return rc;
0810     }
0811     rc = qeth_send_simple_setassparms_v6(card, IPA_IPV6, IPA_CMD_ASS_START,
0812                          NULL);
0813     if (rc) {
0814         dev_err(&card->gdev->dev,
0815             "Activating IPv6 support for %s failed\n",
0816              netdev_name(card->dev));
0817         return rc;
0818     }
0819     rc = qeth_send_simple_setassparms_v6(card, IPA_PASSTHRU,
0820                          IPA_CMD_ASS_START, NULL);
0821     if (rc) {
0822         dev_warn(&card->gdev->dev,
0823              "Enabling the passthrough mode for %s failed\n",
0824              netdev_name(card->dev));
0825         return rc;
0826     }
0827 out:
0828     dev_info(&card->gdev->dev, "IPV6 enabled\n");
0829     return 0;
0830 }
0831 
0832 static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
0833 {
0834     QETH_CARD_TEXT(card, 3, "strtipv6");
0835 
0836     if (!qeth_is_supported(card, IPA_IPV6)) {
0837         dev_info(&card->gdev->dev,
0838              "IPv6 not supported on %s\n", netdev_name(card->dev));
0839         return 0;
0840     }
0841     return qeth_l3_softsetup_ipv6(card);
0842 }
0843 
0844 static int qeth_l3_start_ipa_broadcast(struct qeth_card *card)
0845 {
0846     u32 filter_data = 1;
0847     int rc;
0848 
0849     QETH_CARD_TEXT(card, 3, "stbrdcst");
0850     card->info.broadcast_capable = 0;
0851     if (!qeth_is_supported(card, IPA_FILTERING)) {
0852         dev_info(&card->gdev->dev,
0853              "Broadcast not supported on %s\n",
0854              netdev_name(card->dev));
0855         rc = -EOPNOTSUPP;
0856         goto out;
0857     }
0858     rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
0859                       IPA_CMD_ASS_START, NULL);
0860     if (rc) {
0861         dev_warn(&card->gdev->dev,
0862              "Enabling broadcast filtering for %s failed\n",
0863              netdev_name(card->dev));
0864         goto out;
0865     }
0866 
0867     rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
0868                       IPA_CMD_ASS_CONFIGURE, &filter_data);
0869     if (rc) {
0870         dev_warn(&card->gdev->dev,
0871              "Setting up broadcast filtering for %s failed\n",
0872              netdev_name(card->dev));
0873         goto out;
0874     }
0875     card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
0876     dev_info(&card->gdev->dev, "Broadcast enabled\n");
0877     rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
0878                       IPA_CMD_ASS_ENABLE, &filter_data);
0879     if (rc) {
0880         dev_warn(&card->gdev->dev,
0881              "Setting up broadcast echo filtering for %s failed\n",
0882              netdev_name(card->dev));
0883         goto out;
0884     }
0885     card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
0886 out:
0887     if (card->info.broadcast_capable)
0888         card->dev->flags |= IFF_BROADCAST;
0889     else
0890         card->dev->flags &= ~IFF_BROADCAST;
0891     return rc;
0892 }
0893 
0894 static void qeth_l3_start_ipassists(struct qeth_card *card)
0895 {
0896     QETH_CARD_TEXT(card, 3, "strtipas");
0897 
0898     qeth_l3_start_ipa_arp_processing(card); /* go on*/
0899     qeth_l3_start_ipa_source_mac(card); /* go on*/
0900     qeth_l3_start_ipa_vlan(card);       /* go on*/
0901     qeth_l3_start_ipa_multicast(card);      /* go on*/
0902     qeth_l3_start_ipa_ipv6(card);       /* go on*/
0903     qeth_l3_start_ipa_broadcast(card);      /* go on*/
0904 }
0905 
0906 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
0907         struct qeth_reply *reply, unsigned long data)
0908 {
0909     struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
0910 
0911     if (cmd->hdr.return_code)
0912         return -EIO;
0913     if (!is_valid_ether_addr(cmd->data.create_destroy_addr.mac_addr))
0914         return -EADDRNOTAVAIL;
0915 
0916     eth_hw_addr_set(card->dev, cmd->data.create_destroy_addr.mac_addr);
0917     return 0;
0918 }
0919 
0920 static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card)
0921 {
0922     int rc = 0;
0923     struct qeth_cmd_buffer *iob;
0924 
0925     QETH_CARD_TEXT(card, 2, "hsrmac");
0926 
0927     iob = qeth_ipa_alloc_cmd(card, IPA_CMD_CREATE_ADDR, QETH_PROT_IPV6,
0928                  IPA_DATA_SIZEOF(create_destroy_addr));
0929     if (!iob)
0930         return -ENOMEM;
0931 
0932     rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb,
0933                 NULL);
0934     return rc;
0935 }
0936 
0937 static int qeth_l3_get_unique_id_cb(struct qeth_card *card,
0938         struct qeth_reply *reply, unsigned long data)
0939 {
0940     struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
0941     u16 *uid = reply->param;
0942 
0943     if (cmd->hdr.return_code == 0) {
0944         *uid = cmd->data.create_destroy_addr.uid;
0945         return 0;
0946     }
0947 
0948     dev_warn(&card->gdev->dev, "The network adapter failed to generate a unique ID\n");
0949     return -EIO;
0950 }
0951 
0952 static u16 qeth_l3_get_unique_id(struct qeth_card *card, u16 uid)
0953 {
0954     struct qeth_cmd_buffer *iob;
0955 
0956     QETH_CARD_TEXT(card, 2, "guniqeid");
0957 
0958     if (!qeth_is_supported(card, IPA_IPV6))
0959         goto out;
0960 
0961     iob = qeth_ipa_alloc_cmd(card, IPA_CMD_CREATE_ADDR, QETH_PROT_IPV6,
0962                  IPA_DATA_SIZEOF(create_destroy_addr));
0963     if (!iob)
0964         goto out;
0965 
0966     __ipa_cmd(iob)->data.create_destroy_addr.uid = uid;
0967     qeth_send_ipa_cmd(card, iob, qeth_l3_get_unique_id_cb, &uid);
0968 
0969 out:
0970     return uid;
0971 }
0972 
0973 static int
0974 qeth_diags_trace_cb(struct qeth_card *card, struct qeth_reply *reply,
0975                 unsigned long data)
0976 {
0977     struct qeth_ipa_cmd    *cmd;
0978     __u16 rc;
0979 
0980     QETH_CARD_TEXT(card, 2, "diastrcb");
0981 
0982     cmd = (struct qeth_ipa_cmd *)data;
0983     rc = cmd->hdr.return_code;
0984     if (rc)
0985         QETH_CARD_TEXT_(card, 2, "dxter%x", rc);
0986     switch (cmd->data.diagass.action) {
0987     case QETH_DIAGS_CMD_TRACE_QUERY:
0988         break;
0989     case QETH_DIAGS_CMD_TRACE_DISABLE:
0990         switch (rc) {
0991         case 0:
0992         case IPA_RC_INVALID_SUBCMD:
0993             card->info.promisc_mode = SET_PROMISC_MODE_OFF;
0994             dev_info(&card->gdev->dev, "The HiperSockets network "
0995                 "traffic analyzer is deactivated\n");
0996             break;
0997         default:
0998             break;
0999         }
1000         break;
1001     case QETH_DIAGS_CMD_TRACE_ENABLE:
1002         switch (rc) {
1003         case 0:
1004             card->info.promisc_mode = SET_PROMISC_MODE_ON;
1005             dev_info(&card->gdev->dev, "The HiperSockets network "
1006                 "traffic analyzer is activated\n");
1007             break;
1008         case IPA_RC_HARDWARE_AUTH_ERROR:
1009             dev_warn(&card->gdev->dev, "The device is not "
1010                 "authorized to run as a HiperSockets network "
1011                 "traffic analyzer\n");
1012             break;
1013         case IPA_RC_TRACE_ALREADY_ACTIVE:
1014             dev_warn(&card->gdev->dev, "A HiperSockets "
1015                 "network traffic analyzer is already "
1016                 "active in the HiperSockets LAN\n");
1017             break;
1018         default:
1019             break;
1020         }
1021         break;
1022     default:
1023         QETH_DBF_MESSAGE(2, "Unknown sniffer action (%#06x) on device %x\n",
1024                  cmd->data.diagass.action, CARD_DEVID(card));
1025     }
1026 
1027     return rc ? -EIO : 0;
1028 }
1029 
1030 static int
1031 qeth_diags_trace(struct qeth_card *card, enum qeth_diags_trace_cmds diags_cmd)
1032 {
1033     struct qeth_cmd_buffer *iob;
1034     struct qeth_ipa_cmd    *cmd;
1035 
1036     QETH_CARD_TEXT(card, 2, "diagtrac");
1037 
1038     iob = qeth_get_diag_cmd(card, QETH_DIAGS_CMD_TRACE, 0);
1039     if (!iob)
1040         return -ENOMEM;
1041     cmd = __ipa_cmd(iob);
1042     cmd->data.diagass.type = QETH_DIAGS_TYPE_HIPERSOCKET;
1043     cmd->data.diagass.action = diags_cmd;
1044     return qeth_send_ipa_cmd(card, iob, qeth_diags_trace_cb, NULL);
1045 }
1046 
1047 static int qeth_l3_add_mcast_rtnl(struct net_device *dev, int vid, void *arg)
1048 {
1049     struct qeth_card *card = arg;
1050     struct inet6_dev *in6_dev;
1051     struct in_device *in4_dev;
1052     struct qeth_ipaddr *ipm;
1053     struct qeth_ipaddr tmp;
1054     struct ip_mc_list *im4;
1055     struct ifmcaddr6 *im6;
1056 
1057     QETH_CARD_TEXT(card, 4, "addmc");
1058 
1059     if (!dev || !(dev->flags & IFF_UP))
1060         goto out;
1061 
1062     in4_dev = __in_dev_get_rtnl(dev);
1063     if (!in4_dev)
1064         goto walk_ipv6;
1065 
1066     qeth_l3_init_ipaddr(&tmp, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV4);
1067     tmp.disp_flag = QETH_DISP_ADDR_ADD;
1068     tmp.is_multicast = 1;
1069 
1070     for (im4 = rtnl_dereference(in4_dev->mc_list); im4 != NULL;
1071          im4 = rtnl_dereference(im4->next_rcu)) {
1072         tmp.u.a4.addr = im4->multiaddr;
1073 
1074         ipm = qeth_l3_find_addr_by_ip(card, &tmp);
1075         if (ipm) {
1076             /* for mcast, by-IP match means full match */
1077             ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1078             continue;
1079         }
1080 
1081         ipm = kmemdup(&tmp, sizeof(tmp), GFP_KERNEL);
1082         if (!ipm)
1083             continue;
1084 
1085         hash_add(card->rx_mode_addrs, &ipm->hnode,
1086              qeth_l3_ipaddr_hash(ipm));
1087     }
1088 
1089 walk_ipv6:
1090     if (!qeth_is_supported(card, IPA_IPV6))
1091         goto out;
1092 
1093     in6_dev = __in6_dev_get(dev);
1094     if (!in6_dev)
1095         goto out;
1096 
1097     qeth_l3_init_ipaddr(&tmp, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV6);
1098     tmp.disp_flag = QETH_DISP_ADDR_ADD;
1099     tmp.is_multicast = 1;
1100 
1101     for (im6 = rtnl_dereference(in6_dev->mc_list);
1102          im6;
1103          im6 = rtnl_dereference(im6->next)) {
1104         tmp.u.a6.addr = im6->mca_addr;
1105 
1106         ipm = qeth_l3_find_addr_by_ip(card, &tmp);
1107         if (ipm) {
1108             /* for mcast, by-IP match means full match */
1109             ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1110             continue;
1111         }
1112 
1113         ipm = kmemdup(&tmp, sizeof(tmp), GFP_ATOMIC);
1114         if (!ipm)
1115             continue;
1116 
1117         hash_add(card->rx_mode_addrs, &ipm->hnode,
1118              qeth_l3_ipaddr_hash(ipm));
1119 
1120     }
1121 
1122 out:
1123     return 0;
1124 }
1125 
1126 static void qeth_l3_set_promisc_mode(struct qeth_card *card)
1127 {
1128     bool enable = card->dev->flags & IFF_PROMISC;
1129 
1130     if (card->info.promisc_mode == enable)
1131         return;
1132 
1133     if (IS_VM_NIC(card)) {      /* Guestlan trace */
1134         if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
1135             qeth_setadp_promisc_mode(card, enable);
1136     } else if (card->options.sniffer && /* HiperSockets trace */
1137            qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) {
1138         if (enable) {
1139             QETH_CARD_TEXT(card, 3, "+promisc");
1140             qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE);
1141         } else {
1142             QETH_CARD_TEXT(card, 3, "-promisc");
1143             qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1144         }
1145     }
1146 }
1147 
1148 static void qeth_l3_rx_mode_work(struct work_struct *work)
1149 {
1150     struct qeth_card *card = container_of(work, struct qeth_card,
1151                           rx_mode_work);
1152     struct qeth_ipaddr *addr;
1153     struct hlist_node *tmp;
1154     int i, rc;
1155 
1156     QETH_CARD_TEXT(card, 3, "setmulti");
1157 
1158     if (!card->options.sniffer) {
1159         rtnl_lock();
1160         qeth_l3_add_mcast_rtnl(card->dev, 0, card);
1161         if (qeth_is_supported(card, IPA_FULL_VLAN))
1162             vlan_for_each(card->dev, qeth_l3_add_mcast_rtnl, card);
1163         rtnl_unlock();
1164 
1165         hash_for_each_safe(card->rx_mode_addrs, i, tmp, addr, hnode) {
1166             switch (addr->disp_flag) {
1167             case QETH_DISP_ADDR_DELETE:
1168                 rc = qeth_l3_deregister_addr_entry(card, addr);
1169                 if (!rc || rc == -ENOENT) {
1170                     hash_del(&addr->hnode);
1171                     kfree(addr);
1172                 }
1173                 break;
1174             case QETH_DISP_ADDR_ADD:
1175                 rc = qeth_l3_register_addr_entry(card, addr);
1176                 if (rc && rc != -ENETDOWN) {
1177                     hash_del(&addr->hnode);
1178                     kfree(addr);
1179                     break;
1180                 }
1181                 fallthrough;
1182             default:
1183                 /* for next call to set_rx_mode(): */
1184                 addr->disp_flag = QETH_DISP_ADDR_DELETE;
1185             }
1186         }
1187     }
1188 
1189     qeth_l3_set_promisc_mode(card);
1190 }
1191 
1192 static int qeth_l3_arp_makerc(u16 rc)
1193 {
1194     switch (rc) {
1195     case IPA_RC_SUCCESS:
1196         return 0;
1197     case QETH_IPA_ARP_RC_NOTSUPP:
1198     case QETH_IPA_ARP_RC_Q_NOTSUPP:
1199         return -EOPNOTSUPP;
1200     case QETH_IPA_ARP_RC_OUT_OF_RANGE:
1201         return -EINVAL;
1202     case QETH_IPA_ARP_RC_Q_NO_DATA:
1203         return -ENOENT;
1204     default:
1205         return -EIO;
1206     }
1207 }
1208 
1209 static int qeth_l3_arp_cmd_cb(struct qeth_card *card, struct qeth_reply *reply,
1210                   unsigned long data)
1211 {
1212     struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1213 
1214     qeth_setassparms_cb(card, reply, data);
1215     return qeth_l3_arp_makerc(cmd->hdr.return_code);
1216 }
1217 
1218 static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
1219 {
1220     struct qeth_cmd_buffer *iob;
1221     int rc;
1222 
1223     QETH_CARD_TEXT(card, 3, "arpstnoe");
1224 
1225     /*
1226      * currently GuestLAN only supports the ARP assist function
1227      * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
1228      * thus we say EOPNOTSUPP for this ARP function
1229      */
1230     if (IS_VM_NIC(card))
1231         return -EOPNOTSUPP;
1232     if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1233         return -EOPNOTSUPP;
1234     }
1235 
1236     iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
1237                        IPA_CMD_ASS_ARP_SET_NO_ENTRIES,
1238                        SETASS_DATA_SIZEOF(flags_32bit),
1239                        QETH_PROT_IPV4);
1240     if (!iob)
1241         return -ENOMEM;
1242 
1243     __ipa_cmd(iob)->data.setassparms.data.flags_32bit = (u32) no_entries;
1244     rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL);
1245     if (rc)
1246         QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on device %x: %#x\n",
1247                  CARD_DEVID(card), rc);
1248     return rc;
1249 }
1250 
1251 static __u32 get_arp_entry_size(struct qeth_card *card,
1252             struct qeth_arp_query_data *qdata,
1253             struct qeth_arp_entrytype *type, __u8 strip_entries)
1254 {
1255     __u32 rc;
1256     __u8 is_hsi;
1257 
1258     is_hsi = qdata->reply_bits == 5;
1259     if (type->ip == QETHARP_IP_ADDR_V4) {
1260         QETH_CARD_TEXT(card, 4, "arpev4");
1261         if (strip_entries) {
1262             rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5_short) :
1263                 sizeof(struct qeth_arp_qi_entry7_short);
1264         } else {
1265             rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5) :
1266                 sizeof(struct qeth_arp_qi_entry7);
1267         }
1268     } else if (type->ip == QETHARP_IP_ADDR_V6) {
1269         QETH_CARD_TEXT(card, 4, "arpev6");
1270         if (strip_entries) {
1271             rc = is_hsi ?
1272                 sizeof(struct qeth_arp_qi_entry5_short_ipv6) :
1273                 sizeof(struct qeth_arp_qi_entry7_short_ipv6);
1274         } else {
1275             rc = is_hsi ?
1276                 sizeof(struct qeth_arp_qi_entry5_ipv6) :
1277                 sizeof(struct qeth_arp_qi_entry7_ipv6);
1278         }
1279     } else {
1280         QETH_CARD_TEXT(card, 4, "arpinv");
1281         rc = 0;
1282     }
1283 
1284     return rc;
1285 }
1286 
1287 static int arpentry_matches_prot(struct qeth_arp_entrytype *type, __u16 prot)
1288 {
1289     return (type->ip == QETHARP_IP_ADDR_V4 && prot == QETH_PROT_IPV4) ||
1290         (type->ip == QETHARP_IP_ADDR_V6 && prot == QETH_PROT_IPV6);
1291 }
1292 
1293 static int qeth_l3_arp_query_cb(struct qeth_card *card,
1294         struct qeth_reply *reply, unsigned long data)
1295 {
1296     struct qeth_ipa_cmd *cmd;
1297     struct qeth_arp_query_data *qdata;
1298     struct qeth_arp_query_info *qinfo;
1299     int e;
1300     int entrybytes_done;
1301     int stripped_bytes;
1302     __u8 do_strip_entries;
1303 
1304     QETH_CARD_TEXT(card, 3, "arpquecb");
1305 
1306     qinfo = (struct qeth_arp_query_info *) reply->param;
1307     cmd = (struct qeth_ipa_cmd *) data;
1308     QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.prot_version);
1309     if (cmd->hdr.return_code) {
1310         QETH_CARD_TEXT(card, 4, "arpcberr");
1311         QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
1312         return qeth_l3_arp_makerc(cmd->hdr.return_code);
1313     }
1314     if (cmd->data.setassparms.hdr.return_code) {
1315         cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
1316         QETH_CARD_TEXT(card, 4, "setaperr");
1317         QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
1318         return qeth_l3_arp_makerc(cmd->hdr.return_code);
1319     }
1320     qdata = &cmd->data.setassparms.data.query_arp;
1321     QETH_CARD_TEXT_(card, 4, "anoen%i", qdata->no_entries);
1322 
1323     do_strip_entries = (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) > 0;
1324     stripped_bytes = do_strip_entries ? QETH_QARP_MEDIASPECIFIC_BYTES : 0;
1325     entrybytes_done = 0;
1326     for (e = 0; e < qdata->no_entries; ++e) {
1327         char *cur_entry;
1328         __u32 esize;
1329         struct qeth_arp_entrytype *etype;
1330 
1331         cur_entry = &qdata->data + entrybytes_done;
1332         etype = &((struct qeth_arp_qi_entry5 *) cur_entry)->type;
1333         if (!arpentry_matches_prot(etype, cmd->hdr.prot_version)) {
1334             QETH_CARD_TEXT(card, 4, "pmis");
1335             QETH_CARD_TEXT_(card, 4, "%i", etype->ip);
1336             break;
1337         }
1338         esize = get_arp_entry_size(card, qdata, etype,
1339             do_strip_entries);
1340         QETH_CARD_TEXT_(card, 5, "esz%i", esize);
1341         if (!esize)
1342             break;
1343 
1344         if ((qinfo->udata_len - qinfo->udata_offset) < esize) {
1345             QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOSPC);
1346             memset(qinfo->udata, 0, 4);
1347             return -ENOSPC;
1348         }
1349 
1350         memcpy(qinfo->udata + qinfo->udata_offset,
1351             &qdata->data + entrybytes_done + stripped_bytes,
1352             esize);
1353         entrybytes_done += esize + stripped_bytes;
1354         qinfo->udata_offset += esize;
1355         ++qinfo->no_entries;
1356     }
1357     /* check if all replies received ... */
1358     if (cmd->data.setassparms.hdr.seq_no <
1359         cmd->data.setassparms.hdr.number_of_replies)
1360         return 1;
1361     QETH_CARD_TEXT_(card, 4, "nove%i", qinfo->no_entries);
1362     memcpy(qinfo->udata, &qinfo->no_entries, 4);
1363     /* keep STRIP_ENTRIES flag so the user program can distinguish
1364      * stripped entries from normal ones */
1365     if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
1366         qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES;
1367     memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2);
1368     QETH_CARD_TEXT_(card, 4, "rc%i", 0);
1369     return 0;
1370 }
1371 
1372 static int qeth_l3_query_arp_cache_info(struct qeth_card *card,
1373     enum qeth_prot_versions prot,
1374     struct qeth_arp_query_info *qinfo)
1375 {
1376     struct qeth_cmd_buffer *iob;
1377     struct qeth_ipa_cmd *cmd;
1378     int rc;
1379 
1380     QETH_CARD_TEXT_(card, 3, "qarpipv%i", prot);
1381 
1382     iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
1383                        IPA_CMD_ASS_ARP_QUERY_INFO,
1384                        SETASS_DATA_SIZEOF(query_arp), prot);
1385     if (!iob)
1386         return -ENOMEM;
1387     cmd = __ipa_cmd(iob);
1388     cmd->data.setassparms.data.query_arp.request_bits = 0x000F;
1389     rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_query_cb, qinfo);
1390     if (rc)
1391         QETH_DBF_MESSAGE(2, "Error while querying ARP cache on device %x: %#x\n",
1392                  CARD_DEVID(card), rc);
1393     return rc;
1394 }
1395 
1396 static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
1397 {
1398     struct qeth_arp_query_info qinfo = {0, };
1399     int rc;
1400 
1401     QETH_CARD_TEXT(card, 3, "arpquery");
1402 
1403     if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
1404                    IPA_ARP_PROCESSING)) {
1405         QETH_CARD_TEXT(card, 3, "arpqnsup");
1406         rc = -EOPNOTSUPP;
1407         goto out;
1408     }
1409     /* get size of userspace buffer and mask_bits -> 6 bytes */
1410     if (copy_from_user(&qinfo, udata, 6)) {
1411         rc = -EFAULT;
1412         goto out;
1413     }
1414     qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL);
1415     if (!qinfo.udata) {
1416         rc = -ENOMEM;
1417         goto out;
1418     }
1419     qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
1420     rc = qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV4, &qinfo);
1421     if (rc) {
1422         if (copy_to_user(udata, qinfo.udata, 4))
1423             rc = -EFAULT;
1424         goto free_and_out;
1425     }
1426     if (qinfo.mask_bits & QETH_QARP_WITH_IPV6) {
1427         /* fails in case of GuestLAN QDIO mode */
1428         qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV6, &qinfo);
1429     }
1430     if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) {
1431         QETH_CARD_TEXT(card, 4, "qactf");
1432         rc = -EFAULT;
1433         goto free_and_out;
1434     }
1435     QETH_CARD_TEXT(card, 4, "qacts");
1436 
1437 free_and_out:
1438     kfree(qinfo.udata);
1439 out:
1440     return rc;
1441 }
1442 
1443 static int qeth_l3_arp_modify_entry(struct qeth_card *card,
1444                     struct qeth_arp_cache_entry *entry,
1445                     enum qeth_arp_process_subcmds arp_cmd)
1446 {
1447     struct qeth_arp_cache_entry *cmd_entry;
1448     struct qeth_cmd_buffer *iob;
1449     int rc;
1450 
1451     if (arp_cmd == IPA_CMD_ASS_ARP_ADD_ENTRY)
1452         QETH_CARD_TEXT(card, 3, "arpadd");
1453     else
1454         QETH_CARD_TEXT(card, 3, "arpdel");
1455 
1456     /*
1457      * currently GuestLAN only supports the ARP assist function
1458      * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
1459      * thus we say EOPNOTSUPP for this ARP function
1460      */
1461     if (IS_VM_NIC(card))
1462         return -EOPNOTSUPP;
1463     if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1464         return -EOPNOTSUPP;
1465     }
1466 
1467     iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING, arp_cmd,
1468                        SETASS_DATA_SIZEOF(arp_entry),
1469                        QETH_PROT_IPV4);
1470     if (!iob)
1471         return -ENOMEM;
1472 
1473     cmd_entry = &__ipa_cmd(iob)->data.setassparms.data.arp_entry;
1474     ether_addr_copy(cmd_entry->macaddr, entry->macaddr);
1475     memcpy(cmd_entry->ipaddr, entry->ipaddr, 4);
1476     rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL);
1477     if (rc)
1478         QETH_DBF_MESSAGE(2, "Could not modify (cmd: %#x) ARP entry on device %x: %#x\n",
1479                  arp_cmd, CARD_DEVID(card), rc);
1480     return rc;
1481 }
1482 
1483 static int qeth_l3_arp_flush_cache(struct qeth_card *card)
1484 {
1485     struct qeth_cmd_buffer *iob;
1486     int rc;
1487 
1488     QETH_CARD_TEXT(card, 3, "arpflush");
1489 
1490     /*
1491      * currently GuestLAN only supports the ARP assist function
1492      * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
1493      * thus we say EOPNOTSUPP for this ARP function
1494     */
1495     if (IS_VM_NIC(card) || IS_IQD(card))
1496         return -EOPNOTSUPP;
1497     if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1498         return -EOPNOTSUPP;
1499     }
1500 
1501     iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
1502                        IPA_CMD_ASS_ARP_FLUSH_CACHE, 0,
1503                        QETH_PROT_IPV4);
1504     if (!iob)
1505         return -ENOMEM;
1506 
1507     rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL);
1508     if (rc)
1509         QETH_DBF_MESSAGE(2, "Could not flush ARP cache on device %x: %#x\n",
1510                  CARD_DEVID(card), rc);
1511     return rc;
1512 }
1513 
1514 static int qeth_l3_ndo_siocdevprivate(struct net_device *dev, struct ifreq *rq,
1515                       void __user *data, int cmd)
1516 {
1517     struct qeth_card *card = dev->ml_priv;
1518     struct qeth_arp_cache_entry arp_entry;
1519     enum qeth_arp_process_subcmds arp_cmd;
1520     int rc = 0;
1521 
1522     switch (cmd) {
1523     case SIOC_QETH_ARP_SET_NO_ENTRIES:
1524         if (!capable(CAP_NET_ADMIN)) {
1525             rc = -EPERM;
1526             break;
1527         }
1528         rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue);
1529         break;
1530     case SIOC_QETH_ARP_QUERY_INFO:
1531         if (!capable(CAP_NET_ADMIN)) {
1532             rc = -EPERM;
1533             break;
1534         }
1535         rc = qeth_l3_arp_query(card, data);
1536         break;
1537     case SIOC_QETH_ARP_ADD_ENTRY:
1538     case SIOC_QETH_ARP_REMOVE_ENTRY:
1539         if (!capable(CAP_NET_ADMIN))
1540             return -EPERM;
1541         if (copy_from_user(&arp_entry, data, sizeof(arp_entry)))
1542             return -EFAULT;
1543 
1544         arp_cmd = (cmd == SIOC_QETH_ARP_ADD_ENTRY) ?
1545                 IPA_CMD_ASS_ARP_ADD_ENTRY :
1546                 IPA_CMD_ASS_ARP_REMOVE_ENTRY;
1547         return qeth_l3_arp_modify_entry(card, &arp_entry, arp_cmd);
1548     case SIOC_QETH_ARP_FLUSH_CACHE:
1549         if (!capable(CAP_NET_ADMIN)) {
1550             rc = -EPERM;
1551             break;
1552         }
1553         rc = qeth_l3_arp_flush_cache(card);
1554         break;
1555     default:
1556         rc = qeth_siocdevprivate(dev, rq, data, cmd);
1557     }
1558     return rc;
1559 }
1560 
1561 static int qeth_l3_get_cast_type_rcu(struct sk_buff *skb, struct dst_entry *dst,
1562                      __be16 proto)
1563 {
1564     struct neighbour *n = NULL;
1565 
1566     if (dst)
1567         n = dst_neigh_lookup_skb(dst, skb);
1568 
1569     if (n) {
1570         int cast_type = n->type;
1571 
1572         neigh_release(n);
1573         if ((cast_type == RTN_BROADCAST) ||
1574             (cast_type == RTN_MULTICAST) ||
1575             (cast_type == RTN_ANYCAST))
1576             return cast_type;
1577         return RTN_UNICAST;
1578     }
1579 
1580     /* no neighbour (eg AF_PACKET), fall back to target's IP address ... */
1581     switch (proto) {
1582     case htons(ETH_P_IP):
1583         if (ipv4_is_lbcast(ip_hdr(skb)->daddr))
1584             return RTN_BROADCAST;
1585         return ipv4_is_multicast(ip_hdr(skb)->daddr) ?
1586                 RTN_MULTICAST : RTN_UNICAST;
1587     case htons(ETH_P_IPV6):
1588         return ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr) ?
1589                 RTN_MULTICAST : RTN_UNICAST;
1590     case htons(ETH_P_AF_IUCV):
1591         return RTN_UNICAST;
1592     default:
1593         /* OSA only: ... and MAC address */
1594         return qeth_get_ether_cast_type(skb);
1595     }
1596 }
1597 
1598 static int qeth_l3_get_cast_type(struct sk_buff *skb, __be16 proto)
1599 {
1600     struct dst_entry *dst;
1601     int cast_type;
1602 
1603     rcu_read_lock();
1604     dst = qeth_dst_check_rcu(skb, proto);
1605     cast_type = qeth_l3_get_cast_type_rcu(skb, dst, proto);
1606     rcu_read_unlock();
1607 
1608     return cast_type;
1609 }
1610 
1611 static u8 qeth_l3_cast_type_to_flag(int cast_type)
1612 {
1613     if (cast_type == RTN_MULTICAST)
1614         return QETH_CAST_MULTICAST;
1615     if (cast_type == RTN_ANYCAST)
1616         return QETH_CAST_ANYCAST;
1617     if (cast_type == RTN_BROADCAST)
1618         return QETH_CAST_BROADCAST;
1619     return QETH_CAST_UNICAST;
1620 }
1621 
1622 static void qeth_l3_fill_header(struct qeth_qdio_out_q *queue,
1623                 struct qeth_hdr *hdr, struct sk_buff *skb,
1624                 __be16 proto, unsigned int data_len)
1625 {
1626     struct qeth_hdr_layer3 *l3_hdr = &hdr->hdr.l3;
1627     struct vlan_ethhdr *veth = vlan_eth_hdr(skb);
1628     struct qeth_card *card = queue->card;
1629     struct dst_entry *dst;
1630     int cast_type;
1631 
1632     hdr->hdr.l3.length = data_len;
1633 
1634     if (skb_is_gso(skb)) {
1635         hdr->hdr.l3.id = QETH_HEADER_TYPE_L3_TSO;
1636     } else {
1637         hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
1638 
1639         if (skb->ip_summed == CHECKSUM_PARTIAL) {
1640             qeth_tx_csum(skb, &hdr->hdr.l3.ext_flags, proto);
1641             /* some HW requires combined L3+L4 csum offload: */
1642             if (proto == htons(ETH_P_IP))
1643                 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_CSUM_HDR_REQ;
1644         }
1645     }
1646 
1647     if (proto == htons(ETH_P_IP) || IS_IQD(card)) {
1648         /* NETIF_F_HW_VLAN_CTAG_TX */
1649         if (skb_vlan_tag_present(skb)) {
1650             hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_VLAN_FRAME;
1651             hdr->hdr.l3.vlan_id = skb_vlan_tag_get(skb);
1652         }
1653     } else if (veth->h_vlan_proto == htons(ETH_P_8021Q)) {
1654         hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_INCLUDE_VLAN_TAG;
1655         hdr->hdr.l3.vlan_id = ntohs(veth->h_vlan_TCI);
1656     }
1657 
1658     rcu_read_lock();
1659     dst = qeth_dst_check_rcu(skb, proto);
1660 
1661     if (IS_IQD(card) && skb_get_queue_mapping(skb) != QETH_IQD_MCAST_TXQ)
1662         cast_type = RTN_UNICAST;
1663     else
1664         cast_type = qeth_l3_get_cast_type_rcu(skb, dst, proto);
1665     l3_hdr->flags |= qeth_l3_cast_type_to_flag(cast_type);
1666 
1667     switch (proto) {
1668     case htons(ETH_P_IP):
1669         l3_hdr->next_hop.addr.s6_addr32[3] =
1670                     qeth_next_hop_v4_rcu(skb, dst);
1671         break;
1672     case htons(ETH_P_IPV6):
1673         l3_hdr->next_hop.addr = *qeth_next_hop_v6_rcu(skb, dst);
1674 
1675         hdr->hdr.l3.flags |= QETH_HDR_IPV6;
1676         if (!IS_IQD(card))
1677             hdr->hdr.l3.flags |= QETH_HDR_PASSTHRU;
1678         break;
1679     case htons(ETH_P_AF_IUCV):
1680         l3_hdr->next_hop.addr.s6_addr16[0] = htons(0xfe80);
1681         memcpy(&l3_hdr->next_hop.addr.s6_addr32[2],
1682                iucv_trans_hdr(skb)->destUserID, 8);
1683         l3_hdr->flags |= QETH_HDR_IPV6;
1684         break;
1685     default:
1686         /* OSA only: */
1687         l3_hdr->flags |= QETH_HDR_PASSTHRU;
1688     }
1689     rcu_read_unlock();
1690 }
1691 
1692 static void qeth_l3_fixup_headers(struct sk_buff *skb)
1693 {
1694     struct iphdr *iph = ip_hdr(skb);
1695 
1696     /* this is safe, IPv6 traffic takes a different path */
1697     if (skb->ip_summed == CHECKSUM_PARTIAL)
1698         iph->check = 0;
1699     if (skb_is_gso(skb)) {
1700         iph->tot_len = 0;
1701         tcp_hdr(skb)->check = ~tcp_v4_check(0, iph->saddr,
1702                             iph->daddr, 0);
1703     }
1704 }
1705 
1706 static int qeth_l3_xmit(struct qeth_card *card, struct sk_buff *skb,
1707             struct qeth_qdio_out_q *queue, __be16 proto)
1708 {
1709     unsigned int hw_hdr_len;
1710     int rc;
1711 
1712     /* re-use the L2 header area for the HW header: */
1713     hw_hdr_len = skb_is_gso(skb) ? sizeof(struct qeth_hdr_tso) :
1714                        sizeof(struct qeth_hdr);
1715     rc = skb_cow_head(skb, hw_hdr_len - ETH_HLEN);
1716     if (rc)
1717         return rc;
1718     skb_pull(skb, ETH_HLEN);
1719 
1720     qeth_l3_fixup_headers(skb);
1721     return qeth_xmit(card, skb, queue, proto, qeth_l3_fill_header);
1722 }
1723 
1724 static netdev_tx_t qeth_l3_hard_start_xmit(struct sk_buff *skb,
1725                        struct net_device *dev)
1726 {
1727     struct qeth_card *card = dev->ml_priv;
1728     __be16 proto = vlan_get_protocol(skb);
1729     u16 txq = skb_get_queue_mapping(skb);
1730     struct qeth_qdio_out_q *queue;
1731     int rc;
1732 
1733     if (!skb_is_gso(skb))
1734         qdisc_skb_cb(skb)->pkt_len = skb->len;
1735     if (IS_IQD(card)) {
1736         queue = card->qdio.out_qs[qeth_iqd_translate_txq(dev, txq)];
1737 
1738         if (card->options.sniffer)
1739             goto tx_drop;
1740 
1741         switch (proto) {
1742         case htons(ETH_P_AF_IUCV):
1743             if (card->options.cq != QETH_CQ_ENABLED)
1744                 goto tx_drop;
1745             break;
1746         case htons(ETH_P_IP):
1747         case htons(ETH_P_IPV6):
1748             if (card->options.cq == QETH_CQ_ENABLED)
1749                 goto tx_drop;
1750             break;
1751         default:
1752             goto tx_drop;
1753         }
1754     } else {
1755         queue = card->qdio.out_qs[txq];
1756     }
1757 
1758     if (!(dev->flags & IFF_BROADCAST) &&
1759         qeth_l3_get_cast_type(skb, proto) == RTN_BROADCAST)
1760         goto tx_drop;
1761 
1762     if (proto == htons(ETH_P_IP) || IS_IQD(card))
1763         rc = qeth_l3_xmit(card, skb, queue, proto);
1764     else
1765         rc = qeth_xmit(card, skb, queue, proto, qeth_l3_fill_header);
1766 
1767     if (!rc)
1768         return NETDEV_TX_OK;
1769 
1770 tx_drop:
1771     QETH_TXQ_STAT_INC(queue, tx_dropped);
1772     kfree_skb(skb);
1773     return NETDEV_TX_OK;
1774 }
1775 
1776 static void qeth_l3_set_rx_mode(struct net_device *dev)
1777 {
1778     struct qeth_card *card = dev->ml_priv;
1779 
1780     schedule_work(&card->rx_mode_work);
1781 }
1782 
1783 /*
1784  * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
1785  * NOARP on the netdevice is no option because it also turns off neighbor
1786  * solicitation. For IPv4 we install a neighbor_setup function. We don't want
1787  * arp resolution but we want the hard header (packet socket will work
1788  * e.g. tcpdump)
1789  */
1790 static int qeth_l3_neigh_setup_noarp(struct neighbour *n)
1791 {
1792     n->nud_state = NUD_NOARP;
1793     memcpy(n->ha, "FAKELL", 6);
1794     n->output = n->ops->connected_output;
1795     return 0;
1796 }
1797 
1798 static int
1799 qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np)
1800 {
1801     if (np->tbl->family == AF_INET)
1802         np->neigh_setup = qeth_l3_neigh_setup_noarp;
1803 
1804     return 0;
1805 }
1806 
1807 static netdev_features_t qeth_l3_osa_features_check(struct sk_buff *skb,
1808                             struct net_device *dev,
1809                             netdev_features_t features)
1810 {
1811     if (vlan_get_protocol(skb) != htons(ETH_P_IP))
1812         features &= ~NETIF_F_HW_VLAN_CTAG_TX;
1813     return qeth_features_check(skb, dev, features);
1814 }
1815 
1816 static u16 qeth_l3_iqd_select_queue(struct net_device *dev, struct sk_buff *skb,
1817                     struct net_device *sb_dev)
1818 {
1819     __be16 proto = vlan_get_protocol(skb);
1820 
1821     return qeth_iqd_select_queue(dev, skb,
1822                      qeth_l3_get_cast_type(skb, proto), sb_dev);
1823 }
1824 
1825 static const struct net_device_ops qeth_l3_netdev_ops = {
1826     .ndo_open       = qeth_open,
1827     .ndo_stop       = qeth_stop,
1828     .ndo_get_stats64    = qeth_get_stats64,
1829     .ndo_start_xmit     = qeth_l3_hard_start_xmit,
1830     .ndo_select_queue   = qeth_l3_iqd_select_queue,
1831     .ndo_validate_addr  = eth_validate_addr,
1832     .ndo_set_rx_mode    = qeth_l3_set_rx_mode,
1833     .ndo_eth_ioctl      = qeth_do_ioctl,
1834     .ndo_siocdevprivate = qeth_l3_ndo_siocdevprivate,
1835     .ndo_fix_features   = qeth_fix_features,
1836     .ndo_set_features   = qeth_set_features,
1837     .ndo_tx_timeout     = qeth_tx_timeout,
1838 };
1839 
1840 static const struct net_device_ops qeth_l3_osa_netdev_ops = {
1841     .ndo_open       = qeth_open,
1842     .ndo_stop       = qeth_stop,
1843     .ndo_get_stats64    = qeth_get_stats64,
1844     .ndo_start_xmit     = qeth_l3_hard_start_xmit,
1845     .ndo_features_check = qeth_l3_osa_features_check,
1846     .ndo_select_queue   = qeth_osa_select_queue,
1847     .ndo_validate_addr  = eth_validate_addr,
1848     .ndo_set_rx_mode    = qeth_l3_set_rx_mode,
1849     .ndo_eth_ioctl      = qeth_do_ioctl,
1850     .ndo_siocdevprivate = qeth_l3_ndo_siocdevprivate,
1851     .ndo_fix_features   = qeth_fix_features,
1852     .ndo_set_features   = qeth_set_features,
1853     .ndo_tx_timeout     = qeth_tx_timeout,
1854     .ndo_neigh_setup    = qeth_l3_neigh_setup,
1855 };
1856 
1857 static int qeth_l3_setup_netdev(struct qeth_card *card)
1858 {
1859     struct net_device *dev = card->dev;
1860     unsigned int headroom;
1861     int rc;
1862 
1863     if (IS_OSD(card) || IS_OSX(card)) {
1864         card->dev->netdev_ops = &qeth_l3_osa_netdev_ops;
1865 
1866         /*IPv6 address autoconfiguration stuff*/
1867         dev->dev_id = qeth_l3_get_unique_id(card, dev->dev_id);
1868 
1869         if (!IS_VM_NIC(card)) {
1870             card->dev->features |= NETIF_F_SG;
1871             card->dev->hw_features |= NETIF_F_TSO |
1872                 NETIF_F_RXCSUM | NETIF_F_IP_CSUM;
1873             card->dev->vlan_features |= NETIF_F_TSO |
1874                 NETIF_F_RXCSUM | NETIF_F_IP_CSUM;
1875         }
1876 
1877         if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) {
1878             card->dev->hw_features |= NETIF_F_IPV6_CSUM;
1879             card->dev->vlan_features |= NETIF_F_IPV6_CSUM;
1880         }
1881         if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) {
1882             card->dev->hw_features |= NETIF_F_TSO6;
1883             card->dev->vlan_features |= NETIF_F_TSO6;
1884         }
1885 
1886         /* allow for de-acceleration of NETIF_F_HW_VLAN_CTAG_TX: */
1887         if (card->dev->hw_features & NETIF_F_TSO6)
1888             headroom = sizeof(struct qeth_hdr_tso) + VLAN_HLEN;
1889         else if (card->dev->hw_features & NETIF_F_TSO)
1890             headroom = sizeof(struct qeth_hdr_tso);
1891         else
1892             headroom = sizeof(struct qeth_hdr) + VLAN_HLEN;
1893     } else if (IS_IQD(card)) {
1894         card->dev->flags |= IFF_NOARP;
1895         card->dev->netdev_ops = &qeth_l3_netdev_ops;
1896         headroom = sizeof(struct qeth_hdr) - ETH_HLEN;
1897 
1898         rc = qeth_l3_iqd_read_initial_mac(card);
1899         if (rc)
1900             return rc;
1901     } else
1902         return -ENODEV;
1903 
1904     card->dev->needed_headroom = headroom;
1905     card->dev->features |=  NETIF_F_HW_VLAN_CTAG_TX |
1906                 NETIF_F_HW_VLAN_CTAG_RX;
1907 
1908     netif_keep_dst(card->dev);
1909     if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6))
1910         netif_set_tso_max_size(card->dev,
1911                        PAGE_SIZE * (QETH_MAX_BUFFER_ELEMENTS(card) - 1));
1912 
1913     netif_napi_add(card->dev, &card->napi, qeth_poll, NAPI_POLL_WEIGHT);
1914     return register_netdev(card->dev);
1915 }
1916 
1917 static const struct device_type qeth_l3_devtype = {
1918     .name = "qeth_layer3",
1919     .groups = qeth_l3_attr_groups,
1920 };
1921 
1922 static int qeth_l3_probe_device(struct ccwgroup_device *gdev)
1923 {
1924     struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1925     int rc;
1926 
1927     hash_init(card->ip_htable);
1928     mutex_init(&card->ip_lock);
1929     card->cmd_wq = alloc_ordered_workqueue("%s_cmd", 0,
1930                            dev_name(&gdev->dev));
1931     if (!card->cmd_wq)
1932         return -ENOMEM;
1933 
1934     if (gdev->dev.type) {
1935         rc = device_add_groups(&gdev->dev, qeth_l3_attr_groups);
1936         if (rc) {
1937             destroy_workqueue(card->cmd_wq);
1938             return rc;
1939         }
1940     } else {
1941         gdev->dev.type = &qeth_l3_devtype;
1942     }
1943 
1944     INIT_WORK(&card->rx_mode_work, qeth_l3_rx_mode_work);
1945     return 0;
1946 }
1947 
1948 static void qeth_l3_remove_device(struct ccwgroup_device *cgdev)
1949 {
1950     struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
1951 
1952     if (cgdev->dev.type != &qeth_l3_devtype)
1953         device_remove_groups(&cgdev->dev, qeth_l3_attr_groups);
1954 
1955     qeth_set_allowed_threads(card, 0, 1);
1956     wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
1957 
1958     if (cgdev->state == CCWGROUP_ONLINE)
1959         qeth_set_offline(card, card->discipline, false);
1960 
1961     if (card->dev->reg_state == NETREG_REGISTERED)
1962         unregister_netdev(card->dev);
1963 
1964     destroy_workqueue(card->cmd_wq);
1965     qeth_l3_clear_ip_htable(card, 0);
1966     qeth_l3_clear_ipato_list(card);
1967 }
1968 
1969 static int qeth_l3_set_online(struct qeth_card *card, bool carrier_ok)
1970 {
1971     struct net_device *dev = card->dev;
1972     int rc = 0;
1973 
1974     /* softsetup */
1975     QETH_CARD_TEXT(card, 2, "softsetp");
1976 
1977     rc = qeth_l3_setadapter_parms(card);
1978     if (rc)
1979         QETH_CARD_TEXT_(card, 2, "2err%04x", rc);
1980     if (!card->options.sniffer) {
1981         qeth_l3_start_ipassists(card);
1982 
1983         rc = qeth_l3_setrouting_v4(card);
1984         if (rc)
1985             QETH_CARD_TEXT_(card, 2, "4err%04x", rc);
1986         rc = qeth_l3_setrouting_v6(card);
1987         if (rc)
1988             QETH_CARD_TEXT_(card, 2, "5err%04x", rc);
1989     }
1990 
1991     card->state = CARD_STATE_SOFTSETUP;
1992 
1993     qeth_set_allowed_threads(card, 0xffffffff, 0);
1994     qeth_l3_recover_ip(card);
1995 
1996     if (dev->reg_state != NETREG_REGISTERED) {
1997         rc = qeth_l3_setup_netdev(card);
1998         if (rc)
1999             goto err_setup;
2000 
2001         if (carrier_ok)
2002             netif_carrier_on(dev);
2003     } else {
2004         rtnl_lock();
2005         rc = qeth_set_real_num_tx_queues(card,
2006                          qeth_tx_actual_queues(card));
2007         if (rc) {
2008             rtnl_unlock();
2009             goto err_set_queues;
2010         }
2011 
2012         if (carrier_ok)
2013             netif_carrier_on(dev);
2014         else
2015             netif_carrier_off(dev);
2016 
2017         netif_device_attach(dev);
2018         qeth_enable_hw_features(dev);
2019 
2020         if (card->info.open_when_online) {
2021             card->info.open_when_online = 0;
2022             dev_open(dev, NULL);
2023         }
2024         rtnl_unlock();
2025     }
2026     return 0;
2027 
2028 err_set_queues:
2029 err_setup:
2030     qeth_set_allowed_threads(card, 0, 1);
2031     card->state = CARD_STATE_DOWN;
2032     qeth_l3_clear_ip_htable(card, 1);
2033     return rc;
2034 }
2035 
2036 static void qeth_l3_set_offline(struct qeth_card *card)
2037 {
2038     qeth_set_allowed_threads(card, 0, 1);
2039     qeth_l3_drain_rx_mode_cache(card);
2040 
2041     if (card->options.sniffer &&
2042         (card->info.promisc_mode == SET_PROMISC_MODE_ON))
2043         qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
2044 
2045     if (card->state == CARD_STATE_SOFTSETUP) {
2046         card->state = CARD_STATE_DOWN;
2047         qeth_l3_clear_ip_htable(card, 1);
2048     }
2049 }
2050 
2051 /* Returns zero if the command is successfully "consumed" */
2052 static int qeth_l3_control_event(struct qeth_card *card,
2053                     struct qeth_ipa_cmd *cmd)
2054 {
2055     return 1;
2056 }
2057 
2058 const struct qeth_discipline qeth_l3_discipline = {
2059     .setup = qeth_l3_probe_device,
2060     .remove = qeth_l3_remove_device,
2061     .set_online = qeth_l3_set_online,
2062     .set_offline = qeth_l3_set_offline,
2063     .control_event_handler = qeth_l3_control_event,
2064 };
2065 EXPORT_SYMBOL_GPL(qeth_l3_discipline);
2066 
2067 static int qeth_l3_handle_ip_event(struct qeth_card *card,
2068                    struct qeth_ipaddr *addr,
2069                    unsigned long event)
2070 {
2071     switch (event) {
2072     case NETDEV_UP:
2073         qeth_l3_modify_ip(card, addr, true);
2074         return NOTIFY_OK;
2075     case NETDEV_DOWN:
2076         qeth_l3_modify_ip(card, addr, false);
2077         return NOTIFY_OK;
2078     default:
2079         return NOTIFY_DONE;
2080     }
2081 }
2082 
2083 struct qeth_l3_ip_event_work {
2084     struct work_struct work;
2085     struct qeth_card *card;
2086     struct qeth_ipaddr addr;
2087 };
2088 
2089 #define to_ip_work(w) container_of((w), struct qeth_l3_ip_event_work, work)
2090 
2091 static void qeth_l3_add_ip_worker(struct work_struct *work)
2092 {
2093     struct qeth_l3_ip_event_work *ip_work = to_ip_work(work);
2094 
2095     qeth_l3_modify_ip(ip_work->card, &ip_work->addr, true);
2096     kfree(work);
2097 }
2098 
2099 static void qeth_l3_delete_ip_worker(struct work_struct *work)
2100 {
2101     struct qeth_l3_ip_event_work *ip_work = to_ip_work(work);
2102 
2103     qeth_l3_modify_ip(ip_work->card, &ip_work->addr, false);
2104     kfree(work);
2105 }
2106 
2107 static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev)
2108 {
2109     if (is_vlan_dev(dev))
2110         dev = vlan_dev_real_dev(dev);
2111     if (dev->netdev_ops == &qeth_l3_osa_netdev_ops ||
2112         dev->netdev_ops == &qeth_l3_netdev_ops)
2113         return (struct qeth_card *) dev->ml_priv;
2114     return NULL;
2115 }
2116 
2117 static int qeth_l3_ip_event(struct notifier_block *this,
2118                 unsigned long event, void *ptr)
2119 {
2120     struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
2121     struct net_device *dev = ifa->ifa_dev->dev;
2122     struct qeth_ipaddr addr;
2123     struct qeth_card *card;
2124 
2125     card = qeth_l3_get_card_from_dev(dev);
2126     if (!card)
2127         return NOTIFY_DONE;
2128     QETH_CARD_TEXT(card, 3, "ipevent");
2129 
2130     qeth_l3_init_ipaddr(&addr, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV4);
2131     addr.u.a4.addr = ifa->ifa_address;
2132     addr.u.a4.mask = ifa->ifa_mask;
2133 
2134     return qeth_l3_handle_ip_event(card, &addr, event);
2135 }
2136 
2137 static struct notifier_block qeth_l3_ip_notifier = {
2138     qeth_l3_ip_event,
2139     NULL,
2140 };
2141 
2142 static int qeth_l3_ip6_event(struct notifier_block *this,
2143                  unsigned long event, void *ptr)
2144 {
2145     struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
2146     struct net_device *dev = ifa->idev->dev;
2147     struct qeth_l3_ip_event_work *ip_work;
2148     struct qeth_card *card;
2149 
2150     if (event != NETDEV_UP && event != NETDEV_DOWN)
2151         return NOTIFY_DONE;
2152 
2153     card = qeth_l3_get_card_from_dev(dev);
2154     if (!card)
2155         return NOTIFY_DONE;
2156     QETH_CARD_TEXT(card, 3, "ip6event");
2157     if (!qeth_is_supported(card, IPA_IPV6))
2158         return NOTIFY_DONE;
2159 
2160     ip_work = kmalloc(sizeof(*ip_work), GFP_ATOMIC);
2161     if (!ip_work)
2162         return NOTIFY_DONE;
2163 
2164     if (event == NETDEV_UP)
2165         INIT_WORK(&ip_work->work, qeth_l3_add_ip_worker);
2166     else
2167         INIT_WORK(&ip_work->work, qeth_l3_delete_ip_worker);
2168 
2169     ip_work->card = card;
2170     qeth_l3_init_ipaddr(&ip_work->addr, QETH_IP_TYPE_NORMAL,
2171                 QETH_PROT_IPV6);
2172     ip_work->addr.u.a6.addr = ifa->addr;
2173     ip_work->addr.u.a6.pfxlen = ifa->prefix_len;
2174 
2175     queue_work(card->cmd_wq, &ip_work->work);
2176     return NOTIFY_OK;
2177 }
2178 
2179 static struct notifier_block qeth_l3_ip6_notifier = {
2180     qeth_l3_ip6_event,
2181     NULL,
2182 };
2183 
2184 static int qeth_l3_register_notifiers(void)
2185 {
2186     int rc;
2187 
2188     QETH_DBF_TEXT(SETUP, 5, "regnotif");
2189     rc = register_inetaddr_notifier(&qeth_l3_ip_notifier);
2190     if (rc)
2191         return rc;
2192     rc = register_inet6addr_notifier(&qeth_l3_ip6_notifier);
2193     if (rc) {
2194         unregister_inetaddr_notifier(&qeth_l3_ip_notifier);
2195         return rc;
2196     }
2197     return 0;
2198 }
2199 
2200 static void qeth_l3_unregister_notifiers(void)
2201 {
2202     QETH_DBF_TEXT(SETUP, 5, "unregnot");
2203     WARN_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier));
2204     WARN_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier));
2205 }
2206 
2207 static int __init qeth_l3_init(void)
2208 {
2209     pr_info("register layer 3 discipline\n");
2210     return qeth_l3_register_notifiers();
2211 }
2212 
2213 static void __exit qeth_l3_exit(void)
2214 {
2215     qeth_l3_unregister_notifiers();
2216     pr_info("unregister layer 3 discipline\n");
2217 }
2218 
2219 module_init(qeth_l3_init);
2220 module_exit(qeth_l3_exit);
2221 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
2222 MODULE_DESCRIPTION("qeth layer 3 discipline");
2223 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!