2 * Copyright IBM Corp. 2007, 2009
3 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
4 * Frank Pavlic <fpavlic@de.ibm.com>,
5 * Thomas Spatzier <tspat@de.ibm.com>,
6 * Frank Blaschka <frank.blaschka@de.ibm.com>
9 #define KMSG_COMPONENT "qeth"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 #include <linux/module.h>
13 #include <linux/moduleparam.h>
14 #include <linux/bitops.h>
15 #include <linux/string.h>
16 #include <linux/errno.h>
17 #include <linux/kernel.h>
18 #include <linux/etherdevice.h>
20 #include <linux/ipv6.h>
21 #include <linux/inetdevice.h>
22 #include <linux/igmp.h>
23 #include <linux/slab.h>
24 #include <linux/if_vlan.h>
28 #include <net/route.h>
29 #include <net/ip6_fib.h>
30 #include <net/ip6_checksum.h>
31 #include <net/iucv/af_iucv.h>
32 #include <linux/hashtable.h>
37 static int qeth_l3_set_offline(struct ccwgroup_device *);
38 static int qeth_l3_stop(struct net_device *);
39 static void qeth_l3_set_multicast_list(struct net_device *);
40 static int qeth_l3_register_addr_entry(struct qeth_card *,
41 struct qeth_ipaddr *);
42 static int qeth_l3_deregister_addr_entry(struct qeth_card *,
43 struct qeth_ipaddr *);
45 static int qeth_l3_isxdigit(char *buf)
48 if (!isxdigit(*buf++))
54 static void qeth_l3_ipaddr4_to_string(const __u8 *addr, char *buf)
56 sprintf(buf, "%pI4", addr);
59 static int qeth_l3_string_to_ipaddr4(const char *buf, __u8 *addr)
61 int count = 0, rc = 0;
65 rc = sscanf(buf, "%u.%u.%u.%u%c",
66 &in[0], &in[1], &in[2], &in[3], &c);
67 if (rc != 4 && (rc != 5 || c != '\n'))
69 for (count = 0; count < 4; count++) {
72 addr[count] = in[count];
77 static void qeth_l3_ipaddr6_to_string(const __u8 *addr, char *buf)
79 sprintf(buf, "%pI6", addr);
82 static int qeth_l3_string_to_ipaddr6(const char *buf, __u8 *addr)
84 const char *end, *end_tmp, *start;
87 int num2, cnt, out, found, save_cnt;
88 unsigned short in_tmp[8] = {0, };
90 cnt = out = found = save_cnt = num2 = 0;
95 end = strchr(start, ':');
97 end = buf + strlen(buf);
98 end_tmp = strchr(start, '\n');
105 if ((end - start) > 4)
107 memcpy(num, start, end - start);
108 if (!qeth_l3_isxdigit(num))
110 sscanf(start, "%x", &num2);
112 in_tmp[save_cnt++] = num2;
124 if (cnt + save_cnt > 8)
128 in[cnt--] = in_tmp[--save_cnt];
132 void qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto, const __u8 *addr,
135 if (proto == QETH_PROT_IPV4)
136 qeth_l3_ipaddr4_to_string(addr, buf);
137 else if (proto == QETH_PROT_IPV6)
138 qeth_l3_ipaddr6_to_string(addr, buf);
141 int qeth_l3_string_to_ipaddr(const char *buf, enum qeth_prot_versions proto,
144 if (proto == QETH_PROT_IPV4)
145 return qeth_l3_string_to_ipaddr4(buf, addr);
146 else if (proto == QETH_PROT_IPV6)
147 return qeth_l3_string_to_ipaddr6(buf, addr);
152 static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
157 for (i = 0; i < len; ++i) {
159 for (j = 7; j >= 0; --j) {
160 bits[i*8 + j] = octet & 1;
166 int qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
167 struct qeth_ipaddr *addr)
169 struct qeth_ipato_entry *ipatoe;
170 u8 addr_bits[128] = {0, };
171 u8 ipatoe_bits[128] = {0, };
174 if (!card->ipato.enabled)
177 qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits,
178 (addr->proto == QETH_PROT_IPV4)? 4:16);
179 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
180 if (addr->proto != ipatoe->proto)
182 qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits,
183 (ipatoe->proto == QETH_PROT_IPV4) ?
185 if (addr->proto == QETH_PROT_IPV4)
186 rc = !memcmp(addr_bits, ipatoe_bits,
187 min(32, ipatoe->mask_bits));
189 rc = !memcmp(addr_bits, ipatoe_bits,
190 min(128, ipatoe->mask_bits));
195 if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
197 else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
204 qeth_l3_ipaddrs_is_equal(struct qeth_ipaddr *addr1, struct qeth_ipaddr *addr2)
206 return addr1->proto == addr2->proto &&
207 !memcmp(&addr1->u, &addr2->u, sizeof(addr1->u)) &&
208 !memcmp(&addr1->mac, &addr2->mac, sizeof(addr1->mac));
211 static struct qeth_ipaddr *
212 qeth_l3_ip_from_hash(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
214 struct qeth_ipaddr *addr;
216 if (tmp_addr->is_multicast) {
217 hash_for_each_possible(card->ip_mc_htable, addr,
218 hnode, qeth_l3_ipaddr_hash(tmp_addr))
219 if (qeth_l3_ipaddrs_is_equal(tmp_addr, addr))
222 hash_for_each_possible(card->ip_htable, addr,
223 hnode, qeth_l3_ipaddr_hash(tmp_addr))
224 if (qeth_l3_ipaddrs_is_equal(tmp_addr, addr))
231 int qeth_l3_delete_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
234 struct qeth_ipaddr *addr;
236 QETH_CARD_TEXT(card, 4, "delip");
238 if (tmp_addr->proto == QETH_PROT_IPV4)
239 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
241 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
242 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
245 addr = qeth_l3_ip_from_hash(card, tmp_addr);
250 if (addr->ref_counter > 0 && (addr->type == QETH_IP_TYPE_NORMAL ||
251 addr->type == QETH_IP_TYPE_RXIP))
253 if (addr->in_progress)
256 if (!qeth_card_hw_is_reachable(card)) {
257 addr->disp_flag = QETH_DISP_ADDR_DELETE;
261 rc = qeth_l3_deregister_addr_entry(card, addr);
263 hash_del(&addr->hnode);
269 int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
272 struct qeth_ipaddr *addr;
274 QETH_CARD_TEXT(card, 4, "addip");
276 if (tmp_addr->proto == QETH_PROT_IPV4)
277 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
279 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
280 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
283 addr = qeth_l3_ip_from_hash(card, tmp_addr);
285 addr = qeth_l3_get_addr_buffer(tmp_addr->proto);
289 memcpy(addr, tmp_addr, sizeof(struct qeth_ipaddr));
290 addr->ref_counter = 1;
292 if (addr->type == QETH_IP_TYPE_NORMAL &&
293 qeth_l3_is_addr_covered_by_ipato(card, addr)) {
294 QETH_CARD_TEXT(card, 2, "tkovaddr");
295 addr->set_flags |= QETH_IPA_SETIP_TAKEOVER_FLAG;
297 hash_add(card->ip_htable, &addr->hnode,
298 qeth_l3_ipaddr_hash(addr));
300 if (!qeth_card_hw_is_reachable(card)) {
301 addr->disp_flag = QETH_DISP_ADDR_ADD;
305 /* qeth_l3_register_addr_entry can go to sleep
306 * if we add a IPV4 addr. It is caused by the reason
307 * that SETIP ipa cmd starts ARP staff for IPV4 addr.
308 * Thus we should unlock spinlock, and make a protection
309 * using in_progress variable to indicate that there is
310 * an hardware operation with this IPV4 address
312 if (addr->proto == QETH_PROT_IPV4) {
313 addr->in_progress = 1;
314 spin_unlock_bh(&card->ip_lock);
315 rc = qeth_l3_register_addr_entry(card, addr);
316 spin_lock_bh(&card->ip_lock);
317 addr->in_progress = 0;
319 rc = qeth_l3_register_addr_entry(card, addr);
321 if (!rc || (rc == IPA_RC_DUPLICATE_IP_ADDRESS) ||
322 (rc == IPA_RC_LAN_OFFLINE)) {
323 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
324 if (addr->ref_counter < 1) {
325 qeth_l3_delete_ip(card, addr);
329 hash_del(&addr->hnode);
333 if (addr->type == QETH_IP_TYPE_NORMAL ||
334 addr->type == QETH_IP_TYPE_RXIP)
342 struct qeth_ipaddr *qeth_l3_get_addr_buffer(
343 enum qeth_prot_versions prot)
345 struct qeth_ipaddr *addr;
347 addr = kzalloc(sizeof(struct qeth_ipaddr), GFP_ATOMIC);
351 addr->type = QETH_IP_TYPE_NORMAL;
352 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
358 static void qeth_l3_clear_ip_htable(struct qeth_card *card, int recover)
360 struct qeth_ipaddr *addr;
361 struct hlist_node *tmp;
364 QETH_CARD_TEXT(card, 4, "clearip");
366 if (recover && card->options.sniffer)
369 spin_lock_bh(&card->ip_lock);
371 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
373 hash_del(&addr->hnode);
377 addr->disp_flag = QETH_DISP_ADDR_ADD;
380 spin_unlock_bh(&card->ip_lock);
382 spin_lock_bh(&card->mclock);
384 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
385 hash_del(&addr->hnode);
389 spin_unlock_bh(&card->mclock);
393 static void qeth_l3_recover_ip(struct qeth_card *card)
395 struct qeth_ipaddr *addr;
396 struct hlist_node *tmp;
400 QETH_CARD_TEXT(card, 4, "recovrip");
402 spin_lock_bh(&card->ip_lock);
404 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
405 if (addr->disp_flag == QETH_DISP_ADDR_DELETE) {
406 qeth_l3_deregister_addr_entry(card, addr);
407 hash_del(&addr->hnode);
409 } else if (addr->disp_flag == QETH_DISP_ADDR_ADD) {
410 if (addr->proto == QETH_PROT_IPV4) {
411 addr->in_progress = 1;
412 spin_unlock_bh(&card->ip_lock);
413 rc = qeth_l3_register_addr_entry(card, addr);
414 spin_lock_bh(&card->ip_lock);
415 addr->in_progress = 0;
417 rc = qeth_l3_register_addr_entry(card, addr);
420 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
421 if (addr->ref_counter < 1)
422 qeth_l3_delete_ip(card, addr);
424 hash_del(&addr->hnode);
430 spin_unlock_bh(&card->ip_lock);
434 static int qeth_l3_send_setdelmc(struct qeth_card *card,
435 struct qeth_ipaddr *addr, int ipacmd)
438 struct qeth_cmd_buffer *iob;
439 struct qeth_ipa_cmd *cmd;
441 QETH_CARD_TEXT(card, 4, "setdelmc");
443 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
446 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
447 memcpy(&cmd->data.setdelipm.mac, addr->mac, OSA_ADDR_LEN);
448 if (addr->proto == QETH_PROT_IPV6)
449 memcpy(cmd->data.setdelipm.ip6, &addr->u.a6.addr,
450 sizeof(struct in6_addr));
452 memcpy(&cmd->data.setdelipm.ip4, &addr->u.a4.addr, 4);
454 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
459 static void qeth_l3_fill_netmask(u8 *netmask, unsigned int len)
462 for (i = 0; i < 16; i++) {
467 netmask[i] = (u8)(0xFF00 >> j);
473 static int qeth_l3_send_setdelip(struct qeth_card *card,
474 struct qeth_ipaddr *addr, int ipacmd, unsigned int flags)
477 struct qeth_cmd_buffer *iob;
478 struct qeth_ipa_cmd *cmd;
481 QETH_CARD_TEXT(card, 4, "setdelip");
482 QETH_CARD_TEXT_(card, 4, "flags%02X", flags);
484 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
487 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
488 if (addr->proto == QETH_PROT_IPV6) {
489 memcpy(cmd->data.setdelip6.ip_addr, &addr->u.a6.addr,
490 sizeof(struct in6_addr));
491 qeth_l3_fill_netmask(netmask, addr->u.a6.pfxlen);
492 memcpy(cmd->data.setdelip6.mask, netmask,
493 sizeof(struct in6_addr));
494 cmd->data.setdelip6.flags = flags;
496 memcpy(cmd->data.setdelip4.ip_addr, &addr->u.a4.addr, 4);
497 memcpy(cmd->data.setdelip4.mask, &addr->u.a4.mask, 4);
498 cmd->data.setdelip4.flags = flags;
501 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
506 static int qeth_l3_send_setrouting(struct qeth_card *card,
507 enum qeth_routing_types type, enum qeth_prot_versions prot)
510 struct qeth_ipa_cmd *cmd;
511 struct qeth_cmd_buffer *iob;
513 QETH_CARD_TEXT(card, 4, "setroutg");
514 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETRTG, prot);
517 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
518 cmd->data.setrtg.type = (type);
519 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
524 static int qeth_l3_correct_routing_type(struct qeth_card *card,
525 enum qeth_routing_types *type, enum qeth_prot_versions prot)
527 if (card->info.type == QETH_CARD_TYPE_IQD) {
530 case PRIMARY_CONNECTOR:
531 case SECONDARY_CONNECTOR:
532 case MULTICAST_ROUTER:
541 case SECONDARY_ROUTER:
543 case MULTICAST_ROUTER:
544 if (qeth_is_ipafunc_supported(card, prot,
556 int qeth_l3_setrouting_v4(struct qeth_card *card)
560 QETH_CARD_TEXT(card, 3, "setrtg4");
562 rc = qeth_l3_correct_routing_type(card, &card->options.route4.type,
567 rc = qeth_l3_send_setrouting(card, card->options.route4.type,
570 card->options.route4.type = NO_ROUTER;
571 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
572 " on %s. Type set to 'no router'.\n", rc,
573 QETH_CARD_IFNAME(card));
578 int qeth_l3_setrouting_v6(struct qeth_card *card)
582 QETH_CARD_TEXT(card, 3, "setrtg6");
583 #ifdef CONFIG_QETH_IPV6
585 if (!qeth_is_supported(card, IPA_IPV6))
587 rc = qeth_l3_correct_routing_type(card, &card->options.route6.type,
592 rc = qeth_l3_send_setrouting(card, card->options.route6.type,
595 card->options.route6.type = NO_ROUTER;
596 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
597 " on %s. Type set to 'no router'.\n", rc,
598 QETH_CARD_IFNAME(card));
605 * IP address takeover related functions
607 static void qeth_l3_clear_ipato_list(struct qeth_card *card)
609 struct qeth_ipato_entry *ipatoe, *tmp;
611 spin_lock_bh(&card->ip_lock);
613 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
614 list_del(&ipatoe->entry);
618 spin_unlock_bh(&card->ip_lock);
621 int qeth_l3_add_ipato_entry(struct qeth_card *card,
622 struct qeth_ipato_entry *new)
624 struct qeth_ipato_entry *ipatoe;
627 QETH_CARD_TEXT(card, 2, "addipato");
629 spin_lock_bh(&card->ip_lock);
631 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
632 if (ipatoe->proto != new->proto)
634 if (!memcmp(ipatoe->addr, new->addr,
635 (ipatoe->proto == QETH_PROT_IPV4)? 4:16) &&
636 (ipatoe->mask_bits == new->mask_bits)) {
643 list_add_tail(&new->entry, &card->ipato.entries);
645 spin_unlock_bh(&card->ip_lock);
650 void qeth_l3_del_ipato_entry(struct qeth_card *card,
651 enum qeth_prot_versions proto, u8 *addr, int mask_bits)
653 struct qeth_ipato_entry *ipatoe, *tmp;
655 QETH_CARD_TEXT(card, 2, "delipato");
657 spin_lock_bh(&card->ip_lock);
659 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
660 if (ipatoe->proto != proto)
662 if (!memcmp(ipatoe->addr, addr,
663 (proto == QETH_PROT_IPV4)? 4:16) &&
664 (ipatoe->mask_bits == mask_bits)) {
665 list_del(&ipatoe->entry);
670 spin_unlock_bh(&card->ip_lock);
674 * VIPA related functions
676 int qeth_l3_add_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
679 struct qeth_ipaddr *ipaddr;
682 ipaddr = qeth_l3_get_addr_buffer(proto);
684 if (proto == QETH_PROT_IPV4) {
685 QETH_CARD_TEXT(card, 2, "addvipa4");
686 memcpy(&ipaddr->u.a4.addr, addr, 4);
687 ipaddr->u.a4.mask = 0;
688 } else if (proto == QETH_PROT_IPV6) {
689 QETH_CARD_TEXT(card, 2, "addvipa6");
690 memcpy(&ipaddr->u.a6.addr, addr, 16);
691 ipaddr->u.a6.pfxlen = 0;
693 ipaddr->type = QETH_IP_TYPE_VIPA;
694 ipaddr->set_flags = QETH_IPA_SETIP_VIPA_FLAG;
695 ipaddr->del_flags = QETH_IPA_DELIP_VIPA_FLAG;
699 spin_lock_bh(&card->ip_lock);
701 if (qeth_l3_ip_from_hash(card, ipaddr))
704 qeth_l3_add_ip(card, ipaddr);
706 spin_unlock_bh(&card->ip_lock);
713 void qeth_l3_del_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
716 struct qeth_ipaddr *ipaddr;
718 ipaddr = qeth_l3_get_addr_buffer(proto);
720 if (proto == QETH_PROT_IPV4) {
721 QETH_CARD_TEXT(card, 2, "delvipa4");
722 memcpy(&ipaddr->u.a4.addr, addr, 4);
723 ipaddr->u.a4.mask = 0;
724 } else if (proto == QETH_PROT_IPV6) {
725 QETH_CARD_TEXT(card, 2, "delvipa6");
726 memcpy(&ipaddr->u.a6.addr, addr, 16);
727 ipaddr->u.a6.pfxlen = 0;
729 ipaddr->type = QETH_IP_TYPE_VIPA;
733 spin_lock_bh(&card->ip_lock);
734 qeth_l3_delete_ip(card, ipaddr);
735 spin_unlock_bh(&card->ip_lock);
741 * proxy ARP related functions
743 int qeth_l3_add_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
746 struct qeth_ipaddr *ipaddr;
749 ipaddr = qeth_l3_get_addr_buffer(proto);
751 if (proto == QETH_PROT_IPV4) {
752 QETH_CARD_TEXT(card, 2, "addrxip4");
753 memcpy(&ipaddr->u.a4.addr, addr, 4);
754 ipaddr->u.a4.mask = 0;
755 } else if (proto == QETH_PROT_IPV6) {
756 QETH_CARD_TEXT(card, 2, "addrxip6");
757 memcpy(&ipaddr->u.a6.addr, addr, 16);
758 ipaddr->u.a6.pfxlen = 0;
761 ipaddr->type = QETH_IP_TYPE_RXIP;
762 ipaddr->set_flags = QETH_IPA_SETIP_TAKEOVER_FLAG;
763 ipaddr->del_flags = 0;
767 spin_lock_bh(&card->ip_lock);
769 if (qeth_l3_ip_from_hash(card, ipaddr))
772 qeth_l3_add_ip(card, ipaddr);
774 spin_unlock_bh(&card->ip_lock);
781 void qeth_l3_del_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
784 struct qeth_ipaddr *ipaddr;
786 ipaddr = qeth_l3_get_addr_buffer(proto);
788 if (proto == QETH_PROT_IPV4) {
789 QETH_CARD_TEXT(card, 2, "delrxip4");
790 memcpy(&ipaddr->u.a4.addr, addr, 4);
791 ipaddr->u.a4.mask = 0;
792 } else if (proto == QETH_PROT_IPV6) {
793 QETH_CARD_TEXT(card, 2, "delrxip6");
794 memcpy(&ipaddr->u.a6.addr, addr, 16);
795 ipaddr->u.a6.pfxlen = 0;
797 ipaddr->type = QETH_IP_TYPE_RXIP;
801 spin_lock_bh(&card->ip_lock);
802 qeth_l3_delete_ip(card, ipaddr);
803 spin_unlock_bh(&card->ip_lock);
808 static int qeth_l3_register_addr_entry(struct qeth_card *card,
809 struct qeth_ipaddr *addr)
816 if (addr->proto == QETH_PROT_IPV4) {
817 QETH_CARD_TEXT(card, 2, "setaddr4");
818 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
819 } else if (addr->proto == QETH_PROT_IPV6) {
820 QETH_CARD_TEXT(card, 2, "setaddr6");
821 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
822 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
824 QETH_CARD_TEXT(card, 2, "setaddr?");
825 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
828 if (addr->is_multicast)
829 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
831 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP,
834 QETH_CARD_TEXT(card, 2, "failed");
835 } while ((--cnt > 0) && rc);
837 QETH_CARD_TEXT(card, 2, "FAILED");
838 qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
839 dev_warn(&card->gdev->dev,
840 "Registering IP address %s failed\n", buf);
845 static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
846 struct qeth_ipaddr *addr)
850 if (addr->proto == QETH_PROT_IPV4) {
851 QETH_CARD_TEXT(card, 2, "deladdr4");
852 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
853 } else if (addr->proto == QETH_PROT_IPV6) {
854 QETH_CARD_TEXT(card, 2, "deladdr6");
855 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
856 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
858 QETH_CARD_TEXT(card, 2, "deladdr?");
859 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
861 if (addr->is_multicast)
862 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
864 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP,
867 QETH_CARD_TEXT(card, 2, "failed");
872 static u8 qeth_l3_get_qeth_hdr_flags4(int cast_type)
874 if (cast_type == RTN_MULTICAST)
875 return QETH_CAST_MULTICAST;
876 if (cast_type == RTN_BROADCAST)
877 return QETH_CAST_BROADCAST;
878 return QETH_CAST_UNICAST;
881 static u8 qeth_l3_get_qeth_hdr_flags6(int cast_type)
883 u8 ct = QETH_HDR_PASSTHRU | QETH_HDR_IPV6;
884 if (cast_type == RTN_MULTICAST)
885 return ct | QETH_CAST_MULTICAST;
886 if (cast_type == RTN_ANYCAST)
887 return ct | QETH_CAST_ANYCAST;
888 if (cast_type == RTN_BROADCAST)
889 return ct | QETH_CAST_BROADCAST;
890 return ct | QETH_CAST_UNICAST;
893 static int qeth_l3_setadapter_parms(struct qeth_card *card)
897 QETH_DBF_TEXT(SETUP, 2, "setadprm");
899 if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
900 rc = qeth_setadpparms_change_macaddr(card);
902 dev_warn(&card->gdev->dev, "Reading the adapter MAC"
903 " address failed\n");
909 #ifdef CONFIG_QETH_IPV6
910 static int qeth_l3_send_simple_setassparms_ipv6(struct qeth_card *card,
911 enum qeth_ipa_funcs ipa_func, __u16 cmd_code)
914 struct qeth_cmd_buffer *iob;
916 QETH_CARD_TEXT(card, 4, "simassp6");
917 iob = qeth_get_setassparms_cmd(card, ipa_func, cmd_code,
921 rc = qeth_send_setassparms(card, iob, 0, 0,
922 qeth_setassparms_cb, NULL);
927 static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
931 QETH_CARD_TEXT(card, 3, "ipaarp");
933 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
934 dev_info(&card->gdev->dev,
935 "ARP processing not supported on %s!\n",
936 QETH_CARD_IFNAME(card));
939 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
940 IPA_CMD_ASS_START, 0);
942 dev_warn(&card->gdev->dev,
943 "Starting ARP processing support for %s failed\n",
944 QETH_CARD_IFNAME(card));
949 static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
953 QETH_CARD_TEXT(card, 3, "stsrcmac");
955 if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
956 dev_info(&card->gdev->dev,
957 "Inbound source MAC-address not supported on %s\n",
958 QETH_CARD_IFNAME(card));
962 rc = qeth_send_simple_setassparms(card, IPA_SOURCE_MAC,
963 IPA_CMD_ASS_START, 0);
965 dev_warn(&card->gdev->dev,
966 "Starting source MAC-address support for %s failed\n",
967 QETH_CARD_IFNAME(card));
971 static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
975 QETH_CARD_TEXT(card, 3, "strtvlan");
977 if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
978 dev_info(&card->gdev->dev,
979 "VLAN not supported on %s\n", QETH_CARD_IFNAME(card));
983 rc = qeth_send_simple_setassparms(card, IPA_VLAN_PRIO,
984 IPA_CMD_ASS_START, 0);
986 dev_warn(&card->gdev->dev,
987 "Starting VLAN support for %s failed\n",
988 QETH_CARD_IFNAME(card));
990 dev_info(&card->gdev->dev, "VLAN enabled\n");
995 static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
999 QETH_CARD_TEXT(card, 3, "stmcast");
1001 if (!qeth_is_supported(card, IPA_MULTICASTING)) {
1002 dev_info(&card->gdev->dev,
1003 "Multicast not supported on %s\n",
1004 QETH_CARD_IFNAME(card));
1008 rc = qeth_send_simple_setassparms(card, IPA_MULTICASTING,
1009 IPA_CMD_ASS_START, 0);
1011 dev_warn(&card->gdev->dev,
1012 "Starting multicast support for %s failed\n",
1013 QETH_CARD_IFNAME(card));
1015 dev_info(&card->gdev->dev, "Multicast enabled\n");
1016 card->dev->flags |= IFF_MULTICAST;
1021 #ifdef CONFIG_QETH_IPV6
1022 static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
1026 QETH_CARD_TEXT(card, 3, "softipv6");
1028 rc = qeth_query_ipassists(card, QETH_PROT_IPV6);
1030 dev_err(&card->gdev->dev,
1031 "Activating IPv6 support for %s failed\n",
1032 QETH_CARD_IFNAME(card));
1036 if (card->info.type == QETH_CARD_TYPE_IQD)
1039 rc = qeth_send_simple_setassparms(card, IPA_IPV6,
1040 IPA_CMD_ASS_START, 3);
1042 dev_err(&card->gdev->dev,
1043 "Activating IPv6 support for %s failed\n",
1044 QETH_CARD_IFNAME(card));
1047 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_IPV6,
1050 dev_err(&card->gdev->dev,
1051 "Activating IPv6 support for %s failed\n",
1052 QETH_CARD_IFNAME(card));
1055 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_PASSTHRU,
1058 dev_warn(&card->gdev->dev,
1059 "Enabling the passthrough mode for %s failed\n",
1060 QETH_CARD_IFNAME(card));
1064 dev_info(&card->gdev->dev, "IPV6 enabled\n");
1069 static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
1073 QETH_CARD_TEXT(card, 3, "strtipv6");
1075 if (!qeth_is_supported(card, IPA_IPV6)) {
1076 dev_info(&card->gdev->dev,
1077 "IPv6 not supported on %s\n", QETH_CARD_IFNAME(card));
1080 #ifdef CONFIG_QETH_IPV6
1081 rc = 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 memcpy(card->dev->dev_addr,
1156 cmd->data.create_destroy_addr.unique_id, ETH_ALEN);
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);
1304 static void qeth_l3_get_mac_for_ipm(__be32 ipm, char *mac)
1306 ip_eth_mc_map(ipm, mac);
1309 static void qeth_l3_mark_all_mc_to_be_deleted(struct qeth_card *card)
1311 struct qeth_ipaddr *addr;
1314 hash_for_each(card->ip_mc_htable, i, addr, hnode)
1315 addr->disp_flag = QETH_DISP_ADDR_DELETE;
1319 static void qeth_l3_add_all_new_mc(struct qeth_card *card)
1321 struct qeth_ipaddr *addr;
1322 struct hlist_node *tmp;
1326 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
1327 if (addr->disp_flag == QETH_DISP_ADDR_ADD) {
1328 rc = qeth_l3_register_addr_entry(card, addr);
1329 if (!rc || (rc == IPA_RC_LAN_OFFLINE))
1330 addr->ref_counter = 1;
1332 hash_del(&addr->hnode);
1340 static void qeth_l3_delete_nonused_mc(struct qeth_card *card)
1342 struct qeth_ipaddr *addr;
1343 struct hlist_node *tmp;
1347 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
1348 if (addr->disp_flag == QETH_DISP_ADDR_DELETE) {
1349 rc = qeth_l3_deregister_addr_entry(card, addr);
1350 if (!rc || (rc == IPA_RC_MC_ADDR_NOT_FOUND)) {
1351 hash_del(&addr->hnode);
1361 qeth_l3_add_mc_to_hash(struct qeth_card *card, struct in_device *in4_dev)
1363 struct ip_mc_list *im4;
1364 struct qeth_ipaddr *tmp, *ipm;
1365 char buf[MAX_ADDR_LEN];
1367 QETH_CARD_TEXT(card, 4, "addmc");
1369 tmp = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1373 for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
1374 im4 = rcu_dereference(im4->next_rcu)) {
1375 qeth_l3_get_mac_for_ipm(im4->multiaddr, buf);
1377 tmp->u.a4.addr = be32_to_cpu(im4->multiaddr);
1378 memcpy(tmp->mac, buf, sizeof(tmp->mac));
1380 ipm = qeth_l3_ip_from_hash(card, tmp);
1382 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1384 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1387 memcpy(ipm->mac, buf, sizeof(tmp->mac));
1388 ipm->u.a4.addr = be32_to_cpu(im4->multiaddr);
1389 ipm->is_multicast = 1;
1390 ipm->disp_flag = QETH_DISP_ADDR_ADD;
1391 hash_add(card->ip_mc_htable,
1392 &ipm->hnode, qeth_l3_ipaddr_hash(ipm));
1399 /* called with rcu_read_lock */
1400 static void qeth_l3_add_vlan_mc(struct qeth_card *card)
1402 struct in_device *in_dev;
1405 QETH_CARD_TEXT(card, 4, "addmcvl");
1407 if (!qeth_is_supported(card, IPA_FULL_VLAN))
1410 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1411 struct net_device *netdev;
1413 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1415 if (netdev == NULL ||
1416 !(netdev->flags & IFF_UP))
1418 in_dev = __in_dev_get_rcu(netdev);
1421 qeth_l3_add_mc_to_hash(card, in_dev);
1425 static void qeth_l3_add_multicast_ipv4(struct qeth_card *card)
1427 struct in_device *in4_dev;
1429 QETH_CARD_TEXT(card, 4, "chkmcv4");
1432 in4_dev = __in_dev_get_rcu(card->dev);
1433 if (in4_dev == NULL)
1435 qeth_l3_add_mc_to_hash(card, in4_dev);
1436 qeth_l3_add_vlan_mc(card);
1441 #ifdef CONFIG_QETH_IPV6
1443 qeth_l3_add_mc6_to_hash(struct qeth_card *card, struct inet6_dev *in6_dev)
1445 struct qeth_ipaddr *ipm;
1446 struct ifmcaddr6 *im6;
1447 struct qeth_ipaddr *tmp;
1448 char buf[MAX_ADDR_LEN];
1450 QETH_CARD_TEXT(card, 4, "addmc6");
1452 tmp = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1456 for (im6 = in6_dev->mc_list; im6 != NULL; im6 = im6->next) {
1457 ndisc_mc_map(&im6->mca_addr, buf, in6_dev->dev, 0);
1459 memcpy(tmp->mac, buf, sizeof(tmp->mac));
1460 memcpy(&tmp->u.a6.addr, &im6->mca_addr.s6_addr,
1461 sizeof(struct in6_addr));
1462 tmp->is_multicast = 1;
1464 ipm = qeth_l3_ip_from_hash(card, tmp);
1466 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1470 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1474 memcpy(ipm->mac, buf, OSA_ADDR_LEN);
1475 memcpy(&ipm->u.a6.addr, &im6->mca_addr.s6_addr,
1476 sizeof(struct in6_addr));
1477 ipm->is_multicast = 1;
1478 ipm->disp_flag = QETH_DISP_ADDR_ADD;
1479 hash_add(card->ip_mc_htable,
1480 &ipm->hnode, qeth_l3_ipaddr_hash(ipm));
1486 /* called with rcu_read_lock */
1487 static void qeth_l3_add_vlan_mc6(struct qeth_card *card)
1489 struct inet6_dev *in_dev;
1492 QETH_CARD_TEXT(card, 4, "admc6vl");
1494 if (!qeth_is_supported(card, IPA_FULL_VLAN))
1497 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1498 struct net_device *netdev;
1500 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1502 if (netdev == NULL ||
1503 !(netdev->flags & IFF_UP))
1505 in_dev = in6_dev_get(netdev);
1508 read_lock_bh(&in_dev->lock);
1509 qeth_l3_add_mc6_to_hash(card, in_dev);
1510 read_unlock_bh(&in_dev->lock);
1511 in6_dev_put(in_dev);
1515 static void qeth_l3_add_multicast_ipv6(struct qeth_card *card)
1517 struct inet6_dev *in6_dev;
1519 QETH_CARD_TEXT(card, 4, "chkmcv6");
1521 if (!qeth_is_supported(card, IPA_IPV6))
1523 in6_dev = in6_dev_get(card->dev);
1528 read_lock_bh(&in6_dev->lock);
1529 qeth_l3_add_mc6_to_hash(card, in6_dev);
1530 qeth_l3_add_vlan_mc6(card);
1531 read_unlock_bh(&in6_dev->lock);
1533 in6_dev_put(in6_dev);
1535 #endif /* CONFIG_QETH_IPV6 */
1537 static void qeth_l3_free_vlan_addresses4(struct qeth_card *card,
1540 struct in_device *in_dev;
1541 struct in_ifaddr *ifa;
1542 struct qeth_ipaddr *addr;
1543 struct net_device *netdev;
1545 QETH_CARD_TEXT(card, 4, "frvaddr4");
1547 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q), vid);
1550 in_dev = in_dev_get(netdev);
1554 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1558 spin_lock_bh(&card->ip_lock);
1560 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1561 addr->u.a4.addr = be32_to_cpu(ifa->ifa_address);
1562 addr->u.a4.mask = be32_to_cpu(ifa->ifa_mask);
1563 addr->type = QETH_IP_TYPE_NORMAL;
1564 qeth_l3_delete_ip(card, addr);
1567 spin_unlock_bh(&card->ip_lock);
1574 static void qeth_l3_free_vlan_addresses6(struct qeth_card *card,
1577 #ifdef CONFIG_QETH_IPV6
1578 struct inet6_dev *in6_dev;
1579 struct inet6_ifaddr *ifa;
1580 struct qeth_ipaddr *addr;
1581 struct net_device *netdev;
1583 QETH_CARD_TEXT(card, 4, "frvaddr6");
1585 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q), vid);
1589 in6_dev = in6_dev_get(netdev);
1593 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1597 spin_lock_bh(&card->ip_lock);
1599 list_for_each_entry(ifa, &in6_dev->addr_list, if_list) {
1600 memcpy(&addr->u.a6.addr, &ifa->addr,
1601 sizeof(struct in6_addr));
1602 addr->u.a6.pfxlen = ifa->prefix_len;
1603 addr->type = QETH_IP_TYPE_NORMAL;
1604 qeth_l3_delete_ip(card, addr);
1607 spin_unlock_bh(&card->ip_lock);
1611 in6_dev_put(in6_dev);
1612 #endif /* CONFIG_QETH_IPV6 */
1615 static void qeth_l3_free_vlan_addresses(struct qeth_card *card,
1619 qeth_l3_free_vlan_addresses4(card, vid);
1620 qeth_l3_free_vlan_addresses6(card, vid);
1624 static int qeth_l3_vlan_rx_add_vid(struct net_device *dev,
1625 __be16 proto, u16 vid)
1627 struct qeth_card *card = dev->ml_priv;
1629 set_bit(vid, card->active_vlans);
1633 static int qeth_l3_vlan_rx_kill_vid(struct net_device *dev,
1634 __be16 proto, u16 vid)
1636 struct qeth_card *card = dev->ml_priv;
1638 QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
1640 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
1641 QETH_CARD_TEXT(card, 3, "kidREC");
1644 /* unregister IP addresses of vlan device */
1645 qeth_l3_free_vlan_addresses(card, vid);
1646 clear_bit(vid, card->active_vlans);
1647 qeth_l3_set_multicast_list(card->dev);
1651 static void qeth_l3_rebuild_skb(struct qeth_card *card, struct sk_buff *skb,
1652 struct qeth_hdr *hdr)
1655 struct iphdr *ip_hdr;
1656 unsigned char tg_addr[MAX_ADDR_LEN];
1658 if (!(hdr->hdr.l3.flags & QETH_HDR_PASSTHRU)) {
1659 prot = (hdr->hdr.l3.flags & QETH_HDR_IPV6) ? ETH_P_IPV6 :
1661 switch (hdr->hdr.l3.flags & QETH_HDR_CAST_MASK) {
1662 case QETH_CAST_MULTICAST:
1664 #ifdef CONFIG_QETH_IPV6
1666 ndisc_mc_map((struct in6_addr *)
1668 tg_addr, card->dev, 0);
1672 ip_hdr = (struct iphdr *)skb->data;
1673 ip_eth_mc_map(ip_hdr->daddr, tg_addr);
1676 memcpy(tg_addr, card->dev->broadcast,
1677 card->dev->addr_len);
1679 card->stats.multicast++;
1680 skb->pkt_type = PACKET_MULTICAST;
1682 case QETH_CAST_BROADCAST:
1683 memcpy(tg_addr, card->dev->broadcast,
1684 card->dev->addr_len);
1685 card->stats.multicast++;
1686 skb->pkt_type = PACKET_BROADCAST;
1688 case QETH_CAST_UNICAST:
1689 case QETH_CAST_ANYCAST:
1690 case QETH_CAST_NOCAST:
1692 if (card->options.sniffer)
1693 skb->pkt_type = PACKET_OTHERHOST;
1695 skb->pkt_type = PACKET_HOST;
1696 memcpy(tg_addr, card->dev->dev_addr,
1697 card->dev->addr_len);
1699 if (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_SRC_MAC_ADDR)
1700 card->dev->header_ops->create(skb, card->dev, prot,
1701 tg_addr, &hdr->hdr.l3.dest_addr[2],
1702 card->dev->addr_len);
1704 card->dev->header_ops->create(skb, card->dev, prot,
1705 tg_addr, "FAKELL", card->dev->addr_len);
1708 skb->protocol = eth_type_trans(skb, card->dev);
1710 /* copy VLAN tag from hdr into skb */
1711 if (!card->options.sniffer &&
1712 (hdr->hdr.l3.ext_flags & (QETH_HDR_EXT_VLAN_FRAME |
1713 QETH_HDR_EXT_INCLUDE_VLAN_TAG))) {
1714 u16 tag = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME) ?
1715 hdr->hdr.l3.vlan_id :
1716 *((u16 *)&hdr->hdr.l3.dest_addr[12]);
1717 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), tag);
1720 if (card->dev->features & NETIF_F_RXCSUM) {
1721 if ((hdr->hdr.l3.ext_flags &
1722 (QETH_HDR_EXT_CSUM_HDR_REQ |
1723 QETH_HDR_EXT_CSUM_TRANSP_REQ)) ==
1724 (QETH_HDR_EXT_CSUM_HDR_REQ |
1725 QETH_HDR_EXT_CSUM_TRANSP_REQ))
1726 skb->ip_summed = CHECKSUM_UNNECESSARY;
1728 skb->ip_summed = CHECKSUM_NONE;
1730 skb->ip_summed = CHECKSUM_NONE;
1733 static int qeth_l3_process_inbound_buffer(struct qeth_card *card,
1734 int budget, int *done)
1737 struct sk_buff *skb;
1738 struct qeth_hdr *hdr;
1743 WARN_ON_ONCE(!budget);
1745 skb = qeth_core_get_next_skb(card,
1746 &card->qdio.in_q->bufs[card->rx.b_index],
1747 &card->rx.b_element, &card->rx.e_offset, &hdr);
1752 skb->dev = card->dev;
1753 switch (hdr->hdr.l3.id) {
1754 case QETH_HEADER_TYPE_LAYER3:
1755 magic = *(__u16 *)skb->data;
1756 if ((card->info.type == QETH_CARD_TYPE_IQD) &&
1757 (magic == ETH_P_AF_IUCV)) {
1758 skb->protocol = cpu_to_be16(ETH_P_AF_IUCV);
1759 skb->pkt_type = PACKET_HOST;
1760 skb->mac_header = NET_SKB_PAD;
1761 skb->dev = card->dev;
1763 card->dev->header_ops->create(skb, card->dev, 0,
1764 card->dev->dev_addr, "FAKELL",
1765 card->dev->addr_len);
1766 netif_receive_skb(skb);
1768 qeth_l3_rebuild_skb(card, skb, hdr);
1770 napi_gro_receive(&card->napi, skb);
1773 case QETH_HEADER_TYPE_LAYER2: /* for HiperSockets sniffer */
1774 skb->pkt_type = PACKET_HOST;
1775 skb->protocol = eth_type_trans(skb, skb->dev);
1777 netif_receive_skb(skb);
1780 dev_kfree_skb_any(skb);
1781 QETH_CARD_TEXT(card, 3, "inbunkno");
1782 QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN);
1787 card->stats.rx_packets++;
1788 card->stats.rx_bytes += len;
1793 static int qeth_l3_verify_vlan_dev(struct net_device *dev,
1794 struct qeth_card *card)
1799 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1800 struct net_device *netdev;
1803 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1806 if (netdev == dev) {
1807 rc = QETH_VLAN_CARD;
1812 if (rc && !(vlan_dev_real_dev(dev)->ml_priv == (void *)card))
1818 static int qeth_l3_verify_dev(struct net_device *dev)
1820 struct qeth_card *card;
1822 unsigned long flags;
1824 read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
1825 list_for_each_entry(card, &qeth_core_card_list.list, list) {
1826 if (card->dev == dev) {
1827 rc = QETH_REAL_CARD;
1830 rc = qeth_l3_verify_vlan_dev(dev, card);
1834 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
1839 static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev)
1841 struct qeth_card *card = NULL;
1844 rc = qeth_l3_verify_dev(dev);
1845 if (rc == QETH_REAL_CARD)
1846 card = dev->ml_priv;
1847 else if (rc == QETH_VLAN_CARD)
1848 card = vlan_dev_real_dev(dev)->ml_priv;
1849 if (card && card->options.layer2)
1852 QETH_CARD_TEXT_(card, 4, "%d", rc);
1856 static void qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
1858 QETH_DBF_TEXT(SETUP, 2, "stopcard");
1859 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
1861 qeth_set_allowed_threads(card, 0, 1);
1862 if (card->options.sniffer &&
1863 (card->info.promisc_mode == SET_PROMISC_MODE_ON))
1864 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1865 if (card->read.state == CH_STATE_UP &&
1866 card->write.state == CH_STATE_UP &&
1867 (card->state == CARD_STATE_UP)) {
1869 qeth_l3_stop(card->dev);
1872 dev_close(card->dev);
1875 card->state = CARD_STATE_SOFTSETUP;
1877 if (card->state == CARD_STATE_SOFTSETUP) {
1878 qeth_l3_clear_ip_htable(card, 1);
1879 qeth_clear_ipacmd_list(card);
1880 card->state = CARD_STATE_HARDSETUP;
1882 if (card->state == CARD_STATE_HARDSETUP) {
1883 qeth_qdio_clear_card(card, 0);
1884 qeth_clear_qdio_buffers(card);
1885 qeth_clear_working_pool_list(card);
1886 card->state = CARD_STATE_DOWN;
1888 if (card->state == CARD_STATE_DOWN) {
1889 qeth_clear_cmd_buffers(&card->read);
1890 qeth_clear_cmd_buffers(&card->write);
1895 * test for and Switch promiscuous mode (on or off)
1896 * either for guestlan or HiperSocket Sniffer
1899 qeth_l3_handle_promisc_mode(struct qeth_card *card)
1901 struct net_device *dev = card->dev;
1903 if (((dev->flags & IFF_PROMISC) &&
1904 (card->info.promisc_mode == SET_PROMISC_MODE_ON)) ||
1905 (!(dev->flags & IFF_PROMISC) &&
1906 (card->info.promisc_mode == SET_PROMISC_MODE_OFF)))
1909 if (card->info.guestlan) { /* Guestlan trace */
1910 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
1911 qeth_setadp_promisc_mode(card);
1912 } else if (card->options.sniffer && /* HiperSockets trace */
1913 qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) {
1914 if (dev->flags & IFF_PROMISC) {
1915 QETH_CARD_TEXT(card, 3, "+promisc");
1916 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE);
1918 QETH_CARD_TEXT(card, 3, "-promisc");
1919 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1924 static void qeth_l3_set_multicast_list(struct net_device *dev)
1926 struct qeth_card *card = dev->ml_priv;
1928 QETH_CARD_TEXT(card, 3, "setmulti");
1929 if (qeth_threads_running(card, QETH_RECOVER_THREAD) &&
1930 (card->state != CARD_STATE_UP))
1932 if (!card->options.sniffer) {
1934 spin_lock_bh(&card->mclock);
1936 qeth_l3_mark_all_mc_to_be_deleted(card);
1938 qeth_l3_add_multicast_ipv4(card);
1939 #ifdef CONFIG_QETH_IPV6
1940 qeth_l3_add_multicast_ipv6(card);
1942 qeth_l3_delete_nonused_mc(card);
1943 qeth_l3_add_all_new_mc(card);
1945 spin_unlock_bh(&card->mclock);
1947 if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
1950 qeth_l3_handle_promisc_mode(card);
1953 static const char *qeth_l3_arp_get_error_cause(int *rc)
1956 case QETH_IPA_ARP_RC_FAILED:
1958 return "operation failed";
1959 case QETH_IPA_ARP_RC_NOTSUPP:
1961 return "operation not supported";
1962 case QETH_IPA_ARP_RC_OUT_OF_RANGE:
1964 return "argument out of range";
1965 case QETH_IPA_ARP_RC_Q_NOTSUPP:
1967 return "query operation not supported";
1968 case QETH_IPA_ARP_RC_Q_NO_DATA:
1970 return "no query data available";
1972 return "unknown error";
1976 static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
1981 QETH_CARD_TEXT(card, 3, "arpstnoe");
1984 * currently GuestLAN only supports the ARP assist function
1985 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
1986 * thus we say EOPNOTSUPP for this ARP function
1988 if (card->info.guestlan)
1990 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1993 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
1994 IPA_CMD_ASS_ARP_SET_NO_ENTRIES,
1998 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on "
1999 "%s: %s (0x%x/%d)\n", QETH_CARD_IFNAME(card),
2000 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2005 static __u32 get_arp_entry_size(struct qeth_card *card,
2006 struct qeth_arp_query_data *qdata,
2007 struct qeth_arp_entrytype *type, __u8 strip_entries)
2012 is_hsi = qdata->reply_bits == 5;
2013 if (type->ip == QETHARP_IP_ADDR_V4) {
2014 QETH_CARD_TEXT(card, 4, "arpev4");
2015 if (strip_entries) {
2016 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5_short) :
2017 sizeof(struct qeth_arp_qi_entry7_short);
2019 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5) :
2020 sizeof(struct qeth_arp_qi_entry7);
2022 } else if (type->ip == QETHARP_IP_ADDR_V6) {
2023 QETH_CARD_TEXT(card, 4, "arpev6");
2024 if (strip_entries) {
2026 sizeof(struct qeth_arp_qi_entry5_short_ipv6) :
2027 sizeof(struct qeth_arp_qi_entry7_short_ipv6);
2030 sizeof(struct qeth_arp_qi_entry5_ipv6) :
2031 sizeof(struct qeth_arp_qi_entry7_ipv6);
2034 QETH_CARD_TEXT(card, 4, "arpinv");
2041 static int arpentry_matches_prot(struct qeth_arp_entrytype *type, __u16 prot)
2043 return (type->ip == QETHARP_IP_ADDR_V4 && prot == QETH_PROT_IPV4) ||
2044 (type->ip == QETHARP_IP_ADDR_V6 && prot == QETH_PROT_IPV6);
2047 static int qeth_l3_arp_query_cb(struct qeth_card *card,
2048 struct qeth_reply *reply, unsigned long data)
2050 struct qeth_ipa_cmd *cmd;
2051 struct qeth_arp_query_data *qdata;
2052 struct qeth_arp_query_info *qinfo;
2055 int entrybytes_done;
2057 __u8 do_strip_entries;
2059 QETH_CARD_TEXT(card, 3, "arpquecb");
2061 qinfo = (struct qeth_arp_query_info *) reply->param;
2062 cmd = (struct qeth_ipa_cmd *) data;
2063 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.prot_version);
2064 if (cmd->hdr.return_code) {
2065 QETH_CARD_TEXT(card, 4, "arpcberr");
2066 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
2069 if (cmd->data.setassparms.hdr.return_code) {
2070 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
2071 QETH_CARD_TEXT(card, 4, "setaperr");
2072 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
2075 qdata = &cmd->data.setassparms.data.query_arp;
2076 QETH_CARD_TEXT_(card, 4, "anoen%i", qdata->no_entries);
2078 do_strip_entries = (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) > 0;
2079 stripped_bytes = do_strip_entries ? QETH_QARP_MEDIASPECIFIC_BYTES : 0;
2080 entrybytes_done = 0;
2081 for (e = 0; e < qdata->no_entries; ++e) {
2084 struct qeth_arp_entrytype *etype;
2086 cur_entry = &qdata->data + entrybytes_done;
2087 etype = &((struct qeth_arp_qi_entry5 *) cur_entry)->type;
2088 if (!arpentry_matches_prot(etype, cmd->hdr.prot_version)) {
2089 QETH_CARD_TEXT(card, 4, "pmis");
2090 QETH_CARD_TEXT_(card, 4, "%i", etype->ip);
2093 esize = get_arp_entry_size(card, qdata, etype,
2095 QETH_CARD_TEXT_(card, 5, "esz%i", esize);
2099 if ((qinfo->udata_len - qinfo->udata_offset) < esize) {
2100 QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOMEM);
2101 cmd->hdr.return_code = IPA_RC_ENOMEM;
2105 memcpy(qinfo->udata + qinfo->udata_offset,
2106 &qdata->data + entrybytes_done + stripped_bytes,
2108 entrybytes_done += esize + stripped_bytes;
2109 qinfo->udata_offset += esize;
2110 ++qinfo->no_entries;
2112 /* check if all replies received ... */
2113 if (cmd->data.setassparms.hdr.seq_no <
2114 cmd->data.setassparms.hdr.number_of_replies)
2116 QETH_CARD_TEXT_(card, 4, "nove%i", qinfo->no_entries);
2117 memcpy(qinfo->udata, &qinfo->no_entries, 4);
2118 /* keep STRIP_ENTRIES flag so the user program can distinguish
2119 * stripped entries from normal ones */
2120 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
2121 qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES;
2122 memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2);
2123 QETH_CARD_TEXT_(card, 4, "rc%i", 0);
2127 memcpy(qinfo->udata, &i, 4);
2131 static int qeth_l3_send_ipa_arp_cmd(struct qeth_card *card,
2132 struct qeth_cmd_buffer *iob, int len,
2133 int (*reply_cb)(struct qeth_card *, struct qeth_reply *,
2137 QETH_CARD_TEXT(card, 4, "sendarp");
2139 memcpy(iob->data, IPA_PDU_HEADER, IPA_PDU_HEADER_SIZE);
2140 memcpy(QETH_IPA_CMD_DEST_ADDR(iob->data),
2141 &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH);
2142 return qeth_send_control_data(card, IPA_PDU_HEADER_SIZE + len, iob,
2143 reply_cb, reply_param);
2146 static int qeth_l3_query_arp_cache_info(struct qeth_card *card,
2147 enum qeth_prot_versions prot,
2148 struct qeth_arp_query_info *qinfo)
2150 struct qeth_cmd_buffer *iob;
2151 struct qeth_ipa_cmd *cmd;
2155 QETH_CARD_TEXT_(card, 3, "qarpipv%i", prot);
2157 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2158 IPA_CMD_ASS_ARP_QUERY_INFO,
2159 sizeof(struct qeth_arp_query_data)
2164 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
2165 cmd->data.setassparms.data.query_arp.request_bits = 0x000F;
2166 cmd->data.setassparms.data.query_arp.reply_bits = 0;
2167 cmd->data.setassparms.data.query_arp.no_entries = 0;
2168 rc = qeth_l3_send_ipa_arp_cmd(card, iob,
2169 QETH_SETASS_BASE_LEN+QETH_ARP_CMD_LEN,
2170 qeth_l3_arp_query_cb, (void *)qinfo);
2174 "Error while querying ARP cache on %s: %s "
2175 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2176 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2182 static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
2184 struct qeth_arp_query_info qinfo = {0, };
2187 QETH_CARD_TEXT(card, 3, "arpquery");
2189 if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
2190 IPA_ARP_PROCESSING)) {
2191 QETH_CARD_TEXT(card, 3, "arpqnsup");
2195 /* get size of userspace buffer and mask_bits -> 6 bytes */
2196 if (copy_from_user(&qinfo, udata, 6)) {
2200 qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL);
2205 qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
2206 rc = qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV4, &qinfo);
2208 if (copy_to_user(udata, qinfo.udata, 4))
2212 #ifdef CONFIG_QETH_IPV6
2213 if (qinfo.mask_bits & QETH_QARP_WITH_IPV6) {
2214 /* fails in case of GuestLAN QDIO mode */
2215 qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV6, &qinfo);
2218 if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) {
2219 QETH_CARD_TEXT(card, 4, "qactf");
2223 QETH_CARD_TEXT(card, 4, "qacts");
2231 static int qeth_l3_arp_add_entry(struct qeth_card *card,
2232 struct qeth_arp_cache_entry *entry)
2234 struct qeth_cmd_buffer *iob;
2239 QETH_CARD_TEXT(card, 3, "arpadent");
2242 * currently GuestLAN only supports the ARP assist function
2243 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
2244 * thus we say EOPNOTSUPP for this ARP function
2246 if (card->info.guestlan)
2248 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2252 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2253 IPA_CMD_ASS_ARP_ADD_ENTRY,
2254 sizeof(struct qeth_arp_cache_entry),
2258 rc = qeth_send_setassparms(card, iob,
2259 sizeof(struct qeth_arp_cache_entry),
2260 (unsigned long) entry,
2261 qeth_setassparms_cb, NULL);
2264 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
2265 QETH_DBF_MESSAGE(2, "Could not add ARP entry for address %s "
2266 "on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2267 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2272 static int qeth_l3_arp_remove_entry(struct qeth_card *card,
2273 struct qeth_arp_cache_entry *entry)
2275 struct qeth_cmd_buffer *iob;
2276 char buf[16] = {0, };
2280 QETH_CARD_TEXT(card, 3, "arprment");
2283 * currently GuestLAN only supports the ARP assist function
2284 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_REMOVE_ENTRY;
2285 * thus we say EOPNOTSUPP for this ARP function
2287 if (card->info.guestlan)
2289 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2292 memcpy(buf, entry, 12);
2293 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2294 IPA_CMD_ASS_ARP_REMOVE_ENTRY,
2299 rc = qeth_send_setassparms(card, iob,
2300 12, (unsigned long)buf,
2301 qeth_setassparms_cb, NULL);
2305 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
2306 QETH_DBF_MESSAGE(2, "Could not delete ARP entry for address %s"
2307 " on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2308 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2313 static int qeth_l3_arp_flush_cache(struct qeth_card *card)
2318 QETH_CARD_TEXT(card, 3, "arpflush");
2321 * currently GuestLAN only supports the ARP assist function
2322 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
2323 * thus we say EOPNOTSUPP for this ARP function
2325 if (card->info.guestlan || (card->info.type == QETH_CARD_TYPE_IQD))
2327 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2330 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2331 IPA_CMD_ASS_ARP_FLUSH_CACHE, 0);
2334 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on %s: %s "
2335 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2336 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2341 static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2343 struct qeth_card *card = dev->ml_priv;
2344 struct qeth_arp_cache_entry arp_entry;
2348 case SIOC_QETH_ARP_SET_NO_ENTRIES:
2349 if (!capable(CAP_NET_ADMIN)) {
2353 rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue);
2355 case SIOC_QETH_ARP_QUERY_INFO:
2356 if (!capable(CAP_NET_ADMIN)) {
2360 rc = qeth_l3_arp_query(card, rq->ifr_ifru.ifru_data);
2362 case SIOC_QETH_ARP_ADD_ENTRY:
2363 if (!capable(CAP_NET_ADMIN)) {
2367 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
2368 sizeof(struct qeth_arp_cache_entry)))
2371 rc = qeth_l3_arp_add_entry(card, &arp_entry);
2373 case SIOC_QETH_ARP_REMOVE_ENTRY:
2374 if (!capable(CAP_NET_ADMIN)) {
2378 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
2379 sizeof(struct qeth_arp_cache_entry)))
2382 rc = qeth_l3_arp_remove_entry(card, &arp_entry);
2384 case SIOC_QETH_ARP_FLUSH_CACHE:
2385 if (!capable(CAP_NET_ADMIN)) {
2389 rc = qeth_l3_arp_flush_cache(card);
2397 static int qeth_l3_get_cast_type(struct qeth_card *card, struct sk_buff *skb)
2399 int cast_type = RTN_UNSPEC;
2400 struct neighbour *n = NULL;
2401 struct dst_entry *dst;
2406 n = dst_neigh_lookup_skb(dst, skb);
2408 cast_type = n->type;
2411 if ((cast_type == RTN_BROADCAST) ||
2412 (cast_type == RTN_MULTICAST) ||
2413 (cast_type == RTN_ANYCAST))
2420 /* try something else */
2421 if (be16_to_cpu(skb->protocol) == ETH_P_IPV6)
2422 return (skb_network_header(skb)[24] == 0xff) ?
2424 else if (be16_to_cpu(skb->protocol) == ETH_P_IP)
2425 return ((skb_network_header(skb)[16] & 0xf0) == 0xe0) ?
2428 if (!memcmp(skb->data, skb->dev->broadcast, 6))
2429 return RTN_BROADCAST;
2433 hdr_mac = *((u16 *)skb->data);
2435 switch (card->info.link_type) {
2436 case QETH_LINK_TYPE_HSTR:
2437 case QETH_LINK_TYPE_LANE_TR:
2438 if ((hdr_mac == QETH_TR_MAC_NC) ||
2439 (hdr_mac == QETH_TR_MAC_C))
2440 return RTN_MULTICAST;
2442 /* eth or so multicast? */
2444 if ((hdr_mac == QETH_ETH_MAC_V4) ||
2445 (hdr_mac == QETH_ETH_MAC_V6))
2446 return RTN_MULTICAST;
2452 static void qeth_l3_fill_af_iucv_hdr(struct qeth_card *card,
2453 struct qeth_hdr *hdr, struct sk_buff *skb)
2456 struct af_iucv_trans_hdr *iucv_hdr;
2458 memset(hdr, 0, sizeof(struct qeth_hdr));
2459 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
2460 hdr->hdr.l3.ext_flags = 0;
2461 hdr->hdr.l3.length = skb->len - ETH_HLEN;
2462 hdr->hdr.l3.flags = QETH_HDR_IPV6 | QETH_CAST_UNICAST;
2464 iucv_hdr = (struct af_iucv_trans_hdr *) (skb->data + ETH_HLEN);
2465 memset(daddr, 0, sizeof(daddr));
2468 memcpy(&daddr[8], iucv_hdr->destUserID, 8);
2469 memcpy(hdr->hdr.l3.dest_addr, daddr, 16);
2472 static void qeth_l3_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
2473 struct sk_buff *skb, int ipv, int cast_type)
2475 struct dst_entry *dst;
2477 memset(hdr, 0, sizeof(struct qeth_hdr));
2478 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
2479 hdr->hdr.l3.ext_flags = 0;
2482 * before we're going to overwrite this location with next hop ip.
2483 * v6 uses passthrough, v4 sets the tag in the QDIO header.
2485 if (skb_vlan_tag_present(skb)) {
2486 if ((ipv == 4) || (card->info.type == QETH_CARD_TYPE_IQD))
2487 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_VLAN_FRAME;
2489 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_INCLUDE_VLAN_TAG;
2490 hdr->hdr.l3.vlan_id = skb_vlan_tag_get(skb);
2493 hdr->hdr.l3.length = skb->len - sizeof(struct qeth_hdr);
2498 struct rtable *rt = (struct rtable *) dst;
2499 __be32 *pkey = &ip_hdr(skb)->daddr;
2501 if (rt && rt->rt_gateway)
2502 pkey = &rt->rt_gateway;
2505 hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags4(cast_type);
2506 memset(hdr->hdr.l3.dest_addr, 0, 12);
2507 *((__be32 *) (&hdr->hdr.l3.dest_addr[12])) = *pkey;
2508 } else if (ipv == 6) {
2509 struct rt6_info *rt = (struct rt6_info *) dst;
2510 struct in6_addr *pkey = &ipv6_hdr(skb)->daddr;
2512 if (rt && !ipv6_addr_any(&rt->rt6i_gateway))
2513 pkey = &rt->rt6i_gateway;
2516 hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags6(cast_type);
2517 if (card->info.type == QETH_CARD_TYPE_IQD)
2518 hdr->hdr.l3.flags &= ~QETH_HDR_PASSTHRU;
2519 memcpy(hdr->hdr.l3.dest_addr, pkey, 16);
2521 if (!memcmp(skb->data + sizeof(struct qeth_hdr),
2522 skb->dev->broadcast, 6)) {
2524 hdr->hdr.l3.flags = QETH_CAST_BROADCAST |
2527 hdr->hdr.l3.flags = (cast_type == RTN_MULTICAST) ?
2528 QETH_CAST_MULTICAST | QETH_HDR_PASSTHRU :
2529 QETH_CAST_UNICAST | QETH_HDR_PASSTHRU;
2535 static void qeth_l3_hdr_csum(struct qeth_card *card, struct qeth_hdr *hdr,
2536 struct sk_buff *skb)
2538 struct iphdr *iph = ip_hdr(skb);
2540 /* tcph->check contains already the pseudo hdr checksum
2541 * so just set the header flags
2543 if (iph->protocol == IPPROTO_UDP)
2544 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_UDP;
2545 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_CSUM_TRANSP_REQ |
2546 QETH_HDR_EXT_CSUM_HDR_REQ;
2548 if (card->options.performance_stats)
2549 card->perf_stats.tx_csum++;
2552 static void qeth_tso_fill_header(struct qeth_card *card,
2553 struct qeth_hdr *qhdr, struct sk_buff *skb)
2555 struct qeth_hdr_tso *hdr = (struct qeth_hdr_tso *)qhdr;
2556 struct tcphdr *tcph = tcp_hdr(skb);
2557 struct iphdr *iph = ip_hdr(skb);
2558 struct ipv6hdr *ip6h = ipv6_hdr(skb);
2560 /*fix header to TSO values ...*/
2561 hdr->hdr.hdr.l3.id = QETH_HEADER_TYPE_TSO;
2562 hdr->hdr.hdr.l3.length = skb->len - sizeof(struct qeth_hdr_tso);
2563 /*set values which are fix for the first approach ...*/
2564 hdr->ext.hdr_tot_len = (__u16) sizeof(struct qeth_hdr_ext_tso);
2565 hdr->ext.imb_hdr_no = 1;
2566 hdr->ext.hdr_type = 1;
2567 hdr->ext.hdr_version = 1;
2568 hdr->ext.hdr_len = 28;
2569 /*insert non-fix values */
2570 hdr->ext.mss = skb_shinfo(skb)->gso_size;
2571 hdr->ext.dg_hdr_len = (__u16)(ip_hdrlen(skb) + tcp_hdrlen(skb));
2572 hdr->ext.payload_len = (__u16)(skb->len - hdr->ext.dg_hdr_len -
2573 sizeof(struct qeth_hdr_tso));
2575 if (be16_to_cpu(skb->protocol) == ETH_P_IPV6) {
2576 ip6h->payload_len = 0;
2577 tcph->check = ~csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
2580 /*OSA want us to set these values ...*/
2581 tcph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
2589 * qeth_l3_get_elements_no_tso() - find number of SBALEs for skb data for tso
2590 * @card: qeth card structure, to check max. elems.
2592 * @extra_elems: extra elems needed, to check against max.
2594 * Returns the number of pages, and thus QDIO buffer elements, needed to cover
2595 * skb data, including linear part and fragments, but excluding TCP header.
2596 * (Exclusion of TCP header distinguishes it from qeth_get_elements_no().)
2597 * Checks if the result plus extra_elems fits under the limit for the card.
2598 * Returns 0 if it does not.
2599 * Note: extra_elems is not included in the returned result.
2601 static int qeth_l3_get_elements_no_tso(struct qeth_card *card,
2602 struct sk_buff *skb, int extra_elems)
2604 addr_t tcpdptr = (addr_t)tcp_hdr(skb) + tcp_hdrlen(skb);
2605 int elements = qeth_get_elements_for_range(
2607 (addr_t)skb->data + skb_headlen(skb)) +
2608 qeth_get_elements_for_frags(skb);
2610 if ((elements + extra_elems) > QETH_MAX_BUFFER_ELEMENTS(card)) {
2612 "Invalid size of TSO IP packet (Number=%d / Length=%d). Discarded.\n",
2613 elements + extra_elems, skb->len);
2619 static netdev_tx_t qeth_l3_hard_start_xmit(struct sk_buff *skb,
2620 struct net_device *dev)
2624 struct qeth_hdr *hdr = NULL;
2625 int hdr_elements = 0;
2627 struct qeth_card *card = dev->ml_priv;
2628 struct sk_buff *new_skb = NULL;
2629 int ipv = qeth_get_ip_version(skb);
2630 int cast_type = qeth_l3_get_cast_type(card, skb);
2631 struct qeth_qdio_out_q *queue =
2632 card->qdio.out_qs[card->qdio.do_prio_queueing
2633 || (cast_type && card->info.is_multicast_different) ?
2634 qeth_get_priority_queue(card, skb, ipv, cast_type) :
2635 card->qdio.default_out_queue];
2636 int tx_bytes = skb->len;
2637 unsigned int hd_len = 0;
2639 int data_offset = -1;
2640 unsigned int nr_frags;
2642 if (((card->info.type == QETH_CARD_TYPE_IQD) &&
2643 (((card->options.cq != QETH_CQ_ENABLED) && !ipv) ||
2644 ((card->options.cq == QETH_CQ_ENABLED) &&
2645 (be16_to_cpu(skb->protocol) != ETH_P_AF_IUCV)))) ||
2646 card->options.sniffer)
2649 if ((card->state != CARD_STATE_UP) || !card->lan_online) {
2650 card->stats.tx_carrier_errors++;
2654 if ((cast_type == RTN_BROADCAST) &&
2655 (card->info.broadcast_capable == 0))
2658 if (card->options.performance_stats) {
2659 card->perf_stats.outbound_cnt++;
2660 card->perf_stats.outbound_start_time = qeth_get_micros();
2663 /* Ignore segment size from skb_is_gso(), 1 page is always used. */
2664 use_tso = skb_is_gso(skb) &&
2665 (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4);
2667 if (card->info.type == QETH_CARD_TYPE_IQD) {
2669 data_offset = ETH_HLEN;
2670 hd_len = sizeof(*hdr);
2671 hdr = kmem_cache_alloc(qeth_core_header_cache, GFP_ATOMIC);
2676 /* create a clone with writeable headroom */
2677 new_skb = skb_realloc_headroom(skb, sizeof(struct qeth_hdr_tso)
2683 skb_pull(new_skb, ETH_HLEN);
2686 if (ipv != 4 && skb_vlan_tag_present(new_skb)) {
2687 skb_push(new_skb, VLAN_HLEN);
2688 skb_copy_to_linear_data(new_skb, new_skb->data + 4, 4);
2689 skb_copy_to_linear_data_offset(new_skb, 4,
2690 new_skb->data + 8, 4);
2691 skb_copy_to_linear_data_offset(new_skb, 8,
2692 new_skb->data + 12, 4);
2693 tag = (__be16 *)(new_skb->data + 12);
2694 *tag = cpu_to_be16(ETH_P_8021Q);
2695 *(tag + 1) = cpu_to_be16(skb_vlan_tag_get(new_skb));
2699 netif_stop_queue(dev);
2701 /* fix hardware limitation: as long as we do not have sbal
2702 * chaining we can not send long frag lists
2704 if ((card->info.type != QETH_CARD_TYPE_IQD) &&
2705 ((use_tso && !qeth_l3_get_elements_no_tso(card, new_skb, 1)) ||
2706 (!use_tso && !qeth_get_elements_no(card, new_skb, 0, 0)))) {
2707 int lin_rc = skb_linearize(new_skb);
2709 if (card->options.performance_stats) {
2711 card->perf_stats.tx_linfail++;
2713 card->perf_stats.tx_lin++;
2718 nr_frags = skb_shinfo(new_skb)->nr_frags;
2721 hdr = skb_push(new_skb, sizeof(struct qeth_hdr_tso));
2722 memset(hdr, 0, sizeof(struct qeth_hdr_tso));
2723 qeth_l3_fill_header(card, hdr, new_skb, ipv, cast_type);
2724 qeth_tso_fill_header(card, hdr, new_skb);
2727 if (data_offset < 0) {
2728 hdr = skb_push(new_skb, sizeof(struct qeth_hdr));
2729 qeth_l3_fill_header(card, hdr, new_skb, ipv,
2732 if (be16_to_cpu(new_skb->protocol) == ETH_P_AF_IUCV)
2733 qeth_l3_fill_af_iucv_hdr(card, hdr, new_skb);
2735 qeth_l3_fill_header(card, hdr, new_skb, ipv,
2737 hdr->hdr.l3.length = new_skb->len - data_offset;
2741 if (skb->ip_summed == CHECKSUM_PARTIAL)
2742 qeth_l3_hdr_csum(card, hdr, new_skb);
2745 elements = use_tso ?
2746 qeth_l3_get_elements_no_tso(card, new_skb, hdr_elements) :
2747 qeth_get_elements_no(card, new_skb, hdr_elements,
2748 (data_offset > 0) ? data_offset : 0);
2750 if (data_offset >= 0)
2751 kmem_cache_free(qeth_core_header_cache, hdr);
2754 elements += hdr_elements;
2756 if (card->info.type != QETH_CARD_TYPE_IQD) {
2759 hd_len = sizeof(struct qeth_hdr_tso) +
2760 ip_hdrlen(new_skb) + tcp_hdrlen(new_skb);
2763 len = sizeof(struct qeth_hdr_layer3);
2766 if (qeth_hdr_chk_and_bounce(new_skb, &hdr, len))
2768 rc = qeth_do_send_packet(card, queue, new_skb, hdr, hd_len,
2771 rc = qeth_do_send_packet_fast(queue, new_skb, hdr, data_offset,
2775 card->stats.tx_packets++;
2776 card->stats.tx_bytes += tx_bytes;
2778 dev_kfree_skb_any(skb);
2779 if (card->options.performance_stats) {
2781 card->perf_stats.large_send_bytes += tx_bytes;
2782 card->perf_stats.large_send_cnt++;
2785 card->perf_stats.sg_skbs_sent++;
2786 /* nr_frags + skb->data */
2787 card->perf_stats.sg_frags_sent += nr_frags + 1;
2792 if (data_offset >= 0)
2793 kmem_cache_free(qeth_core_header_cache, hdr);
2797 dev_kfree_skb_any(new_skb);
2798 return NETDEV_TX_BUSY;
2803 netif_wake_queue(dev);
2804 if (card->options.performance_stats)
2805 card->perf_stats.outbound_time += qeth_get_micros() -
2806 card->perf_stats.outbound_start_time;
2810 card->stats.tx_dropped++;
2811 card->stats.tx_errors++;
2812 if ((new_skb != skb) && new_skb)
2813 dev_kfree_skb_any(new_skb);
2814 dev_kfree_skb_any(skb);
2815 netif_wake_queue(dev);
2816 return NETDEV_TX_OK;
2819 static int __qeth_l3_open(struct net_device *dev)
2821 struct qeth_card *card = dev->ml_priv;
2824 QETH_CARD_TEXT(card, 4, "qethopen");
2825 if (card->state == CARD_STATE_UP)
2827 if (card->state != CARD_STATE_SOFTSETUP)
2829 card->data.state = CH_STATE_UP;
2830 card->state = CARD_STATE_UP;
2831 netif_start_queue(dev);
2833 if (qdio_stop_irq(card->data.ccwdev, 0) >= 0) {
2834 napi_enable(&card->napi);
2835 napi_schedule(&card->napi);
2841 static int qeth_l3_open(struct net_device *dev)
2843 struct qeth_card *card = dev->ml_priv;
2845 QETH_CARD_TEXT(card, 5, "qethope_");
2846 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
2847 QETH_CARD_TEXT(card, 3, "openREC");
2848 return -ERESTARTSYS;
2850 return __qeth_l3_open(dev);
2853 static int qeth_l3_stop(struct net_device *dev)
2855 struct qeth_card *card = dev->ml_priv;
2857 QETH_CARD_TEXT(card, 4, "qethstop");
2858 netif_tx_disable(dev);
2859 if (card->state == CARD_STATE_UP) {
2860 card->state = CARD_STATE_SOFTSETUP;
2861 napi_disable(&card->napi);
2866 static const struct ethtool_ops qeth_l3_ethtool_ops = {
2867 .get_link = ethtool_op_get_link,
2868 .get_strings = qeth_core_get_strings,
2869 .get_ethtool_stats = qeth_core_get_ethtool_stats,
2870 .get_sset_count = qeth_core_get_sset_count,
2871 .get_drvinfo = qeth_core_get_drvinfo,
2872 .get_link_ksettings = qeth_core_ethtool_get_link_ksettings,
2876 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
2877 * NOARP on the netdevice is no option because it also turns off neighbor
2878 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
2879 * arp resolution but we want the hard header (packet socket will work
2882 static int qeth_l3_neigh_setup_noarp(struct neighbour *n)
2884 n->nud_state = NUD_NOARP;
2885 memcpy(n->ha, "FAKELL", 6);
2886 n->output = n->ops->connected_output;
2891 qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np)
2893 if (np->tbl->family == AF_INET)
2894 np->neigh_setup = qeth_l3_neigh_setup_noarp;
2899 static const struct net_device_ops qeth_l3_netdev_ops = {
2900 .ndo_open = qeth_l3_open,
2901 .ndo_stop = qeth_l3_stop,
2902 .ndo_get_stats = qeth_get_stats,
2903 .ndo_start_xmit = qeth_l3_hard_start_xmit,
2904 .ndo_validate_addr = eth_validate_addr,
2905 .ndo_set_rx_mode = qeth_l3_set_multicast_list,
2906 .ndo_do_ioctl = qeth_do_ioctl,
2907 .ndo_change_mtu = qeth_change_mtu,
2908 .ndo_fix_features = qeth_fix_features,
2909 .ndo_set_features = qeth_set_features,
2910 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid,
2911 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid,
2912 .ndo_tx_timeout = qeth_tx_timeout,
2915 static const struct net_device_ops qeth_l3_osa_netdev_ops = {
2916 .ndo_open = qeth_l3_open,
2917 .ndo_stop = qeth_l3_stop,
2918 .ndo_get_stats = qeth_get_stats,
2919 .ndo_start_xmit = qeth_l3_hard_start_xmit,
2920 .ndo_validate_addr = eth_validate_addr,
2921 .ndo_set_rx_mode = qeth_l3_set_multicast_list,
2922 .ndo_do_ioctl = qeth_do_ioctl,
2923 .ndo_change_mtu = qeth_change_mtu,
2924 .ndo_fix_features = qeth_fix_features,
2925 .ndo_set_features = qeth_set_features,
2926 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid,
2927 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid,
2928 .ndo_tx_timeout = qeth_tx_timeout,
2929 .ndo_neigh_setup = qeth_l3_neigh_setup,
2932 static int qeth_l3_setup_netdev(struct qeth_card *card)
2936 if (card->info.type == QETH_CARD_TYPE_OSD ||
2937 card->info.type == QETH_CARD_TYPE_OSX) {
2938 if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) ||
2939 (card->info.link_type == QETH_LINK_TYPE_HSTR)) {
2940 pr_info("qeth_l3: ignoring TR device\n");
2943 card->dev = alloc_etherdev(0);
2946 card->dev->netdev_ops = &qeth_l3_osa_netdev_ops;
2948 /*IPv6 address autoconfiguration stuff*/
2949 qeth_l3_get_unique_id(card);
2950 if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
2951 card->dev->dev_id = card->info.unique_id &
2953 if (!card->info.guestlan) {
2954 card->dev->hw_features = NETIF_F_SG |
2955 NETIF_F_RXCSUM | NETIF_F_IP_CSUM |
2957 card->dev->vlan_features = NETIF_F_SG |
2958 NETIF_F_RXCSUM | NETIF_F_IP_CSUM |
2962 } else if (card->info.type == QETH_CARD_TYPE_IQD) {
2963 card->dev = alloc_netdev(0, "hsi%d", NET_NAME_UNKNOWN,
2967 card->dev->flags |= IFF_NOARP;
2968 card->dev->netdev_ops = &qeth_l3_netdev_ops;
2969 rc = qeth_l3_iqd_read_initial_mac(card);
2972 if (card->options.hsuid[0])
2973 memcpy(card->dev->perm_addr, card->options.hsuid, 9);
2977 card->dev->ml_priv = card;
2978 card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
2979 card->dev->mtu = card->info.initial_mtu;
2980 card->dev->min_mtu = 64;
2981 card->dev->max_mtu = ETH_MAX_MTU;
2982 card->dev->ethtool_ops = &qeth_l3_ethtool_ops;
2983 card->dev->features |= NETIF_F_HW_VLAN_CTAG_TX |
2984 NETIF_F_HW_VLAN_CTAG_RX |
2985 NETIF_F_HW_VLAN_CTAG_FILTER;
2986 netif_keep_dst(card->dev);
2987 card->dev->gso_max_size = (QETH_MAX_BUFFER_ELEMENTS(card) - 1) *
2990 SET_NETDEV_DEV(card->dev, &card->gdev->dev);
2991 netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
2992 netif_carrier_off(card->dev);
2993 return register_netdev(card->dev);
2996 static const struct device_type qeth_l3_devtype = {
2997 .name = "qeth_layer3",
2998 .groups = qeth_l3_attr_groups,
3001 static int qeth_l3_probe_device(struct ccwgroup_device *gdev)
3003 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3006 if (gdev->dev.type == &qeth_generic_devtype) {
3007 rc = qeth_l3_create_device_attributes(&gdev->dev);
3011 hash_init(card->ip_htable);
3012 hash_init(card->ip_mc_htable);
3013 card->options.layer2 = 0;
3014 card->info.hwtrap = 0;
3018 static void qeth_l3_remove_device(struct ccwgroup_device *cgdev)
3020 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
3022 if (cgdev->dev.type == &qeth_generic_devtype)
3023 qeth_l3_remove_device_attributes(&cgdev->dev);
3025 qeth_set_allowed_threads(card, 0, 1);
3026 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
3028 if (cgdev->state == CCWGROUP_ONLINE)
3029 qeth_l3_set_offline(cgdev);
3032 netif_napi_del(&card->napi);
3033 unregister_netdev(card->dev);
3037 qeth_l3_clear_ip_htable(card, 0);
3038 qeth_l3_clear_ipato_list(card);
3042 static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
3044 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3046 enum qeth_card_states recover_flag;
3048 mutex_lock(&card->discipline_mutex);
3049 mutex_lock(&card->conf_mutex);
3050 QETH_DBF_TEXT(SETUP, 2, "setonlin");
3051 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
3053 recover_flag = card->state;
3054 rc = qeth_core_hardsetup_card(card);
3056 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
3061 if (!card->dev && qeth_l3_setup_netdev(card)) {
3066 if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) {
3067 if (card->info.hwtrap &&
3068 qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM))
3069 card->info.hwtrap = 0;
3071 card->info.hwtrap = 0;
3073 card->state = CARD_STATE_HARDSETUP;
3074 memset(&card->rx, 0, sizeof(struct qeth_rx));
3075 qeth_print_status_message(card);
3078 QETH_DBF_TEXT(SETUP, 2, "softsetp");
3080 rc = qeth_l3_setadapter_parms(card);
3082 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
3083 if (!card->options.sniffer) {
3084 rc = qeth_l3_start_ipassists(card);
3086 QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
3089 rc = qeth_l3_setrouting_v4(card);
3091 QETH_DBF_TEXT_(SETUP, 2, "4err%04x", rc);
3092 rc = qeth_l3_setrouting_v6(card);
3094 QETH_DBF_TEXT_(SETUP, 2, "5err%04x", rc);
3096 netif_tx_disable(card->dev);
3098 rc = qeth_init_qdio_queues(card);
3100 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
3104 card->state = CARD_STATE_SOFTSETUP;
3106 qeth_set_allowed_threads(card, 0xffffffff, 0);
3107 qeth_l3_recover_ip(card);
3108 if (card->lan_online)
3109 netif_carrier_on(card->dev);
3111 netif_carrier_off(card->dev);
3112 if (recover_flag == CARD_STATE_RECOVER) {
3115 __qeth_l3_open(card->dev);
3117 dev_open(card->dev);
3118 qeth_l3_set_multicast_list(card->dev);
3119 qeth_recover_features(card->dev);
3122 qeth_trace_features(card);
3123 /* let user_space know that device is online */
3124 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
3125 mutex_unlock(&card->conf_mutex);
3126 mutex_unlock(&card->discipline_mutex);
3129 qeth_l3_stop_card(card, 0);
3130 ccw_device_set_offline(CARD_DDEV(card));
3131 ccw_device_set_offline(CARD_WDEV(card));
3132 ccw_device_set_offline(CARD_RDEV(card));
3133 qdio_free(CARD_DDEV(card));
3134 if (recover_flag == CARD_STATE_RECOVER)
3135 card->state = CARD_STATE_RECOVER;
3137 card->state = CARD_STATE_DOWN;
3138 mutex_unlock(&card->conf_mutex);
3139 mutex_unlock(&card->discipline_mutex);
3143 static int qeth_l3_set_online(struct ccwgroup_device *gdev)
3145 return __qeth_l3_set_online(gdev, 0);
3148 static int __qeth_l3_set_offline(struct ccwgroup_device *cgdev,
3151 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
3152 int rc = 0, rc2 = 0, rc3 = 0;
3153 enum qeth_card_states recover_flag;
3155 mutex_lock(&card->discipline_mutex);
3156 mutex_lock(&card->conf_mutex);
3157 QETH_DBF_TEXT(SETUP, 3, "setoffl");
3158 QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
3160 if (card->dev && netif_carrier_ok(card->dev))
3161 netif_carrier_off(card->dev);
3162 recover_flag = card->state;
3163 if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
3164 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
3165 card->info.hwtrap = 1;
3167 qeth_l3_stop_card(card, recovery_mode);
3168 if ((card->options.cq == QETH_CQ_ENABLED) && card->dev) {
3170 call_netdevice_notifiers(NETDEV_REBOOT, card->dev);
3173 rc = ccw_device_set_offline(CARD_DDEV(card));
3174 rc2 = ccw_device_set_offline(CARD_WDEV(card));
3175 rc3 = ccw_device_set_offline(CARD_RDEV(card));
3177 rc = (rc2) ? rc2 : rc3;
3179 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
3180 qdio_free(CARD_DDEV(card));
3181 if (recover_flag == CARD_STATE_UP)
3182 card->state = CARD_STATE_RECOVER;
3183 /* let user_space know that device is offline */
3184 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
3185 mutex_unlock(&card->conf_mutex);
3186 mutex_unlock(&card->discipline_mutex);
3190 static int qeth_l3_set_offline(struct ccwgroup_device *cgdev)
3192 return __qeth_l3_set_offline(cgdev, 0);
3195 static int qeth_l3_recover(void *ptr)
3197 struct qeth_card *card;
3200 card = (struct qeth_card *) ptr;
3201 QETH_CARD_TEXT(card, 2, "recover1");
3202 QETH_CARD_HEX(card, 2, &card, sizeof(void *));
3203 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
3205 QETH_CARD_TEXT(card, 2, "recover2");
3206 dev_warn(&card->gdev->dev,
3207 "A recovery process has been started for the device\n");
3208 qeth_set_recovery_task(card);
3209 __qeth_l3_set_offline(card->gdev, 1);
3210 rc = __qeth_l3_set_online(card->gdev, 1);
3212 dev_info(&card->gdev->dev,
3213 "Device successfully recovered!\n");
3215 qeth_close_dev(card);
3216 dev_warn(&card->gdev->dev, "The qeth device driver "
3217 "failed to recover an error on the device\n");
3219 qeth_clear_recovery_task(card);
3220 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
3221 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
3225 static int qeth_l3_pm_suspend(struct ccwgroup_device *gdev)
3227 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3230 netif_device_detach(card->dev);
3231 qeth_set_allowed_threads(card, 0, 1);
3232 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
3233 if (gdev->state == CCWGROUP_OFFLINE)
3235 if (card->state == CARD_STATE_UP) {
3236 if (card->info.hwtrap)
3237 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
3238 __qeth_l3_set_offline(card->gdev, 1);
3240 __qeth_l3_set_offline(card->gdev, 0);
3244 static int qeth_l3_pm_resume(struct ccwgroup_device *gdev)
3246 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3249 if (gdev->state == CCWGROUP_OFFLINE)
3252 if (card->state == CARD_STATE_RECOVER) {
3253 rc = __qeth_l3_set_online(card->gdev, 1);
3256 dev_close(card->dev);
3260 rc = __qeth_l3_set_online(card->gdev, 0);
3262 qeth_set_allowed_threads(card, 0xffffffff, 0);
3264 netif_device_attach(card->dev);
3266 dev_warn(&card->gdev->dev, "The qeth device driver "
3267 "failed to recover an error on the device\n");
3271 /* Returns zero if the command is successfully "consumed" */
3272 static int qeth_l3_control_event(struct qeth_card *card,
3273 struct qeth_ipa_cmd *cmd)
3278 struct qeth_discipline qeth_l3_discipline = {
3279 .devtype = &qeth_l3_devtype,
3280 .start_poll = qeth_qdio_start_poll,
3281 .input_handler = (qdio_handler_t *) qeth_qdio_input_handler,
3282 .output_handler = (qdio_handler_t *) qeth_qdio_output_handler,
3283 .process_rx_buffer = qeth_l3_process_inbound_buffer,
3284 .recover = qeth_l3_recover,
3285 .setup = qeth_l3_probe_device,
3286 .remove = qeth_l3_remove_device,
3287 .set_online = qeth_l3_set_online,
3288 .set_offline = qeth_l3_set_offline,
3289 .freeze = qeth_l3_pm_suspend,
3290 .thaw = qeth_l3_pm_resume,
3291 .restore = qeth_l3_pm_resume,
3292 .do_ioctl = qeth_l3_do_ioctl,
3293 .control_event_handler = qeth_l3_control_event,
3295 EXPORT_SYMBOL_GPL(qeth_l3_discipline);
3297 static int qeth_l3_ip_event(struct notifier_block *this,
3298 unsigned long event, void *ptr)
3301 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
3302 struct net_device *dev = (struct net_device *)ifa->ifa_dev->dev;
3303 struct qeth_ipaddr *addr;
3304 struct qeth_card *card;
3306 if (dev_net(dev) != &init_net)
3309 card = qeth_l3_get_card_from_dev(dev);
3312 QETH_CARD_TEXT(card, 3, "ipevent");
3314 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
3316 addr->u.a4.addr = be32_to_cpu(ifa->ifa_address);
3317 addr->u.a4.mask = be32_to_cpu(ifa->ifa_mask);
3318 addr->type = QETH_IP_TYPE_NORMAL;
3324 spin_lock_bh(&card->ip_lock);
3325 qeth_l3_add_ip(card, addr);
3326 spin_unlock_bh(&card->ip_lock);
3329 spin_lock_bh(&card->ip_lock);
3330 qeth_l3_delete_ip(card, addr);
3331 spin_unlock_bh(&card->ip_lock);
3339 static struct notifier_block qeth_l3_ip_notifier = {
3344 #ifdef CONFIG_QETH_IPV6
3346 * IPv6 event handler
3348 static int qeth_l3_ip6_event(struct notifier_block *this,
3349 unsigned long event, void *ptr)
3351 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
3352 struct net_device *dev = (struct net_device *)ifa->idev->dev;
3353 struct qeth_ipaddr *addr;
3354 struct qeth_card *card;
3356 card = qeth_l3_get_card_from_dev(dev);
3359 QETH_CARD_TEXT(card, 3, "ip6event");
3360 if (!qeth_is_supported(card, IPA_IPV6))
3363 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
3365 memcpy(&addr->u.a6.addr, &ifa->addr, sizeof(struct in6_addr));
3366 addr->u.a6.pfxlen = ifa->prefix_len;
3367 addr->type = QETH_IP_TYPE_NORMAL;
3373 spin_lock_bh(&card->ip_lock);
3374 qeth_l3_add_ip(card, addr);
3375 spin_unlock_bh(&card->ip_lock);
3378 spin_lock_bh(&card->ip_lock);
3379 qeth_l3_delete_ip(card, addr);
3380 spin_unlock_bh(&card->ip_lock);
3388 static struct notifier_block qeth_l3_ip6_notifier = {
3394 static int qeth_l3_register_notifiers(void)
3398 QETH_DBF_TEXT(SETUP, 5, "regnotif");
3399 rc = register_inetaddr_notifier(&qeth_l3_ip_notifier);
3402 #ifdef CONFIG_QETH_IPV6
3403 rc = register_inet6addr_notifier(&qeth_l3_ip6_notifier);
3405 unregister_inetaddr_notifier(&qeth_l3_ip_notifier);
3409 pr_warn("There is no IPv6 support for the layer 3 discipline\n");
3414 static void qeth_l3_unregister_notifiers(void)
3417 QETH_DBF_TEXT(SETUP, 5, "unregnot");
3418 WARN_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier));
3419 #ifdef CONFIG_QETH_IPV6
3420 WARN_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier));
3421 #endif /* QETH_IPV6 */
3424 static int __init qeth_l3_init(void)
3428 pr_info("register layer 3 discipline\n");
3429 rc = qeth_l3_register_notifiers();
3433 static void __exit qeth_l3_exit(void)
3435 qeth_l3_unregister_notifiers();
3436 pr_info("unregister layer 3 discipline\n");
3439 module_init(qeth_l3_init);
3440 module_exit(qeth_l3_exit);
3441 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
3442 MODULE_DESCRIPTION("qeth layer 3 discipline");
3443 MODULE_LICENSE("GPL");