1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright IBM Corp. 2007, 2009
4 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
5 * Frank Pavlic <fpavlic@de.ibm.com>,
6 * Thomas Spatzier <tspat@de.ibm.com>,
7 * Frank Blaschka <frank.blaschka@de.ibm.com>
10 #define KMSG_COMPONENT "qeth"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/bitops.h>
16 #include <linux/string.h>
17 #include <linux/errno.h>
18 #include <linux/kernel.h>
19 #include <linux/etherdevice.h>
22 #include <linux/ipv6.h>
23 #include <linux/inetdevice.h>
24 #include <linux/igmp.h>
25 #include <linux/slab.h>
26 #include <linux/if_ether.h>
27 #include <linux/if_vlan.h>
28 #include <linux/skbuff.h>
32 #include <net/route.h>
34 #include <net/ip6_route.h>
35 #include <net/ip6_fib.h>
36 #include <net/iucv/af_iucv.h>
37 #include <linux/hashtable.h>
42 static int qeth_l3_set_offline(struct ccwgroup_device *);
43 static void qeth_l3_set_rx_mode(struct net_device *dev);
44 static int qeth_l3_register_addr_entry(struct qeth_card *,
45 struct qeth_ipaddr *);
46 static int qeth_l3_deregister_addr_entry(struct qeth_card *,
47 struct qeth_ipaddr *);
49 static void qeth_l3_ipaddr4_to_string(const __u8 *addr, char *buf)
51 sprintf(buf, "%pI4", addr);
54 static void qeth_l3_ipaddr6_to_string(const __u8 *addr, char *buf)
56 sprintf(buf, "%pI6", addr);
59 void qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto, const __u8 *addr,
62 if (proto == QETH_PROT_IPV4)
63 qeth_l3_ipaddr4_to_string(addr, buf);
64 else if (proto == QETH_PROT_IPV6)
65 qeth_l3_ipaddr6_to_string(addr, buf);
68 static struct qeth_ipaddr *qeth_l3_get_addr_buffer(enum qeth_prot_versions prot)
70 struct qeth_ipaddr *addr = kmalloc(sizeof(*addr), GFP_ATOMIC);
73 qeth_l3_init_ipaddr(addr, QETH_IP_TYPE_NORMAL, prot);
77 static struct qeth_ipaddr *qeth_l3_find_addr_by_ip(struct qeth_card *card,
78 struct qeth_ipaddr *query)
80 u64 key = qeth_l3_ipaddr_hash(query);
81 struct qeth_ipaddr *addr;
83 if (query->is_multicast) {
84 hash_for_each_possible(card->ip_mc_htable, addr, hnode, key)
85 if (qeth_l3_addr_match_ip(addr, query))
88 hash_for_each_possible(card->ip_htable, addr, hnode, key)
89 if (qeth_l3_addr_match_ip(addr, query))
95 static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
100 for (i = 0; i < len; ++i) {
102 for (j = 7; j >= 0; --j) {
103 bits[i*8 + j] = octet & 1;
109 static bool qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
110 struct qeth_ipaddr *addr)
112 struct qeth_ipato_entry *ipatoe;
113 u8 addr_bits[128] = {0, };
114 u8 ipatoe_bits[128] = {0, };
117 if (!card->ipato.enabled)
119 if (addr->type != QETH_IP_TYPE_NORMAL)
122 qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits,
123 (addr->proto == QETH_PROT_IPV4)? 4:16);
124 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
125 if (addr->proto != ipatoe->proto)
127 qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits,
128 (ipatoe->proto == QETH_PROT_IPV4) ?
130 if (addr->proto == QETH_PROT_IPV4)
131 rc = !memcmp(addr_bits, ipatoe_bits,
132 min(32, ipatoe->mask_bits));
134 rc = !memcmp(addr_bits, ipatoe_bits,
135 min(128, ipatoe->mask_bits));
140 if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
142 else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
148 static int qeth_l3_delete_ip(struct qeth_card *card,
149 struct qeth_ipaddr *tmp_addr)
152 struct qeth_ipaddr *addr;
154 if (tmp_addr->type == QETH_IP_TYPE_RXIP)
155 QETH_CARD_TEXT(card, 2, "delrxip");
156 else if (tmp_addr->type == QETH_IP_TYPE_VIPA)
157 QETH_CARD_TEXT(card, 2, "delvipa");
159 QETH_CARD_TEXT(card, 2, "delip");
161 if (tmp_addr->proto == QETH_PROT_IPV4)
162 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
164 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
165 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
168 addr = qeth_l3_find_addr_by_ip(card, tmp_addr);
169 if (!addr || !qeth_l3_addr_match_all(addr, tmp_addr))
173 if (addr->type == QETH_IP_TYPE_NORMAL && addr->ref_counter > 0)
175 if (addr->in_progress)
178 if (qeth_card_hw_is_reachable(card))
179 rc = qeth_l3_deregister_addr_entry(card, addr);
181 hash_del(&addr->hnode);
187 static int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
190 struct qeth_ipaddr *addr;
193 if (tmp_addr->type == QETH_IP_TYPE_RXIP)
194 QETH_CARD_TEXT(card, 2, "addrxip");
195 else if (tmp_addr->type == QETH_IP_TYPE_VIPA)
196 QETH_CARD_TEXT(card, 2, "addvipa");
198 QETH_CARD_TEXT(card, 2, "addip");
200 if (tmp_addr->proto == QETH_PROT_IPV4)
201 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
203 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
204 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
207 addr = qeth_l3_find_addr_by_ip(card, tmp_addr);
209 if (tmp_addr->type != QETH_IP_TYPE_NORMAL)
211 if (qeth_l3_addr_match_all(addr, tmp_addr)) {
215 qeth_l3_ipaddr_to_string(tmp_addr->proto, (u8 *)&tmp_addr->u,
217 dev_warn(&card->gdev->dev,
218 "Registering IP address %s failed\n", buf);
221 addr = qeth_l3_get_addr_buffer(tmp_addr->proto);
225 memcpy(addr, tmp_addr, sizeof(struct qeth_ipaddr));
226 addr->ref_counter = 1;
228 if (qeth_l3_is_addr_covered_by_ipato(card, addr)) {
229 QETH_CARD_TEXT(card, 2, "tkovaddr");
232 hash_add(card->ip_htable, &addr->hnode,
233 qeth_l3_ipaddr_hash(addr));
235 if (!qeth_card_hw_is_reachable(card)) {
236 addr->disp_flag = QETH_DISP_ADDR_ADD;
240 /* qeth_l3_register_addr_entry can go to sleep
241 * if we add a IPV4 addr. It is caused by the reason
242 * that SETIP ipa cmd starts ARP staff for IPV4 addr.
243 * Thus we should unlock spinlock, and make a protection
244 * using in_progress variable to indicate that there is
245 * an hardware operation with this IPV4 address
247 if (addr->proto == QETH_PROT_IPV4) {
248 addr->in_progress = 1;
249 spin_unlock_bh(&card->ip_lock);
250 rc = qeth_l3_register_addr_entry(card, addr);
251 spin_lock_bh(&card->ip_lock);
252 addr->in_progress = 0;
254 rc = qeth_l3_register_addr_entry(card, addr);
256 if (!rc || rc == -EADDRINUSE || rc == -ENETDOWN) {
257 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
258 if (addr->ref_counter < 1) {
259 qeth_l3_deregister_addr_entry(card, addr);
260 hash_del(&addr->hnode);
264 hash_del(&addr->hnode);
271 static int qeth_l3_modify_ip(struct qeth_card *card, struct qeth_ipaddr *addr,
276 spin_lock_bh(&card->ip_lock);
277 rc = add ? qeth_l3_add_ip(card, addr) : qeth_l3_delete_ip(card, addr);
278 spin_unlock_bh(&card->ip_lock);
283 static void qeth_l3_drain_rx_mode_cache(struct qeth_card *card)
285 struct qeth_ipaddr *addr;
286 struct hlist_node *tmp;
289 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
290 hash_del(&addr->hnode);
295 static void qeth_l3_clear_ip_htable(struct qeth_card *card, int recover)
297 struct qeth_ipaddr *addr;
298 struct hlist_node *tmp;
301 QETH_CARD_TEXT(card, 4, "clearip");
303 spin_lock_bh(&card->ip_lock);
305 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
307 hash_del(&addr->hnode);
311 addr->disp_flag = QETH_DISP_ADDR_ADD;
314 spin_unlock_bh(&card->ip_lock);
317 static void qeth_l3_recover_ip(struct qeth_card *card)
319 struct qeth_ipaddr *addr;
320 struct hlist_node *tmp;
324 QETH_CARD_TEXT(card, 4, "recovrip");
326 spin_lock_bh(&card->ip_lock);
328 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
329 if (addr->disp_flag == QETH_DISP_ADDR_ADD) {
330 if (addr->proto == QETH_PROT_IPV4) {
331 addr->in_progress = 1;
332 spin_unlock_bh(&card->ip_lock);
333 rc = qeth_l3_register_addr_entry(card, addr);
334 spin_lock_bh(&card->ip_lock);
335 addr->in_progress = 0;
337 rc = qeth_l3_register_addr_entry(card, addr);
340 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
341 if (addr->ref_counter < 1)
342 qeth_l3_delete_ip(card, addr);
344 hash_del(&addr->hnode);
350 spin_unlock_bh(&card->ip_lock);
354 static int qeth_l3_setdelip_cb(struct qeth_card *card, struct qeth_reply *reply,
357 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
359 switch (cmd->hdr.return_code) {
362 case IPA_RC_DUPLICATE_IP_ADDRESS:
364 case IPA_RC_MC_ADDR_NOT_FOUND:
366 case IPA_RC_LAN_OFFLINE:
373 static int qeth_l3_send_setdelmc(struct qeth_card *card,
374 struct qeth_ipaddr *addr, int ipacmd)
376 struct qeth_cmd_buffer *iob;
377 struct qeth_ipa_cmd *cmd;
379 QETH_CARD_TEXT(card, 4, "setdelmc");
381 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
384 cmd = __ipa_cmd(iob);
385 ether_addr_copy(cmd->data.setdelipm.mac, addr->mac);
386 if (addr->proto == QETH_PROT_IPV6)
387 memcpy(cmd->data.setdelipm.ip6, &addr->u.a6.addr,
388 sizeof(struct in6_addr));
390 memcpy(&cmd->data.setdelipm.ip4, &addr->u.a4.addr, 4);
392 return qeth_send_ipa_cmd(card, iob, qeth_l3_setdelip_cb, NULL);
395 static void qeth_l3_fill_netmask(u8 *netmask, unsigned int len)
398 for (i = 0; i < 16; i++) {
403 netmask[i] = (u8)(0xFF00 >> j);
409 static u32 qeth_l3_get_setdelip_flags(struct qeth_ipaddr *addr, bool set)
411 switch (addr->type) {
412 case QETH_IP_TYPE_RXIP:
413 return (set) ? QETH_IPA_SETIP_TAKEOVER_FLAG : 0;
414 case QETH_IP_TYPE_VIPA:
415 return (set) ? QETH_IPA_SETIP_VIPA_FLAG :
416 QETH_IPA_DELIP_VIPA_FLAG;
418 return (set && addr->ipato) ? QETH_IPA_SETIP_TAKEOVER_FLAG : 0;
422 static int qeth_l3_send_setdelip(struct qeth_card *card,
423 struct qeth_ipaddr *addr,
424 enum qeth_ipa_cmds ipacmd)
426 struct qeth_cmd_buffer *iob;
427 struct qeth_ipa_cmd *cmd;
431 QETH_CARD_TEXT(card, 4, "setdelip");
433 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
436 cmd = __ipa_cmd(iob);
438 flags = qeth_l3_get_setdelip_flags(addr, ipacmd == IPA_CMD_SETIP);
439 QETH_CARD_TEXT_(card, 4, "flags%02X", flags);
441 if (addr->proto == QETH_PROT_IPV6) {
442 memcpy(cmd->data.setdelip6.ip_addr, &addr->u.a6.addr,
443 sizeof(struct in6_addr));
444 qeth_l3_fill_netmask(netmask, addr->u.a6.pfxlen);
445 memcpy(cmd->data.setdelip6.mask, netmask,
446 sizeof(struct in6_addr));
447 cmd->data.setdelip6.flags = flags;
449 memcpy(cmd->data.setdelip4.ip_addr, &addr->u.a4.addr, 4);
450 memcpy(cmd->data.setdelip4.mask, &addr->u.a4.mask, 4);
451 cmd->data.setdelip4.flags = flags;
454 return qeth_send_ipa_cmd(card, iob, qeth_l3_setdelip_cb, NULL);
457 static int qeth_l3_send_setrouting(struct qeth_card *card,
458 enum qeth_routing_types type, enum qeth_prot_versions prot)
461 struct qeth_ipa_cmd *cmd;
462 struct qeth_cmd_buffer *iob;
464 QETH_CARD_TEXT(card, 4, "setroutg");
465 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETRTG, prot);
468 cmd = __ipa_cmd(iob);
469 cmd->data.setrtg.type = (type);
470 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
475 static int qeth_l3_correct_routing_type(struct qeth_card *card,
476 enum qeth_routing_types *type, enum qeth_prot_versions prot)
478 if (card->info.type == QETH_CARD_TYPE_IQD) {
481 case PRIMARY_CONNECTOR:
482 case SECONDARY_CONNECTOR:
483 case MULTICAST_ROUTER:
492 case SECONDARY_ROUTER:
494 case MULTICAST_ROUTER:
495 if (qeth_is_ipafunc_supported(card, prot,
507 int qeth_l3_setrouting_v4(struct qeth_card *card)
511 QETH_CARD_TEXT(card, 3, "setrtg4");
513 rc = qeth_l3_correct_routing_type(card, &card->options.route4.type,
518 rc = qeth_l3_send_setrouting(card, card->options.route4.type,
521 card->options.route4.type = NO_ROUTER;
522 QETH_DBF_MESSAGE(2, "Error (%#06x) while setting routing type on device %x. Type set to 'no router'.\n",
523 rc, CARD_DEVID(card));
528 int qeth_l3_setrouting_v6(struct qeth_card *card)
532 QETH_CARD_TEXT(card, 3, "setrtg6");
534 if (!qeth_is_supported(card, IPA_IPV6))
536 rc = qeth_l3_correct_routing_type(card, &card->options.route6.type,
541 rc = qeth_l3_send_setrouting(card, card->options.route6.type,
544 card->options.route6.type = NO_ROUTER;
545 QETH_DBF_MESSAGE(2, "Error (%#06x) while setting routing type on device %x. Type set to 'no router'.\n",
546 rc, CARD_DEVID(card));
552 * IP address takeover related functions
556 * qeth_l3_update_ipato() - Update 'takeover' property, for all NORMAL IPs.
558 * Caller must hold ip_lock.
560 void qeth_l3_update_ipato(struct qeth_card *card)
562 struct qeth_ipaddr *addr;
565 hash_for_each(card->ip_htable, i, addr, hnode) {
566 if (addr->type != QETH_IP_TYPE_NORMAL)
568 addr->ipato = qeth_l3_is_addr_covered_by_ipato(card, addr);
572 static void qeth_l3_clear_ipato_list(struct qeth_card *card)
574 struct qeth_ipato_entry *ipatoe, *tmp;
576 spin_lock_bh(&card->ip_lock);
578 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
579 list_del(&ipatoe->entry);
583 qeth_l3_update_ipato(card);
584 spin_unlock_bh(&card->ip_lock);
587 int qeth_l3_add_ipato_entry(struct qeth_card *card,
588 struct qeth_ipato_entry *new)
590 struct qeth_ipato_entry *ipatoe;
593 QETH_CARD_TEXT(card, 2, "addipato");
595 spin_lock_bh(&card->ip_lock);
597 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
598 if (ipatoe->proto != new->proto)
600 if (!memcmp(ipatoe->addr, new->addr,
601 (ipatoe->proto == QETH_PROT_IPV4)? 4:16) &&
602 (ipatoe->mask_bits == new->mask_bits)) {
609 list_add_tail(&new->entry, &card->ipato.entries);
610 qeth_l3_update_ipato(card);
613 spin_unlock_bh(&card->ip_lock);
618 int qeth_l3_del_ipato_entry(struct qeth_card *card,
619 enum qeth_prot_versions proto, u8 *addr,
622 struct qeth_ipato_entry *ipatoe, *tmp;
625 QETH_CARD_TEXT(card, 2, "delipato");
627 spin_lock_bh(&card->ip_lock);
629 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
630 if (ipatoe->proto != proto)
632 if (!memcmp(ipatoe->addr, addr,
633 (proto == QETH_PROT_IPV4)? 4:16) &&
634 (ipatoe->mask_bits == mask_bits)) {
635 list_del(&ipatoe->entry);
636 qeth_l3_update_ipato(card);
642 spin_unlock_bh(&card->ip_lock);
646 int qeth_l3_modify_rxip_vipa(struct qeth_card *card, bool add, const u8 *ip,
647 enum qeth_ip_types type,
648 enum qeth_prot_versions proto)
650 struct qeth_ipaddr addr;
652 qeth_l3_init_ipaddr(&addr, type, proto);
653 if (proto == QETH_PROT_IPV4)
654 memcpy(&addr.u.a4.addr, ip, 4);
656 memcpy(&addr.u.a6.addr, ip, 16);
658 return qeth_l3_modify_ip(card, &addr, add);
661 int qeth_l3_modify_hsuid(struct qeth_card *card, bool add)
663 struct qeth_ipaddr addr;
666 qeth_l3_init_ipaddr(&addr, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV6);
667 addr.u.a6.addr.s6_addr[0] = 0xfe;
668 addr.u.a6.addr.s6_addr[1] = 0x80;
669 for (i = 0; i < 8; i++)
670 addr.u.a6.addr.s6_addr[8+i] = card->options.hsuid[i];
672 return qeth_l3_modify_ip(card, &addr, add);
675 static int qeth_l3_register_addr_entry(struct qeth_card *card,
676 struct qeth_ipaddr *addr)
682 if (card->options.sniffer)
685 if (addr->proto == QETH_PROT_IPV4) {
686 QETH_CARD_TEXT(card, 2, "setaddr4");
687 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
688 } else if (addr->proto == QETH_PROT_IPV6) {
689 QETH_CARD_TEXT(card, 2, "setaddr6");
690 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
691 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
693 QETH_CARD_TEXT(card, 2, "setaddr?");
694 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
697 if (addr->is_multicast)
698 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
700 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP);
702 QETH_CARD_TEXT(card, 2, "failed");
703 } while ((--cnt > 0) && rc);
705 QETH_CARD_TEXT(card, 2, "FAILED");
706 qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
707 dev_warn(&card->gdev->dev,
708 "Registering IP address %s failed\n", buf);
713 static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
714 struct qeth_ipaddr *addr)
718 if (card->options.sniffer)
721 if (addr->proto == QETH_PROT_IPV4) {
722 QETH_CARD_TEXT(card, 2, "deladdr4");
723 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
724 } else if (addr->proto == QETH_PROT_IPV6) {
725 QETH_CARD_TEXT(card, 2, "deladdr6");
726 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
727 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
729 QETH_CARD_TEXT(card, 2, "deladdr?");
730 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
732 if (addr->is_multicast)
733 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
735 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP);
737 QETH_CARD_TEXT(card, 2, "failed");
742 static int qeth_l3_setadapter_parms(struct qeth_card *card)
746 QETH_DBF_TEXT(SETUP, 2, "setadprm");
748 if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
749 rc = qeth_setadpparms_change_macaddr(card);
751 dev_warn(&card->gdev->dev, "Reading the adapter MAC"
752 " address failed\n");
758 static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
762 QETH_CARD_TEXT(card, 3, "ipaarp");
764 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
765 dev_info(&card->gdev->dev,
766 "ARP processing not supported on %s!\n",
767 QETH_CARD_IFNAME(card));
770 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
771 IPA_CMD_ASS_START, 0);
773 dev_warn(&card->gdev->dev,
774 "Starting ARP processing support for %s failed\n",
775 QETH_CARD_IFNAME(card));
780 static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
784 QETH_CARD_TEXT(card, 3, "stsrcmac");
786 if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
787 dev_info(&card->gdev->dev,
788 "Inbound source MAC-address not supported on %s\n",
789 QETH_CARD_IFNAME(card));
793 rc = qeth_send_simple_setassparms(card, IPA_SOURCE_MAC,
794 IPA_CMD_ASS_START, 0);
796 dev_warn(&card->gdev->dev,
797 "Starting source MAC-address support for %s failed\n",
798 QETH_CARD_IFNAME(card));
802 static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
806 QETH_CARD_TEXT(card, 3, "strtvlan");
808 if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
809 dev_info(&card->gdev->dev,
810 "VLAN not supported on %s\n", QETH_CARD_IFNAME(card));
814 rc = qeth_send_simple_setassparms(card, IPA_VLAN_PRIO,
815 IPA_CMD_ASS_START, 0);
817 dev_warn(&card->gdev->dev,
818 "Starting VLAN support for %s failed\n",
819 QETH_CARD_IFNAME(card));
821 dev_info(&card->gdev->dev, "VLAN enabled\n");
826 static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
830 QETH_CARD_TEXT(card, 3, "stmcast");
832 if (!qeth_is_supported(card, IPA_MULTICASTING)) {
833 dev_info(&card->gdev->dev,
834 "Multicast not supported on %s\n",
835 QETH_CARD_IFNAME(card));
839 rc = qeth_send_simple_setassparms(card, IPA_MULTICASTING,
840 IPA_CMD_ASS_START, 0);
842 dev_warn(&card->gdev->dev,
843 "Starting multicast support for %s failed\n",
844 QETH_CARD_IFNAME(card));
846 dev_info(&card->gdev->dev, "Multicast enabled\n");
847 card->dev->flags |= IFF_MULTICAST;
852 static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
856 QETH_CARD_TEXT(card, 3, "softipv6");
858 if (card->info.type == QETH_CARD_TYPE_IQD)
861 rc = qeth_send_simple_setassparms(card, IPA_IPV6,
862 IPA_CMD_ASS_START, 3);
864 dev_err(&card->gdev->dev,
865 "Activating IPv6 support for %s failed\n",
866 QETH_CARD_IFNAME(card));
869 rc = qeth_send_simple_setassparms_v6(card, IPA_IPV6,
870 IPA_CMD_ASS_START, 0);
872 dev_err(&card->gdev->dev,
873 "Activating IPv6 support for %s failed\n",
874 QETH_CARD_IFNAME(card));
877 rc = qeth_send_simple_setassparms_v6(card, IPA_PASSTHRU,
878 IPA_CMD_ASS_START, 0);
880 dev_warn(&card->gdev->dev,
881 "Enabling the passthrough mode for %s failed\n",
882 QETH_CARD_IFNAME(card));
886 dev_info(&card->gdev->dev, "IPV6 enabled\n");
890 static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
892 QETH_CARD_TEXT(card, 3, "strtipv6");
894 if (!qeth_is_supported(card, IPA_IPV6)) {
895 dev_info(&card->gdev->dev,
896 "IPv6 not supported on %s\n", QETH_CARD_IFNAME(card));
899 return qeth_l3_softsetup_ipv6(card);
902 static int qeth_l3_start_ipa_broadcast(struct qeth_card *card)
906 QETH_CARD_TEXT(card, 3, "stbrdcst");
907 card->info.broadcast_capable = 0;
908 if (!qeth_is_supported(card, IPA_FILTERING)) {
909 dev_info(&card->gdev->dev,
910 "Broadcast not supported on %s\n",
911 QETH_CARD_IFNAME(card));
915 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
916 IPA_CMD_ASS_START, 0);
918 dev_warn(&card->gdev->dev, "Enabling broadcast filtering for "
919 "%s failed\n", QETH_CARD_IFNAME(card));
923 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
924 IPA_CMD_ASS_CONFIGURE, 1);
926 dev_warn(&card->gdev->dev,
927 "Setting up broadcast filtering for %s failed\n",
928 QETH_CARD_IFNAME(card));
931 card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
932 dev_info(&card->gdev->dev, "Broadcast enabled\n");
933 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
934 IPA_CMD_ASS_ENABLE, 1);
936 dev_warn(&card->gdev->dev, "Setting up broadcast echo "
937 "filtering for %s failed\n", QETH_CARD_IFNAME(card));
940 card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
942 if (card->info.broadcast_capable)
943 card->dev->flags |= IFF_BROADCAST;
945 card->dev->flags &= ~IFF_BROADCAST;
949 static int qeth_l3_start_ipassists(struct qeth_card *card)
951 QETH_CARD_TEXT(card, 3, "strtipas");
953 if (qeth_set_access_ctrl_online(card, 0))
955 qeth_l3_start_ipa_arp_processing(card); /* go on*/
956 qeth_l3_start_ipa_source_mac(card); /* go on*/
957 qeth_l3_start_ipa_vlan(card); /* go on*/
958 qeth_l3_start_ipa_multicast(card); /* go on*/
959 qeth_l3_start_ipa_ipv6(card); /* go on*/
960 qeth_l3_start_ipa_broadcast(card); /* go on*/
964 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
965 struct qeth_reply *reply, unsigned long data)
967 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
969 if (cmd->hdr.return_code)
972 ether_addr_copy(card->dev->dev_addr,
973 cmd->data.create_destroy_addr.unique_id);
977 static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card)
980 struct qeth_cmd_buffer *iob;
981 struct qeth_ipa_cmd *cmd;
983 QETH_DBF_TEXT(SETUP, 2, "hsrmac");
985 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
989 cmd = __ipa_cmd(iob);
990 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
991 card->info.unique_id;
993 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb,
998 static int qeth_l3_get_unique_id_cb(struct qeth_card *card,
999 struct qeth_reply *reply, unsigned long data)
1001 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1003 if (cmd->hdr.return_code == 0) {
1004 card->info.unique_id = *((__u16 *)
1005 &cmd->data.create_destroy_addr.unique_id[6]);
1009 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1010 UNIQUE_ID_NOT_BY_CARD;
1011 dev_warn(&card->gdev->dev, "The network adapter failed to generate a unique ID\n");
1015 static int qeth_l3_get_unique_id(struct qeth_card *card)
1018 struct qeth_cmd_buffer *iob;
1019 struct qeth_ipa_cmd *cmd;
1021 QETH_DBF_TEXT(SETUP, 2, "guniqeid");
1023 if (!qeth_is_supported(card, IPA_IPV6)) {
1024 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1025 UNIQUE_ID_NOT_BY_CARD;
1029 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
1033 cmd = __ipa_cmd(iob);
1034 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1035 card->info.unique_id;
1037 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_get_unique_id_cb, NULL);
1042 qeth_diags_trace_cb(struct qeth_card *card, struct qeth_reply *reply,
1045 struct qeth_ipa_cmd *cmd;
1048 QETH_DBF_TEXT(SETUP, 2, "diastrcb");
1050 cmd = (struct qeth_ipa_cmd *)data;
1051 rc = cmd->hdr.return_code;
1053 QETH_CARD_TEXT_(card, 2, "dxter%x", rc);
1054 switch (cmd->data.diagass.action) {
1055 case QETH_DIAGS_CMD_TRACE_QUERY:
1057 case QETH_DIAGS_CMD_TRACE_DISABLE:
1060 case IPA_RC_INVALID_SUBCMD:
1061 card->info.promisc_mode = SET_PROMISC_MODE_OFF;
1062 dev_info(&card->gdev->dev, "The HiperSockets network "
1063 "traffic analyzer is deactivated\n");
1069 case QETH_DIAGS_CMD_TRACE_ENABLE:
1072 card->info.promisc_mode = SET_PROMISC_MODE_ON;
1073 dev_info(&card->gdev->dev, "The HiperSockets network "
1074 "traffic analyzer is activated\n");
1076 case IPA_RC_HARDWARE_AUTH_ERROR:
1077 dev_warn(&card->gdev->dev, "The device is not "
1078 "authorized to run as a HiperSockets network "
1079 "traffic analyzer\n");
1081 case IPA_RC_TRACE_ALREADY_ACTIVE:
1082 dev_warn(&card->gdev->dev, "A HiperSockets "
1083 "network traffic analyzer is already "
1084 "active in the HiperSockets LAN\n");
1091 QETH_DBF_MESSAGE(2, "Unknown sniffer action (%#06x) on device %x\n",
1092 cmd->data.diagass.action, CARD_DEVID(card));
1095 return rc ? -EIO : 0;
1099 qeth_diags_trace(struct qeth_card *card, enum qeth_diags_trace_cmds diags_cmd)
1101 struct qeth_cmd_buffer *iob;
1102 struct qeth_ipa_cmd *cmd;
1104 QETH_DBF_TEXT(SETUP, 2, "diagtrac");
1106 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SET_DIAG_ASS, 0);
1109 cmd = __ipa_cmd(iob);
1110 cmd->data.diagass.subcmd_len = 16;
1111 cmd->data.diagass.subcmd = QETH_DIAGS_CMD_TRACE;
1112 cmd->data.diagass.type = QETH_DIAGS_TYPE_HIPERSOCKET;
1113 cmd->data.diagass.action = diags_cmd;
1114 return qeth_send_ipa_cmd(card, iob, qeth_diags_trace_cb, NULL);
1118 qeth_l3_add_mc_to_hash(struct qeth_card *card, struct in_device *in4_dev)
1120 struct ip_mc_list *im4;
1121 struct qeth_ipaddr *tmp, *ipm;
1123 QETH_CARD_TEXT(card, 4, "addmc");
1125 tmp = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1129 for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
1130 im4 = rcu_dereference(im4->next_rcu)) {
1131 ip_eth_mc_map(im4->multiaddr, tmp->mac);
1132 tmp->u.a4.addr = be32_to_cpu(im4->multiaddr);
1133 tmp->is_multicast = 1;
1135 ipm = qeth_l3_find_addr_by_ip(card, tmp);
1137 /* for mcast, by-IP match means full match */
1138 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1140 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1143 ether_addr_copy(ipm->mac, tmp->mac);
1144 ipm->u.a4.addr = be32_to_cpu(im4->multiaddr);
1145 ipm->is_multicast = 1;
1146 ipm->disp_flag = QETH_DISP_ADDR_ADD;
1147 hash_add(card->ip_mc_htable,
1148 &ipm->hnode, qeth_l3_ipaddr_hash(ipm));
1155 /* called with rcu_read_lock */
1156 static void qeth_l3_add_vlan_mc(struct qeth_card *card)
1158 struct in_device *in_dev;
1161 QETH_CARD_TEXT(card, 4, "addmcvl");
1163 if (!qeth_is_supported(card, IPA_FULL_VLAN))
1166 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1167 struct net_device *netdev;
1169 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1171 if (netdev == NULL ||
1172 !(netdev->flags & IFF_UP))
1174 in_dev = __in_dev_get_rcu(netdev);
1177 qeth_l3_add_mc_to_hash(card, in_dev);
1181 static void qeth_l3_add_multicast_ipv4(struct qeth_card *card)
1183 struct in_device *in4_dev;
1185 QETH_CARD_TEXT(card, 4, "chkmcv4");
1188 in4_dev = __in_dev_get_rcu(card->dev);
1189 if (in4_dev == NULL)
1191 qeth_l3_add_mc_to_hash(card, in4_dev);
1192 qeth_l3_add_vlan_mc(card);
1197 static void qeth_l3_add_mc6_to_hash(struct qeth_card *card,
1198 struct inet6_dev *in6_dev)
1200 struct qeth_ipaddr *ipm;
1201 struct ifmcaddr6 *im6;
1202 struct qeth_ipaddr *tmp;
1204 QETH_CARD_TEXT(card, 4, "addmc6");
1206 tmp = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1210 for (im6 = in6_dev->mc_list; im6 != NULL; im6 = im6->next) {
1211 ipv6_eth_mc_map(&im6->mca_addr, tmp->mac);
1212 memcpy(&tmp->u.a6.addr, &im6->mca_addr.s6_addr,
1213 sizeof(struct in6_addr));
1214 tmp->is_multicast = 1;
1216 ipm = qeth_l3_find_addr_by_ip(card, tmp);
1218 /* for mcast, by-IP match means full match */
1219 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1223 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1227 ether_addr_copy(ipm->mac, tmp->mac);
1228 memcpy(&ipm->u.a6.addr, &im6->mca_addr.s6_addr,
1229 sizeof(struct in6_addr));
1230 ipm->is_multicast = 1;
1231 ipm->disp_flag = QETH_DISP_ADDR_ADD;
1232 hash_add(card->ip_mc_htable,
1233 &ipm->hnode, qeth_l3_ipaddr_hash(ipm));
1239 /* called with rcu_read_lock */
1240 static void qeth_l3_add_vlan_mc6(struct qeth_card *card)
1242 struct inet6_dev *in_dev;
1245 QETH_CARD_TEXT(card, 4, "admc6vl");
1247 if (!qeth_is_supported(card, IPA_FULL_VLAN))
1250 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1251 struct net_device *netdev;
1253 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1255 if (netdev == NULL ||
1256 !(netdev->flags & IFF_UP))
1258 in_dev = in6_dev_get(netdev);
1261 read_lock_bh(&in_dev->lock);
1262 qeth_l3_add_mc6_to_hash(card, in_dev);
1263 read_unlock_bh(&in_dev->lock);
1264 in6_dev_put(in_dev);
1268 static void qeth_l3_add_multicast_ipv6(struct qeth_card *card)
1270 struct inet6_dev *in6_dev;
1272 QETH_CARD_TEXT(card, 4, "chkmcv6");
1274 if (!qeth_is_supported(card, IPA_IPV6))
1276 in6_dev = in6_dev_get(card->dev);
1281 read_lock_bh(&in6_dev->lock);
1282 qeth_l3_add_mc6_to_hash(card, in6_dev);
1283 qeth_l3_add_vlan_mc6(card);
1284 read_unlock_bh(&in6_dev->lock);
1286 in6_dev_put(in6_dev);
1289 static int qeth_l3_vlan_rx_add_vid(struct net_device *dev,
1290 __be16 proto, u16 vid)
1292 struct qeth_card *card = dev->ml_priv;
1294 set_bit(vid, card->active_vlans);
1298 static int qeth_l3_vlan_rx_kill_vid(struct net_device *dev,
1299 __be16 proto, u16 vid)
1301 struct qeth_card *card = dev->ml_priv;
1303 QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
1305 clear_bit(vid, card->active_vlans);
1306 qeth_l3_set_rx_mode(dev);
1310 static void qeth_l3_rebuild_skb(struct qeth_card *card, struct sk_buff *skb,
1311 struct qeth_hdr *hdr)
1313 if (!(hdr->hdr.l3.flags & QETH_HDR_PASSTHRU)) {
1314 u16 prot = (hdr->hdr.l3.flags & QETH_HDR_IPV6) ? ETH_P_IPV6 :
1316 unsigned char tg_addr[ETH_ALEN];
1318 skb_reset_network_header(skb);
1319 switch (hdr->hdr.l3.flags & QETH_HDR_CAST_MASK) {
1320 case QETH_CAST_MULTICAST:
1321 if (prot == ETH_P_IP)
1322 ip_eth_mc_map(ip_hdr(skb)->daddr, tg_addr);
1324 ipv6_eth_mc_map(&ipv6_hdr(skb)->daddr, tg_addr);
1325 QETH_CARD_STAT_INC(card, rx_multicast);
1327 case QETH_CAST_BROADCAST:
1328 ether_addr_copy(tg_addr, card->dev->broadcast);
1329 QETH_CARD_STAT_INC(card, rx_multicast);
1332 if (card->options.sniffer)
1333 skb->pkt_type = PACKET_OTHERHOST;
1334 ether_addr_copy(tg_addr, card->dev->dev_addr);
1337 if (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_SRC_MAC_ADDR)
1338 card->dev->header_ops->create(skb, card->dev, prot,
1339 tg_addr, &hdr->hdr.l3.next_hop.rx.src_mac,
1342 card->dev->header_ops->create(skb, card->dev, prot,
1343 tg_addr, "FAKELL", skb->len);
1346 skb->protocol = eth_type_trans(skb, card->dev);
1348 /* copy VLAN tag from hdr into skb */
1349 if (!card->options.sniffer &&
1350 (hdr->hdr.l3.ext_flags & (QETH_HDR_EXT_VLAN_FRAME |
1351 QETH_HDR_EXT_INCLUDE_VLAN_TAG))) {
1352 u16 tag = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME) ?
1353 hdr->hdr.l3.vlan_id :
1354 hdr->hdr.l3.next_hop.rx.vlan_id;
1355 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), tag);
1358 qeth_rx_csum(card, skb, hdr->hdr.l3.ext_flags);
1361 static int qeth_l3_process_inbound_buffer(struct qeth_card *card,
1362 int budget, int *done)
1364 struct net_device *dev = card->dev;
1366 struct sk_buff *skb;
1367 struct qeth_hdr *hdr;
1372 WARN_ON_ONCE(!budget);
1374 skb = qeth_core_get_next_skb(card,
1375 &card->qdio.in_q->bufs[card->rx.b_index],
1376 &card->rx.b_element, &card->rx.e_offset, &hdr);
1381 switch (hdr->hdr.l3.id) {
1382 case QETH_HEADER_TYPE_LAYER3:
1383 magic = *(__u16 *)skb->data;
1384 if ((card->info.type == QETH_CARD_TYPE_IQD) &&
1385 (magic == ETH_P_AF_IUCV)) {
1387 dev_hard_header(skb, dev, ETH_P_AF_IUCV,
1388 dev->dev_addr, "FAKELL", len);
1389 skb->protocol = eth_type_trans(skb, dev);
1390 netif_receive_skb(skb);
1392 qeth_l3_rebuild_skb(card, skb, hdr);
1394 napi_gro_receive(&card->napi, skb);
1397 case QETH_HEADER_TYPE_LAYER2: /* for HiperSockets sniffer */
1398 skb->protocol = eth_type_trans(skb, skb->dev);
1400 netif_receive_skb(skb);
1403 dev_kfree_skb_any(skb);
1404 QETH_CARD_TEXT(card, 3, "inbunkno");
1405 QETH_DBF_HEX(CTRL, 3, hdr, sizeof(*hdr));
1410 QETH_CARD_STAT_INC(card, rx_packets);
1411 QETH_CARD_STAT_ADD(card, rx_bytes, len);
1416 static void qeth_l3_stop_card(struct qeth_card *card)
1418 QETH_DBF_TEXT(SETUP, 2, "stopcard");
1419 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
1421 qeth_set_allowed_threads(card, 0, 1);
1423 cancel_work_sync(&card->rx_mode_work);
1424 qeth_l3_drain_rx_mode_cache(card);
1426 if (card->options.sniffer &&
1427 (card->info.promisc_mode == SET_PROMISC_MODE_ON))
1428 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1430 if (card->state == CARD_STATE_SOFTSETUP) {
1431 qeth_l3_clear_ip_htable(card, 1);
1432 qeth_clear_ipacmd_list(card);
1433 card->state = CARD_STATE_HARDSETUP;
1435 if (card->state == CARD_STATE_HARDSETUP) {
1436 qeth_qdio_clear_card(card, 0);
1437 qeth_clear_qdio_buffers(card);
1438 qeth_clear_working_pool_list(card);
1439 card->state = CARD_STATE_DOWN;
1441 if (card->state == CARD_STATE_DOWN) {
1442 qeth_clear_cmd_buffers(&card->read);
1443 qeth_clear_cmd_buffers(&card->write);
1446 flush_workqueue(card->event_wq);
1450 * test for and Switch promiscuous mode (on or off)
1451 * either for guestlan or HiperSocket Sniffer
1454 qeth_l3_handle_promisc_mode(struct qeth_card *card)
1456 struct net_device *dev = card->dev;
1458 if (((dev->flags & IFF_PROMISC) &&
1459 (card->info.promisc_mode == SET_PROMISC_MODE_ON)) ||
1460 (!(dev->flags & IFF_PROMISC) &&
1461 (card->info.promisc_mode == SET_PROMISC_MODE_OFF)))
1464 if (card->info.guestlan) { /* Guestlan trace */
1465 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
1466 qeth_setadp_promisc_mode(card);
1467 } else if (card->options.sniffer && /* HiperSockets trace */
1468 qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) {
1469 if (dev->flags & IFF_PROMISC) {
1470 QETH_CARD_TEXT(card, 3, "+promisc");
1471 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE);
1473 QETH_CARD_TEXT(card, 3, "-promisc");
1474 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1479 static void qeth_l3_rx_mode_work(struct work_struct *work)
1481 struct qeth_card *card = container_of(work, struct qeth_card,
1483 struct qeth_ipaddr *addr;
1484 struct hlist_node *tmp;
1487 QETH_CARD_TEXT(card, 3, "setmulti");
1489 if (!card->options.sniffer) {
1490 qeth_l3_add_multicast_ipv4(card);
1491 qeth_l3_add_multicast_ipv6(card);
1493 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
1494 switch (addr->disp_flag) {
1495 case QETH_DISP_ADDR_DELETE:
1496 rc = qeth_l3_deregister_addr_entry(card, addr);
1497 if (!rc || rc == -ENOENT) {
1498 hash_del(&addr->hnode);
1502 case QETH_DISP_ADDR_ADD:
1503 rc = qeth_l3_register_addr_entry(card, addr);
1504 if (rc && rc != -ENETDOWN) {
1505 hash_del(&addr->hnode);
1509 addr->ref_counter = 1;
1512 /* for next call to set_rx_mode(): */
1513 addr->disp_flag = QETH_DISP_ADDR_DELETE;
1517 if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
1520 qeth_l3_handle_promisc_mode(card);
1523 static int qeth_l3_arp_makerc(u16 rc)
1526 case IPA_RC_SUCCESS:
1528 case QETH_IPA_ARP_RC_NOTSUPP:
1529 case QETH_IPA_ARP_RC_Q_NOTSUPP:
1531 case QETH_IPA_ARP_RC_OUT_OF_RANGE:
1533 case QETH_IPA_ARP_RC_Q_NO_DATA:
1540 static int qeth_l3_arp_cmd_cb(struct qeth_card *card, struct qeth_reply *reply,
1543 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1545 qeth_setassparms_cb(card, reply, data);
1546 return qeth_l3_arp_makerc(cmd->hdr.return_code);
1549 static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
1551 struct qeth_cmd_buffer *iob;
1554 QETH_CARD_TEXT(card, 3, "arpstnoe");
1557 * currently GuestLAN only supports the ARP assist function
1558 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
1559 * thus we say EOPNOTSUPP for this ARP function
1561 if (card->info.guestlan)
1563 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1567 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
1568 IPA_CMD_ASS_ARP_SET_NO_ENTRIES, 4,
1573 __ipa_cmd(iob)->data.setassparms.data.flags_32bit = (u32) no_entries;
1574 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL);
1576 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on device %x: %#x\n",
1577 CARD_DEVID(card), rc);
1581 static __u32 get_arp_entry_size(struct qeth_card *card,
1582 struct qeth_arp_query_data *qdata,
1583 struct qeth_arp_entrytype *type, __u8 strip_entries)
1588 is_hsi = qdata->reply_bits == 5;
1589 if (type->ip == QETHARP_IP_ADDR_V4) {
1590 QETH_CARD_TEXT(card, 4, "arpev4");
1591 if (strip_entries) {
1592 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5_short) :
1593 sizeof(struct qeth_arp_qi_entry7_short);
1595 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5) :
1596 sizeof(struct qeth_arp_qi_entry7);
1598 } else if (type->ip == QETHARP_IP_ADDR_V6) {
1599 QETH_CARD_TEXT(card, 4, "arpev6");
1600 if (strip_entries) {
1602 sizeof(struct qeth_arp_qi_entry5_short_ipv6) :
1603 sizeof(struct qeth_arp_qi_entry7_short_ipv6);
1606 sizeof(struct qeth_arp_qi_entry5_ipv6) :
1607 sizeof(struct qeth_arp_qi_entry7_ipv6);
1610 QETH_CARD_TEXT(card, 4, "arpinv");
1617 static int arpentry_matches_prot(struct qeth_arp_entrytype *type, __u16 prot)
1619 return (type->ip == QETHARP_IP_ADDR_V4 && prot == QETH_PROT_IPV4) ||
1620 (type->ip == QETHARP_IP_ADDR_V6 && prot == QETH_PROT_IPV6);
1623 static int qeth_l3_arp_query_cb(struct qeth_card *card,
1624 struct qeth_reply *reply, unsigned long data)
1626 struct qeth_ipa_cmd *cmd;
1627 struct qeth_arp_query_data *qdata;
1628 struct qeth_arp_query_info *qinfo;
1630 int entrybytes_done;
1632 __u8 do_strip_entries;
1634 QETH_CARD_TEXT(card, 3, "arpquecb");
1636 qinfo = (struct qeth_arp_query_info *) reply->param;
1637 cmd = (struct qeth_ipa_cmd *) data;
1638 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.prot_version);
1639 if (cmd->hdr.return_code) {
1640 QETH_CARD_TEXT(card, 4, "arpcberr");
1641 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
1642 return qeth_l3_arp_makerc(cmd->hdr.return_code);
1644 if (cmd->data.setassparms.hdr.return_code) {
1645 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
1646 QETH_CARD_TEXT(card, 4, "setaperr");
1647 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
1648 return qeth_l3_arp_makerc(cmd->hdr.return_code);
1650 qdata = &cmd->data.setassparms.data.query_arp;
1651 QETH_CARD_TEXT_(card, 4, "anoen%i", qdata->no_entries);
1653 do_strip_entries = (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) > 0;
1654 stripped_bytes = do_strip_entries ? QETH_QARP_MEDIASPECIFIC_BYTES : 0;
1655 entrybytes_done = 0;
1656 for (e = 0; e < qdata->no_entries; ++e) {
1659 struct qeth_arp_entrytype *etype;
1661 cur_entry = &qdata->data + entrybytes_done;
1662 etype = &((struct qeth_arp_qi_entry5 *) cur_entry)->type;
1663 if (!arpentry_matches_prot(etype, cmd->hdr.prot_version)) {
1664 QETH_CARD_TEXT(card, 4, "pmis");
1665 QETH_CARD_TEXT_(card, 4, "%i", etype->ip);
1668 esize = get_arp_entry_size(card, qdata, etype,
1670 QETH_CARD_TEXT_(card, 5, "esz%i", esize);
1674 if ((qinfo->udata_len - qinfo->udata_offset) < esize) {
1675 QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOSPC);
1676 memset(qinfo->udata, 0, 4);
1680 memcpy(qinfo->udata + qinfo->udata_offset,
1681 &qdata->data + entrybytes_done + stripped_bytes,
1683 entrybytes_done += esize + stripped_bytes;
1684 qinfo->udata_offset += esize;
1685 ++qinfo->no_entries;
1687 /* check if all replies received ... */
1688 if (cmd->data.setassparms.hdr.seq_no <
1689 cmd->data.setassparms.hdr.number_of_replies)
1691 QETH_CARD_TEXT_(card, 4, "nove%i", qinfo->no_entries);
1692 memcpy(qinfo->udata, &qinfo->no_entries, 4);
1693 /* keep STRIP_ENTRIES flag so the user program can distinguish
1694 * stripped entries from normal ones */
1695 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
1696 qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES;
1697 memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2);
1698 QETH_CARD_TEXT_(card, 4, "rc%i", 0);
1702 static int qeth_l3_query_arp_cache_info(struct qeth_card *card,
1703 enum qeth_prot_versions prot,
1704 struct qeth_arp_query_info *qinfo)
1706 struct qeth_cmd_buffer *iob;
1707 struct qeth_ipa_cmd *cmd;
1710 QETH_CARD_TEXT_(card, 3, "qarpipv%i", prot);
1712 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
1713 IPA_CMD_ASS_ARP_QUERY_INFO,
1714 sizeof(struct qeth_arp_query_data)
1719 cmd = __ipa_cmd(iob);
1720 cmd->data.setassparms.data.query_arp.request_bits = 0x000F;
1721 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_query_cb, qinfo);
1723 QETH_DBF_MESSAGE(2, "Error while querying ARP cache on device %x: %#x\n",
1724 CARD_DEVID(card), rc);
1728 static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
1730 struct qeth_arp_query_info qinfo = {0, };
1733 QETH_CARD_TEXT(card, 3, "arpquery");
1735 if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
1736 IPA_ARP_PROCESSING)) {
1737 QETH_CARD_TEXT(card, 3, "arpqnsup");
1741 /* get size of userspace buffer and mask_bits -> 6 bytes */
1742 if (copy_from_user(&qinfo, udata, 6)) {
1746 qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL);
1751 qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
1752 rc = qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV4, &qinfo);
1754 if (copy_to_user(udata, qinfo.udata, 4))
1758 if (qinfo.mask_bits & QETH_QARP_WITH_IPV6) {
1759 /* fails in case of GuestLAN QDIO mode */
1760 qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV6, &qinfo);
1762 if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) {
1763 QETH_CARD_TEXT(card, 4, "qactf");
1767 QETH_CARD_TEXT(card, 4, "qacts");
1775 static int qeth_l3_arp_modify_entry(struct qeth_card *card,
1776 struct qeth_arp_cache_entry *entry,
1777 enum qeth_arp_process_subcmds arp_cmd)
1779 struct qeth_arp_cache_entry *cmd_entry;
1780 struct qeth_cmd_buffer *iob;
1783 if (arp_cmd == IPA_CMD_ASS_ARP_ADD_ENTRY)
1784 QETH_CARD_TEXT(card, 3, "arpadd");
1786 QETH_CARD_TEXT(card, 3, "arpdel");
1789 * currently GuestLAN only supports the ARP assist function
1790 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
1791 * thus we say EOPNOTSUPP for this ARP function
1793 if (card->info.guestlan)
1795 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1799 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING, arp_cmd,
1800 sizeof(*cmd_entry), QETH_PROT_IPV4);
1804 cmd_entry = &__ipa_cmd(iob)->data.setassparms.data.arp_entry;
1805 ether_addr_copy(cmd_entry->macaddr, entry->macaddr);
1806 memcpy(cmd_entry->ipaddr, entry->ipaddr, 4);
1807 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL);
1809 QETH_DBF_MESSAGE(2, "Could not modify (cmd: %#x) ARP entry on device %x: %#x\n",
1810 arp_cmd, CARD_DEVID(card), rc);
1814 static int qeth_l3_arp_flush_cache(struct qeth_card *card)
1816 struct qeth_cmd_buffer *iob;
1819 QETH_CARD_TEXT(card, 3, "arpflush");
1822 * currently GuestLAN only supports the ARP assist function
1823 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
1824 * thus we say EOPNOTSUPP for this ARP function
1826 if (card->info.guestlan || (card->info.type == QETH_CARD_TYPE_IQD))
1828 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1832 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
1833 IPA_CMD_ASS_ARP_FLUSH_CACHE, 0,
1838 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL);
1840 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on device %x: %#x\n",
1841 CARD_DEVID(card), rc);
1845 static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1847 struct qeth_card *card = dev->ml_priv;
1848 struct qeth_arp_cache_entry arp_entry;
1849 enum qeth_arp_process_subcmds arp_cmd;
1853 case SIOC_QETH_ARP_SET_NO_ENTRIES:
1854 if (!capable(CAP_NET_ADMIN)) {
1858 rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue);
1860 case SIOC_QETH_ARP_QUERY_INFO:
1861 if (!capable(CAP_NET_ADMIN)) {
1865 rc = qeth_l3_arp_query(card, rq->ifr_ifru.ifru_data);
1867 case SIOC_QETH_ARP_ADD_ENTRY:
1868 case SIOC_QETH_ARP_REMOVE_ENTRY:
1869 if (!capable(CAP_NET_ADMIN))
1871 if (copy_from_user(&arp_entry, rq->ifr_data, sizeof(arp_entry)))
1874 arp_cmd = (cmd == SIOC_QETH_ARP_ADD_ENTRY) ?
1875 IPA_CMD_ASS_ARP_ADD_ENTRY :
1876 IPA_CMD_ASS_ARP_REMOVE_ENTRY;
1877 return qeth_l3_arp_modify_entry(card, &arp_entry, arp_cmd);
1878 case SIOC_QETH_ARP_FLUSH_CACHE:
1879 if (!capable(CAP_NET_ADMIN)) {
1883 rc = qeth_l3_arp_flush_cache(card);
1891 static int qeth_l3_get_cast_type(struct sk_buff *skb)
1893 struct neighbour *n = NULL;
1894 struct dst_entry *dst;
1899 n = dst_neigh_lookup_skb(dst, skb);
1901 int cast_type = n->type;
1905 if ((cast_type == RTN_BROADCAST) ||
1906 (cast_type == RTN_MULTICAST) ||
1907 (cast_type == RTN_ANYCAST))
1913 /* no neighbour (eg AF_PACKET), fall back to target's IP address ... */
1914 switch (qeth_get_ip_version(skb)) {
1916 return ipv4_is_multicast(ip_hdr(skb)->daddr) ?
1917 RTN_MULTICAST : RTN_UNICAST;
1919 return ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr) ?
1920 RTN_MULTICAST : RTN_UNICAST;
1922 /* ... and MAC address */
1923 if (ether_addr_equal_64bits(eth_hdr(skb)->h_dest,
1924 skb->dev->broadcast))
1925 return RTN_BROADCAST;
1926 if (is_multicast_ether_addr(eth_hdr(skb)->h_dest))
1927 return RTN_MULTICAST;
1928 /* default to unicast */
1933 static u8 qeth_l3_cast_type_to_flag(int cast_type)
1935 if (cast_type == RTN_MULTICAST)
1936 return QETH_CAST_MULTICAST;
1937 if (cast_type == RTN_ANYCAST)
1938 return QETH_CAST_ANYCAST;
1939 if (cast_type == RTN_BROADCAST)
1940 return QETH_CAST_BROADCAST;
1941 return QETH_CAST_UNICAST;
1944 static void qeth_l3_fill_header(struct qeth_qdio_out_q *queue,
1945 struct qeth_hdr *hdr, struct sk_buff *skb,
1946 int ipv, int cast_type, unsigned int data_len)
1948 struct qeth_hdr_layer3 *l3_hdr = &hdr->hdr.l3;
1949 struct vlan_ethhdr *veth = vlan_eth_hdr(skb);
1950 struct qeth_card *card = queue->card;
1952 hdr->hdr.l3.length = data_len;
1954 if (skb_is_gso(skb)) {
1955 hdr->hdr.l3.id = QETH_HEADER_TYPE_L3_TSO;
1957 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
1959 if (skb->protocol == htons(ETH_P_AF_IUCV)) {
1960 l3_hdr->flags = QETH_HDR_IPV6 | QETH_CAST_UNICAST;
1961 l3_hdr->next_hop.ipv6_addr.s6_addr16[0] = htons(0xfe80);
1962 memcpy(&l3_hdr->next_hop.ipv6_addr.s6_addr32[2],
1963 iucv_trans_hdr(skb)->destUserID, 8);
1967 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1968 qeth_tx_csum(skb, &hdr->hdr.l3.ext_flags, ipv);
1969 /* some HW requires combined L3+L4 csum offload: */
1971 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_CSUM_HDR_REQ;
1972 QETH_TXQ_STAT_INC(queue, skbs_csum);
1976 if (ipv == 4 || IS_IQD(card)) {
1977 /* NETIF_F_HW_VLAN_CTAG_TX */
1978 if (skb_vlan_tag_present(skb)) {
1979 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_VLAN_FRAME;
1980 hdr->hdr.l3.vlan_id = skb_vlan_tag_get(skb);
1982 } else if (veth->h_vlan_proto == htons(ETH_P_8021Q)) {
1983 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_INCLUDE_VLAN_TAG;
1984 hdr->hdr.l3.vlan_id = ntohs(veth->h_vlan_TCI);
1989 hdr->hdr.l3.flags = QETH_HDR_PASSTHRU;
1990 if (ether_addr_equal_64bits(eth_hdr(skb)->h_dest,
1991 skb->dev->broadcast))
1992 hdr->hdr.l3.flags |= QETH_CAST_BROADCAST;
1994 hdr->hdr.l3.flags |= (cast_type == RTN_MULTICAST) ?
1995 QETH_CAST_MULTICAST : QETH_CAST_UNICAST;
1999 hdr->hdr.l3.flags = qeth_l3_cast_type_to_flag(cast_type);
2002 struct rtable *rt = skb_rtable(skb);
2004 *((__be32 *) &hdr->hdr.l3.next_hop.ipv4.addr) = (rt) ?
2005 rt_nexthop(rt, ip_hdr(skb)->daddr) :
2009 const struct rt6_info *rt = skb_rt6_info(skb);
2011 if (rt && !ipv6_addr_any(&rt->rt6i_gateway))
2012 l3_hdr->next_hop.ipv6_addr = rt->rt6i_gateway;
2014 l3_hdr->next_hop.ipv6_addr = ipv6_hdr(skb)->daddr;
2016 hdr->hdr.l3.flags |= QETH_HDR_IPV6;
2017 if (card->info.type != QETH_CARD_TYPE_IQD)
2018 hdr->hdr.l3.flags |= QETH_HDR_PASSTHRU;
2023 static void qeth_l3_fixup_headers(struct sk_buff *skb)
2025 struct iphdr *iph = ip_hdr(skb);
2027 /* this is safe, IPv6 traffic takes a different path */
2028 if (skb->ip_summed == CHECKSUM_PARTIAL)
2030 if (skb_is_gso(skb)) {
2032 tcp_hdr(skb)->check = ~tcp_v4_check(0, iph->saddr,
2037 static int qeth_l3_xmit(struct qeth_card *card, struct sk_buff *skb,
2038 struct qeth_qdio_out_q *queue, int ipv, int cast_type)
2040 unsigned char eth_hdr[ETH_HLEN];
2041 unsigned int hw_hdr_len;
2044 /* re-use the L2 header area for the HW header: */
2045 hw_hdr_len = skb_is_gso(skb) ? sizeof(struct qeth_hdr_tso) :
2046 sizeof(struct qeth_hdr);
2047 rc = skb_cow_head(skb, hw_hdr_len - ETH_HLEN);
2050 skb_copy_from_linear_data(skb, eth_hdr, ETH_HLEN);
2051 skb_pull(skb, ETH_HLEN);
2053 qeth_l3_fixup_headers(skb);
2054 rc = qeth_xmit(card, skb, queue, ipv, cast_type, qeth_l3_fill_header);
2056 /* roll back to ETH header */
2057 skb_push(skb, ETH_HLEN);
2058 skb_copy_to_linear_data(skb, eth_hdr, ETH_HLEN);
2063 static netdev_tx_t qeth_l3_hard_start_xmit(struct sk_buff *skb,
2064 struct net_device *dev)
2066 int cast_type = qeth_l3_get_cast_type(skb);
2067 struct qeth_card *card = dev->ml_priv;
2068 int ipv = qeth_get_ip_version(skb);
2069 struct qeth_qdio_out_q *queue;
2070 int tx_bytes = skb->len;
2073 queue = qeth_get_tx_queue(card, skb, ipv, cast_type);
2076 if (card->options.sniffer)
2078 if ((card->options.cq != QETH_CQ_ENABLED && !ipv) ||
2079 (card->options.cq == QETH_CQ_ENABLED &&
2080 skb->protocol != htons(ETH_P_AF_IUCV)))
2084 if (cast_type == RTN_BROADCAST && !card->info.broadcast_capable)
2087 netif_stop_queue(dev);
2089 if (ipv == 4 || IS_IQD(card))
2090 rc = qeth_l3_xmit(card, skb, queue, ipv, cast_type);
2092 rc = qeth_xmit(card, skb, queue, ipv, cast_type,
2093 qeth_l3_fill_header);
2096 QETH_TXQ_STAT_INC(queue, tx_packets);
2097 QETH_TXQ_STAT_ADD(queue, tx_bytes, tx_bytes);
2098 netif_wake_queue(dev);
2099 return NETDEV_TX_OK;
2100 } else if (rc == -EBUSY) {
2101 return NETDEV_TX_BUSY;
2102 } /* else fall through */
2105 QETH_TXQ_STAT_INC(queue, tx_dropped);
2107 netif_wake_queue(dev);
2108 return NETDEV_TX_OK;
2111 static void qeth_l3_set_rx_mode(struct net_device *dev)
2113 struct qeth_card *card = dev->ml_priv;
2115 schedule_work(&card->rx_mode_work);
2119 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
2120 * NOARP on the netdevice is no option because it also turns off neighbor
2121 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
2122 * arp resolution but we want the hard header (packet socket will work
2125 static int qeth_l3_neigh_setup_noarp(struct neighbour *n)
2127 n->nud_state = NUD_NOARP;
2128 memcpy(n->ha, "FAKELL", 6);
2129 n->output = n->ops->connected_output;
2134 qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np)
2136 if (np->tbl->family == AF_INET)
2137 np->neigh_setup = qeth_l3_neigh_setup_noarp;
2142 static netdev_features_t qeth_l3_osa_features_check(struct sk_buff *skb,
2143 struct net_device *dev,
2144 netdev_features_t features)
2146 if (qeth_get_ip_version(skb) != 4)
2147 features &= ~NETIF_F_HW_VLAN_CTAG_TX;
2148 return qeth_features_check(skb, dev, features);
2151 static const struct net_device_ops qeth_l3_netdev_ops = {
2152 .ndo_open = qeth_open,
2153 .ndo_stop = qeth_stop,
2154 .ndo_get_stats64 = qeth_get_stats64,
2155 .ndo_start_xmit = qeth_l3_hard_start_xmit,
2156 .ndo_validate_addr = eth_validate_addr,
2157 .ndo_set_rx_mode = qeth_l3_set_rx_mode,
2158 .ndo_do_ioctl = qeth_do_ioctl,
2159 .ndo_fix_features = qeth_fix_features,
2160 .ndo_set_features = qeth_set_features,
2161 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid,
2162 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid,
2163 .ndo_tx_timeout = qeth_tx_timeout,
2166 static const struct net_device_ops qeth_l3_osa_netdev_ops = {
2167 .ndo_open = qeth_open,
2168 .ndo_stop = qeth_stop,
2169 .ndo_get_stats64 = qeth_get_stats64,
2170 .ndo_start_xmit = qeth_l3_hard_start_xmit,
2171 .ndo_features_check = qeth_l3_osa_features_check,
2172 .ndo_validate_addr = eth_validate_addr,
2173 .ndo_set_rx_mode = qeth_l3_set_rx_mode,
2174 .ndo_do_ioctl = qeth_do_ioctl,
2175 .ndo_fix_features = qeth_fix_features,
2176 .ndo_set_features = qeth_set_features,
2177 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid,
2178 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid,
2179 .ndo_tx_timeout = qeth_tx_timeout,
2180 .ndo_neigh_setup = qeth_l3_neigh_setup,
2183 static int qeth_l3_setup_netdev(struct qeth_card *card, bool carrier_ok)
2185 unsigned int headroom;
2188 if (card->info.type == QETH_CARD_TYPE_OSD ||
2189 card->info.type == QETH_CARD_TYPE_OSX) {
2190 if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) ||
2191 (card->info.link_type == QETH_LINK_TYPE_HSTR)) {
2192 pr_info("qeth_l3: ignoring TR device\n");
2196 card->dev->netdev_ops = &qeth_l3_osa_netdev_ops;
2198 /*IPv6 address autoconfiguration stuff*/
2199 qeth_l3_get_unique_id(card);
2200 if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
2201 card->dev->dev_id = card->info.unique_id & 0xffff;
2203 if (!card->info.guestlan) {
2204 card->dev->features |= NETIF_F_SG;
2205 card->dev->hw_features |= NETIF_F_TSO |
2206 NETIF_F_RXCSUM | NETIF_F_IP_CSUM;
2207 card->dev->vlan_features |= NETIF_F_TSO |
2208 NETIF_F_RXCSUM | NETIF_F_IP_CSUM;
2211 if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) {
2212 card->dev->hw_features |= NETIF_F_IPV6_CSUM;
2213 card->dev->vlan_features |= NETIF_F_IPV6_CSUM;
2215 if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) {
2216 card->dev->hw_features |= NETIF_F_TSO6;
2217 card->dev->vlan_features |= NETIF_F_TSO6;
2220 /* allow for de-acceleration of NETIF_F_HW_VLAN_CTAG_TX: */
2221 if (card->dev->hw_features & NETIF_F_TSO6)
2222 headroom = sizeof(struct qeth_hdr_tso) + VLAN_HLEN;
2223 else if (card->dev->hw_features & NETIF_F_TSO)
2224 headroom = sizeof(struct qeth_hdr_tso);
2226 headroom = sizeof(struct qeth_hdr) + VLAN_HLEN;
2227 } else if (card->info.type == QETH_CARD_TYPE_IQD) {
2228 card->dev->flags |= IFF_NOARP;
2229 card->dev->netdev_ops = &qeth_l3_netdev_ops;
2230 headroom = sizeof(struct qeth_hdr) - ETH_HLEN;
2232 rc = qeth_l3_iqd_read_initial_mac(card);
2238 card->dev->needed_headroom = headroom;
2239 card->dev->features |= NETIF_F_HW_VLAN_CTAG_TX |
2240 NETIF_F_HW_VLAN_CTAG_RX |
2241 NETIF_F_HW_VLAN_CTAG_FILTER;
2243 netif_keep_dst(card->dev);
2244 if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6))
2245 netif_set_gso_max_size(card->dev,
2246 PAGE_SIZE * (QETH_MAX_BUFFER_ELEMENTS(card) - 1));
2248 netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
2249 rc = register_netdev(card->dev);
2250 if (!rc && carrier_ok)
2251 netif_carrier_on(card->dev);
2255 card->dev->netdev_ops = NULL;
2259 static const struct device_type qeth_l3_devtype = {
2260 .name = "qeth_layer3",
2261 .groups = qeth_l3_attr_groups,
2264 static int qeth_l3_probe_device(struct ccwgroup_device *gdev)
2266 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2269 hash_init(card->ip_htable);
2270 card->cmd_wq = alloc_ordered_workqueue("%s_cmd", 0,
2271 dev_name(&gdev->dev));
2275 if (gdev->dev.type == &qeth_generic_devtype) {
2276 rc = qeth_l3_create_device_attributes(&gdev->dev);
2278 destroy_workqueue(card->cmd_wq);
2283 hash_init(card->ip_mc_htable);
2284 INIT_WORK(&card->rx_mode_work, qeth_l3_rx_mode_work);
2288 static void qeth_l3_remove_device(struct ccwgroup_device *cgdev)
2290 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
2292 if (cgdev->dev.type == &qeth_generic_devtype)
2293 qeth_l3_remove_device_attributes(&cgdev->dev);
2295 qeth_set_allowed_threads(card, 0, 1);
2296 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
2298 if (cgdev->state == CCWGROUP_ONLINE)
2299 qeth_l3_set_offline(cgdev);
2301 cancel_work_sync(&card->close_dev_work);
2302 if (qeth_netdev_is_registered(card->dev))
2303 unregister_netdev(card->dev);
2305 flush_workqueue(card->cmd_wq);
2306 destroy_workqueue(card->cmd_wq);
2307 qeth_l3_clear_ip_htable(card, 0);
2308 qeth_l3_clear_ipato_list(card);
2311 static int qeth_l3_set_online(struct ccwgroup_device *gdev)
2313 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2314 struct net_device *dev = card->dev;
2318 mutex_lock(&card->discipline_mutex);
2319 mutex_lock(&card->conf_mutex);
2320 QETH_DBF_TEXT(SETUP, 2, "setonlin");
2321 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
2323 rc = qeth_core_hardsetup_card(card, &carrier_ok);
2325 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
2330 if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) {
2331 if (card->info.hwtrap &&
2332 qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM))
2333 card->info.hwtrap = 0;
2335 card->info.hwtrap = 0;
2337 card->state = CARD_STATE_HARDSETUP;
2338 qeth_print_status_message(card);
2341 QETH_DBF_TEXT(SETUP, 2, "softsetp");
2343 rc = qeth_l3_setadapter_parms(card);
2345 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
2346 if (!card->options.sniffer) {
2347 rc = qeth_l3_start_ipassists(card);
2349 QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
2352 rc = qeth_l3_setrouting_v4(card);
2354 QETH_DBF_TEXT_(SETUP, 2, "4err%04x", rc);
2355 rc = qeth_l3_setrouting_v6(card);
2357 QETH_DBF_TEXT_(SETUP, 2, "5err%04x", rc);
2360 rc = qeth_init_qdio_queues(card);
2362 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
2366 card->state = CARD_STATE_SOFTSETUP;
2368 qeth_set_allowed_threads(card, 0xffffffff, 0);
2369 qeth_l3_recover_ip(card);
2371 if (!qeth_netdev_is_registered(dev)) {
2372 rc = qeth_l3_setup_netdev(card, carrier_ok);
2378 netif_carrier_on(dev);
2380 netif_carrier_off(dev);
2382 netif_device_attach(dev);
2383 qeth_enable_hw_features(dev);
2385 if (card->info.open_when_online) {
2386 card->info.open_when_online = 0;
2387 dev_open(dev, NULL);
2391 qeth_trace_features(card);
2392 /* let user_space know that device is online */
2393 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
2394 mutex_unlock(&card->conf_mutex);
2395 mutex_unlock(&card->discipline_mutex);
2398 qeth_l3_stop_card(card);
2399 ccw_device_set_offline(CARD_DDEV(card));
2400 ccw_device_set_offline(CARD_WDEV(card));
2401 ccw_device_set_offline(CARD_RDEV(card));
2402 qdio_free(CARD_DDEV(card));
2403 card->state = CARD_STATE_DOWN;
2405 mutex_unlock(&card->conf_mutex);
2406 mutex_unlock(&card->discipline_mutex);
2410 static int __qeth_l3_set_offline(struct ccwgroup_device *cgdev,
2413 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
2414 int rc = 0, rc2 = 0, rc3 = 0;
2416 mutex_lock(&card->discipline_mutex);
2417 mutex_lock(&card->conf_mutex);
2418 QETH_DBF_TEXT(SETUP, 3, "setoffl");
2419 QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
2421 if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
2422 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
2423 card->info.hwtrap = 1;
2427 card->info.open_when_online = card->dev->flags & IFF_UP;
2428 dev_close(card->dev);
2429 netif_device_detach(card->dev);
2430 netif_carrier_off(card->dev);
2433 qeth_l3_stop_card(card);
2434 if (card->options.cq == QETH_CQ_ENABLED) {
2436 call_netdevice_notifiers(NETDEV_REBOOT, card->dev);
2439 rc = ccw_device_set_offline(CARD_DDEV(card));
2440 rc2 = ccw_device_set_offline(CARD_WDEV(card));
2441 rc3 = ccw_device_set_offline(CARD_RDEV(card));
2443 rc = (rc2) ? rc2 : rc3;
2445 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
2446 qdio_free(CARD_DDEV(card));
2448 /* let user_space know that device is offline */
2449 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
2450 mutex_unlock(&card->conf_mutex);
2451 mutex_unlock(&card->discipline_mutex);
2455 static int qeth_l3_set_offline(struct ccwgroup_device *cgdev)
2457 return __qeth_l3_set_offline(cgdev, 0);
2460 static int qeth_l3_recover(void *ptr)
2462 struct qeth_card *card;
2465 card = (struct qeth_card *) ptr;
2466 QETH_CARD_TEXT(card, 2, "recover1");
2467 QETH_CARD_HEX(card, 2, &card, sizeof(void *));
2468 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
2470 QETH_CARD_TEXT(card, 2, "recover2");
2471 dev_warn(&card->gdev->dev,
2472 "A recovery process has been started for the device\n");
2473 __qeth_l3_set_offline(card->gdev, 1);
2474 rc = qeth_l3_set_online(card->gdev);
2476 dev_info(&card->gdev->dev,
2477 "Device successfully recovered!\n");
2479 ccwgroup_set_offline(card->gdev);
2480 dev_warn(&card->gdev->dev, "The qeth device driver "
2481 "failed to recover an error on the device\n");
2483 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
2484 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
2488 static int qeth_l3_pm_suspend(struct ccwgroup_device *gdev)
2490 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2492 qeth_set_allowed_threads(card, 0, 1);
2493 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
2494 if (gdev->state == CCWGROUP_OFFLINE)
2497 qeth_l3_set_offline(gdev);
2501 static int qeth_l3_pm_resume(struct ccwgroup_device *gdev)
2503 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2506 rc = qeth_l3_set_online(gdev);
2508 qeth_set_allowed_threads(card, 0xffffffff, 0);
2510 dev_warn(&card->gdev->dev, "The qeth device driver "
2511 "failed to recover an error on the device\n");
2515 /* Returns zero if the command is successfully "consumed" */
2516 static int qeth_l3_control_event(struct qeth_card *card,
2517 struct qeth_ipa_cmd *cmd)
2522 struct qeth_discipline qeth_l3_discipline = {
2523 .devtype = &qeth_l3_devtype,
2524 .process_rx_buffer = qeth_l3_process_inbound_buffer,
2525 .recover = qeth_l3_recover,
2526 .setup = qeth_l3_probe_device,
2527 .remove = qeth_l3_remove_device,
2528 .set_online = qeth_l3_set_online,
2529 .set_offline = qeth_l3_set_offline,
2530 .freeze = qeth_l3_pm_suspend,
2531 .thaw = qeth_l3_pm_resume,
2532 .restore = qeth_l3_pm_resume,
2533 .do_ioctl = qeth_l3_do_ioctl,
2534 .control_event_handler = qeth_l3_control_event,
2536 EXPORT_SYMBOL_GPL(qeth_l3_discipline);
2538 static int qeth_l3_handle_ip_event(struct qeth_card *card,
2539 struct qeth_ipaddr *addr,
2540 unsigned long event)
2544 qeth_l3_modify_ip(card, addr, true);
2547 qeth_l3_modify_ip(card, addr, false);
2554 struct qeth_l3_ip_event_work {
2555 struct work_struct work;
2556 struct qeth_card *card;
2557 struct qeth_ipaddr addr;
2560 #define to_ip_work(w) container_of((w), struct qeth_l3_ip_event_work, work)
2562 static void qeth_l3_add_ip_worker(struct work_struct *work)
2564 struct qeth_l3_ip_event_work *ip_work = to_ip_work(work);
2566 qeth_l3_modify_ip(ip_work->card, &ip_work->addr, true);
2570 static void qeth_l3_delete_ip_worker(struct work_struct *work)
2572 struct qeth_l3_ip_event_work *ip_work = to_ip_work(work);
2574 qeth_l3_modify_ip(ip_work->card, &ip_work->addr, false);
2578 static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev)
2580 if (is_vlan_dev(dev))
2581 dev = vlan_dev_real_dev(dev);
2582 if (dev->netdev_ops == &qeth_l3_osa_netdev_ops ||
2583 dev->netdev_ops == &qeth_l3_netdev_ops)
2584 return (struct qeth_card *) dev->ml_priv;
2588 static int qeth_l3_ip_event(struct notifier_block *this,
2589 unsigned long event, void *ptr)
2592 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
2593 struct net_device *dev = ifa->ifa_dev->dev;
2594 struct qeth_ipaddr addr;
2595 struct qeth_card *card;
2597 if (dev_net(dev) != &init_net)
2600 card = qeth_l3_get_card_from_dev(dev);
2603 QETH_CARD_TEXT(card, 3, "ipevent");
2605 qeth_l3_init_ipaddr(&addr, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV4);
2606 addr.u.a4.addr = be32_to_cpu(ifa->ifa_address);
2607 addr.u.a4.mask = be32_to_cpu(ifa->ifa_mask);
2609 return qeth_l3_handle_ip_event(card, &addr, event);
2612 static struct notifier_block qeth_l3_ip_notifier = {
2617 static int qeth_l3_ip6_event(struct notifier_block *this,
2618 unsigned long event, void *ptr)
2620 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
2621 struct net_device *dev = ifa->idev->dev;
2622 struct qeth_l3_ip_event_work *ip_work;
2623 struct qeth_card *card;
2625 if (event != NETDEV_UP && event != NETDEV_DOWN)
2628 card = qeth_l3_get_card_from_dev(dev);
2631 QETH_CARD_TEXT(card, 3, "ip6event");
2632 if (!qeth_is_supported(card, IPA_IPV6))
2635 ip_work = kmalloc(sizeof(*ip_work), GFP_ATOMIC);
2639 if (event == NETDEV_UP)
2640 INIT_WORK(&ip_work->work, qeth_l3_add_ip_worker);
2642 INIT_WORK(&ip_work->work, qeth_l3_delete_ip_worker);
2644 ip_work->card = card;
2645 qeth_l3_init_ipaddr(&ip_work->addr, QETH_IP_TYPE_NORMAL,
2647 ip_work->addr.u.a6.addr = ifa->addr;
2648 ip_work->addr.u.a6.pfxlen = ifa->prefix_len;
2650 queue_work(card->cmd_wq, &ip_work->work);
2654 static struct notifier_block qeth_l3_ip6_notifier = {
2659 static int qeth_l3_register_notifiers(void)
2663 QETH_DBF_TEXT(SETUP, 5, "regnotif");
2664 rc = register_inetaddr_notifier(&qeth_l3_ip_notifier);
2667 rc = register_inet6addr_notifier(&qeth_l3_ip6_notifier);
2669 unregister_inetaddr_notifier(&qeth_l3_ip_notifier);
2675 static void qeth_l3_unregister_notifiers(void)
2677 QETH_DBF_TEXT(SETUP, 5, "unregnot");
2678 WARN_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier));
2679 WARN_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier));
2682 static int __init qeth_l3_init(void)
2684 pr_info("register layer 3 discipline\n");
2685 return qeth_l3_register_notifiers();
2688 static void __exit qeth_l3_exit(void)
2690 qeth_l3_unregister_notifiers();
2691 pr_info("unregister layer 3 discipline\n");
2694 module_init(qeth_l3_init);
2695 module_exit(qeth_l3_exit);
2696 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
2697 MODULE_DESCRIPTION("qeth layer 3 discipline");
2698 MODULE_LICENSE("GPL");