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/ip6_checksum.h>
37 #include <net/iucv/af_iucv.h>
38 #include <linux/hashtable.h>
43 static int qeth_l3_set_offline(struct ccwgroup_device *);
44 static int qeth_l3_stop(struct net_device *);
45 static void qeth_l3_set_rx_mode(struct net_device *dev);
46 static int qeth_l3_register_addr_entry(struct qeth_card *,
47 struct qeth_ipaddr *);
48 static int qeth_l3_deregister_addr_entry(struct qeth_card *,
49 struct qeth_ipaddr *);
51 static int qeth_l3_isxdigit(char *buf)
54 if (!isxdigit(*buf++))
60 static void qeth_l3_ipaddr4_to_string(const __u8 *addr, char *buf)
62 sprintf(buf, "%pI4", addr);
65 static int qeth_l3_string_to_ipaddr4(const char *buf, __u8 *addr)
67 int count = 0, rc = 0;
71 rc = sscanf(buf, "%u.%u.%u.%u%c",
72 &in[0], &in[1], &in[2], &in[3], &c);
73 if (rc != 4 && (rc != 5 || c != '\n'))
75 for (count = 0; count < 4; count++) {
78 addr[count] = in[count];
83 static void qeth_l3_ipaddr6_to_string(const __u8 *addr, char *buf)
85 sprintf(buf, "%pI6", addr);
88 static int qeth_l3_string_to_ipaddr6(const char *buf, __u8 *addr)
90 const char *end, *end_tmp, *start;
93 int num2, cnt, out, found, save_cnt;
94 unsigned short in_tmp[8] = {0, };
96 cnt = out = found = save_cnt = num2 = 0;
101 end = strchr(start, ':');
103 end = buf + strlen(buf);
104 end_tmp = strchr(start, '\n');
111 if ((end - start) > 4)
113 memcpy(num, start, end - start);
114 if (!qeth_l3_isxdigit(num))
116 sscanf(start, "%x", &num2);
118 in_tmp[save_cnt++] = num2;
130 if (cnt + save_cnt > 8)
134 in[cnt--] = in_tmp[--save_cnt];
138 void qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto, const __u8 *addr,
141 if (proto == QETH_PROT_IPV4)
142 qeth_l3_ipaddr4_to_string(addr, buf);
143 else if (proto == QETH_PROT_IPV6)
144 qeth_l3_ipaddr6_to_string(addr, buf);
147 int qeth_l3_string_to_ipaddr(const char *buf, enum qeth_prot_versions proto,
150 if (proto == QETH_PROT_IPV4)
151 return qeth_l3_string_to_ipaddr4(buf, addr);
152 else if (proto == QETH_PROT_IPV6)
153 return qeth_l3_string_to_ipaddr6(buf, addr);
158 static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
163 for (i = 0; i < len; ++i) {
165 for (j = 7; j >= 0; --j) {
166 bits[i*8 + j] = octet & 1;
172 static bool qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
173 struct qeth_ipaddr *addr)
175 struct qeth_ipato_entry *ipatoe;
176 u8 addr_bits[128] = {0, };
177 u8 ipatoe_bits[128] = {0, };
180 if (!card->ipato.enabled)
182 if (addr->type != QETH_IP_TYPE_NORMAL)
185 qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits,
186 (addr->proto == QETH_PROT_IPV4)? 4:16);
187 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
188 if (addr->proto != ipatoe->proto)
190 qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits,
191 (ipatoe->proto == QETH_PROT_IPV4) ?
193 if (addr->proto == QETH_PROT_IPV4)
194 rc = !memcmp(addr_bits, ipatoe_bits,
195 min(32, ipatoe->mask_bits));
197 rc = !memcmp(addr_bits, ipatoe_bits,
198 min(128, ipatoe->mask_bits));
203 if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
205 else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
212 qeth_l3_ipaddrs_is_equal(struct qeth_ipaddr *addr1, struct qeth_ipaddr *addr2)
214 return addr1->proto == addr2->proto &&
215 !memcmp(&addr1->u, &addr2->u, sizeof(addr1->u)) &&
216 ether_addr_equal_64bits(addr1->mac, addr2->mac);
219 static struct qeth_ipaddr *
220 qeth_l3_ip_from_hash(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
222 struct qeth_ipaddr *addr;
224 if (tmp_addr->is_multicast) {
225 hash_for_each_possible(card->ip_mc_htable, addr,
226 hnode, qeth_l3_ipaddr_hash(tmp_addr))
227 if (qeth_l3_ipaddrs_is_equal(tmp_addr, addr))
230 hash_for_each_possible(card->ip_htable, addr,
231 hnode, qeth_l3_ipaddr_hash(tmp_addr))
232 if (qeth_l3_ipaddrs_is_equal(tmp_addr, addr))
239 int qeth_l3_delete_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
242 struct qeth_ipaddr *addr;
244 QETH_CARD_TEXT(card, 4, "delip");
246 if (tmp_addr->proto == QETH_PROT_IPV4)
247 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
249 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
250 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
253 addr = qeth_l3_ip_from_hash(card, tmp_addr);
258 if (addr->ref_counter > 0 && (addr->type == QETH_IP_TYPE_NORMAL ||
259 addr->type == QETH_IP_TYPE_RXIP))
261 if (addr->in_progress)
264 if (!qeth_card_hw_is_reachable(card)) {
265 addr->disp_flag = QETH_DISP_ADDR_DELETE;
269 rc = qeth_l3_deregister_addr_entry(card, addr);
271 hash_del(&addr->hnode);
277 int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
280 struct qeth_ipaddr *addr;
282 QETH_CARD_TEXT(card, 4, "addip");
284 if (tmp_addr->proto == QETH_PROT_IPV4)
285 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
287 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
288 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
291 addr = qeth_l3_ip_from_hash(card, tmp_addr);
293 addr = qeth_l3_get_addr_buffer(tmp_addr->proto);
297 memcpy(addr, tmp_addr, sizeof(struct qeth_ipaddr));
298 addr->ref_counter = 1;
300 if (qeth_l3_is_addr_covered_by_ipato(card, addr)) {
301 QETH_CARD_TEXT(card, 2, "tkovaddr");
302 addr->set_flags |= QETH_IPA_SETIP_TAKEOVER_FLAG;
304 hash_add(card->ip_htable, &addr->hnode,
305 qeth_l3_ipaddr_hash(addr));
307 if (!qeth_card_hw_is_reachable(card)) {
308 addr->disp_flag = QETH_DISP_ADDR_ADD;
312 /* qeth_l3_register_addr_entry can go to sleep
313 * if we add a IPV4 addr. It is caused by the reason
314 * that SETIP ipa cmd starts ARP staff for IPV4 addr.
315 * Thus we should unlock spinlock, and make a protection
316 * using in_progress variable to indicate that there is
317 * an hardware operation with this IPV4 address
319 if (addr->proto == QETH_PROT_IPV4) {
320 addr->in_progress = 1;
321 spin_unlock_bh(&card->ip_lock);
322 rc = qeth_l3_register_addr_entry(card, addr);
323 spin_lock_bh(&card->ip_lock);
324 addr->in_progress = 0;
326 rc = qeth_l3_register_addr_entry(card, addr);
328 if (!rc || (rc == IPA_RC_DUPLICATE_IP_ADDRESS) ||
329 (rc == IPA_RC_LAN_OFFLINE)) {
330 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
331 if (addr->ref_counter < 1) {
332 qeth_l3_delete_ip(card, addr);
336 hash_del(&addr->hnode);
340 if (addr->type == QETH_IP_TYPE_NORMAL ||
341 addr->type == QETH_IP_TYPE_RXIP)
349 struct qeth_ipaddr *qeth_l3_get_addr_buffer(
350 enum qeth_prot_versions prot)
352 struct qeth_ipaddr *addr;
354 addr = kzalloc(sizeof(struct qeth_ipaddr), GFP_ATOMIC);
358 addr->type = QETH_IP_TYPE_NORMAL;
359 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
365 static void qeth_l3_clear_ip_htable(struct qeth_card *card, int recover)
367 struct qeth_ipaddr *addr;
368 struct hlist_node *tmp;
371 QETH_CARD_TEXT(card, 4, "clearip");
373 if (recover && card->options.sniffer)
376 spin_lock_bh(&card->ip_lock);
378 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
380 hash_del(&addr->hnode);
384 addr->disp_flag = QETH_DISP_ADDR_ADD;
387 spin_unlock_bh(&card->ip_lock);
389 spin_lock_bh(&card->mclock);
391 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
392 hash_del(&addr->hnode);
396 spin_unlock_bh(&card->mclock);
400 static void qeth_l3_recover_ip(struct qeth_card *card)
402 struct qeth_ipaddr *addr;
403 struct hlist_node *tmp;
407 QETH_CARD_TEXT(card, 4, "recovrip");
409 spin_lock_bh(&card->ip_lock);
411 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
412 if (addr->disp_flag == QETH_DISP_ADDR_DELETE) {
413 qeth_l3_deregister_addr_entry(card, addr);
414 hash_del(&addr->hnode);
416 } else if (addr->disp_flag == QETH_DISP_ADDR_ADD) {
417 if (addr->proto == QETH_PROT_IPV4) {
418 addr->in_progress = 1;
419 spin_unlock_bh(&card->ip_lock);
420 rc = qeth_l3_register_addr_entry(card, addr);
421 spin_lock_bh(&card->ip_lock);
422 addr->in_progress = 0;
424 rc = qeth_l3_register_addr_entry(card, addr);
427 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
428 if (addr->ref_counter < 1)
429 qeth_l3_delete_ip(card, addr);
431 hash_del(&addr->hnode);
437 spin_unlock_bh(&card->ip_lock);
441 static int qeth_l3_send_setdelmc(struct qeth_card *card,
442 struct qeth_ipaddr *addr, int ipacmd)
445 struct qeth_cmd_buffer *iob;
446 struct qeth_ipa_cmd *cmd;
448 QETH_CARD_TEXT(card, 4, "setdelmc");
450 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
453 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
454 ether_addr_copy(cmd->data.setdelipm.mac, addr->mac);
455 if (addr->proto == QETH_PROT_IPV6)
456 memcpy(cmd->data.setdelipm.ip6, &addr->u.a6.addr,
457 sizeof(struct in6_addr));
459 memcpy(&cmd->data.setdelipm.ip4, &addr->u.a4.addr, 4);
461 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
466 static void qeth_l3_fill_netmask(u8 *netmask, unsigned int len)
469 for (i = 0; i < 16; i++) {
474 netmask[i] = (u8)(0xFF00 >> j);
480 static int qeth_l3_send_setdelip(struct qeth_card *card,
481 struct qeth_ipaddr *addr, int ipacmd, unsigned int flags)
484 struct qeth_cmd_buffer *iob;
485 struct qeth_ipa_cmd *cmd;
488 QETH_CARD_TEXT(card, 4, "setdelip");
489 QETH_CARD_TEXT_(card, 4, "flags%02X", flags);
491 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
494 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
495 if (addr->proto == QETH_PROT_IPV6) {
496 memcpy(cmd->data.setdelip6.ip_addr, &addr->u.a6.addr,
497 sizeof(struct in6_addr));
498 qeth_l3_fill_netmask(netmask, addr->u.a6.pfxlen);
499 memcpy(cmd->data.setdelip6.mask, netmask,
500 sizeof(struct in6_addr));
501 cmd->data.setdelip6.flags = flags;
503 memcpy(cmd->data.setdelip4.ip_addr, &addr->u.a4.addr, 4);
504 memcpy(cmd->data.setdelip4.mask, &addr->u.a4.mask, 4);
505 cmd->data.setdelip4.flags = flags;
508 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
513 static int qeth_l3_send_setrouting(struct qeth_card *card,
514 enum qeth_routing_types type, enum qeth_prot_versions prot)
517 struct qeth_ipa_cmd *cmd;
518 struct qeth_cmd_buffer *iob;
520 QETH_CARD_TEXT(card, 4, "setroutg");
521 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETRTG, prot);
524 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
525 cmd->data.setrtg.type = (type);
526 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
531 static int qeth_l3_correct_routing_type(struct qeth_card *card,
532 enum qeth_routing_types *type, enum qeth_prot_versions prot)
534 if (card->info.type == QETH_CARD_TYPE_IQD) {
537 case PRIMARY_CONNECTOR:
538 case SECONDARY_CONNECTOR:
539 case MULTICAST_ROUTER:
548 case SECONDARY_ROUTER:
550 case MULTICAST_ROUTER:
551 if (qeth_is_ipafunc_supported(card, prot,
563 int qeth_l3_setrouting_v4(struct qeth_card *card)
567 QETH_CARD_TEXT(card, 3, "setrtg4");
569 rc = qeth_l3_correct_routing_type(card, &card->options.route4.type,
574 rc = qeth_l3_send_setrouting(card, card->options.route4.type,
577 card->options.route4.type = NO_ROUTER;
578 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
579 " on %s. Type set to 'no router'.\n", rc,
580 QETH_CARD_IFNAME(card));
585 int qeth_l3_setrouting_v6(struct qeth_card *card)
589 QETH_CARD_TEXT(card, 3, "setrtg6");
591 if (!qeth_is_supported(card, IPA_IPV6))
593 rc = qeth_l3_correct_routing_type(card, &card->options.route6.type,
598 rc = qeth_l3_send_setrouting(card, card->options.route6.type,
601 card->options.route6.type = NO_ROUTER;
602 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
603 " on %s. Type set to 'no router'.\n", rc,
604 QETH_CARD_IFNAME(card));
610 * IP address takeover related functions
614 * qeth_l3_update_ipato() - Update 'takeover' property, for all NORMAL IPs.
616 * Caller must hold ip_lock.
618 void qeth_l3_update_ipato(struct qeth_card *card)
620 struct qeth_ipaddr *addr;
623 hash_for_each(card->ip_htable, i, addr, hnode) {
624 if (addr->type != QETH_IP_TYPE_NORMAL)
626 if (qeth_l3_is_addr_covered_by_ipato(card, addr))
627 addr->set_flags |= QETH_IPA_SETIP_TAKEOVER_FLAG;
629 addr->set_flags &= ~QETH_IPA_SETIP_TAKEOVER_FLAG;
633 static void qeth_l3_clear_ipato_list(struct qeth_card *card)
635 struct qeth_ipato_entry *ipatoe, *tmp;
637 spin_lock_bh(&card->ip_lock);
639 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
640 list_del(&ipatoe->entry);
644 qeth_l3_update_ipato(card);
645 spin_unlock_bh(&card->ip_lock);
648 int qeth_l3_add_ipato_entry(struct qeth_card *card,
649 struct qeth_ipato_entry *new)
651 struct qeth_ipato_entry *ipatoe;
654 QETH_CARD_TEXT(card, 2, "addipato");
656 spin_lock_bh(&card->ip_lock);
658 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
659 if (ipatoe->proto != new->proto)
661 if (!memcmp(ipatoe->addr, new->addr,
662 (ipatoe->proto == QETH_PROT_IPV4)? 4:16) &&
663 (ipatoe->mask_bits == new->mask_bits)) {
670 list_add_tail(&new->entry, &card->ipato.entries);
671 qeth_l3_update_ipato(card);
674 spin_unlock_bh(&card->ip_lock);
679 void qeth_l3_del_ipato_entry(struct qeth_card *card,
680 enum qeth_prot_versions proto, u8 *addr, int mask_bits)
682 struct qeth_ipato_entry *ipatoe, *tmp;
684 QETH_CARD_TEXT(card, 2, "delipato");
686 spin_lock_bh(&card->ip_lock);
688 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
689 if (ipatoe->proto != proto)
691 if (!memcmp(ipatoe->addr, addr,
692 (proto == QETH_PROT_IPV4)? 4:16) &&
693 (ipatoe->mask_bits == mask_bits)) {
694 list_del(&ipatoe->entry);
695 qeth_l3_update_ipato(card);
700 spin_unlock_bh(&card->ip_lock);
704 * VIPA related functions
706 int qeth_l3_add_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
709 struct qeth_ipaddr *ipaddr;
712 ipaddr = qeth_l3_get_addr_buffer(proto);
714 if (proto == QETH_PROT_IPV4) {
715 QETH_CARD_TEXT(card, 2, "addvipa4");
716 memcpy(&ipaddr->u.a4.addr, addr, 4);
717 ipaddr->u.a4.mask = 0;
718 } else if (proto == QETH_PROT_IPV6) {
719 QETH_CARD_TEXT(card, 2, "addvipa6");
720 memcpy(&ipaddr->u.a6.addr, addr, 16);
721 ipaddr->u.a6.pfxlen = 0;
723 ipaddr->type = QETH_IP_TYPE_VIPA;
724 ipaddr->set_flags = QETH_IPA_SETIP_VIPA_FLAG;
725 ipaddr->del_flags = QETH_IPA_DELIP_VIPA_FLAG;
729 spin_lock_bh(&card->ip_lock);
731 if (qeth_l3_ip_from_hash(card, ipaddr))
734 qeth_l3_add_ip(card, ipaddr);
736 spin_unlock_bh(&card->ip_lock);
743 void qeth_l3_del_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
746 struct qeth_ipaddr *ipaddr;
748 ipaddr = qeth_l3_get_addr_buffer(proto);
750 if (proto == QETH_PROT_IPV4) {
751 QETH_CARD_TEXT(card, 2, "delvipa4");
752 memcpy(&ipaddr->u.a4.addr, addr, 4);
753 ipaddr->u.a4.mask = 0;
754 } else if (proto == QETH_PROT_IPV6) {
755 QETH_CARD_TEXT(card, 2, "delvipa6");
756 memcpy(&ipaddr->u.a6.addr, addr, 16);
757 ipaddr->u.a6.pfxlen = 0;
759 ipaddr->type = QETH_IP_TYPE_VIPA;
763 spin_lock_bh(&card->ip_lock);
764 qeth_l3_delete_ip(card, ipaddr);
765 spin_unlock_bh(&card->ip_lock);
771 * proxy ARP related functions
773 int qeth_l3_add_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
776 struct qeth_ipaddr *ipaddr;
779 ipaddr = qeth_l3_get_addr_buffer(proto);
781 if (proto == QETH_PROT_IPV4) {
782 QETH_CARD_TEXT(card, 2, "addrxip4");
783 memcpy(&ipaddr->u.a4.addr, addr, 4);
784 ipaddr->u.a4.mask = 0;
785 } else if (proto == QETH_PROT_IPV6) {
786 QETH_CARD_TEXT(card, 2, "addrxip6");
787 memcpy(&ipaddr->u.a6.addr, addr, 16);
788 ipaddr->u.a6.pfxlen = 0;
791 ipaddr->type = QETH_IP_TYPE_RXIP;
792 ipaddr->set_flags = QETH_IPA_SETIP_TAKEOVER_FLAG;
793 ipaddr->del_flags = 0;
797 spin_lock_bh(&card->ip_lock);
799 if (qeth_l3_ip_from_hash(card, ipaddr))
802 qeth_l3_add_ip(card, ipaddr);
804 spin_unlock_bh(&card->ip_lock);
811 void qeth_l3_del_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
814 struct qeth_ipaddr *ipaddr;
816 ipaddr = qeth_l3_get_addr_buffer(proto);
818 if (proto == QETH_PROT_IPV4) {
819 QETH_CARD_TEXT(card, 2, "delrxip4");
820 memcpy(&ipaddr->u.a4.addr, addr, 4);
821 ipaddr->u.a4.mask = 0;
822 } else if (proto == QETH_PROT_IPV6) {
823 QETH_CARD_TEXT(card, 2, "delrxip6");
824 memcpy(&ipaddr->u.a6.addr, addr, 16);
825 ipaddr->u.a6.pfxlen = 0;
827 ipaddr->type = QETH_IP_TYPE_RXIP;
831 spin_lock_bh(&card->ip_lock);
832 qeth_l3_delete_ip(card, ipaddr);
833 spin_unlock_bh(&card->ip_lock);
838 static int qeth_l3_register_addr_entry(struct qeth_card *card,
839 struct qeth_ipaddr *addr)
846 if (addr->proto == QETH_PROT_IPV4) {
847 QETH_CARD_TEXT(card, 2, "setaddr4");
848 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
849 } else if (addr->proto == QETH_PROT_IPV6) {
850 QETH_CARD_TEXT(card, 2, "setaddr6");
851 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
852 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
854 QETH_CARD_TEXT(card, 2, "setaddr?");
855 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
858 if (addr->is_multicast)
859 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
861 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP,
864 QETH_CARD_TEXT(card, 2, "failed");
865 } while ((--cnt > 0) && rc);
867 QETH_CARD_TEXT(card, 2, "FAILED");
868 qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
869 dev_warn(&card->gdev->dev,
870 "Registering IP address %s failed\n", buf);
875 static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
876 struct qeth_ipaddr *addr)
880 if (addr->proto == QETH_PROT_IPV4) {
881 QETH_CARD_TEXT(card, 2, "deladdr4");
882 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
883 } else if (addr->proto == QETH_PROT_IPV6) {
884 QETH_CARD_TEXT(card, 2, "deladdr6");
885 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
886 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
888 QETH_CARD_TEXT(card, 2, "deladdr?");
889 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
891 if (addr->is_multicast)
892 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
894 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP,
897 QETH_CARD_TEXT(card, 2, "failed");
902 static int qeth_l3_setadapter_parms(struct qeth_card *card)
906 QETH_DBF_TEXT(SETUP, 2, "setadprm");
908 if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
909 rc = qeth_setadpparms_change_macaddr(card);
911 dev_warn(&card->gdev->dev, "Reading the adapter MAC"
912 " address failed\n");
918 static int qeth_l3_send_simple_setassparms_ipv6(struct qeth_card *card,
919 enum qeth_ipa_funcs ipa_func, __u16 cmd_code)
922 struct qeth_cmd_buffer *iob;
924 QETH_CARD_TEXT(card, 4, "simassp6");
925 iob = qeth_get_setassparms_cmd(card, ipa_func, cmd_code,
929 rc = qeth_send_setassparms(card, iob, 0, 0,
930 qeth_setassparms_cb, NULL);
934 static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
938 QETH_CARD_TEXT(card, 3, "ipaarp");
940 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
941 dev_info(&card->gdev->dev,
942 "ARP processing not supported on %s!\n",
943 QETH_CARD_IFNAME(card));
946 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
947 IPA_CMD_ASS_START, 0);
949 dev_warn(&card->gdev->dev,
950 "Starting ARP processing support for %s failed\n",
951 QETH_CARD_IFNAME(card));
956 static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
960 QETH_CARD_TEXT(card, 3, "stsrcmac");
962 if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
963 dev_info(&card->gdev->dev,
964 "Inbound source MAC-address not supported on %s\n",
965 QETH_CARD_IFNAME(card));
969 rc = qeth_send_simple_setassparms(card, IPA_SOURCE_MAC,
970 IPA_CMD_ASS_START, 0);
972 dev_warn(&card->gdev->dev,
973 "Starting source MAC-address support for %s failed\n",
974 QETH_CARD_IFNAME(card));
978 static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
982 QETH_CARD_TEXT(card, 3, "strtvlan");
984 if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
985 dev_info(&card->gdev->dev,
986 "VLAN not supported on %s\n", QETH_CARD_IFNAME(card));
990 rc = qeth_send_simple_setassparms(card, IPA_VLAN_PRIO,
991 IPA_CMD_ASS_START, 0);
993 dev_warn(&card->gdev->dev,
994 "Starting VLAN support for %s failed\n",
995 QETH_CARD_IFNAME(card));
997 dev_info(&card->gdev->dev, "VLAN enabled\n");
1002 static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
1006 QETH_CARD_TEXT(card, 3, "stmcast");
1008 if (!qeth_is_supported(card, IPA_MULTICASTING)) {
1009 dev_info(&card->gdev->dev,
1010 "Multicast not supported on %s\n",
1011 QETH_CARD_IFNAME(card));
1015 rc = qeth_send_simple_setassparms(card, IPA_MULTICASTING,
1016 IPA_CMD_ASS_START, 0);
1018 dev_warn(&card->gdev->dev,
1019 "Starting multicast support for %s failed\n",
1020 QETH_CARD_IFNAME(card));
1022 dev_info(&card->gdev->dev, "Multicast enabled\n");
1023 card->dev->flags |= IFF_MULTICAST;
1028 static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
1032 QETH_CARD_TEXT(card, 3, "softipv6");
1034 rc = qeth_query_ipassists(card, QETH_PROT_IPV6);
1036 dev_err(&card->gdev->dev,
1037 "Activating IPv6 support for %s failed\n",
1038 QETH_CARD_IFNAME(card));
1042 if (card->info.type == QETH_CARD_TYPE_IQD)
1045 rc = qeth_send_simple_setassparms(card, IPA_IPV6,
1046 IPA_CMD_ASS_START, 3);
1048 dev_err(&card->gdev->dev,
1049 "Activating IPv6 support for %s failed\n",
1050 QETH_CARD_IFNAME(card));
1053 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_IPV6,
1056 dev_err(&card->gdev->dev,
1057 "Activating IPv6 support for %s failed\n",
1058 QETH_CARD_IFNAME(card));
1061 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_PASSTHRU,
1064 dev_warn(&card->gdev->dev,
1065 "Enabling the passthrough mode for %s failed\n",
1066 QETH_CARD_IFNAME(card));
1070 dev_info(&card->gdev->dev, "IPV6 enabled\n");
1074 static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
1076 QETH_CARD_TEXT(card, 3, "strtipv6");
1078 if (!qeth_is_supported(card, IPA_IPV6)) {
1079 dev_info(&card->gdev->dev,
1080 "IPv6 not supported on %s\n", QETH_CARD_IFNAME(card));
1083 return qeth_l3_softsetup_ipv6(card);
1086 static int qeth_l3_start_ipa_broadcast(struct qeth_card *card)
1090 QETH_CARD_TEXT(card, 3, "stbrdcst");
1091 card->info.broadcast_capable = 0;
1092 if (!qeth_is_supported(card, IPA_FILTERING)) {
1093 dev_info(&card->gdev->dev,
1094 "Broadcast not supported on %s\n",
1095 QETH_CARD_IFNAME(card));
1099 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
1100 IPA_CMD_ASS_START, 0);
1102 dev_warn(&card->gdev->dev, "Enabling broadcast filtering for "
1103 "%s failed\n", QETH_CARD_IFNAME(card));
1107 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
1108 IPA_CMD_ASS_CONFIGURE, 1);
1110 dev_warn(&card->gdev->dev,
1111 "Setting up broadcast filtering for %s failed\n",
1112 QETH_CARD_IFNAME(card));
1115 card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
1116 dev_info(&card->gdev->dev, "Broadcast enabled\n");
1117 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
1118 IPA_CMD_ASS_ENABLE, 1);
1120 dev_warn(&card->gdev->dev, "Setting up broadcast echo "
1121 "filtering for %s failed\n", QETH_CARD_IFNAME(card));
1124 card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
1126 if (card->info.broadcast_capable)
1127 card->dev->flags |= IFF_BROADCAST;
1129 card->dev->flags &= ~IFF_BROADCAST;
1133 static int qeth_l3_start_ipassists(struct qeth_card *card)
1135 QETH_CARD_TEXT(card, 3, "strtipas");
1137 if (qeth_set_access_ctrl_online(card, 0))
1139 qeth_l3_start_ipa_arp_processing(card); /* go on*/
1140 qeth_l3_start_ipa_source_mac(card); /* go on*/
1141 qeth_l3_start_ipa_vlan(card); /* go on*/
1142 qeth_l3_start_ipa_multicast(card); /* go on*/
1143 qeth_l3_start_ipa_ipv6(card); /* go on*/
1144 qeth_l3_start_ipa_broadcast(card); /* go on*/
1148 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
1149 struct qeth_reply *reply, unsigned long data)
1151 struct qeth_ipa_cmd *cmd;
1153 cmd = (struct qeth_ipa_cmd *) data;
1154 if (cmd->hdr.return_code == 0)
1155 ether_addr_copy(card->dev->dev_addr,
1156 cmd->data.create_destroy_addr.unique_id);
1158 eth_random_addr(card->dev->dev_addr);
1163 static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card)
1166 struct qeth_cmd_buffer *iob;
1167 struct qeth_ipa_cmd *cmd;
1169 QETH_DBF_TEXT(SETUP, 2, "hsrmac");
1171 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
1175 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1176 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1177 card->info.unique_id;
1179 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb,
1184 static int qeth_l3_get_unique_id_cb(struct qeth_card *card,
1185 struct qeth_reply *reply, unsigned long data)
1187 struct qeth_ipa_cmd *cmd;
1189 cmd = (struct qeth_ipa_cmd *) data;
1190 if (cmd->hdr.return_code == 0)
1191 card->info.unique_id = *((__u16 *)
1192 &cmd->data.create_destroy_addr.unique_id[6]);
1194 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1195 UNIQUE_ID_NOT_BY_CARD;
1196 dev_warn(&card->gdev->dev, "The network adapter failed to "
1197 "generate a unique ID\n");
1202 static int qeth_l3_get_unique_id(struct qeth_card *card)
1205 struct qeth_cmd_buffer *iob;
1206 struct qeth_ipa_cmd *cmd;
1208 QETH_DBF_TEXT(SETUP, 2, "guniqeid");
1210 if (!qeth_is_supported(card, IPA_IPV6)) {
1211 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1212 UNIQUE_ID_NOT_BY_CARD;
1216 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
1220 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1221 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1222 card->info.unique_id;
1224 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_get_unique_id_cb, NULL);
1229 qeth_diags_trace_cb(struct qeth_card *card, struct qeth_reply *reply,
1232 struct qeth_ipa_cmd *cmd;
1235 QETH_DBF_TEXT(SETUP, 2, "diastrcb");
1237 cmd = (struct qeth_ipa_cmd *)data;
1238 rc = cmd->hdr.return_code;
1240 QETH_CARD_TEXT_(card, 2, "dxter%x", rc);
1241 switch (cmd->data.diagass.action) {
1242 case QETH_DIAGS_CMD_TRACE_QUERY:
1244 case QETH_DIAGS_CMD_TRACE_DISABLE:
1247 case IPA_RC_INVALID_SUBCMD:
1248 card->info.promisc_mode = SET_PROMISC_MODE_OFF;
1249 dev_info(&card->gdev->dev, "The HiperSockets network "
1250 "traffic analyzer is deactivated\n");
1256 case QETH_DIAGS_CMD_TRACE_ENABLE:
1259 card->info.promisc_mode = SET_PROMISC_MODE_ON;
1260 dev_info(&card->gdev->dev, "The HiperSockets network "
1261 "traffic analyzer is activated\n");
1263 case IPA_RC_HARDWARE_AUTH_ERROR:
1264 dev_warn(&card->gdev->dev, "The device is not "
1265 "authorized to run as a HiperSockets network "
1266 "traffic analyzer\n");
1268 case IPA_RC_TRACE_ALREADY_ACTIVE:
1269 dev_warn(&card->gdev->dev, "A HiperSockets "
1270 "network traffic analyzer is already "
1271 "active in the HiperSockets LAN\n");
1278 QETH_DBF_MESSAGE(2, "Unknown sniffer action (0x%04x) on %s\n",
1279 cmd->data.diagass.action, QETH_CARD_IFNAME(card));
1286 qeth_diags_trace(struct qeth_card *card, enum qeth_diags_trace_cmds diags_cmd)
1288 struct qeth_cmd_buffer *iob;
1289 struct qeth_ipa_cmd *cmd;
1291 QETH_DBF_TEXT(SETUP, 2, "diagtrac");
1293 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SET_DIAG_ASS, 0);
1296 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1297 cmd->data.diagass.subcmd_len = 16;
1298 cmd->data.diagass.subcmd = QETH_DIAGS_CMD_TRACE;
1299 cmd->data.diagass.type = QETH_DIAGS_TYPE_HIPERSOCKET;
1300 cmd->data.diagass.action = diags_cmd;
1301 return qeth_send_ipa_cmd(card, iob, qeth_diags_trace_cb, NULL);
1305 qeth_l3_add_mc_to_hash(struct qeth_card *card, struct in_device *in4_dev)
1307 struct ip_mc_list *im4;
1308 struct qeth_ipaddr *tmp, *ipm;
1310 QETH_CARD_TEXT(card, 4, "addmc");
1312 tmp = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1316 for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
1317 im4 = rcu_dereference(im4->next_rcu)) {
1318 ip_eth_mc_map(im4->multiaddr, tmp->mac);
1319 tmp->u.a4.addr = be32_to_cpu(im4->multiaddr);
1320 tmp->is_multicast = 1;
1322 ipm = qeth_l3_ip_from_hash(card, tmp);
1324 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1326 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1329 ether_addr_copy(ipm->mac, tmp->mac);
1330 ipm->u.a4.addr = be32_to_cpu(im4->multiaddr);
1331 ipm->is_multicast = 1;
1332 ipm->disp_flag = QETH_DISP_ADDR_ADD;
1333 hash_add(card->ip_mc_htable,
1334 &ipm->hnode, qeth_l3_ipaddr_hash(ipm));
1341 /* called with rcu_read_lock */
1342 static void qeth_l3_add_vlan_mc(struct qeth_card *card)
1344 struct in_device *in_dev;
1347 QETH_CARD_TEXT(card, 4, "addmcvl");
1349 if (!qeth_is_supported(card, IPA_FULL_VLAN))
1352 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1353 struct net_device *netdev;
1355 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1357 if (netdev == NULL ||
1358 !(netdev->flags & IFF_UP))
1360 in_dev = __in_dev_get_rcu(netdev);
1363 qeth_l3_add_mc_to_hash(card, in_dev);
1367 static void qeth_l3_add_multicast_ipv4(struct qeth_card *card)
1369 struct in_device *in4_dev;
1371 QETH_CARD_TEXT(card, 4, "chkmcv4");
1374 in4_dev = __in_dev_get_rcu(card->dev);
1375 if (in4_dev == NULL)
1377 qeth_l3_add_mc_to_hash(card, in4_dev);
1378 qeth_l3_add_vlan_mc(card);
1383 static void qeth_l3_add_mc6_to_hash(struct qeth_card *card,
1384 struct inet6_dev *in6_dev)
1386 struct qeth_ipaddr *ipm;
1387 struct ifmcaddr6 *im6;
1388 struct qeth_ipaddr *tmp;
1390 QETH_CARD_TEXT(card, 4, "addmc6");
1392 tmp = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1396 for (im6 = in6_dev->mc_list; im6 != NULL; im6 = im6->next) {
1397 ipv6_eth_mc_map(&im6->mca_addr, tmp->mac);
1398 memcpy(&tmp->u.a6.addr, &im6->mca_addr.s6_addr,
1399 sizeof(struct in6_addr));
1400 tmp->is_multicast = 1;
1402 ipm = qeth_l3_ip_from_hash(card, tmp);
1404 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1408 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1412 ether_addr_copy(ipm->mac, tmp->mac);
1413 memcpy(&ipm->u.a6.addr, &im6->mca_addr.s6_addr,
1414 sizeof(struct in6_addr));
1415 ipm->is_multicast = 1;
1416 ipm->disp_flag = QETH_DISP_ADDR_ADD;
1417 hash_add(card->ip_mc_htable,
1418 &ipm->hnode, qeth_l3_ipaddr_hash(ipm));
1424 /* called with rcu_read_lock */
1425 static void qeth_l3_add_vlan_mc6(struct qeth_card *card)
1427 struct inet6_dev *in_dev;
1430 QETH_CARD_TEXT(card, 4, "admc6vl");
1432 if (!qeth_is_supported(card, IPA_FULL_VLAN))
1435 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1436 struct net_device *netdev;
1438 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1440 if (netdev == NULL ||
1441 !(netdev->flags & IFF_UP))
1443 in_dev = in6_dev_get(netdev);
1446 read_lock_bh(&in_dev->lock);
1447 qeth_l3_add_mc6_to_hash(card, in_dev);
1448 read_unlock_bh(&in_dev->lock);
1449 in6_dev_put(in_dev);
1453 static void qeth_l3_add_multicast_ipv6(struct qeth_card *card)
1455 struct inet6_dev *in6_dev;
1457 QETH_CARD_TEXT(card, 4, "chkmcv6");
1459 if (!qeth_is_supported(card, IPA_IPV6))
1461 in6_dev = in6_dev_get(card->dev);
1466 read_lock_bh(&in6_dev->lock);
1467 qeth_l3_add_mc6_to_hash(card, in6_dev);
1468 qeth_l3_add_vlan_mc6(card);
1469 read_unlock_bh(&in6_dev->lock);
1471 in6_dev_put(in6_dev);
1474 static void qeth_l3_free_vlan_addresses4(struct qeth_card *card,
1477 struct in_device *in_dev;
1478 struct in_ifaddr *ifa;
1479 struct qeth_ipaddr *addr;
1480 struct net_device *netdev;
1482 QETH_CARD_TEXT(card, 4, "frvaddr4");
1484 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q), vid);
1487 in_dev = in_dev_get(netdev);
1491 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1495 spin_lock_bh(&card->ip_lock);
1497 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1498 addr->u.a4.addr = be32_to_cpu(ifa->ifa_address);
1499 addr->u.a4.mask = be32_to_cpu(ifa->ifa_mask);
1500 addr->type = QETH_IP_TYPE_NORMAL;
1501 qeth_l3_delete_ip(card, addr);
1504 spin_unlock_bh(&card->ip_lock);
1511 static void qeth_l3_free_vlan_addresses6(struct qeth_card *card,
1514 struct inet6_dev *in6_dev;
1515 struct inet6_ifaddr *ifa;
1516 struct qeth_ipaddr *addr;
1517 struct net_device *netdev;
1519 QETH_CARD_TEXT(card, 4, "frvaddr6");
1521 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q), vid);
1525 in6_dev = in6_dev_get(netdev);
1529 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1533 spin_lock_bh(&card->ip_lock);
1535 list_for_each_entry(ifa, &in6_dev->addr_list, if_list) {
1536 memcpy(&addr->u.a6.addr, &ifa->addr,
1537 sizeof(struct in6_addr));
1538 addr->u.a6.pfxlen = ifa->prefix_len;
1539 addr->type = QETH_IP_TYPE_NORMAL;
1540 qeth_l3_delete_ip(card, addr);
1543 spin_unlock_bh(&card->ip_lock);
1547 in6_dev_put(in6_dev);
1550 static void qeth_l3_free_vlan_addresses(struct qeth_card *card,
1554 qeth_l3_free_vlan_addresses4(card, vid);
1555 qeth_l3_free_vlan_addresses6(card, vid);
1559 static int qeth_l3_vlan_rx_add_vid(struct net_device *dev,
1560 __be16 proto, u16 vid)
1562 struct qeth_card *card = dev->ml_priv;
1564 set_bit(vid, card->active_vlans);
1568 static int qeth_l3_vlan_rx_kill_vid(struct net_device *dev,
1569 __be16 proto, u16 vid)
1571 struct qeth_card *card = dev->ml_priv;
1573 QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
1575 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
1576 QETH_CARD_TEXT(card, 3, "kidREC");
1579 /* unregister IP addresses of vlan device */
1580 qeth_l3_free_vlan_addresses(card, vid);
1581 clear_bit(vid, card->active_vlans);
1582 qeth_l3_set_rx_mode(dev);
1586 static void qeth_l3_rebuild_skb(struct qeth_card *card, struct sk_buff *skb,
1587 struct qeth_hdr *hdr)
1589 if (!(hdr->hdr.l3.flags & QETH_HDR_PASSTHRU)) {
1590 u16 prot = (hdr->hdr.l3.flags & QETH_HDR_IPV6) ? ETH_P_IPV6 :
1592 unsigned char tg_addr[ETH_ALEN];
1594 skb_reset_network_header(skb);
1595 switch (hdr->hdr.l3.flags & QETH_HDR_CAST_MASK) {
1596 case QETH_CAST_MULTICAST:
1597 if (prot == ETH_P_IP)
1598 ip_eth_mc_map(ip_hdr(skb)->daddr, tg_addr);
1600 ipv6_eth_mc_map(&ipv6_hdr(skb)->daddr, tg_addr);
1602 card->stats.multicast++;
1603 skb->pkt_type = PACKET_MULTICAST;
1605 case QETH_CAST_BROADCAST:
1606 ether_addr_copy(tg_addr, card->dev->broadcast);
1607 card->stats.multicast++;
1608 skb->pkt_type = PACKET_BROADCAST;
1610 case QETH_CAST_UNICAST:
1611 case QETH_CAST_ANYCAST:
1612 case QETH_CAST_NOCAST:
1614 if (card->options.sniffer)
1615 skb->pkt_type = PACKET_OTHERHOST;
1617 skb->pkt_type = PACKET_HOST;
1618 ether_addr_copy(tg_addr, card->dev->dev_addr);
1620 if (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_SRC_MAC_ADDR)
1621 card->dev->header_ops->create(skb, card->dev, prot,
1622 tg_addr, &hdr->hdr.l3.next_hop.rx.src_mac,
1623 card->dev->addr_len);
1625 card->dev->header_ops->create(skb, card->dev, prot,
1626 tg_addr, "FAKELL", card->dev->addr_len);
1629 skb->protocol = eth_type_trans(skb, card->dev);
1631 /* copy VLAN tag from hdr into skb */
1632 if (!card->options.sniffer &&
1633 (hdr->hdr.l3.ext_flags & (QETH_HDR_EXT_VLAN_FRAME |
1634 QETH_HDR_EXT_INCLUDE_VLAN_TAG))) {
1635 u16 tag = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME) ?
1636 hdr->hdr.l3.vlan_id :
1637 hdr->hdr.l3.next_hop.rx.vlan_id;
1638 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), tag);
1641 if (card->dev->features & NETIF_F_RXCSUM) {
1642 if ((hdr->hdr.l3.ext_flags &
1643 (QETH_HDR_EXT_CSUM_HDR_REQ |
1644 QETH_HDR_EXT_CSUM_TRANSP_REQ)) ==
1645 (QETH_HDR_EXT_CSUM_HDR_REQ |
1646 QETH_HDR_EXT_CSUM_TRANSP_REQ))
1647 skb->ip_summed = CHECKSUM_UNNECESSARY;
1649 skb->ip_summed = CHECKSUM_NONE;
1651 skb->ip_summed = CHECKSUM_NONE;
1654 static int qeth_l3_process_inbound_buffer(struct qeth_card *card,
1655 int budget, int *done)
1658 struct sk_buff *skb;
1659 struct qeth_hdr *hdr;
1664 WARN_ON_ONCE(!budget);
1666 skb = qeth_core_get_next_skb(card,
1667 &card->qdio.in_q->bufs[card->rx.b_index],
1668 &card->rx.b_element, &card->rx.e_offset, &hdr);
1673 skb->dev = card->dev;
1674 switch (hdr->hdr.l3.id) {
1675 case QETH_HEADER_TYPE_LAYER3:
1676 magic = *(__u16 *)skb->data;
1677 if ((card->info.type == QETH_CARD_TYPE_IQD) &&
1678 (magic == ETH_P_AF_IUCV)) {
1679 skb->protocol = cpu_to_be16(ETH_P_AF_IUCV);
1680 skb->pkt_type = PACKET_HOST;
1681 skb->mac_header = NET_SKB_PAD;
1682 skb->dev = card->dev;
1684 card->dev->header_ops->create(skb, card->dev, 0,
1685 card->dev->dev_addr, "FAKELL",
1686 card->dev->addr_len);
1687 netif_receive_skb(skb);
1689 qeth_l3_rebuild_skb(card, skb, hdr);
1691 napi_gro_receive(&card->napi, skb);
1694 case QETH_HEADER_TYPE_LAYER2: /* for HiperSockets sniffer */
1695 skb->pkt_type = PACKET_HOST;
1696 skb->protocol = eth_type_trans(skb, skb->dev);
1698 netif_receive_skb(skb);
1701 dev_kfree_skb_any(skb);
1702 QETH_CARD_TEXT(card, 3, "inbunkno");
1703 QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN);
1708 card->stats.rx_packets++;
1709 card->stats.rx_bytes += len;
1714 static int qeth_l3_verify_vlan_dev(struct net_device *dev,
1715 struct qeth_card *card)
1720 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1721 struct net_device *netdev;
1724 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1727 if (netdev == dev) {
1728 rc = QETH_VLAN_CARD;
1733 if (rc && !(vlan_dev_real_dev(dev)->ml_priv == (void *)card))
1739 static int qeth_l3_verify_dev(struct net_device *dev)
1741 struct qeth_card *card;
1743 unsigned long flags;
1745 read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
1746 list_for_each_entry(card, &qeth_core_card_list.list, list) {
1747 if (card->dev == dev) {
1748 rc = QETH_REAL_CARD;
1751 rc = qeth_l3_verify_vlan_dev(dev, card);
1755 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
1760 static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev)
1762 struct qeth_card *card = NULL;
1765 rc = qeth_l3_verify_dev(dev);
1766 if (rc == QETH_REAL_CARD)
1767 card = dev->ml_priv;
1768 else if (rc == QETH_VLAN_CARD)
1769 card = vlan_dev_real_dev(dev)->ml_priv;
1770 if (card && card->options.layer2)
1773 QETH_CARD_TEXT_(card, 4, "%d", rc);
1777 static void qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
1779 QETH_DBF_TEXT(SETUP, 2, "stopcard");
1780 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
1782 qeth_set_allowed_threads(card, 0, 1);
1783 if (card->options.sniffer &&
1784 (card->info.promisc_mode == SET_PROMISC_MODE_ON))
1785 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1786 if (card->read.state == CH_STATE_UP &&
1787 card->write.state == CH_STATE_UP &&
1788 (card->state == CARD_STATE_UP)) {
1790 qeth_l3_stop(card->dev);
1793 dev_close(card->dev);
1796 card->state = CARD_STATE_SOFTSETUP;
1798 if (card->state == CARD_STATE_SOFTSETUP) {
1799 qeth_l3_clear_ip_htable(card, 1);
1800 qeth_clear_ipacmd_list(card);
1801 card->state = CARD_STATE_HARDSETUP;
1803 if (card->state == CARD_STATE_HARDSETUP) {
1804 qeth_qdio_clear_card(card, 0);
1805 qeth_clear_qdio_buffers(card);
1806 qeth_clear_working_pool_list(card);
1807 card->state = CARD_STATE_DOWN;
1809 if (card->state == CARD_STATE_DOWN) {
1810 qeth_clear_cmd_buffers(&card->read);
1811 qeth_clear_cmd_buffers(&card->write);
1816 * test for and Switch promiscuous mode (on or off)
1817 * either for guestlan or HiperSocket Sniffer
1820 qeth_l3_handle_promisc_mode(struct qeth_card *card)
1822 struct net_device *dev = card->dev;
1824 if (((dev->flags & IFF_PROMISC) &&
1825 (card->info.promisc_mode == SET_PROMISC_MODE_ON)) ||
1826 (!(dev->flags & IFF_PROMISC) &&
1827 (card->info.promisc_mode == SET_PROMISC_MODE_OFF)))
1830 if (card->info.guestlan) { /* Guestlan trace */
1831 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
1832 qeth_setadp_promisc_mode(card);
1833 } else if (card->options.sniffer && /* HiperSockets trace */
1834 qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) {
1835 if (dev->flags & IFF_PROMISC) {
1836 QETH_CARD_TEXT(card, 3, "+promisc");
1837 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE);
1839 QETH_CARD_TEXT(card, 3, "-promisc");
1840 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1845 static void qeth_l3_set_rx_mode(struct net_device *dev)
1847 struct qeth_card *card = dev->ml_priv;
1848 struct qeth_ipaddr *addr;
1849 struct hlist_node *tmp;
1852 QETH_CARD_TEXT(card, 3, "setmulti");
1853 if (qeth_threads_running(card, QETH_RECOVER_THREAD) &&
1854 (card->state != CARD_STATE_UP))
1856 if (!card->options.sniffer) {
1857 spin_lock_bh(&card->mclock);
1859 qeth_l3_add_multicast_ipv4(card);
1860 qeth_l3_add_multicast_ipv6(card);
1862 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
1863 switch (addr->disp_flag) {
1864 case QETH_DISP_ADDR_DELETE:
1865 rc = qeth_l3_deregister_addr_entry(card, addr);
1866 if (!rc || rc == IPA_RC_MC_ADDR_NOT_FOUND) {
1867 hash_del(&addr->hnode);
1871 case QETH_DISP_ADDR_ADD:
1872 rc = qeth_l3_register_addr_entry(card, addr);
1873 if (rc && rc != IPA_RC_LAN_OFFLINE) {
1874 hash_del(&addr->hnode);
1878 addr->ref_counter = 1;
1881 /* for next call to set_rx_mode(): */
1882 addr->disp_flag = QETH_DISP_ADDR_DELETE;
1886 spin_unlock_bh(&card->mclock);
1888 if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
1891 qeth_l3_handle_promisc_mode(card);
1894 static const char *qeth_l3_arp_get_error_cause(int *rc)
1897 case QETH_IPA_ARP_RC_FAILED:
1899 return "operation failed";
1900 case QETH_IPA_ARP_RC_NOTSUPP:
1902 return "operation not supported";
1903 case QETH_IPA_ARP_RC_OUT_OF_RANGE:
1905 return "argument out of range";
1906 case QETH_IPA_ARP_RC_Q_NOTSUPP:
1908 return "query operation not supported";
1909 case QETH_IPA_ARP_RC_Q_NO_DATA:
1911 return "no query data available";
1913 return "unknown error";
1917 static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
1922 QETH_CARD_TEXT(card, 3, "arpstnoe");
1925 * currently GuestLAN only supports the ARP assist function
1926 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
1927 * thus we say EOPNOTSUPP for this ARP function
1929 if (card->info.guestlan)
1931 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1934 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
1935 IPA_CMD_ASS_ARP_SET_NO_ENTRIES,
1939 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on "
1940 "%s: %s (0x%x/%d)\n", QETH_CARD_IFNAME(card),
1941 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
1946 static __u32 get_arp_entry_size(struct qeth_card *card,
1947 struct qeth_arp_query_data *qdata,
1948 struct qeth_arp_entrytype *type, __u8 strip_entries)
1953 is_hsi = qdata->reply_bits == 5;
1954 if (type->ip == QETHARP_IP_ADDR_V4) {
1955 QETH_CARD_TEXT(card, 4, "arpev4");
1956 if (strip_entries) {
1957 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5_short) :
1958 sizeof(struct qeth_arp_qi_entry7_short);
1960 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5) :
1961 sizeof(struct qeth_arp_qi_entry7);
1963 } else if (type->ip == QETHARP_IP_ADDR_V6) {
1964 QETH_CARD_TEXT(card, 4, "arpev6");
1965 if (strip_entries) {
1967 sizeof(struct qeth_arp_qi_entry5_short_ipv6) :
1968 sizeof(struct qeth_arp_qi_entry7_short_ipv6);
1971 sizeof(struct qeth_arp_qi_entry5_ipv6) :
1972 sizeof(struct qeth_arp_qi_entry7_ipv6);
1975 QETH_CARD_TEXT(card, 4, "arpinv");
1982 static int arpentry_matches_prot(struct qeth_arp_entrytype *type, __u16 prot)
1984 return (type->ip == QETHARP_IP_ADDR_V4 && prot == QETH_PROT_IPV4) ||
1985 (type->ip == QETHARP_IP_ADDR_V6 && prot == QETH_PROT_IPV6);
1988 static int qeth_l3_arp_query_cb(struct qeth_card *card,
1989 struct qeth_reply *reply, unsigned long data)
1991 struct qeth_ipa_cmd *cmd;
1992 struct qeth_arp_query_data *qdata;
1993 struct qeth_arp_query_info *qinfo;
1996 int entrybytes_done;
1998 __u8 do_strip_entries;
2000 QETH_CARD_TEXT(card, 3, "arpquecb");
2002 qinfo = (struct qeth_arp_query_info *) reply->param;
2003 cmd = (struct qeth_ipa_cmd *) data;
2004 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.prot_version);
2005 if (cmd->hdr.return_code) {
2006 QETH_CARD_TEXT(card, 4, "arpcberr");
2007 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
2010 if (cmd->data.setassparms.hdr.return_code) {
2011 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
2012 QETH_CARD_TEXT(card, 4, "setaperr");
2013 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
2016 qdata = &cmd->data.setassparms.data.query_arp;
2017 QETH_CARD_TEXT_(card, 4, "anoen%i", qdata->no_entries);
2019 do_strip_entries = (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) > 0;
2020 stripped_bytes = do_strip_entries ? QETH_QARP_MEDIASPECIFIC_BYTES : 0;
2021 entrybytes_done = 0;
2022 for (e = 0; e < qdata->no_entries; ++e) {
2025 struct qeth_arp_entrytype *etype;
2027 cur_entry = &qdata->data + entrybytes_done;
2028 etype = &((struct qeth_arp_qi_entry5 *) cur_entry)->type;
2029 if (!arpentry_matches_prot(etype, cmd->hdr.prot_version)) {
2030 QETH_CARD_TEXT(card, 4, "pmis");
2031 QETH_CARD_TEXT_(card, 4, "%i", etype->ip);
2034 esize = get_arp_entry_size(card, qdata, etype,
2036 QETH_CARD_TEXT_(card, 5, "esz%i", esize);
2040 if ((qinfo->udata_len - qinfo->udata_offset) < esize) {
2041 QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOMEM);
2042 cmd->hdr.return_code = IPA_RC_ENOMEM;
2046 memcpy(qinfo->udata + qinfo->udata_offset,
2047 &qdata->data + entrybytes_done + stripped_bytes,
2049 entrybytes_done += esize + stripped_bytes;
2050 qinfo->udata_offset += esize;
2051 ++qinfo->no_entries;
2053 /* check if all replies received ... */
2054 if (cmd->data.setassparms.hdr.seq_no <
2055 cmd->data.setassparms.hdr.number_of_replies)
2057 QETH_CARD_TEXT_(card, 4, "nove%i", qinfo->no_entries);
2058 memcpy(qinfo->udata, &qinfo->no_entries, 4);
2059 /* keep STRIP_ENTRIES flag so the user program can distinguish
2060 * stripped entries from normal ones */
2061 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
2062 qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES;
2063 memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2);
2064 QETH_CARD_TEXT_(card, 4, "rc%i", 0);
2068 memcpy(qinfo->udata, &i, 4);
2072 static int qeth_l3_send_ipa_arp_cmd(struct qeth_card *card,
2073 struct qeth_cmd_buffer *iob, int len,
2074 int (*reply_cb)(struct qeth_card *, struct qeth_reply *,
2078 QETH_CARD_TEXT(card, 4, "sendarp");
2080 memcpy(iob->data, IPA_PDU_HEADER, IPA_PDU_HEADER_SIZE);
2081 memcpy(QETH_IPA_CMD_DEST_ADDR(iob->data),
2082 &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH);
2083 return qeth_send_control_data(card, IPA_PDU_HEADER_SIZE + len, iob,
2084 reply_cb, reply_param);
2087 static int qeth_l3_query_arp_cache_info(struct qeth_card *card,
2088 enum qeth_prot_versions prot,
2089 struct qeth_arp_query_info *qinfo)
2091 struct qeth_cmd_buffer *iob;
2092 struct qeth_ipa_cmd *cmd;
2096 QETH_CARD_TEXT_(card, 3, "qarpipv%i", prot);
2098 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2099 IPA_CMD_ASS_ARP_QUERY_INFO,
2100 sizeof(struct qeth_arp_query_data)
2105 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
2106 cmd->data.setassparms.data.query_arp.request_bits = 0x000F;
2107 cmd->data.setassparms.data.query_arp.reply_bits = 0;
2108 cmd->data.setassparms.data.query_arp.no_entries = 0;
2109 rc = qeth_l3_send_ipa_arp_cmd(card, iob,
2110 QETH_SETASS_BASE_LEN+QETH_ARP_CMD_LEN,
2111 qeth_l3_arp_query_cb, (void *)qinfo);
2115 "Error while querying ARP cache on %s: %s "
2116 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2117 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2123 static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
2125 struct qeth_arp_query_info qinfo = {0, };
2128 QETH_CARD_TEXT(card, 3, "arpquery");
2130 if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
2131 IPA_ARP_PROCESSING)) {
2132 QETH_CARD_TEXT(card, 3, "arpqnsup");
2136 /* get size of userspace buffer and mask_bits -> 6 bytes */
2137 if (copy_from_user(&qinfo, udata, 6)) {
2141 qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL);
2146 qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
2147 rc = qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV4, &qinfo);
2149 if (copy_to_user(udata, qinfo.udata, 4))
2153 if (qinfo.mask_bits & QETH_QARP_WITH_IPV6) {
2154 /* fails in case of GuestLAN QDIO mode */
2155 qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV6, &qinfo);
2157 if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) {
2158 QETH_CARD_TEXT(card, 4, "qactf");
2162 QETH_CARD_TEXT(card, 4, "qacts");
2170 static int qeth_l3_arp_add_entry(struct qeth_card *card,
2171 struct qeth_arp_cache_entry *entry)
2173 struct qeth_cmd_buffer *iob;
2178 QETH_CARD_TEXT(card, 3, "arpadent");
2181 * currently GuestLAN only supports the ARP assist function
2182 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
2183 * thus we say EOPNOTSUPP for this ARP function
2185 if (card->info.guestlan)
2187 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2191 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2192 IPA_CMD_ASS_ARP_ADD_ENTRY,
2193 sizeof(struct qeth_arp_cache_entry),
2197 rc = qeth_send_setassparms(card, iob,
2198 sizeof(struct qeth_arp_cache_entry),
2199 (unsigned long) entry,
2200 qeth_setassparms_cb, NULL);
2203 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
2204 QETH_DBF_MESSAGE(2, "Could not add ARP entry for address %s "
2205 "on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2206 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2211 static int qeth_l3_arp_remove_entry(struct qeth_card *card,
2212 struct qeth_arp_cache_entry *entry)
2214 struct qeth_cmd_buffer *iob;
2215 char buf[16] = {0, };
2219 QETH_CARD_TEXT(card, 3, "arprment");
2222 * currently GuestLAN only supports the ARP assist function
2223 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_REMOVE_ENTRY;
2224 * thus we say EOPNOTSUPP for this ARP function
2226 if (card->info.guestlan)
2228 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2231 memcpy(buf, entry, 12);
2232 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2233 IPA_CMD_ASS_ARP_REMOVE_ENTRY,
2238 rc = qeth_send_setassparms(card, iob,
2239 12, (unsigned long)buf,
2240 qeth_setassparms_cb, NULL);
2244 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
2245 QETH_DBF_MESSAGE(2, "Could not delete ARP entry for address %s"
2246 " on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2247 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2252 static int qeth_l3_arp_flush_cache(struct qeth_card *card)
2257 QETH_CARD_TEXT(card, 3, "arpflush");
2260 * currently GuestLAN only supports the ARP assist function
2261 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
2262 * thus we say EOPNOTSUPP for this ARP function
2264 if (card->info.guestlan || (card->info.type == QETH_CARD_TYPE_IQD))
2266 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2269 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2270 IPA_CMD_ASS_ARP_FLUSH_CACHE, 0);
2273 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on %s: %s "
2274 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2275 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2280 static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2282 struct qeth_card *card = dev->ml_priv;
2283 struct qeth_arp_cache_entry arp_entry;
2287 case SIOC_QETH_ARP_SET_NO_ENTRIES:
2288 if (!capable(CAP_NET_ADMIN)) {
2292 rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue);
2294 case SIOC_QETH_ARP_QUERY_INFO:
2295 if (!capable(CAP_NET_ADMIN)) {
2299 rc = qeth_l3_arp_query(card, rq->ifr_ifru.ifru_data);
2301 case SIOC_QETH_ARP_ADD_ENTRY:
2302 if (!capable(CAP_NET_ADMIN)) {
2306 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
2307 sizeof(struct qeth_arp_cache_entry)))
2310 rc = qeth_l3_arp_add_entry(card, &arp_entry);
2312 case SIOC_QETH_ARP_REMOVE_ENTRY:
2313 if (!capable(CAP_NET_ADMIN)) {
2317 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
2318 sizeof(struct qeth_arp_cache_entry)))
2321 rc = qeth_l3_arp_remove_entry(card, &arp_entry);
2323 case SIOC_QETH_ARP_FLUSH_CACHE:
2324 if (!capable(CAP_NET_ADMIN)) {
2328 rc = qeth_l3_arp_flush_cache(card);
2336 static int qeth_l3_get_cast_type(struct sk_buff *skb)
2338 struct neighbour *n = NULL;
2339 struct dst_entry *dst;
2344 n = dst_neigh_lookup_skb(dst, skb);
2346 int cast_type = n->type;
2350 if ((cast_type == RTN_BROADCAST) ||
2351 (cast_type == RTN_MULTICAST) ||
2352 (cast_type == RTN_ANYCAST))
2358 /* no neighbour (eg AF_PACKET), fall back to target's IP address ... */
2359 if (be16_to_cpu(skb->protocol) == ETH_P_IPV6)
2360 return ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr) ?
2361 RTN_MULTICAST : RTN_UNSPEC;
2362 else if (be16_to_cpu(skb->protocol) == ETH_P_IP)
2363 return ipv4_is_multicast(ip_hdr(skb)->daddr) ?
2364 RTN_MULTICAST : RTN_UNSPEC;
2366 /* ... and MAC address */
2367 if (ether_addr_equal_64bits(eth_hdr(skb)->h_dest, skb->dev->broadcast))
2368 return RTN_BROADCAST;
2369 if (is_multicast_ether_addr(eth_hdr(skb)->h_dest))
2370 return RTN_MULTICAST;
2372 /* default to unicast */
2376 static void qeth_l3_fill_af_iucv_hdr(struct qeth_card *card,
2377 struct qeth_hdr *hdr, struct sk_buff *skb)
2380 struct af_iucv_trans_hdr *iucv_hdr;
2382 memset(hdr, 0, sizeof(struct qeth_hdr));
2383 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
2384 hdr->hdr.l3.ext_flags = 0;
2385 hdr->hdr.l3.length = skb->len - ETH_HLEN;
2386 hdr->hdr.l3.flags = QETH_HDR_IPV6 | QETH_CAST_UNICAST;
2388 iucv_hdr = (struct af_iucv_trans_hdr *) (skb->data + ETH_HLEN);
2389 memset(daddr, 0, sizeof(daddr));
2392 memcpy(&daddr[8], iucv_hdr->destUserID, 8);
2393 memcpy(hdr->hdr.l3.next_hop.ipv6_addr, daddr, 16);
2396 static u8 qeth_l3_cast_type_to_flag(int cast_type)
2398 if (cast_type == RTN_MULTICAST)
2399 return QETH_CAST_MULTICAST;
2400 if (cast_type == RTN_ANYCAST)
2401 return QETH_CAST_ANYCAST;
2402 if (cast_type == RTN_BROADCAST)
2403 return QETH_CAST_BROADCAST;
2404 return QETH_CAST_UNICAST;
2407 static void qeth_l3_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
2408 struct sk_buff *skb, int ipv, int cast_type)
2410 memset(hdr, 0, sizeof(struct qeth_hdr));
2411 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
2412 hdr->hdr.l3.length = skb->len - sizeof(struct qeth_hdr);
2415 * before we're going to overwrite this location with next hop ip.
2416 * v6 uses passthrough, v4 sets the tag in the QDIO header.
2418 if (skb_vlan_tag_present(skb)) {
2419 if ((ipv == 4) || (card->info.type == QETH_CARD_TYPE_IQD))
2420 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_VLAN_FRAME;
2422 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_INCLUDE_VLAN_TAG;
2423 hdr->hdr.l3.vlan_id = skb_vlan_tag_get(skb);
2428 hdr->hdr.l3.flags = QETH_HDR_PASSTHRU;
2429 if (ether_addr_equal_64bits(eth_hdr(skb)->h_dest,
2430 skb->dev->broadcast))
2431 hdr->hdr.l3.flags |= QETH_CAST_BROADCAST;
2433 hdr->hdr.l3.flags |= (cast_type == RTN_MULTICAST) ?
2434 QETH_CAST_MULTICAST : QETH_CAST_UNICAST;
2438 hdr->hdr.l3.flags = qeth_l3_cast_type_to_flag(cast_type);
2441 struct rtable *rt = skb_rtable(skb);
2443 *((__be32 *) &hdr->hdr.l3.next_hop.ipv4.addr) = (rt) ?
2444 rt_nexthop(rt, ip_hdr(skb)->daddr) :
2448 const struct rt6_info *rt = skb_rt6_info(skb);
2449 const struct in6_addr *next_hop;
2451 if (rt && !ipv6_addr_any(&rt->rt6i_gateway))
2452 next_hop = &rt->rt6i_gateway;
2454 next_hop = &ipv6_hdr(skb)->daddr;
2455 memcpy(hdr->hdr.l3.next_hop.ipv6_addr, next_hop, 16);
2457 hdr->hdr.l3.flags |= QETH_HDR_IPV6;
2458 if (card->info.type != QETH_CARD_TYPE_IQD)
2459 hdr->hdr.l3.flags |= QETH_HDR_PASSTHRU;
2464 static void qeth_l3_hdr_csum(struct qeth_card *card, struct qeth_hdr *hdr,
2465 struct sk_buff *skb)
2467 struct iphdr *iph = ip_hdr(skb);
2469 /* tcph->check contains already the pseudo hdr checksum
2470 * so just set the header flags
2472 if (iph->protocol == IPPROTO_UDP)
2473 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_UDP;
2474 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_CSUM_TRANSP_REQ |
2475 QETH_HDR_EXT_CSUM_HDR_REQ;
2477 if (card->options.performance_stats)
2478 card->perf_stats.tx_csum++;
2481 static void qeth_tso_fill_header(struct qeth_card *card,
2482 struct qeth_hdr *qhdr, struct sk_buff *skb)
2484 struct qeth_hdr_tso *hdr = (struct qeth_hdr_tso *)qhdr;
2485 struct tcphdr *tcph = tcp_hdr(skb);
2486 struct iphdr *iph = ip_hdr(skb);
2487 struct ipv6hdr *ip6h = ipv6_hdr(skb);
2489 /*fix header to TSO values ...*/
2490 hdr->hdr.hdr.l3.id = QETH_HEADER_TYPE_TSO;
2491 hdr->hdr.hdr.l3.length = skb->len - sizeof(struct qeth_hdr_tso);
2492 /*set values which are fix for the first approach ...*/
2493 hdr->ext.hdr_tot_len = (__u16) sizeof(struct qeth_hdr_ext_tso);
2494 hdr->ext.imb_hdr_no = 1;
2495 hdr->ext.hdr_type = 1;
2496 hdr->ext.hdr_version = 1;
2497 hdr->ext.hdr_len = 28;
2498 /*insert non-fix values */
2499 hdr->ext.mss = skb_shinfo(skb)->gso_size;
2500 hdr->ext.dg_hdr_len = (__u16)(ip_hdrlen(skb) + tcp_hdrlen(skb));
2501 hdr->ext.payload_len = (__u16)(skb->len - hdr->ext.dg_hdr_len -
2502 sizeof(struct qeth_hdr_tso));
2504 if (be16_to_cpu(skb->protocol) == ETH_P_IPV6) {
2505 ip6h->payload_len = 0;
2506 tcph->check = ~csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
2509 /*OSA want us to set these values ...*/
2510 tcph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
2518 * qeth_l3_get_elements_no_tso() - find number of SBALEs for skb data for tso
2519 * @card: qeth card structure, to check max. elems.
2521 * @extra_elems: extra elems needed, to check against max.
2523 * Returns the number of pages, and thus QDIO buffer elements, needed to cover
2524 * skb data, including linear part and fragments, but excluding TCP header.
2525 * (Exclusion of TCP header distinguishes it from qeth_get_elements_no().)
2526 * Checks if the result plus extra_elems fits under the limit for the card.
2527 * Returns 0 if it does not.
2528 * Note: extra_elems is not included in the returned result.
2530 static int qeth_l3_get_elements_no_tso(struct qeth_card *card,
2531 struct sk_buff *skb, int extra_elems)
2533 addr_t tcpdptr = (addr_t)tcp_hdr(skb) + tcp_hdrlen(skb);
2534 int elements = qeth_get_elements_for_range(
2536 (addr_t)skb->data + skb_headlen(skb)) +
2537 qeth_get_elements_for_frags(skb);
2539 if ((elements + extra_elems) > QETH_MAX_BUFFER_ELEMENTS(card)) {
2541 "Invalid size of TSO IP packet (Number=%d / Length=%d). Discarded.\n",
2542 elements + extra_elems, skb->len);
2548 static netdev_tx_t qeth_l3_hard_start_xmit(struct sk_buff *skb,
2549 struct net_device *dev)
2553 struct qeth_hdr *hdr = NULL;
2554 int hdr_elements = 0;
2556 struct qeth_card *card = dev->ml_priv;
2557 struct sk_buff *new_skb = NULL;
2558 int ipv = qeth_get_ip_version(skb);
2559 int cast_type = qeth_l3_get_cast_type(skb);
2560 struct qeth_qdio_out_q *queue =
2561 card->qdio.out_qs[card->qdio.do_prio_queueing
2562 || (cast_type && card->info.is_multicast_different) ?
2563 qeth_get_priority_queue(card, skb, ipv, cast_type) :
2564 card->qdio.default_out_queue];
2565 int tx_bytes = skb->len;
2566 unsigned int hd_len = 0;
2568 int data_offset = -1;
2569 unsigned int nr_frags;
2571 if (((card->info.type == QETH_CARD_TYPE_IQD) &&
2572 (((card->options.cq != QETH_CQ_ENABLED) && !ipv) ||
2573 ((card->options.cq == QETH_CQ_ENABLED) &&
2574 (be16_to_cpu(skb->protocol) != ETH_P_AF_IUCV)))) ||
2575 card->options.sniffer)
2578 if ((card->state != CARD_STATE_UP) || !card->lan_online) {
2579 card->stats.tx_carrier_errors++;
2583 if ((cast_type == RTN_BROADCAST) &&
2584 (card->info.broadcast_capable == 0))
2587 if (card->options.performance_stats) {
2588 card->perf_stats.outbound_cnt++;
2589 card->perf_stats.outbound_start_time = qeth_get_micros();
2592 /* Ignore segment size from skb_is_gso(), 1 page is always used. */
2593 use_tso = skb_is_gso(skb) &&
2594 (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4);
2596 if (card->info.type == QETH_CARD_TYPE_IQD) {
2598 data_offset = ETH_HLEN;
2599 hd_len = sizeof(*hdr);
2600 hdr = kmem_cache_alloc(qeth_core_header_cache, GFP_ATOMIC);
2605 /* create a clone with writeable headroom */
2606 new_skb = skb_realloc_headroom(skb, sizeof(struct qeth_hdr_tso)
2612 skb_pull(new_skb, ETH_HLEN);
2615 if (ipv != 4 && skb_vlan_tag_present(new_skb)) {
2616 skb_push(new_skb, VLAN_HLEN);
2617 skb_copy_to_linear_data(new_skb, new_skb->data + 4, 4);
2618 skb_copy_to_linear_data_offset(new_skb, 4,
2619 new_skb->data + 8, 4);
2620 skb_copy_to_linear_data_offset(new_skb, 8,
2621 new_skb->data + 12, 4);
2622 tag = (__be16 *)(new_skb->data + 12);
2623 *tag = cpu_to_be16(ETH_P_8021Q);
2624 *(tag + 1) = cpu_to_be16(skb_vlan_tag_get(new_skb));
2628 netif_stop_queue(dev);
2630 /* fix hardware limitation: as long as we do not have sbal
2631 * chaining we can not send long frag lists
2633 if ((card->info.type != QETH_CARD_TYPE_IQD) &&
2634 ((use_tso && !qeth_l3_get_elements_no_tso(card, new_skb, 1)) ||
2635 (!use_tso && !qeth_get_elements_no(card, new_skb, 0, 0)))) {
2636 int lin_rc = skb_linearize(new_skb);
2638 if (card->options.performance_stats) {
2640 card->perf_stats.tx_linfail++;
2642 card->perf_stats.tx_lin++;
2647 nr_frags = skb_shinfo(new_skb)->nr_frags;
2650 hdr = skb_push(new_skb, sizeof(struct qeth_hdr_tso));
2651 memset(hdr, 0, sizeof(struct qeth_hdr_tso));
2652 qeth_l3_fill_header(card, hdr, new_skb, ipv, cast_type);
2653 qeth_tso_fill_header(card, hdr, new_skb);
2656 if (data_offset < 0) {
2657 hdr = skb_push(new_skb, sizeof(struct qeth_hdr));
2658 qeth_l3_fill_header(card, hdr, new_skb, ipv,
2661 if (be16_to_cpu(new_skb->protocol) == ETH_P_AF_IUCV)
2662 qeth_l3_fill_af_iucv_hdr(card, hdr, new_skb);
2664 qeth_l3_fill_header(card, hdr, new_skb, ipv,
2666 hdr->hdr.l3.length = new_skb->len - data_offset;
2670 if (skb->ip_summed == CHECKSUM_PARTIAL)
2671 qeth_l3_hdr_csum(card, hdr, new_skb);
2674 elements = use_tso ?
2675 qeth_l3_get_elements_no_tso(card, new_skb, hdr_elements) :
2676 qeth_get_elements_no(card, new_skb, hdr_elements,
2677 (data_offset > 0) ? data_offset : 0);
2679 if (data_offset >= 0)
2680 kmem_cache_free(qeth_core_header_cache, hdr);
2683 elements += hdr_elements;
2685 if (card->info.type != QETH_CARD_TYPE_IQD) {
2688 hd_len = sizeof(struct qeth_hdr_tso) +
2689 ip_hdrlen(new_skb) + tcp_hdrlen(new_skb);
2692 len = sizeof(struct qeth_hdr_layer3);
2695 if (qeth_hdr_chk_and_bounce(new_skb, &hdr, len))
2697 rc = qeth_do_send_packet(card, queue, new_skb, hdr, hd_len,
2700 rc = qeth_do_send_packet_fast(queue, new_skb, hdr, data_offset,
2704 card->stats.tx_packets++;
2705 card->stats.tx_bytes += tx_bytes;
2707 dev_kfree_skb_any(skb);
2708 if (card->options.performance_stats) {
2710 card->perf_stats.large_send_bytes += tx_bytes;
2711 card->perf_stats.large_send_cnt++;
2714 card->perf_stats.sg_skbs_sent++;
2715 /* nr_frags + skb->data */
2716 card->perf_stats.sg_frags_sent += nr_frags + 1;
2721 if (data_offset >= 0)
2722 kmem_cache_free(qeth_core_header_cache, hdr);
2726 dev_kfree_skb_any(new_skb);
2727 return NETDEV_TX_BUSY;
2732 netif_wake_queue(dev);
2733 if (card->options.performance_stats)
2734 card->perf_stats.outbound_time += qeth_get_micros() -
2735 card->perf_stats.outbound_start_time;
2739 card->stats.tx_dropped++;
2740 card->stats.tx_errors++;
2741 if ((new_skb != skb) && new_skb)
2742 dev_kfree_skb_any(new_skb);
2743 dev_kfree_skb_any(skb);
2744 netif_wake_queue(dev);
2745 return NETDEV_TX_OK;
2748 static int __qeth_l3_open(struct net_device *dev)
2750 struct qeth_card *card = dev->ml_priv;
2753 QETH_CARD_TEXT(card, 4, "qethopen");
2754 if (card->state == CARD_STATE_UP)
2756 if (card->state != CARD_STATE_SOFTSETUP)
2758 card->data.state = CH_STATE_UP;
2759 card->state = CARD_STATE_UP;
2760 netif_start_queue(dev);
2762 if (qdio_stop_irq(card->data.ccwdev, 0) >= 0) {
2763 napi_enable(&card->napi);
2764 napi_schedule(&card->napi);
2770 static int qeth_l3_open(struct net_device *dev)
2772 struct qeth_card *card = dev->ml_priv;
2774 QETH_CARD_TEXT(card, 5, "qethope_");
2775 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
2776 QETH_CARD_TEXT(card, 3, "openREC");
2777 return -ERESTARTSYS;
2779 return __qeth_l3_open(dev);
2782 static int qeth_l3_stop(struct net_device *dev)
2784 struct qeth_card *card = dev->ml_priv;
2786 QETH_CARD_TEXT(card, 4, "qethstop");
2787 netif_tx_disable(dev);
2788 if (card->state == CARD_STATE_UP) {
2789 card->state = CARD_STATE_SOFTSETUP;
2790 napi_disable(&card->napi);
2795 static const struct ethtool_ops qeth_l3_ethtool_ops = {
2796 .get_link = ethtool_op_get_link,
2797 .get_strings = qeth_core_get_strings,
2798 .get_ethtool_stats = qeth_core_get_ethtool_stats,
2799 .get_sset_count = qeth_core_get_sset_count,
2800 .get_drvinfo = qeth_core_get_drvinfo,
2801 .get_link_ksettings = qeth_core_ethtool_get_link_ksettings,
2805 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
2806 * NOARP on the netdevice is no option because it also turns off neighbor
2807 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
2808 * arp resolution but we want the hard header (packet socket will work
2811 static int qeth_l3_neigh_setup_noarp(struct neighbour *n)
2813 n->nud_state = NUD_NOARP;
2814 memcpy(n->ha, "FAKELL", 6);
2815 n->output = n->ops->connected_output;
2820 qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np)
2822 if (np->tbl->family == AF_INET)
2823 np->neigh_setup = qeth_l3_neigh_setup_noarp;
2828 static const struct net_device_ops qeth_l3_netdev_ops = {
2829 .ndo_open = qeth_l3_open,
2830 .ndo_stop = qeth_l3_stop,
2831 .ndo_get_stats = qeth_get_stats,
2832 .ndo_start_xmit = qeth_l3_hard_start_xmit,
2833 .ndo_validate_addr = eth_validate_addr,
2834 .ndo_set_rx_mode = qeth_l3_set_rx_mode,
2835 .ndo_do_ioctl = qeth_do_ioctl,
2836 .ndo_change_mtu = qeth_change_mtu,
2837 .ndo_fix_features = qeth_fix_features,
2838 .ndo_set_features = qeth_set_features,
2839 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid,
2840 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid,
2841 .ndo_tx_timeout = qeth_tx_timeout,
2844 static const struct net_device_ops qeth_l3_osa_netdev_ops = {
2845 .ndo_open = qeth_l3_open,
2846 .ndo_stop = qeth_l3_stop,
2847 .ndo_get_stats = qeth_get_stats,
2848 .ndo_start_xmit = qeth_l3_hard_start_xmit,
2849 .ndo_features_check = qeth_features_check,
2850 .ndo_validate_addr = eth_validate_addr,
2851 .ndo_set_rx_mode = qeth_l3_set_rx_mode,
2852 .ndo_do_ioctl = qeth_do_ioctl,
2853 .ndo_change_mtu = qeth_change_mtu,
2854 .ndo_fix_features = qeth_fix_features,
2855 .ndo_set_features = qeth_set_features,
2856 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid,
2857 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid,
2858 .ndo_tx_timeout = qeth_tx_timeout,
2859 .ndo_neigh_setup = qeth_l3_neigh_setup,
2862 static int qeth_l3_setup_netdev(struct qeth_card *card)
2866 if (card->info.type == QETH_CARD_TYPE_OSD ||
2867 card->info.type == QETH_CARD_TYPE_OSX) {
2868 if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) ||
2869 (card->info.link_type == QETH_LINK_TYPE_HSTR)) {
2870 pr_info("qeth_l3: ignoring TR device\n");
2873 card->dev = alloc_etherdev(0);
2876 card->dev->netdev_ops = &qeth_l3_osa_netdev_ops;
2878 /*IPv6 address autoconfiguration stuff*/
2879 qeth_l3_get_unique_id(card);
2880 if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
2881 card->dev->dev_id = card->info.unique_id &
2883 if (!card->info.guestlan) {
2884 card->dev->hw_features = NETIF_F_SG |
2885 NETIF_F_RXCSUM | NETIF_F_IP_CSUM |
2887 card->dev->vlan_features = NETIF_F_SG |
2888 NETIF_F_RXCSUM | NETIF_F_IP_CSUM |
2890 card->dev->features |= NETIF_F_SG;
2893 } else if (card->info.type == QETH_CARD_TYPE_IQD) {
2894 card->dev = alloc_netdev(0, "hsi%d", NET_NAME_UNKNOWN,
2898 card->dev->flags |= IFF_NOARP;
2899 card->dev->netdev_ops = &qeth_l3_netdev_ops;
2900 rc = qeth_l3_iqd_read_initial_mac(card);
2903 if (card->options.hsuid[0])
2904 memcpy(card->dev->perm_addr, card->options.hsuid, 9);
2908 card->dev->ml_priv = card;
2909 card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
2910 card->dev->mtu = card->info.initial_mtu;
2911 card->dev->min_mtu = 64;
2912 card->dev->max_mtu = ETH_MAX_MTU;
2913 card->dev->ethtool_ops = &qeth_l3_ethtool_ops;
2914 card->dev->features |= NETIF_F_HW_VLAN_CTAG_TX |
2915 NETIF_F_HW_VLAN_CTAG_RX |
2916 NETIF_F_HW_VLAN_CTAG_FILTER;
2917 netif_keep_dst(card->dev);
2918 netif_set_gso_max_size(card->dev, (QETH_MAX_BUFFER_ELEMENTS(card) - 1) *
2921 SET_NETDEV_DEV(card->dev, &card->gdev->dev);
2922 netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
2923 netif_carrier_off(card->dev);
2924 return register_netdev(card->dev);
2927 static const struct device_type qeth_l3_devtype = {
2928 .name = "qeth_layer3",
2929 .groups = qeth_l3_attr_groups,
2932 static int qeth_l3_probe_device(struct ccwgroup_device *gdev)
2934 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2937 if (gdev->dev.type == &qeth_generic_devtype) {
2938 rc = qeth_l3_create_device_attributes(&gdev->dev);
2942 hash_init(card->ip_htable);
2943 hash_init(card->ip_mc_htable);
2944 card->options.layer2 = 0;
2945 card->info.hwtrap = 0;
2949 static void qeth_l3_remove_device(struct ccwgroup_device *cgdev)
2951 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
2953 if (cgdev->dev.type == &qeth_generic_devtype)
2954 qeth_l3_remove_device_attributes(&cgdev->dev);
2956 qeth_set_allowed_threads(card, 0, 1);
2957 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
2959 if (cgdev->state == CCWGROUP_ONLINE)
2960 qeth_l3_set_offline(cgdev);
2963 netif_napi_del(&card->napi);
2964 unregister_netdev(card->dev);
2968 qeth_l3_clear_ip_htable(card, 0);
2969 qeth_l3_clear_ipato_list(card);
2973 static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
2975 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2977 enum qeth_card_states recover_flag;
2979 mutex_lock(&card->discipline_mutex);
2980 mutex_lock(&card->conf_mutex);
2981 QETH_DBF_TEXT(SETUP, 2, "setonlin");
2982 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
2984 recover_flag = card->state;
2985 rc = qeth_core_hardsetup_card(card);
2987 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
2992 if (!card->dev && qeth_l3_setup_netdev(card)) {
2997 if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) {
2998 if (card->info.hwtrap &&
2999 qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM))
3000 card->info.hwtrap = 0;
3002 card->info.hwtrap = 0;
3004 card->state = CARD_STATE_HARDSETUP;
3005 memset(&card->rx, 0, sizeof(struct qeth_rx));
3006 qeth_print_status_message(card);
3009 QETH_DBF_TEXT(SETUP, 2, "softsetp");
3011 rc = qeth_l3_setadapter_parms(card);
3013 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
3014 if (!card->options.sniffer) {
3015 rc = qeth_l3_start_ipassists(card);
3017 QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
3020 rc = qeth_l3_setrouting_v4(card);
3022 QETH_DBF_TEXT_(SETUP, 2, "4err%04x", rc);
3023 rc = qeth_l3_setrouting_v6(card);
3025 QETH_DBF_TEXT_(SETUP, 2, "5err%04x", rc);
3027 netif_tx_disable(card->dev);
3029 rc = qeth_init_qdio_queues(card);
3031 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
3035 card->state = CARD_STATE_SOFTSETUP;
3037 qeth_set_allowed_threads(card, 0xffffffff, 0);
3038 qeth_l3_recover_ip(card);
3039 if (card->lan_online)
3040 netif_carrier_on(card->dev);
3042 netif_carrier_off(card->dev);
3043 if (recover_flag == CARD_STATE_RECOVER) {
3046 __qeth_l3_open(card->dev);
3048 dev_open(card->dev);
3049 qeth_l3_set_rx_mode(card->dev);
3050 qeth_recover_features(card->dev);
3053 qeth_trace_features(card);
3054 /* let user_space know that device is online */
3055 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
3056 mutex_unlock(&card->conf_mutex);
3057 mutex_unlock(&card->discipline_mutex);
3060 qeth_l3_stop_card(card, 0);
3061 ccw_device_set_offline(CARD_DDEV(card));
3062 ccw_device_set_offline(CARD_WDEV(card));
3063 ccw_device_set_offline(CARD_RDEV(card));
3064 qdio_free(CARD_DDEV(card));
3065 if (recover_flag == CARD_STATE_RECOVER)
3066 card->state = CARD_STATE_RECOVER;
3068 card->state = CARD_STATE_DOWN;
3069 mutex_unlock(&card->conf_mutex);
3070 mutex_unlock(&card->discipline_mutex);
3074 static int qeth_l3_set_online(struct ccwgroup_device *gdev)
3076 return __qeth_l3_set_online(gdev, 0);
3079 static int __qeth_l3_set_offline(struct ccwgroup_device *cgdev,
3082 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
3083 int rc = 0, rc2 = 0, rc3 = 0;
3084 enum qeth_card_states recover_flag;
3086 mutex_lock(&card->discipline_mutex);
3087 mutex_lock(&card->conf_mutex);
3088 QETH_DBF_TEXT(SETUP, 3, "setoffl");
3089 QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
3091 if (card->dev && netif_carrier_ok(card->dev))
3092 netif_carrier_off(card->dev);
3093 recover_flag = card->state;
3094 if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
3095 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
3096 card->info.hwtrap = 1;
3098 qeth_l3_stop_card(card, recovery_mode);
3099 if ((card->options.cq == QETH_CQ_ENABLED) && card->dev) {
3101 call_netdevice_notifiers(NETDEV_REBOOT, card->dev);
3104 rc = ccw_device_set_offline(CARD_DDEV(card));
3105 rc2 = ccw_device_set_offline(CARD_WDEV(card));
3106 rc3 = ccw_device_set_offline(CARD_RDEV(card));
3108 rc = (rc2) ? rc2 : rc3;
3110 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
3111 qdio_free(CARD_DDEV(card));
3112 if (recover_flag == CARD_STATE_UP)
3113 card->state = CARD_STATE_RECOVER;
3114 /* let user_space know that device is offline */
3115 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
3116 mutex_unlock(&card->conf_mutex);
3117 mutex_unlock(&card->discipline_mutex);
3121 static int qeth_l3_set_offline(struct ccwgroup_device *cgdev)
3123 return __qeth_l3_set_offline(cgdev, 0);
3126 static int qeth_l3_recover(void *ptr)
3128 struct qeth_card *card;
3131 card = (struct qeth_card *) ptr;
3132 QETH_CARD_TEXT(card, 2, "recover1");
3133 QETH_CARD_HEX(card, 2, &card, sizeof(void *));
3134 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
3136 QETH_CARD_TEXT(card, 2, "recover2");
3137 dev_warn(&card->gdev->dev,
3138 "A recovery process has been started for the device\n");
3139 qeth_set_recovery_task(card);
3140 __qeth_l3_set_offline(card->gdev, 1);
3141 rc = __qeth_l3_set_online(card->gdev, 1);
3143 dev_info(&card->gdev->dev,
3144 "Device successfully recovered!\n");
3146 qeth_close_dev(card);
3147 dev_warn(&card->gdev->dev, "The qeth device driver "
3148 "failed to recover an error on the device\n");
3150 qeth_clear_recovery_task(card);
3151 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
3152 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
3156 static int qeth_l3_pm_suspend(struct ccwgroup_device *gdev)
3158 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3161 netif_device_detach(card->dev);
3162 qeth_set_allowed_threads(card, 0, 1);
3163 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
3164 if (gdev->state == CCWGROUP_OFFLINE)
3166 if (card->state == CARD_STATE_UP) {
3167 if (card->info.hwtrap)
3168 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
3169 __qeth_l3_set_offline(card->gdev, 1);
3171 __qeth_l3_set_offline(card->gdev, 0);
3175 static int qeth_l3_pm_resume(struct ccwgroup_device *gdev)
3177 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3180 if (gdev->state == CCWGROUP_OFFLINE)
3183 if (card->state == CARD_STATE_RECOVER) {
3184 rc = __qeth_l3_set_online(card->gdev, 1);
3187 dev_close(card->dev);
3191 rc = __qeth_l3_set_online(card->gdev, 0);
3193 qeth_set_allowed_threads(card, 0xffffffff, 0);
3195 netif_device_attach(card->dev);
3197 dev_warn(&card->gdev->dev, "The qeth device driver "
3198 "failed to recover an error on the device\n");
3202 /* Returns zero if the command is successfully "consumed" */
3203 static int qeth_l3_control_event(struct qeth_card *card,
3204 struct qeth_ipa_cmd *cmd)
3209 struct qeth_discipline qeth_l3_discipline = {
3210 .devtype = &qeth_l3_devtype,
3211 .start_poll = qeth_qdio_start_poll,
3212 .input_handler = (qdio_handler_t *) qeth_qdio_input_handler,
3213 .output_handler = (qdio_handler_t *) qeth_qdio_output_handler,
3214 .process_rx_buffer = qeth_l3_process_inbound_buffer,
3215 .recover = qeth_l3_recover,
3216 .setup = qeth_l3_probe_device,
3217 .remove = qeth_l3_remove_device,
3218 .set_online = qeth_l3_set_online,
3219 .set_offline = qeth_l3_set_offline,
3220 .freeze = qeth_l3_pm_suspend,
3221 .thaw = qeth_l3_pm_resume,
3222 .restore = qeth_l3_pm_resume,
3223 .do_ioctl = qeth_l3_do_ioctl,
3224 .control_event_handler = qeth_l3_control_event,
3226 EXPORT_SYMBOL_GPL(qeth_l3_discipline);
3228 static int qeth_l3_ip_event(struct notifier_block *this,
3229 unsigned long event, void *ptr)
3232 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
3233 struct net_device *dev = (struct net_device *)ifa->ifa_dev->dev;
3234 struct qeth_ipaddr *addr;
3235 struct qeth_card *card;
3237 if (dev_net(dev) != &init_net)
3240 card = qeth_l3_get_card_from_dev(dev);
3243 QETH_CARD_TEXT(card, 3, "ipevent");
3245 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
3247 addr->u.a4.addr = be32_to_cpu(ifa->ifa_address);
3248 addr->u.a4.mask = be32_to_cpu(ifa->ifa_mask);
3249 addr->type = QETH_IP_TYPE_NORMAL;
3255 spin_lock_bh(&card->ip_lock);
3256 qeth_l3_add_ip(card, addr);
3257 spin_unlock_bh(&card->ip_lock);
3260 spin_lock_bh(&card->ip_lock);
3261 qeth_l3_delete_ip(card, addr);
3262 spin_unlock_bh(&card->ip_lock);
3270 static struct notifier_block qeth_l3_ip_notifier = {
3275 static int qeth_l3_ip6_event(struct notifier_block *this,
3276 unsigned long event, void *ptr)
3278 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
3279 struct net_device *dev = (struct net_device *)ifa->idev->dev;
3280 struct qeth_ipaddr *addr;
3281 struct qeth_card *card;
3283 card = qeth_l3_get_card_from_dev(dev);
3286 QETH_CARD_TEXT(card, 3, "ip6event");
3287 if (!qeth_is_supported(card, IPA_IPV6))
3290 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
3292 memcpy(&addr->u.a6.addr, &ifa->addr, sizeof(struct in6_addr));
3293 addr->u.a6.pfxlen = ifa->prefix_len;
3294 addr->type = QETH_IP_TYPE_NORMAL;
3300 spin_lock_bh(&card->ip_lock);
3301 qeth_l3_add_ip(card, addr);
3302 spin_unlock_bh(&card->ip_lock);
3305 spin_lock_bh(&card->ip_lock);
3306 qeth_l3_delete_ip(card, addr);
3307 spin_unlock_bh(&card->ip_lock);
3315 static struct notifier_block qeth_l3_ip6_notifier = {
3320 static int qeth_l3_register_notifiers(void)
3324 QETH_DBF_TEXT(SETUP, 5, "regnotif");
3325 rc = register_inetaddr_notifier(&qeth_l3_ip_notifier);
3328 rc = register_inet6addr_notifier(&qeth_l3_ip6_notifier);
3330 unregister_inetaddr_notifier(&qeth_l3_ip_notifier);
3336 static void qeth_l3_unregister_notifiers(void)
3338 QETH_DBF_TEXT(SETUP, 5, "unregnot");
3339 WARN_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier));
3340 WARN_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier));
3343 static int __init qeth_l3_init(void)
3345 pr_info("register layer 3 discipline\n");
3346 return qeth_l3_register_notifiers();
3349 static void __exit qeth_l3_exit(void)
3351 qeth_l3_unregister_notifiers();
3352 pr_info("unregister layer 3 discipline\n");
3355 module_init(qeth_l3_init);
3356 module_exit(qeth_l3_exit);
3357 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
3358 MODULE_DESCRIPTION("qeth layer 3 discipline");
3359 MODULE_LICENSE("GPL");