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 struct qeth_ipaddr *qeth_l3_find_addr_by_ip(struct qeth_card *card,
153 struct qeth_ipaddr *query)
155 u64 key = qeth_l3_ipaddr_hash(query);
156 struct qeth_ipaddr *addr;
158 if (query->is_multicast) {
159 hash_for_each_possible(card->ip_mc_htable, addr, hnode, key)
160 if (qeth_l3_addr_match_ip(addr, query))
163 hash_for_each_possible(card->ip_htable, addr, hnode, key)
164 if (qeth_l3_addr_match_ip(addr, query))
170 static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
175 for (i = 0; i < len; ++i) {
177 for (j = 7; j >= 0; --j) {
178 bits[i*8 + j] = octet & 1;
184 static bool qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
185 struct qeth_ipaddr *addr)
187 struct qeth_ipato_entry *ipatoe;
188 u8 addr_bits[128] = {0, };
189 u8 ipatoe_bits[128] = {0, };
192 if (!card->ipato.enabled)
194 if (addr->type != QETH_IP_TYPE_NORMAL)
197 qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits,
198 (addr->proto == QETH_PROT_IPV4)? 4:16);
199 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
200 if (addr->proto != ipatoe->proto)
202 qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits,
203 (ipatoe->proto == QETH_PROT_IPV4) ?
205 if (addr->proto == QETH_PROT_IPV4)
206 rc = !memcmp(addr_bits, ipatoe_bits,
207 min(32, ipatoe->mask_bits));
209 rc = !memcmp(addr_bits, ipatoe_bits,
210 min(128, ipatoe->mask_bits));
215 if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
217 else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
223 int qeth_l3_delete_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
226 struct qeth_ipaddr *addr;
228 QETH_CARD_TEXT(card, 4, "delip");
230 if (tmp_addr->proto == QETH_PROT_IPV4)
231 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
233 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
234 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
237 addr = qeth_l3_find_addr_by_ip(card, tmp_addr);
238 if (!addr || !qeth_l3_addr_match_all(addr, tmp_addr))
242 if (addr->type == QETH_IP_TYPE_NORMAL && addr->ref_counter > 0)
244 if (addr->in_progress)
247 if (qeth_card_hw_is_reachable(card))
248 rc = qeth_l3_deregister_addr_entry(card, addr);
250 hash_del(&addr->hnode);
256 int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
259 struct qeth_ipaddr *addr;
262 QETH_CARD_TEXT(card, 4, "addip");
264 if (tmp_addr->proto == QETH_PROT_IPV4)
265 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
267 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
268 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
271 addr = qeth_l3_find_addr_by_ip(card, tmp_addr);
273 if (tmp_addr->type != QETH_IP_TYPE_NORMAL)
275 if (qeth_l3_addr_match_all(addr, tmp_addr)) {
279 qeth_l3_ipaddr_to_string(tmp_addr->proto, (u8 *)&tmp_addr->u,
281 dev_warn(&card->gdev->dev,
282 "Registering IP address %s failed\n", buf);
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 (qeth_l3_is_addr_covered_by_ipato(card, addr)) {
293 QETH_CARD_TEXT(card, 2, "tkovaddr");
294 addr->set_flags |= QETH_IPA_SETIP_TAKEOVER_FLAG;
296 hash_add(card->ip_htable, &addr->hnode,
297 qeth_l3_ipaddr_hash(addr));
299 if (!qeth_card_hw_is_reachable(card)) {
300 addr->disp_flag = QETH_DISP_ADDR_ADD;
304 /* qeth_l3_register_addr_entry can go to sleep
305 * if we add a IPV4 addr. It is caused by the reason
306 * that SETIP ipa cmd starts ARP staff for IPV4 addr.
307 * Thus we should unlock spinlock, and make a protection
308 * using in_progress variable to indicate that there is
309 * an hardware operation with this IPV4 address
311 if (addr->proto == QETH_PROT_IPV4) {
312 addr->in_progress = 1;
313 spin_unlock_bh(&card->ip_lock);
314 rc = qeth_l3_register_addr_entry(card, addr);
315 spin_lock_bh(&card->ip_lock);
316 addr->in_progress = 0;
318 rc = qeth_l3_register_addr_entry(card, addr);
320 if (!rc || (rc == IPA_RC_DUPLICATE_IP_ADDRESS) ||
321 (rc == IPA_RC_LAN_OFFLINE)) {
322 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
323 if (addr->ref_counter < 1) {
324 qeth_l3_deregister_addr_entry(card, addr);
325 hash_del(&addr->hnode);
329 hash_del(&addr->hnode);
337 struct qeth_ipaddr *qeth_l3_get_addr_buffer(
338 enum qeth_prot_versions prot)
340 struct qeth_ipaddr *addr;
342 addr = kzalloc(sizeof(struct qeth_ipaddr), GFP_ATOMIC);
346 addr->type = QETH_IP_TYPE_NORMAL;
347 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
353 static void qeth_l3_clear_ip_htable(struct qeth_card *card, int recover)
355 struct qeth_ipaddr *addr;
356 struct hlist_node *tmp;
359 QETH_CARD_TEXT(card, 4, "clearip");
361 spin_lock_bh(&card->ip_lock);
363 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
365 hash_del(&addr->hnode);
369 addr->disp_flag = QETH_DISP_ADDR_ADD;
372 spin_unlock_bh(&card->ip_lock);
374 spin_lock_bh(&card->mclock);
376 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
377 hash_del(&addr->hnode);
381 spin_unlock_bh(&card->mclock);
385 static void qeth_l3_recover_ip(struct qeth_card *card)
387 struct qeth_ipaddr *addr;
388 struct hlist_node *tmp;
392 QETH_CARD_TEXT(card, 4, "recovrip");
394 spin_lock_bh(&card->ip_lock);
396 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
397 if (addr->disp_flag == QETH_DISP_ADDR_ADD) {
398 if (addr->proto == QETH_PROT_IPV4) {
399 addr->in_progress = 1;
400 spin_unlock_bh(&card->ip_lock);
401 rc = qeth_l3_register_addr_entry(card, addr);
402 spin_lock_bh(&card->ip_lock);
403 addr->in_progress = 0;
405 rc = qeth_l3_register_addr_entry(card, addr);
408 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
409 if (addr->ref_counter < 1)
410 qeth_l3_delete_ip(card, addr);
412 hash_del(&addr->hnode);
418 spin_unlock_bh(&card->ip_lock);
422 static int qeth_l3_send_setdelmc(struct qeth_card *card,
423 struct qeth_ipaddr *addr, int ipacmd)
426 struct qeth_cmd_buffer *iob;
427 struct qeth_ipa_cmd *cmd;
429 QETH_CARD_TEXT(card, 4, "setdelmc");
431 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
434 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
435 memcpy(&cmd->data.setdelipm.mac, addr->mac, OSA_ADDR_LEN);
436 if (addr->proto == QETH_PROT_IPV6)
437 memcpy(cmd->data.setdelipm.ip6, &addr->u.a6.addr,
438 sizeof(struct in6_addr));
440 memcpy(&cmd->data.setdelipm.ip4, &addr->u.a4.addr, 4);
442 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
447 static void qeth_l3_fill_netmask(u8 *netmask, unsigned int len)
450 for (i = 0; i < 16; i++) {
455 netmask[i] = (u8)(0xFF00 >> j);
461 static int qeth_l3_send_setdelip(struct qeth_card *card,
462 struct qeth_ipaddr *addr, int ipacmd, unsigned int flags)
465 struct qeth_cmd_buffer *iob;
466 struct qeth_ipa_cmd *cmd;
469 QETH_CARD_TEXT(card, 4, "setdelip");
470 QETH_CARD_TEXT_(card, 4, "flags%02X", flags);
472 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
475 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
476 if (addr->proto == QETH_PROT_IPV6) {
477 memcpy(cmd->data.setdelip6.ip_addr, &addr->u.a6.addr,
478 sizeof(struct in6_addr));
479 qeth_l3_fill_netmask(netmask, addr->u.a6.pfxlen);
480 memcpy(cmd->data.setdelip6.mask, netmask,
481 sizeof(struct in6_addr));
482 cmd->data.setdelip6.flags = flags;
484 memcpy(cmd->data.setdelip4.ip_addr, &addr->u.a4.addr, 4);
485 memcpy(cmd->data.setdelip4.mask, &addr->u.a4.mask, 4);
486 cmd->data.setdelip4.flags = flags;
489 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
494 static int qeth_l3_send_setrouting(struct qeth_card *card,
495 enum qeth_routing_types type, enum qeth_prot_versions prot)
498 struct qeth_ipa_cmd *cmd;
499 struct qeth_cmd_buffer *iob;
501 QETH_CARD_TEXT(card, 4, "setroutg");
502 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETRTG, prot);
505 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
506 cmd->data.setrtg.type = (type);
507 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
512 static int qeth_l3_correct_routing_type(struct qeth_card *card,
513 enum qeth_routing_types *type, enum qeth_prot_versions prot)
515 if (card->info.type == QETH_CARD_TYPE_IQD) {
518 case PRIMARY_CONNECTOR:
519 case SECONDARY_CONNECTOR:
520 case MULTICAST_ROUTER:
529 case SECONDARY_ROUTER:
531 case MULTICAST_ROUTER:
532 if (qeth_is_ipafunc_supported(card, prot,
544 int qeth_l3_setrouting_v4(struct qeth_card *card)
548 QETH_CARD_TEXT(card, 3, "setrtg4");
550 rc = qeth_l3_correct_routing_type(card, &card->options.route4.type,
555 rc = qeth_l3_send_setrouting(card, card->options.route4.type,
558 card->options.route4.type = NO_ROUTER;
559 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
560 " on %s. Type set to 'no router'.\n", rc,
561 QETH_CARD_IFNAME(card));
566 int qeth_l3_setrouting_v6(struct qeth_card *card)
570 QETH_CARD_TEXT(card, 3, "setrtg6");
571 #ifdef CONFIG_QETH_IPV6
573 if (!qeth_is_supported(card, IPA_IPV6))
575 rc = qeth_l3_correct_routing_type(card, &card->options.route6.type,
580 rc = qeth_l3_send_setrouting(card, card->options.route6.type,
583 card->options.route6.type = NO_ROUTER;
584 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
585 " on %s. Type set to 'no router'.\n", rc,
586 QETH_CARD_IFNAME(card));
593 * IP address takeover related functions
597 * qeth_l3_update_ipato() - Update 'takeover' property, for all NORMAL IPs.
599 * Caller must hold ip_lock.
601 void qeth_l3_update_ipato(struct qeth_card *card)
603 struct qeth_ipaddr *addr;
606 hash_for_each(card->ip_htable, i, addr, hnode) {
607 if (addr->type != QETH_IP_TYPE_NORMAL)
609 if (qeth_l3_is_addr_covered_by_ipato(card, addr))
610 addr->set_flags |= QETH_IPA_SETIP_TAKEOVER_FLAG;
612 addr->set_flags &= ~QETH_IPA_SETIP_TAKEOVER_FLAG;
616 static void qeth_l3_clear_ipato_list(struct qeth_card *card)
618 struct qeth_ipato_entry *ipatoe, *tmp;
620 spin_lock_bh(&card->ip_lock);
622 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
623 list_del(&ipatoe->entry);
627 qeth_l3_update_ipato(card);
628 spin_unlock_bh(&card->ip_lock);
631 int qeth_l3_add_ipato_entry(struct qeth_card *card,
632 struct qeth_ipato_entry *new)
634 struct qeth_ipato_entry *ipatoe;
637 QETH_CARD_TEXT(card, 2, "addipato");
639 spin_lock_bh(&card->ip_lock);
641 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
642 if (ipatoe->proto != new->proto)
644 if (!memcmp(ipatoe->addr, new->addr,
645 (ipatoe->proto == QETH_PROT_IPV4)? 4:16) &&
646 (ipatoe->mask_bits == new->mask_bits)) {
653 list_add_tail(&new->entry, &card->ipato.entries);
654 qeth_l3_update_ipato(card);
657 spin_unlock_bh(&card->ip_lock);
662 void qeth_l3_del_ipato_entry(struct qeth_card *card,
663 enum qeth_prot_versions proto, u8 *addr, int mask_bits)
665 struct qeth_ipato_entry *ipatoe, *tmp;
667 QETH_CARD_TEXT(card, 2, "delipato");
669 spin_lock_bh(&card->ip_lock);
671 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
672 if (ipatoe->proto != proto)
674 if (!memcmp(ipatoe->addr, addr,
675 (proto == QETH_PROT_IPV4)? 4:16) &&
676 (ipatoe->mask_bits == mask_bits)) {
677 list_del(&ipatoe->entry);
678 qeth_l3_update_ipato(card);
683 spin_unlock_bh(&card->ip_lock);
687 * VIPA related functions
689 int qeth_l3_add_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
692 struct qeth_ipaddr *ipaddr;
695 ipaddr = qeth_l3_get_addr_buffer(proto);
697 if (proto == QETH_PROT_IPV4) {
698 QETH_CARD_TEXT(card, 2, "addvipa4");
699 memcpy(&ipaddr->u.a4.addr, addr, 4);
700 ipaddr->u.a4.mask = 0;
701 } else if (proto == QETH_PROT_IPV6) {
702 QETH_CARD_TEXT(card, 2, "addvipa6");
703 memcpy(&ipaddr->u.a6.addr, addr, 16);
704 ipaddr->u.a6.pfxlen = 0;
706 ipaddr->type = QETH_IP_TYPE_VIPA;
707 ipaddr->set_flags = QETH_IPA_SETIP_VIPA_FLAG;
708 ipaddr->del_flags = QETH_IPA_DELIP_VIPA_FLAG;
712 spin_lock_bh(&card->ip_lock);
713 rc = qeth_l3_add_ip(card, ipaddr);
714 spin_unlock_bh(&card->ip_lock);
721 void qeth_l3_del_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
724 struct qeth_ipaddr *ipaddr;
726 ipaddr = qeth_l3_get_addr_buffer(proto);
728 if (proto == QETH_PROT_IPV4) {
729 QETH_CARD_TEXT(card, 2, "delvipa4");
730 memcpy(&ipaddr->u.a4.addr, addr, 4);
731 ipaddr->u.a4.mask = 0;
732 } else if (proto == QETH_PROT_IPV6) {
733 QETH_CARD_TEXT(card, 2, "delvipa6");
734 memcpy(&ipaddr->u.a6.addr, addr, 16);
735 ipaddr->u.a6.pfxlen = 0;
737 ipaddr->type = QETH_IP_TYPE_VIPA;
741 spin_lock_bh(&card->ip_lock);
742 qeth_l3_delete_ip(card, ipaddr);
743 spin_unlock_bh(&card->ip_lock);
749 * proxy ARP related functions
751 int qeth_l3_add_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
754 struct qeth_ipaddr *ipaddr;
757 ipaddr = qeth_l3_get_addr_buffer(proto);
759 if (proto == QETH_PROT_IPV4) {
760 QETH_CARD_TEXT(card, 2, "addrxip4");
761 memcpy(&ipaddr->u.a4.addr, addr, 4);
762 ipaddr->u.a4.mask = 0;
763 } else if (proto == QETH_PROT_IPV6) {
764 QETH_CARD_TEXT(card, 2, "addrxip6");
765 memcpy(&ipaddr->u.a6.addr, addr, 16);
766 ipaddr->u.a6.pfxlen = 0;
769 ipaddr->type = QETH_IP_TYPE_RXIP;
770 ipaddr->set_flags = QETH_IPA_SETIP_TAKEOVER_FLAG;
771 ipaddr->del_flags = 0;
775 spin_lock_bh(&card->ip_lock);
776 rc = qeth_l3_add_ip(card, ipaddr);
777 spin_unlock_bh(&card->ip_lock);
784 void qeth_l3_del_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
787 struct qeth_ipaddr *ipaddr;
789 ipaddr = qeth_l3_get_addr_buffer(proto);
791 if (proto == QETH_PROT_IPV4) {
792 QETH_CARD_TEXT(card, 2, "delrxip4");
793 memcpy(&ipaddr->u.a4.addr, addr, 4);
794 ipaddr->u.a4.mask = 0;
795 } else if (proto == QETH_PROT_IPV6) {
796 QETH_CARD_TEXT(card, 2, "delrxip6");
797 memcpy(&ipaddr->u.a6.addr, addr, 16);
798 ipaddr->u.a6.pfxlen = 0;
800 ipaddr->type = QETH_IP_TYPE_RXIP;
804 spin_lock_bh(&card->ip_lock);
805 qeth_l3_delete_ip(card, ipaddr);
806 spin_unlock_bh(&card->ip_lock);
811 static int qeth_l3_register_addr_entry(struct qeth_card *card,
812 struct qeth_ipaddr *addr)
818 if (card->options.sniffer)
821 if (addr->proto == QETH_PROT_IPV4) {
822 QETH_CARD_TEXT(card, 2, "setaddr4");
823 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
824 } else if (addr->proto == QETH_PROT_IPV6) {
825 QETH_CARD_TEXT(card, 2, "setaddr6");
826 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
827 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
829 QETH_CARD_TEXT(card, 2, "setaddr?");
830 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
833 if (addr->is_multicast)
834 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
836 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP,
839 QETH_CARD_TEXT(card, 2, "failed");
840 } while ((--cnt > 0) && rc);
842 QETH_CARD_TEXT(card, 2, "FAILED");
843 qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
844 dev_warn(&card->gdev->dev,
845 "Registering IP address %s failed\n", buf);
850 static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
851 struct qeth_ipaddr *addr)
855 if (card->options.sniffer)
858 if (addr->proto == QETH_PROT_IPV4) {
859 QETH_CARD_TEXT(card, 2, "deladdr4");
860 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
861 } else if (addr->proto == QETH_PROT_IPV6) {
862 QETH_CARD_TEXT(card, 2, "deladdr6");
863 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
864 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
866 QETH_CARD_TEXT(card, 2, "deladdr?");
867 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
869 if (addr->is_multicast)
870 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
872 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP,
875 QETH_CARD_TEXT(card, 2, "failed");
880 static u8 qeth_l3_get_qeth_hdr_flags4(int cast_type)
882 if (cast_type == RTN_MULTICAST)
883 return QETH_CAST_MULTICAST;
884 if (cast_type == RTN_BROADCAST)
885 return QETH_CAST_BROADCAST;
886 return QETH_CAST_UNICAST;
889 static u8 qeth_l3_get_qeth_hdr_flags6(int cast_type)
891 u8 ct = QETH_HDR_PASSTHRU | QETH_HDR_IPV6;
892 if (cast_type == RTN_MULTICAST)
893 return ct | QETH_CAST_MULTICAST;
894 if (cast_type == RTN_ANYCAST)
895 return ct | QETH_CAST_ANYCAST;
896 if (cast_type == RTN_BROADCAST)
897 return ct | QETH_CAST_BROADCAST;
898 return ct | QETH_CAST_UNICAST;
901 static int qeth_l3_setadapter_parms(struct qeth_card *card)
905 QETH_DBF_TEXT(SETUP, 2, "setadprm");
907 if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
908 rc = qeth_setadpparms_change_macaddr(card);
910 dev_warn(&card->gdev->dev, "Reading the adapter MAC"
911 " address failed\n");
917 #ifdef CONFIG_QETH_IPV6
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);
935 static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
939 QETH_CARD_TEXT(card, 3, "ipaarp");
941 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
942 dev_info(&card->gdev->dev,
943 "ARP processing not supported on %s!\n",
944 QETH_CARD_IFNAME(card));
947 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
948 IPA_CMD_ASS_START, 0);
950 dev_warn(&card->gdev->dev,
951 "Starting ARP processing support for %s failed\n",
952 QETH_CARD_IFNAME(card));
957 static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
961 QETH_CARD_TEXT(card, 3, "stsrcmac");
963 if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
964 dev_info(&card->gdev->dev,
965 "Inbound source MAC-address not supported on %s\n",
966 QETH_CARD_IFNAME(card));
970 rc = qeth_send_simple_setassparms(card, IPA_SOURCE_MAC,
971 IPA_CMD_ASS_START, 0);
973 dev_warn(&card->gdev->dev,
974 "Starting source MAC-address support for %s failed\n",
975 QETH_CARD_IFNAME(card));
979 static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
983 QETH_CARD_TEXT(card, 3, "strtvlan");
985 if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
986 dev_info(&card->gdev->dev,
987 "VLAN not supported on %s\n", QETH_CARD_IFNAME(card));
991 rc = qeth_send_simple_setassparms(card, IPA_VLAN_PRIO,
992 IPA_CMD_ASS_START, 0);
994 dev_warn(&card->gdev->dev,
995 "Starting VLAN support for %s failed\n",
996 QETH_CARD_IFNAME(card));
998 dev_info(&card->gdev->dev, "VLAN enabled\n");
1003 static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
1007 QETH_CARD_TEXT(card, 3, "stmcast");
1009 if (!qeth_is_supported(card, IPA_MULTICASTING)) {
1010 dev_info(&card->gdev->dev,
1011 "Multicast not supported on %s\n",
1012 QETH_CARD_IFNAME(card));
1016 rc = qeth_send_simple_setassparms(card, IPA_MULTICASTING,
1017 IPA_CMD_ASS_START, 0);
1019 dev_warn(&card->gdev->dev,
1020 "Starting multicast support for %s failed\n",
1021 QETH_CARD_IFNAME(card));
1023 dev_info(&card->gdev->dev, "Multicast enabled\n");
1024 card->dev->flags |= IFF_MULTICAST;
1029 #ifdef CONFIG_QETH_IPV6
1030 static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
1034 QETH_CARD_TEXT(card, 3, "softipv6");
1036 rc = qeth_query_ipassists(card, QETH_PROT_IPV6);
1038 dev_err(&card->gdev->dev,
1039 "Activating IPv6 support for %s failed\n",
1040 QETH_CARD_IFNAME(card));
1044 if (card->info.type == QETH_CARD_TYPE_IQD)
1047 rc = qeth_send_simple_setassparms(card, IPA_IPV6,
1048 IPA_CMD_ASS_START, 3);
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_IPV6,
1058 dev_err(&card->gdev->dev,
1059 "Activating IPv6 support for %s failed\n",
1060 QETH_CARD_IFNAME(card));
1063 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_PASSTHRU,
1066 dev_warn(&card->gdev->dev,
1067 "Enabling the passthrough mode for %s failed\n",
1068 QETH_CARD_IFNAME(card));
1072 dev_info(&card->gdev->dev, "IPV6 enabled\n");
1077 static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
1081 QETH_CARD_TEXT(card, 3, "strtipv6");
1083 if (!qeth_is_supported(card, IPA_IPV6)) {
1084 dev_info(&card->gdev->dev,
1085 "IPv6 not supported on %s\n", QETH_CARD_IFNAME(card));
1088 #ifdef CONFIG_QETH_IPV6
1089 rc = qeth_l3_softsetup_ipv6(card);
1094 static int qeth_l3_start_ipa_broadcast(struct qeth_card *card)
1098 QETH_CARD_TEXT(card, 3, "stbrdcst");
1099 card->info.broadcast_capable = 0;
1100 if (!qeth_is_supported(card, IPA_FILTERING)) {
1101 dev_info(&card->gdev->dev,
1102 "Broadcast not supported on %s\n",
1103 QETH_CARD_IFNAME(card));
1107 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
1108 IPA_CMD_ASS_START, 0);
1110 dev_warn(&card->gdev->dev, "Enabling broadcast filtering for "
1111 "%s failed\n", QETH_CARD_IFNAME(card));
1115 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
1116 IPA_CMD_ASS_CONFIGURE, 1);
1118 dev_warn(&card->gdev->dev,
1119 "Setting up broadcast filtering for %s failed\n",
1120 QETH_CARD_IFNAME(card));
1123 card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
1124 dev_info(&card->gdev->dev, "Broadcast enabled\n");
1125 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
1126 IPA_CMD_ASS_ENABLE, 1);
1128 dev_warn(&card->gdev->dev, "Setting up broadcast echo "
1129 "filtering for %s failed\n", QETH_CARD_IFNAME(card));
1132 card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
1134 if (card->info.broadcast_capable)
1135 card->dev->flags |= IFF_BROADCAST;
1137 card->dev->flags &= ~IFF_BROADCAST;
1141 static int qeth_l3_start_ipassists(struct qeth_card *card)
1143 QETH_CARD_TEXT(card, 3, "strtipas");
1145 if (qeth_set_access_ctrl_online(card, 0))
1147 qeth_l3_start_ipa_arp_processing(card); /* go on*/
1148 qeth_l3_start_ipa_source_mac(card); /* go on*/
1149 qeth_l3_start_ipa_vlan(card); /* go on*/
1150 qeth_l3_start_ipa_multicast(card); /* go on*/
1151 qeth_l3_start_ipa_ipv6(card); /* go on*/
1152 qeth_l3_start_ipa_broadcast(card); /* go on*/
1156 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
1157 struct qeth_reply *reply, unsigned long data)
1159 struct qeth_ipa_cmd *cmd;
1161 cmd = (struct qeth_ipa_cmd *) data;
1162 if (cmd->hdr.return_code == 0)
1163 memcpy(card->dev->dev_addr,
1164 cmd->data.create_destroy_addr.unique_id, ETH_ALEN);
1166 eth_random_addr(card->dev->dev_addr);
1171 static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card)
1174 struct qeth_cmd_buffer *iob;
1175 struct qeth_ipa_cmd *cmd;
1177 QETH_DBF_TEXT(SETUP, 2, "hsrmac");
1179 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
1183 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1184 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1185 card->info.unique_id;
1187 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb,
1192 static int qeth_l3_get_unique_id_cb(struct qeth_card *card,
1193 struct qeth_reply *reply, unsigned long data)
1195 struct qeth_ipa_cmd *cmd;
1197 cmd = (struct qeth_ipa_cmd *) data;
1198 if (cmd->hdr.return_code == 0)
1199 card->info.unique_id = *((__u16 *)
1200 &cmd->data.create_destroy_addr.unique_id[6]);
1202 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1203 UNIQUE_ID_NOT_BY_CARD;
1204 dev_warn(&card->gdev->dev, "The network adapter failed to "
1205 "generate a unique ID\n");
1210 static int qeth_l3_get_unique_id(struct qeth_card *card)
1213 struct qeth_cmd_buffer *iob;
1214 struct qeth_ipa_cmd *cmd;
1216 QETH_DBF_TEXT(SETUP, 2, "guniqeid");
1218 if (!qeth_is_supported(card, IPA_IPV6)) {
1219 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1220 UNIQUE_ID_NOT_BY_CARD;
1224 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
1228 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1229 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1230 card->info.unique_id;
1232 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_get_unique_id_cb, NULL);
1237 qeth_diags_trace_cb(struct qeth_card *card, struct qeth_reply *reply,
1240 struct qeth_ipa_cmd *cmd;
1243 QETH_DBF_TEXT(SETUP, 2, "diastrcb");
1245 cmd = (struct qeth_ipa_cmd *)data;
1246 rc = cmd->hdr.return_code;
1248 QETH_CARD_TEXT_(card, 2, "dxter%x", rc);
1249 switch (cmd->data.diagass.action) {
1250 case QETH_DIAGS_CMD_TRACE_QUERY:
1252 case QETH_DIAGS_CMD_TRACE_DISABLE:
1255 case IPA_RC_INVALID_SUBCMD:
1256 card->info.promisc_mode = SET_PROMISC_MODE_OFF;
1257 dev_info(&card->gdev->dev, "The HiperSockets network "
1258 "traffic analyzer is deactivated\n");
1264 case QETH_DIAGS_CMD_TRACE_ENABLE:
1267 card->info.promisc_mode = SET_PROMISC_MODE_ON;
1268 dev_info(&card->gdev->dev, "The HiperSockets network "
1269 "traffic analyzer is activated\n");
1271 case IPA_RC_HARDWARE_AUTH_ERROR:
1272 dev_warn(&card->gdev->dev, "The device is not "
1273 "authorized to run as a HiperSockets network "
1274 "traffic analyzer\n");
1276 case IPA_RC_TRACE_ALREADY_ACTIVE:
1277 dev_warn(&card->gdev->dev, "A HiperSockets "
1278 "network traffic analyzer is already "
1279 "active in the HiperSockets LAN\n");
1286 QETH_DBF_MESSAGE(2, "Unknown sniffer action (0x%04x) on %s\n",
1287 cmd->data.diagass.action, QETH_CARD_IFNAME(card));
1294 qeth_diags_trace(struct qeth_card *card, enum qeth_diags_trace_cmds diags_cmd)
1296 struct qeth_cmd_buffer *iob;
1297 struct qeth_ipa_cmd *cmd;
1299 QETH_DBF_TEXT(SETUP, 2, "diagtrac");
1301 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SET_DIAG_ASS, 0);
1304 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1305 cmd->data.diagass.subcmd_len = 16;
1306 cmd->data.diagass.subcmd = QETH_DIAGS_CMD_TRACE;
1307 cmd->data.diagass.type = QETH_DIAGS_TYPE_HIPERSOCKET;
1308 cmd->data.diagass.action = diags_cmd;
1309 return qeth_send_ipa_cmd(card, iob, qeth_diags_trace_cb, NULL);
1312 static void qeth_l3_get_mac_for_ipm(__be32 ipm, char *mac)
1314 ip_eth_mc_map(ipm, mac);
1317 static void qeth_l3_mark_all_mc_to_be_deleted(struct qeth_card *card)
1319 struct qeth_ipaddr *addr;
1322 hash_for_each(card->ip_mc_htable, i, addr, hnode)
1323 addr->disp_flag = QETH_DISP_ADDR_DELETE;
1327 static void qeth_l3_add_all_new_mc(struct qeth_card *card)
1329 struct qeth_ipaddr *addr;
1330 struct hlist_node *tmp;
1334 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
1335 if (addr->disp_flag == QETH_DISP_ADDR_ADD) {
1336 rc = qeth_l3_register_addr_entry(card, addr);
1337 if (!rc || (rc == IPA_RC_LAN_OFFLINE))
1338 addr->ref_counter = 1;
1340 hash_del(&addr->hnode);
1348 static void qeth_l3_delete_nonused_mc(struct qeth_card *card)
1350 struct qeth_ipaddr *addr;
1351 struct hlist_node *tmp;
1355 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
1356 if (addr->disp_flag == QETH_DISP_ADDR_DELETE) {
1357 rc = qeth_l3_deregister_addr_entry(card, addr);
1358 if (!rc || (rc == IPA_RC_MC_ADDR_NOT_FOUND)) {
1359 hash_del(&addr->hnode);
1369 qeth_l3_add_mc_to_hash(struct qeth_card *card, struct in_device *in4_dev)
1371 struct ip_mc_list *im4;
1372 struct qeth_ipaddr *tmp, *ipm;
1373 char buf[MAX_ADDR_LEN];
1375 QETH_CARD_TEXT(card, 4, "addmc");
1377 tmp = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1381 for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
1382 im4 = rcu_dereference(im4->next_rcu)) {
1383 qeth_l3_get_mac_for_ipm(im4->multiaddr, buf);
1385 tmp->u.a4.addr = be32_to_cpu(im4->multiaddr);
1386 memcpy(tmp->mac, buf, sizeof(tmp->mac));
1387 tmp->is_multicast = 1;
1389 ipm = qeth_l3_find_addr_by_ip(card, tmp);
1391 /* for mcast, by-IP match means full match */
1392 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1394 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1397 memcpy(ipm->mac, buf, sizeof(tmp->mac));
1398 ipm->u.a4.addr = be32_to_cpu(im4->multiaddr);
1399 ipm->is_multicast = 1;
1400 ipm->disp_flag = QETH_DISP_ADDR_ADD;
1401 hash_add(card->ip_mc_htable,
1402 &ipm->hnode, qeth_l3_ipaddr_hash(ipm));
1409 /* called with rcu_read_lock */
1410 static void qeth_l3_add_vlan_mc(struct qeth_card *card)
1412 struct in_device *in_dev;
1415 QETH_CARD_TEXT(card, 4, "addmcvl");
1417 if (!qeth_is_supported(card, IPA_FULL_VLAN))
1420 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1421 struct net_device *netdev;
1423 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1425 if (netdev == NULL ||
1426 !(netdev->flags & IFF_UP))
1428 in_dev = __in_dev_get_rcu(netdev);
1431 qeth_l3_add_mc_to_hash(card, in_dev);
1435 static void qeth_l3_add_multicast_ipv4(struct qeth_card *card)
1437 struct in_device *in4_dev;
1439 QETH_CARD_TEXT(card, 4, "chkmcv4");
1442 in4_dev = __in_dev_get_rcu(card->dev);
1443 if (in4_dev == NULL)
1445 qeth_l3_add_mc_to_hash(card, in4_dev);
1446 qeth_l3_add_vlan_mc(card);
1451 #ifdef CONFIG_QETH_IPV6
1453 qeth_l3_add_mc6_to_hash(struct qeth_card *card, struct inet6_dev *in6_dev)
1455 struct qeth_ipaddr *ipm;
1456 struct ifmcaddr6 *im6;
1457 struct qeth_ipaddr *tmp;
1458 char buf[MAX_ADDR_LEN];
1460 QETH_CARD_TEXT(card, 4, "addmc6");
1462 tmp = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1466 for (im6 = in6_dev->mc_list; im6 != NULL; im6 = im6->next) {
1467 ndisc_mc_map(&im6->mca_addr, buf, in6_dev->dev, 0);
1469 memcpy(tmp->mac, buf, sizeof(tmp->mac));
1470 memcpy(&tmp->u.a6.addr, &im6->mca_addr.s6_addr,
1471 sizeof(struct in6_addr));
1472 tmp->is_multicast = 1;
1474 ipm = qeth_l3_find_addr_by_ip(card, tmp);
1476 /* for mcast, by-IP match means full match */
1477 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1481 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1485 memcpy(ipm->mac, buf, OSA_ADDR_LEN);
1486 memcpy(&ipm->u.a6.addr, &im6->mca_addr.s6_addr,
1487 sizeof(struct in6_addr));
1488 ipm->is_multicast = 1;
1489 ipm->disp_flag = QETH_DISP_ADDR_ADD;
1490 hash_add(card->ip_mc_htable,
1491 &ipm->hnode, qeth_l3_ipaddr_hash(ipm));
1497 /* called with rcu_read_lock */
1498 static void qeth_l3_add_vlan_mc6(struct qeth_card *card)
1500 struct inet6_dev *in_dev;
1503 QETH_CARD_TEXT(card, 4, "admc6vl");
1505 if (!qeth_is_supported(card, IPA_FULL_VLAN))
1508 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1509 struct net_device *netdev;
1511 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1513 if (netdev == NULL ||
1514 !(netdev->flags & IFF_UP))
1516 in_dev = in6_dev_get(netdev);
1519 read_lock_bh(&in_dev->lock);
1520 qeth_l3_add_mc6_to_hash(card, in_dev);
1521 read_unlock_bh(&in_dev->lock);
1522 in6_dev_put(in_dev);
1526 static void qeth_l3_add_multicast_ipv6(struct qeth_card *card)
1528 struct inet6_dev *in6_dev;
1530 QETH_CARD_TEXT(card, 4, "chkmcv6");
1532 if (!qeth_is_supported(card, IPA_IPV6))
1534 in6_dev = in6_dev_get(card->dev);
1539 read_lock_bh(&in6_dev->lock);
1540 qeth_l3_add_mc6_to_hash(card, in6_dev);
1541 qeth_l3_add_vlan_mc6(card);
1542 read_unlock_bh(&in6_dev->lock);
1544 in6_dev_put(in6_dev);
1546 #endif /* CONFIG_QETH_IPV6 */
1548 static void qeth_l3_free_vlan_addresses4(struct qeth_card *card,
1551 struct in_device *in_dev;
1552 struct in_ifaddr *ifa;
1553 struct qeth_ipaddr *addr;
1554 struct net_device *netdev;
1556 QETH_CARD_TEXT(card, 4, "frvaddr4");
1558 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q), vid);
1561 in_dev = in_dev_get(netdev);
1565 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1569 spin_lock_bh(&card->ip_lock);
1571 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1572 addr->u.a4.addr = be32_to_cpu(ifa->ifa_address);
1573 addr->u.a4.mask = be32_to_cpu(ifa->ifa_mask);
1574 addr->type = QETH_IP_TYPE_NORMAL;
1575 qeth_l3_delete_ip(card, addr);
1578 spin_unlock_bh(&card->ip_lock);
1585 static void qeth_l3_free_vlan_addresses6(struct qeth_card *card,
1588 #ifdef CONFIG_QETH_IPV6
1589 struct inet6_dev *in6_dev;
1590 struct inet6_ifaddr *ifa;
1591 struct qeth_ipaddr *addr;
1592 struct net_device *netdev;
1594 QETH_CARD_TEXT(card, 4, "frvaddr6");
1596 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q), vid);
1600 in6_dev = in6_dev_get(netdev);
1604 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1608 spin_lock_bh(&card->ip_lock);
1610 list_for_each_entry(ifa, &in6_dev->addr_list, if_list) {
1611 memcpy(&addr->u.a6.addr, &ifa->addr,
1612 sizeof(struct in6_addr));
1613 addr->u.a6.pfxlen = ifa->prefix_len;
1614 addr->type = QETH_IP_TYPE_NORMAL;
1615 qeth_l3_delete_ip(card, addr);
1618 spin_unlock_bh(&card->ip_lock);
1622 in6_dev_put(in6_dev);
1623 #endif /* CONFIG_QETH_IPV6 */
1626 static void qeth_l3_free_vlan_addresses(struct qeth_card *card,
1630 qeth_l3_free_vlan_addresses4(card, vid);
1631 qeth_l3_free_vlan_addresses6(card, vid);
1635 static int qeth_l3_vlan_rx_add_vid(struct net_device *dev,
1636 __be16 proto, u16 vid)
1638 struct qeth_card *card = dev->ml_priv;
1640 set_bit(vid, card->active_vlans);
1644 static int qeth_l3_vlan_rx_kill_vid(struct net_device *dev,
1645 __be16 proto, u16 vid)
1647 struct qeth_card *card = dev->ml_priv;
1649 QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
1651 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
1652 QETH_CARD_TEXT(card, 3, "kidREC");
1655 /* unregister IP addresses of vlan device */
1656 qeth_l3_free_vlan_addresses(card, vid);
1657 clear_bit(vid, card->active_vlans);
1658 qeth_l3_set_multicast_list(card->dev);
1662 static int qeth_l3_rebuild_skb(struct qeth_card *card, struct sk_buff *skb,
1663 struct qeth_hdr *hdr, unsigned short *vlan_id)
1666 struct iphdr *ip_hdr;
1667 unsigned char tg_addr[MAX_ADDR_LEN];
1670 if (!(hdr->hdr.l3.flags & QETH_HDR_PASSTHRU)) {
1671 prot = (hdr->hdr.l3.flags & QETH_HDR_IPV6) ? ETH_P_IPV6 :
1673 switch (hdr->hdr.l3.flags & QETH_HDR_CAST_MASK) {
1674 case QETH_CAST_MULTICAST:
1676 #ifdef CONFIG_QETH_IPV6
1678 ndisc_mc_map((struct in6_addr *)
1680 tg_addr, card->dev, 0);
1684 ip_hdr = (struct iphdr *)skb->data;
1685 ip_eth_mc_map(ip_hdr->daddr, tg_addr);
1688 memcpy(tg_addr, card->dev->broadcast,
1689 card->dev->addr_len);
1691 card->stats.multicast++;
1692 skb->pkt_type = PACKET_MULTICAST;
1694 case QETH_CAST_BROADCAST:
1695 memcpy(tg_addr, card->dev->broadcast,
1696 card->dev->addr_len);
1697 card->stats.multicast++;
1698 skb->pkt_type = PACKET_BROADCAST;
1700 case QETH_CAST_UNICAST:
1701 case QETH_CAST_ANYCAST:
1702 case QETH_CAST_NOCAST:
1704 if (card->options.sniffer)
1705 skb->pkt_type = PACKET_OTHERHOST;
1707 skb->pkt_type = PACKET_HOST;
1708 memcpy(tg_addr, card->dev->dev_addr,
1709 card->dev->addr_len);
1711 if (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_SRC_MAC_ADDR)
1712 card->dev->header_ops->create(skb, card->dev, prot,
1713 tg_addr, &hdr->hdr.l3.dest_addr[2],
1714 card->dev->addr_len);
1716 card->dev->header_ops->create(skb, card->dev, prot,
1717 tg_addr, "FAKELL", card->dev->addr_len);
1720 skb->protocol = eth_type_trans(skb, card->dev);
1722 if (hdr->hdr.l3.ext_flags &
1723 (QETH_HDR_EXT_VLAN_FRAME | QETH_HDR_EXT_INCLUDE_VLAN_TAG)) {
1724 *vlan_id = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME) ?
1725 hdr->hdr.l3.vlan_id : *((u16 *)&hdr->hdr.l3.dest_addr[12]);
1729 if (card->dev->features & NETIF_F_RXCSUM) {
1730 if ((hdr->hdr.l3.ext_flags &
1731 (QETH_HDR_EXT_CSUM_HDR_REQ |
1732 QETH_HDR_EXT_CSUM_TRANSP_REQ)) ==
1733 (QETH_HDR_EXT_CSUM_HDR_REQ |
1734 QETH_HDR_EXT_CSUM_TRANSP_REQ))
1735 skb->ip_summed = CHECKSUM_UNNECESSARY;
1737 skb->ip_summed = CHECKSUM_NONE;
1739 skb->ip_summed = CHECKSUM_NONE;
1743 static int qeth_l3_process_inbound_buffer(struct qeth_card *card,
1744 int budget, int *done)
1747 struct sk_buff *skb;
1748 struct qeth_hdr *hdr;
1755 WARN_ON_ONCE(!budget);
1757 skb = qeth_core_get_next_skb(card,
1758 &card->qdio.in_q->bufs[card->rx.b_index],
1759 &card->rx.b_element, &card->rx.e_offset, &hdr);
1764 skb->dev = card->dev;
1765 switch (hdr->hdr.l3.id) {
1766 case QETH_HEADER_TYPE_LAYER3:
1767 magic = *(__u16 *)skb->data;
1768 if ((card->info.type == QETH_CARD_TYPE_IQD) &&
1769 (magic == ETH_P_AF_IUCV)) {
1770 skb->protocol = cpu_to_be16(ETH_P_AF_IUCV);
1771 skb->pkt_type = PACKET_HOST;
1772 skb->mac_header = NET_SKB_PAD;
1773 skb->dev = card->dev;
1775 card->dev->header_ops->create(skb, card->dev, 0,
1776 card->dev->dev_addr, "FAKELL",
1777 card->dev->addr_len);
1778 netif_receive_skb(skb);
1780 is_vlan = qeth_l3_rebuild_skb(card, skb, hdr,
1783 if (is_vlan && !card->options.sniffer)
1784 __vlan_hwaccel_put_tag(skb,
1785 htons(ETH_P_8021Q), vlan_tag);
1786 napi_gro_receive(&card->napi, skb);
1789 case QETH_HEADER_TYPE_LAYER2: /* for HiperSockets sniffer */
1790 skb->pkt_type = PACKET_HOST;
1791 skb->protocol = eth_type_trans(skb, skb->dev);
1793 netif_receive_skb(skb);
1796 dev_kfree_skb_any(skb);
1797 QETH_CARD_TEXT(card, 3, "inbunkno");
1798 QETH_DBF_HEX(CTRL, 3, hdr, sizeof(*hdr));
1803 card->stats.rx_packets++;
1804 card->stats.rx_bytes += len;
1809 static int qeth_l3_verify_vlan_dev(struct net_device *dev,
1810 struct qeth_card *card)
1815 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1816 struct net_device *netdev;
1819 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1822 if (netdev == dev) {
1823 rc = QETH_VLAN_CARD;
1828 if (rc && !(vlan_dev_real_dev(dev)->ml_priv == (void *)card))
1834 static int qeth_l3_verify_dev(struct net_device *dev)
1836 struct qeth_card *card;
1838 unsigned long flags;
1840 read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
1841 list_for_each_entry(card, &qeth_core_card_list.list, list) {
1842 if (card->dev == dev) {
1843 rc = QETH_REAL_CARD;
1846 rc = qeth_l3_verify_vlan_dev(dev, card);
1850 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
1855 static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev)
1857 struct qeth_card *card = NULL;
1860 rc = qeth_l3_verify_dev(dev);
1861 if (rc == QETH_REAL_CARD)
1862 card = dev->ml_priv;
1863 else if (rc == QETH_VLAN_CARD)
1864 card = vlan_dev_real_dev(dev)->ml_priv;
1865 if (card && card->options.layer2)
1868 QETH_CARD_TEXT_(card, 4, "%d", rc);
1872 static void qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
1874 QETH_DBF_TEXT(SETUP, 2, "stopcard");
1875 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
1877 qeth_set_allowed_threads(card, 0, 1);
1878 if (card->options.sniffer &&
1879 (card->info.promisc_mode == SET_PROMISC_MODE_ON))
1880 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1881 if (card->read.state == CH_STATE_UP &&
1882 card->write.state == CH_STATE_UP &&
1883 (card->state == CARD_STATE_UP)) {
1885 qeth_l3_stop(card->dev);
1888 dev_close(card->dev);
1891 card->state = CARD_STATE_SOFTSETUP;
1893 if (card->state == CARD_STATE_SOFTSETUP) {
1894 qeth_l3_clear_ip_htable(card, 1);
1895 qeth_clear_ipacmd_list(card);
1896 card->state = CARD_STATE_HARDSETUP;
1898 if (card->state == CARD_STATE_HARDSETUP) {
1899 qeth_qdio_clear_card(card, 0);
1900 qeth_clear_qdio_buffers(card);
1901 qeth_clear_working_pool_list(card);
1902 card->state = CARD_STATE_DOWN;
1904 if (card->state == CARD_STATE_DOWN) {
1905 qeth_clear_cmd_buffers(&card->read);
1906 qeth_clear_cmd_buffers(&card->write);
1911 * test for and Switch promiscuous mode (on or off)
1912 * either for guestlan or HiperSocket Sniffer
1915 qeth_l3_handle_promisc_mode(struct qeth_card *card)
1917 struct net_device *dev = card->dev;
1919 if (((dev->flags & IFF_PROMISC) &&
1920 (card->info.promisc_mode == SET_PROMISC_MODE_ON)) ||
1921 (!(dev->flags & IFF_PROMISC) &&
1922 (card->info.promisc_mode == SET_PROMISC_MODE_OFF)))
1925 if (card->info.guestlan) { /* Guestlan trace */
1926 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
1927 qeth_setadp_promisc_mode(card);
1928 } else if (card->options.sniffer && /* HiperSockets trace */
1929 qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) {
1930 if (dev->flags & IFF_PROMISC) {
1931 QETH_CARD_TEXT(card, 3, "+promisc");
1932 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE);
1934 QETH_CARD_TEXT(card, 3, "-promisc");
1935 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1940 static void qeth_l3_set_multicast_list(struct net_device *dev)
1942 struct qeth_card *card = dev->ml_priv;
1944 QETH_CARD_TEXT(card, 3, "setmulti");
1945 if (qeth_threads_running(card, QETH_RECOVER_THREAD) &&
1946 (card->state != CARD_STATE_UP))
1948 if (!card->options.sniffer) {
1950 spin_lock_bh(&card->mclock);
1952 qeth_l3_mark_all_mc_to_be_deleted(card);
1954 qeth_l3_add_multicast_ipv4(card);
1955 #ifdef CONFIG_QETH_IPV6
1956 qeth_l3_add_multicast_ipv6(card);
1958 qeth_l3_delete_nonused_mc(card);
1959 qeth_l3_add_all_new_mc(card);
1961 spin_unlock_bh(&card->mclock);
1963 if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
1966 qeth_l3_handle_promisc_mode(card);
1969 static const char *qeth_l3_arp_get_error_cause(int *rc)
1972 case QETH_IPA_ARP_RC_FAILED:
1974 return "operation failed";
1975 case QETH_IPA_ARP_RC_NOTSUPP:
1977 return "operation not supported";
1978 case QETH_IPA_ARP_RC_OUT_OF_RANGE:
1980 return "argument out of range";
1981 case QETH_IPA_ARP_RC_Q_NOTSUPP:
1983 return "query operation not supported";
1984 case QETH_IPA_ARP_RC_Q_NO_DATA:
1986 return "no query data available";
1988 return "unknown error";
1992 static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
1997 QETH_CARD_TEXT(card, 3, "arpstnoe");
2000 * currently GuestLAN only supports the ARP assist function
2001 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
2002 * thus we say EOPNOTSUPP for this ARP function
2004 if (card->info.guestlan)
2006 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2009 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2010 IPA_CMD_ASS_ARP_SET_NO_ENTRIES,
2014 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on "
2015 "%s: %s (0x%x/%d)\n", QETH_CARD_IFNAME(card),
2016 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2021 static __u32 get_arp_entry_size(struct qeth_card *card,
2022 struct qeth_arp_query_data *qdata,
2023 struct qeth_arp_entrytype *type, __u8 strip_entries)
2028 is_hsi = qdata->reply_bits == 5;
2029 if (type->ip == QETHARP_IP_ADDR_V4) {
2030 QETH_CARD_TEXT(card, 4, "arpev4");
2031 if (strip_entries) {
2032 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5_short) :
2033 sizeof(struct qeth_arp_qi_entry7_short);
2035 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5) :
2036 sizeof(struct qeth_arp_qi_entry7);
2038 } else if (type->ip == QETHARP_IP_ADDR_V6) {
2039 QETH_CARD_TEXT(card, 4, "arpev6");
2040 if (strip_entries) {
2042 sizeof(struct qeth_arp_qi_entry5_short_ipv6) :
2043 sizeof(struct qeth_arp_qi_entry7_short_ipv6);
2046 sizeof(struct qeth_arp_qi_entry5_ipv6) :
2047 sizeof(struct qeth_arp_qi_entry7_ipv6);
2050 QETH_CARD_TEXT(card, 4, "arpinv");
2057 static int arpentry_matches_prot(struct qeth_arp_entrytype *type, __u16 prot)
2059 return (type->ip == QETHARP_IP_ADDR_V4 && prot == QETH_PROT_IPV4) ||
2060 (type->ip == QETHARP_IP_ADDR_V6 && prot == QETH_PROT_IPV6);
2063 static int qeth_l3_arp_query_cb(struct qeth_card *card,
2064 struct qeth_reply *reply, unsigned long data)
2066 struct qeth_ipa_cmd *cmd;
2067 struct qeth_arp_query_data *qdata;
2068 struct qeth_arp_query_info *qinfo;
2071 int entrybytes_done;
2073 __u8 do_strip_entries;
2075 QETH_CARD_TEXT(card, 3, "arpquecb");
2077 qinfo = (struct qeth_arp_query_info *) reply->param;
2078 cmd = (struct qeth_ipa_cmd *) data;
2079 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.prot_version);
2080 if (cmd->hdr.return_code) {
2081 QETH_CARD_TEXT(card, 4, "arpcberr");
2082 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
2085 if (cmd->data.setassparms.hdr.return_code) {
2086 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
2087 QETH_CARD_TEXT(card, 4, "setaperr");
2088 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
2091 qdata = &cmd->data.setassparms.data.query_arp;
2092 QETH_CARD_TEXT_(card, 4, "anoen%i", qdata->no_entries);
2094 do_strip_entries = (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) > 0;
2095 stripped_bytes = do_strip_entries ? QETH_QARP_MEDIASPECIFIC_BYTES : 0;
2096 entrybytes_done = 0;
2097 for (e = 0; e < qdata->no_entries; ++e) {
2100 struct qeth_arp_entrytype *etype;
2102 cur_entry = &qdata->data + entrybytes_done;
2103 etype = &((struct qeth_arp_qi_entry5 *) cur_entry)->type;
2104 if (!arpentry_matches_prot(etype, cmd->hdr.prot_version)) {
2105 QETH_CARD_TEXT(card, 4, "pmis");
2106 QETH_CARD_TEXT_(card, 4, "%i", etype->ip);
2109 esize = get_arp_entry_size(card, qdata, etype,
2111 QETH_CARD_TEXT_(card, 5, "esz%i", esize);
2115 if ((qinfo->udata_len - qinfo->udata_offset) < esize) {
2116 QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOMEM);
2117 cmd->hdr.return_code = IPA_RC_ENOMEM;
2121 memcpy(qinfo->udata + qinfo->udata_offset,
2122 &qdata->data + entrybytes_done + stripped_bytes,
2124 entrybytes_done += esize + stripped_bytes;
2125 qinfo->udata_offset += esize;
2126 ++qinfo->no_entries;
2128 /* check if all replies received ... */
2129 if (cmd->data.setassparms.hdr.seq_no <
2130 cmd->data.setassparms.hdr.number_of_replies)
2132 QETH_CARD_TEXT_(card, 4, "nove%i", qinfo->no_entries);
2133 memcpy(qinfo->udata, &qinfo->no_entries, 4);
2134 /* keep STRIP_ENTRIES flag so the user program can distinguish
2135 * stripped entries from normal ones */
2136 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
2137 qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES;
2138 memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2);
2139 QETH_CARD_TEXT_(card, 4, "rc%i", 0);
2143 memcpy(qinfo->udata, &i, 4);
2147 static int qeth_l3_send_ipa_arp_cmd(struct qeth_card *card,
2148 struct qeth_cmd_buffer *iob, int len,
2149 int (*reply_cb)(struct qeth_card *, struct qeth_reply *,
2153 QETH_CARD_TEXT(card, 4, "sendarp");
2155 memcpy(iob->data, IPA_PDU_HEADER, IPA_PDU_HEADER_SIZE);
2156 memcpy(QETH_IPA_CMD_DEST_ADDR(iob->data),
2157 &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH);
2158 return qeth_send_control_data(card, IPA_PDU_HEADER_SIZE + len, iob,
2159 reply_cb, reply_param);
2162 static int qeth_l3_query_arp_cache_info(struct qeth_card *card,
2163 enum qeth_prot_versions prot,
2164 struct qeth_arp_query_info *qinfo)
2166 struct qeth_cmd_buffer *iob;
2167 struct qeth_ipa_cmd *cmd;
2171 QETH_CARD_TEXT_(card, 3, "qarpipv%i", prot);
2173 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2174 IPA_CMD_ASS_ARP_QUERY_INFO,
2175 sizeof(struct qeth_arp_query_data)
2180 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
2181 cmd->data.setassparms.data.query_arp.request_bits = 0x000F;
2182 cmd->data.setassparms.data.query_arp.reply_bits = 0;
2183 cmd->data.setassparms.data.query_arp.no_entries = 0;
2184 rc = qeth_l3_send_ipa_arp_cmd(card, iob,
2185 QETH_SETASS_BASE_LEN+QETH_ARP_CMD_LEN,
2186 qeth_l3_arp_query_cb, (void *)qinfo);
2190 "Error while querying ARP cache on %s: %s "
2191 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2192 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2198 static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
2200 struct qeth_arp_query_info qinfo = {0, };
2203 QETH_CARD_TEXT(card, 3, "arpquery");
2205 if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
2206 IPA_ARP_PROCESSING)) {
2207 QETH_CARD_TEXT(card, 3, "arpqnsup");
2211 /* get size of userspace buffer and mask_bits -> 6 bytes */
2212 if (copy_from_user(&qinfo, udata, 6)) {
2216 qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL);
2221 qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
2222 rc = qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV4, &qinfo);
2224 if (copy_to_user(udata, qinfo.udata, 4))
2228 #ifdef CONFIG_QETH_IPV6
2229 if (qinfo.mask_bits & QETH_QARP_WITH_IPV6) {
2230 /* fails in case of GuestLAN QDIO mode */
2231 qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV6, &qinfo);
2234 if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) {
2235 QETH_CARD_TEXT(card, 4, "qactf");
2239 QETH_CARD_TEXT(card, 4, "qacts");
2247 static int qeth_l3_arp_add_entry(struct qeth_card *card,
2248 struct qeth_arp_cache_entry *entry)
2250 struct qeth_cmd_buffer *iob;
2255 QETH_CARD_TEXT(card, 3, "arpadent");
2258 * currently GuestLAN only supports the ARP assist function
2259 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
2260 * thus we say EOPNOTSUPP for this ARP function
2262 if (card->info.guestlan)
2264 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2268 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2269 IPA_CMD_ASS_ARP_ADD_ENTRY,
2270 sizeof(struct qeth_arp_cache_entry),
2274 rc = qeth_send_setassparms(card, iob,
2275 sizeof(struct qeth_arp_cache_entry),
2276 (unsigned long) entry,
2277 qeth_setassparms_cb, NULL);
2280 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
2281 QETH_DBF_MESSAGE(2, "Could not add ARP entry for address %s "
2282 "on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2283 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2288 static int qeth_l3_arp_remove_entry(struct qeth_card *card,
2289 struct qeth_arp_cache_entry *entry)
2291 struct qeth_cmd_buffer *iob;
2292 char buf[16] = {0, };
2296 QETH_CARD_TEXT(card, 3, "arprment");
2299 * currently GuestLAN only supports the ARP assist function
2300 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_REMOVE_ENTRY;
2301 * thus we say EOPNOTSUPP for this ARP function
2303 if (card->info.guestlan)
2305 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2308 memcpy(buf, entry, 12);
2309 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2310 IPA_CMD_ASS_ARP_REMOVE_ENTRY,
2315 rc = qeth_send_setassparms(card, iob,
2316 12, (unsigned long)buf,
2317 qeth_setassparms_cb, NULL);
2321 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
2322 QETH_DBF_MESSAGE(2, "Could not delete ARP entry for address %s"
2323 " on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2324 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2329 static int qeth_l3_arp_flush_cache(struct qeth_card *card)
2334 QETH_CARD_TEXT(card, 3, "arpflush");
2337 * currently GuestLAN only supports the ARP assist function
2338 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
2339 * thus we say EOPNOTSUPP for this ARP function
2341 if (card->info.guestlan || (card->info.type == QETH_CARD_TYPE_IQD))
2343 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2346 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2347 IPA_CMD_ASS_ARP_FLUSH_CACHE, 0);
2350 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on %s: %s "
2351 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2352 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2357 static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2359 struct qeth_card *card = dev->ml_priv;
2360 struct qeth_arp_cache_entry arp_entry;
2364 case SIOC_QETH_ARP_SET_NO_ENTRIES:
2365 if (!capable(CAP_NET_ADMIN)) {
2369 rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue);
2371 case SIOC_QETH_ARP_QUERY_INFO:
2372 if (!capable(CAP_NET_ADMIN)) {
2376 rc = qeth_l3_arp_query(card, rq->ifr_ifru.ifru_data);
2378 case SIOC_QETH_ARP_ADD_ENTRY:
2379 if (!capable(CAP_NET_ADMIN)) {
2383 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
2384 sizeof(struct qeth_arp_cache_entry)))
2387 rc = qeth_l3_arp_add_entry(card, &arp_entry);
2389 case SIOC_QETH_ARP_REMOVE_ENTRY:
2390 if (!capable(CAP_NET_ADMIN)) {
2394 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
2395 sizeof(struct qeth_arp_cache_entry)))
2398 rc = qeth_l3_arp_remove_entry(card, &arp_entry);
2400 case SIOC_QETH_ARP_FLUSH_CACHE:
2401 if (!capable(CAP_NET_ADMIN)) {
2405 rc = qeth_l3_arp_flush_cache(card);
2413 static int qeth_l3_get_cast_type(struct qeth_card *card, struct sk_buff *skb)
2415 int cast_type = RTN_UNSPEC;
2416 struct neighbour *n = NULL;
2417 struct dst_entry *dst;
2422 n = dst_neigh_lookup_skb(dst, skb);
2424 cast_type = n->type;
2427 if ((cast_type == RTN_BROADCAST) ||
2428 (cast_type == RTN_MULTICAST) ||
2429 (cast_type == RTN_ANYCAST))
2436 /* try something else */
2437 if (be16_to_cpu(skb->protocol) == ETH_P_IPV6)
2438 return (skb_network_header(skb)[24] == 0xff) ?
2440 else if (be16_to_cpu(skb->protocol) == ETH_P_IP)
2441 return ((skb_network_header(skb)[16] & 0xf0) == 0xe0) ?
2444 if (!memcmp(skb->data, skb->dev->broadcast, 6))
2445 return RTN_BROADCAST;
2449 hdr_mac = *((u16 *)skb->data);
2451 switch (card->info.link_type) {
2452 case QETH_LINK_TYPE_HSTR:
2453 case QETH_LINK_TYPE_LANE_TR:
2454 if ((hdr_mac == QETH_TR_MAC_NC) ||
2455 (hdr_mac == QETH_TR_MAC_C))
2456 return RTN_MULTICAST;
2458 /* eth or so multicast? */
2460 if ((hdr_mac == QETH_ETH_MAC_V4) ||
2461 (hdr_mac == QETH_ETH_MAC_V6))
2462 return RTN_MULTICAST;
2468 static void qeth_l3_fill_af_iucv_hdr(struct qeth_card *card,
2469 struct qeth_hdr *hdr, struct sk_buff *skb)
2472 struct af_iucv_trans_hdr *iucv_hdr;
2474 memset(hdr, 0, sizeof(struct qeth_hdr));
2475 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
2476 hdr->hdr.l3.ext_flags = 0;
2477 hdr->hdr.l3.length = skb->len - ETH_HLEN;
2478 hdr->hdr.l3.flags = QETH_HDR_IPV6 | QETH_CAST_UNICAST;
2480 iucv_hdr = (struct af_iucv_trans_hdr *) (skb->data + ETH_HLEN);
2481 memset(daddr, 0, sizeof(daddr));
2484 memcpy(&daddr[8], iucv_hdr->destUserID, 8);
2485 memcpy(hdr->hdr.l3.dest_addr, daddr, 16);
2488 static void qeth_l3_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
2489 struct sk_buff *skb, int ipv, int cast_type)
2491 struct dst_entry *dst;
2493 memset(hdr, 0, sizeof(struct qeth_hdr));
2494 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
2495 hdr->hdr.l3.ext_flags = 0;
2498 * before we're going to overwrite this location with next hop ip.
2499 * v6 uses passthrough, v4 sets the tag in the QDIO header.
2501 if (skb_vlan_tag_present(skb)) {
2502 if ((ipv == 4) || (card->info.type == QETH_CARD_TYPE_IQD))
2503 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_VLAN_FRAME;
2505 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_INCLUDE_VLAN_TAG;
2506 hdr->hdr.l3.vlan_id = skb_vlan_tag_get(skb);
2509 hdr->hdr.l3.length = skb->len - sizeof(struct qeth_hdr);
2514 struct rtable *rt = (struct rtable *) dst;
2515 __be32 *pkey = &ip_hdr(skb)->daddr;
2517 if (rt && rt->rt_gateway)
2518 pkey = &rt->rt_gateway;
2521 hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags4(cast_type);
2522 memset(hdr->hdr.l3.dest_addr, 0, 12);
2523 *((__be32 *) (&hdr->hdr.l3.dest_addr[12])) = *pkey;
2524 } else if (ipv == 6) {
2525 struct rt6_info *rt = (struct rt6_info *) dst;
2526 struct in6_addr *pkey = &ipv6_hdr(skb)->daddr;
2528 if (rt && !ipv6_addr_any(&rt->rt6i_gateway))
2529 pkey = &rt->rt6i_gateway;
2532 hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags6(cast_type);
2533 if (card->info.type == QETH_CARD_TYPE_IQD)
2534 hdr->hdr.l3.flags &= ~QETH_HDR_PASSTHRU;
2535 memcpy(hdr->hdr.l3.dest_addr, pkey, 16);
2537 if (!memcmp(skb->data + sizeof(struct qeth_hdr),
2538 skb->dev->broadcast, 6)) {
2540 hdr->hdr.l3.flags = QETH_CAST_BROADCAST |
2543 hdr->hdr.l3.flags = (cast_type == RTN_MULTICAST) ?
2544 QETH_CAST_MULTICAST | QETH_HDR_PASSTHRU :
2545 QETH_CAST_UNICAST | QETH_HDR_PASSTHRU;
2551 static void qeth_l3_hdr_csum(struct qeth_card *card, struct qeth_hdr *hdr,
2552 struct sk_buff *skb)
2554 struct iphdr *iph = ip_hdr(skb);
2556 /* tcph->check contains already the pseudo hdr checksum
2557 * so just set the header flags
2559 if (iph->protocol == IPPROTO_UDP)
2560 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_UDP;
2561 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_CSUM_TRANSP_REQ |
2562 QETH_HDR_EXT_CSUM_HDR_REQ;
2564 if (card->options.performance_stats)
2565 card->perf_stats.tx_csum++;
2568 static void qeth_tso_fill_header(struct qeth_card *card,
2569 struct qeth_hdr *qhdr, struct sk_buff *skb)
2571 struct qeth_hdr_tso *hdr = (struct qeth_hdr_tso *)qhdr;
2572 struct tcphdr *tcph = tcp_hdr(skb);
2573 struct iphdr *iph = ip_hdr(skb);
2574 struct ipv6hdr *ip6h = ipv6_hdr(skb);
2576 /*fix header to TSO values ...*/
2577 hdr->hdr.hdr.l3.id = QETH_HEADER_TYPE_TSO;
2578 hdr->hdr.hdr.l3.length = skb->len - sizeof(struct qeth_hdr_tso);
2579 /*set values which are fix for the first approach ...*/
2580 hdr->ext.hdr_tot_len = (__u16) sizeof(struct qeth_hdr_ext_tso);
2581 hdr->ext.imb_hdr_no = 1;
2582 hdr->ext.hdr_type = 1;
2583 hdr->ext.hdr_version = 1;
2584 hdr->ext.hdr_len = 28;
2585 /*insert non-fix values */
2586 hdr->ext.mss = skb_shinfo(skb)->gso_size;
2587 hdr->ext.dg_hdr_len = (__u16)(ip_hdrlen(skb) + tcp_hdrlen(skb));
2588 hdr->ext.payload_len = (__u16)(skb->len - hdr->ext.dg_hdr_len -
2589 sizeof(struct qeth_hdr_tso));
2591 if (be16_to_cpu(skb->protocol) == ETH_P_IPV6) {
2592 ip6h->payload_len = 0;
2593 tcph->check = ~csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr,
2596 /*OSA want us to set these values ...*/
2597 tcph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr,
2605 * qeth_l3_get_elements_no_tso() - find number of SBALEs for skb data for tso
2606 * @card: qeth card structure, to check max. elems.
2608 * @extra_elems: extra elems needed, to check against max.
2610 * Returns the number of pages, and thus QDIO buffer elements, needed to cover
2611 * skb data, including linear part and fragments, but excluding TCP header.
2612 * (Exclusion of TCP header distinguishes it from qeth_get_elements_no().)
2613 * Checks if the result plus extra_elems fits under the limit for the card.
2614 * Returns 0 if it does not.
2615 * Note: extra_elems is not included in the returned result.
2617 static int qeth_l3_get_elements_no_tso(struct qeth_card *card,
2618 struct sk_buff *skb, int extra_elems)
2620 addr_t start = (addr_t)tcp_hdr(skb) + tcp_hdrlen(skb);
2621 addr_t end = (addr_t)skb->data + skb_headlen(skb);
2622 int elements = qeth_get_elements_for_frags(skb);
2625 elements += qeth_get_elements_for_range(start, end);
2627 if ((elements + extra_elems) > QETH_MAX_BUFFER_ELEMENTS(card)) {
2629 "Invalid size of TSO IP packet (Number=%d / Length=%d). Discarded.\n",
2630 elements + extra_elems, skb->len);
2636 static netdev_tx_t qeth_l3_hard_start_xmit(struct sk_buff *skb,
2637 struct net_device *dev)
2641 struct qeth_hdr *hdr = NULL;
2642 int hdr_elements = 0;
2644 struct qeth_card *card = dev->ml_priv;
2645 struct sk_buff *new_skb = NULL;
2646 int ipv = qeth_get_ip_version(skb);
2647 int cast_type = qeth_l3_get_cast_type(card, skb);
2648 struct qeth_qdio_out_q *queue =
2649 card->qdio.out_qs[card->qdio.do_prio_queueing
2650 || (cast_type && card->info.is_multicast_different) ?
2651 qeth_get_priority_queue(card, skb, ipv, cast_type) :
2652 card->qdio.default_out_queue];
2653 int tx_bytes = skb->len;
2654 unsigned int hd_len = 0;
2656 int data_offset = -1;
2657 unsigned int nr_frags;
2659 if (((card->info.type == QETH_CARD_TYPE_IQD) &&
2660 (((card->options.cq != QETH_CQ_ENABLED) && !ipv) ||
2661 ((card->options.cq == QETH_CQ_ENABLED) &&
2662 (be16_to_cpu(skb->protocol) != ETH_P_AF_IUCV)))) ||
2663 card->options.sniffer)
2666 if ((card->state != CARD_STATE_UP) || !card->lan_online) {
2667 card->stats.tx_carrier_errors++;
2671 if ((cast_type == RTN_BROADCAST) &&
2672 (card->info.broadcast_capable == 0))
2675 if (card->options.performance_stats) {
2676 card->perf_stats.outbound_cnt++;
2677 card->perf_stats.outbound_start_time = qeth_get_micros();
2680 /* Ignore segment size from skb_is_gso(), 1 page is always used. */
2681 use_tso = skb_is_gso(skb) &&
2682 (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4);
2684 if (card->info.type == QETH_CARD_TYPE_IQD) {
2686 data_offset = ETH_HLEN;
2687 hd_len = sizeof(*hdr);
2688 hdr = kmem_cache_alloc(qeth_core_header_cache, GFP_ATOMIC);
2693 /* create a clone with writeable headroom */
2694 new_skb = skb_realloc_headroom(skb, sizeof(struct qeth_hdr_tso)
2700 skb_pull(new_skb, ETH_HLEN);
2703 if (ipv != 4 && skb_vlan_tag_present(new_skb)) {
2704 skb_push(new_skb, VLAN_HLEN);
2705 skb_copy_to_linear_data(new_skb, new_skb->data + 4, 4);
2706 skb_copy_to_linear_data_offset(new_skb, 4,
2707 new_skb->data + 8, 4);
2708 skb_copy_to_linear_data_offset(new_skb, 8,
2709 new_skb->data + 12, 4);
2710 tag = (__be16 *)(new_skb->data + 12);
2711 *tag = cpu_to_be16(ETH_P_8021Q);
2712 *(tag + 1) = cpu_to_be16(skb_vlan_tag_get(new_skb));
2716 netif_stop_queue(dev);
2718 /* fix hardware limitation: as long as we do not have sbal
2719 * chaining we can not send long frag lists
2721 if ((card->info.type != QETH_CARD_TYPE_IQD) &&
2722 ((use_tso && !qeth_l3_get_elements_no_tso(card, new_skb, 1)) ||
2723 (!use_tso && !qeth_get_elements_no(card, new_skb, 0, 0)))) {
2724 int lin_rc = skb_linearize(new_skb);
2726 if (card->options.performance_stats) {
2728 card->perf_stats.tx_linfail++;
2730 card->perf_stats.tx_lin++;
2735 nr_frags = skb_shinfo(new_skb)->nr_frags;
2738 hdr = skb_push(new_skb, sizeof(struct qeth_hdr_tso));
2739 memset(hdr, 0, sizeof(struct qeth_hdr_tso));
2740 qeth_l3_fill_header(card, hdr, new_skb, ipv, cast_type);
2741 qeth_tso_fill_header(card, hdr, new_skb);
2744 if (data_offset < 0) {
2745 hdr = skb_push(new_skb, sizeof(struct qeth_hdr));
2746 qeth_l3_fill_header(card, hdr, new_skb, ipv,
2749 if (be16_to_cpu(new_skb->protocol) == ETH_P_AF_IUCV)
2750 qeth_l3_fill_af_iucv_hdr(card, hdr, new_skb);
2752 qeth_l3_fill_header(card, hdr, new_skb, ipv,
2754 hdr->hdr.l3.length = new_skb->len - data_offset;
2758 if (skb->ip_summed == CHECKSUM_PARTIAL)
2759 qeth_l3_hdr_csum(card, hdr, new_skb);
2762 elements = use_tso ?
2763 qeth_l3_get_elements_no_tso(card, new_skb, hdr_elements) :
2764 qeth_get_elements_no(card, new_skb, hdr_elements,
2765 (data_offset > 0) ? data_offset : 0);
2767 if (data_offset >= 0)
2768 kmem_cache_free(qeth_core_header_cache, hdr);
2771 elements += hdr_elements;
2773 if (card->info.type != QETH_CARD_TYPE_IQD) {
2776 hd_len = sizeof(struct qeth_hdr_tso) +
2777 ip_hdrlen(new_skb) + tcp_hdrlen(new_skb);
2780 len = sizeof(struct qeth_hdr_layer3);
2783 if (qeth_hdr_chk_and_bounce(new_skb, &hdr, len))
2785 rc = qeth_do_send_packet(card, queue, new_skb, hdr, hd_len,
2788 rc = qeth_do_send_packet_fast(card, queue, new_skb, hdr,
2789 data_offset, hd_len);
2792 card->stats.tx_packets++;
2793 card->stats.tx_bytes += tx_bytes;
2795 dev_kfree_skb_any(skb);
2796 if (card->options.performance_stats) {
2798 card->perf_stats.large_send_bytes += tx_bytes;
2799 card->perf_stats.large_send_cnt++;
2802 card->perf_stats.sg_skbs_sent++;
2803 /* nr_frags + skb->data */
2804 card->perf_stats.sg_frags_sent += nr_frags + 1;
2809 if (data_offset >= 0)
2810 kmem_cache_free(qeth_core_header_cache, hdr);
2814 dev_kfree_skb_any(new_skb);
2815 return NETDEV_TX_BUSY;
2820 netif_wake_queue(dev);
2821 if (card->options.performance_stats)
2822 card->perf_stats.outbound_time += qeth_get_micros() -
2823 card->perf_stats.outbound_start_time;
2827 card->stats.tx_dropped++;
2828 card->stats.tx_errors++;
2829 if ((new_skb != skb) && new_skb)
2830 dev_kfree_skb_any(new_skb);
2831 dev_kfree_skb_any(skb);
2832 netif_wake_queue(dev);
2833 return NETDEV_TX_OK;
2836 static int __qeth_l3_open(struct net_device *dev)
2838 struct qeth_card *card = dev->ml_priv;
2841 QETH_CARD_TEXT(card, 4, "qethopen");
2842 if (card->state == CARD_STATE_UP)
2844 if (card->state != CARD_STATE_SOFTSETUP)
2846 card->data.state = CH_STATE_UP;
2847 card->state = CARD_STATE_UP;
2848 netif_start_queue(dev);
2850 if (qdio_stop_irq(card->data.ccwdev, 0) >= 0) {
2851 napi_enable(&card->napi);
2853 napi_schedule(&card->napi);
2854 /* kick-start the NAPI softirq: */
2861 static int qeth_l3_open(struct net_device *dev)
2863 struct qeth_card *card = dev->ml_priv;
2865 QETH_CARD_TEXT(card, 5, "qethope_");
2866 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) {
2867 QETH_CARD_TEXT(card, 3, "openREC");
2868 return -ERESTARTSYS;
2870 return __qeth_l3_open(dev);
2873 static int qeth_l3_stop(struct net_device *dev)
2875 struct qeth_card *card = dev->ml_priv;
2877 QETH_CARD_TEXT(card, 4, "qethstop");
2878 netif_tx_disable(dev);
2879 if (card->state == CARD_STATE_UP) {
2880 card->state = CARD_STATE_SOFTSETUP;
2881 napi_disable(&card->napi);
2886 static const struct ethtool_ops qeth_l3_ethtool_ops = {
2887 .get_link = ethtool_op_get_link,
2888 .get_strings = qeth_core_get_strings,
2889 .get_ethtool_stats = qeth_core_get_ethtool_stats,
2890 .get_sset_count = qeth_core_get_sset_count,
2891 .get_drvinfo = qeth_core_get_drvinfo,
2892 .get_link_ksettings = qeth_core_ethtool_get_link_ksettings,
2896 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
2897 * NOARP on the netdevice is no option because it also turns off neighbor
2898 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
2899 * arp resolution but we want the hard header (packet socket will work
2902 static int qeth_l3_neigh_setup_noarp(struct neighbour *n)
2904 n->nud_state = NUD_NOARP;
2905 memcpy(n->ha, "FAKELL", 6);
2906 n->output = n->ops->connected_output;
2911 qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np)
2913 if (np->tbl->family == AF_INET)
2914 np->neigh_setup = qeth_l3_neigh_setup_noarp;
2919 static const struct net_device_ops qeth_l3_netdev_ops = {
2920 .ndo_open = qeth_l3_open,
2921 .ndo_stop = qeth_l3_stop,
2922 .ndo_get_stats = qeth_get_stats,
2923 .ndo_start_xmit = qeth_l3_hard_start_xmit,
2924 .ndo_validate_addr = eth_validate_addr,
2925 .ndo_set_rx_mode = qeth_l3_set_multicast_list,
2926 .ndo_do_ioctl = qeth_do_ioctl,
2927 .ndo_change_mtu = qeth_change_mtu,
2928 .ndo_fix_features = qeth_fix_features,
2929 .ndo_set_features = qeth_set_features,
2930 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid,
2931 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid,
2932 .ndo_tx_timeout = qeth_tx_timeout,
2935 static const struct net_device_ops qeth_l3_osa_netdev_ops = {
2936 .ndo_open = qeth_l3_open,
2937 .ndo_stop = qeth_l3_stop,
2938 .ndo_get_stats = qeth_get_stats,
2939 .ndo_start_xmit = qeth_l3_hard_start_xmit,
2940 .ndo_features_check = qeth_features_check,
2941 .ndo_validate_addr = eth_validate_addr,
2942 .ndo_set_rx_mode = qeth_l3_set_multicast_list,
2943 .ndo_do_ioctl = qeth_do_ioctl,
2944 .ndo_change_mtu = qeth_change_mtu,
2945 .ndo_fix_features = qeth_fix_features,
2946 .ndo_set_features = qeth_set_features,
2947 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid,
2948 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid,
2949 .ndo_tx_timeout = qeth_tx_timeout,
2950 .ndo_neigh_setup = qeth_l3_neigh_setup,
2953 static int qeth_l3_setup_netdev(struct qeth_card *card)
2957 if (card->info.type == QETH_CARD_TYPE_OSD ||
2958 card->info.type == QETH_CARD_TYPE_OSX) {
2959 if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) ||
2960 (card->info.link_type == QETH_LINK_TYPE_HSTR)) {
2961 pr_info("qeth_l3: ignoring TR device\n");
2964 card->dev = alloc_etherdev(0);
2967 card->dev->netdev_ops = &qeth_l3_osa_netdev_ops;
2969 /*IPv6 address autoconfiguration stuff*/
2970 qeth_l3_get_unique_id(card);
2971 if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
2972 card->dev->dev_id = card->info.unique_id &
2974 if (!card->info.guestlan) {
2975 card->dev->hw_features = NETIF_F_SG |
2976 NETIF_F_RXCSUM | NETIF_F_IP_CSUM |
2978 card->dev->vlan_features = NETIF_F_SG |
2979 NETIF_F_RXCSUM | NETIF_F_IP_CSUM |
2981 card->dev->features |= NETIF_F_SG;
2984 } else if (card->info.type == QETH_CARD_TYPE_IQD) {
2985 card->dev = alloc_netdev(0, "hsi%d", NET_NAME_UNKNOWN,
2989 card->dev->flags |= IFF_NOARP;
2990 card->dev->netdev_ops = &qeth_l3_netdev_ops;
2991 rc = qeth_l3_iqd_read_initial_mac(card);
2994 if (card->options.hsuid[0])
2995 memcpy(card->dev->perm_addr, card->options.hsuid, 9);
2999 card->dev->ml_priv = card;
3000 card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
3001 card->dev->mtu = card->info.initial_mtu;
3002 card->dev->min_mtu = 64;
3003 card->dev->max_mtu = ETH_MAX_MTU;
3004 card->dev->ethtool_ops = &qeth_l3_ethtool_ops;
3005 card->dev->features |= NETIF_F_HW_VLAN_CTAG_TX |
3006 NETIF_F_HW_VLAN_CTAG_RX |
3007 NETIF_F_HW_VLAN_CTAG_FILTER;
3008 netif_keep_dst(card->dev);
3009 netif_set_gso_max_size(card->dev, (QETH_MAX_BUFFER_ELEMENTS(card) - 1) *
3012 SET_NETDEV_DEV(card->dev, &card->gdev->dev);
3013 netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
3014 netif_carrier_off(card->dev);
3015 return register_netdev(card->dev);
3018 static const struct device_type qeth_l3_devtype = {
3019 .name = "qeth_layer3",
3020 .groups = qeth_l3_attr_groups,
3023 static int qeth_l3_probe_device(struct ccwgroup_device *gdev)
3025 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3028 hash_init(card->ip_htable);
3030 if (gdev->dev.type == &qeth_generic_devtype) {
3031 rc = qeth_l3_create_device_attributes(&gdev->dev);
3036 hash_init(card->ip_mc_htable);
3037 card->options.layer2 = 0;
3038 card->info.hwtrap = 0;
3042 static void qeth_l3_remove_device(struct ccwgroup_device *cgdev)
3044 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
3046 if (cgdev->dev.type == &qeth_generic_devtype)
3047 qeth_l3_remove_device_attributes(&cgdev->dev);
3049 qeth_set_allowed_threads(card, 0, 1);
3050 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
3052 if (cgdev->state == CCWGROUP_ONLINE)
3053 qeth_l3_set_offline(cgdev);
3056 unregister_netdev(card->dev);
3057 free_netdev(card->dev);
3061 qeth_l3_clear_ip_htable(card, 0);
3062 qeth_l3_clear_ipato_list(card);
3066 static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
3068 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3070 enum qeth_card_states recover_flag;
3072 mutex_lock(&card->discipline_mutex);
3073 mutex_lock(&card->conf_mutex);
3074 QETH_DBF_TEXT(SETUP, 2, "setonlin");
3075 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
3077 recover_flag = card->state;
3078 rc = qeth_core_hardsetup_card(card);
3080 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
3085 if (!card->dev && qeth_l3_setup_netdev(card)) {
3090 if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) {
3091 if (card->info.hwtrap &&
3092 qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM))
3093 card->info.hwtrap = 0;
3095 card->info.hwtrap = 0;
3097 card->state = CARD_STATE_HARDSETUP;
3098 memset(&card->rx, 0, sizeof(struct qeth_rx));
3099 qeth_print_status_message(card);
3102 QETH_DBF_TEXT(SETUP, 2, "softsetp");
3104 rc = qeth_l3_setadapter_parms(card);
3106 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
3107 if (!card->options.sniffer) {
3108 rc = qeth_l3_start_ipassists(card);
3110 QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
3113 rc = qeth_l3_setrouting_v4(card);
3115 QETH_DBF_TEXT_(SETUP, 2, "4err%04x", rc);
3116 rc = qeth_l3_setrouting_v6(card);
3118 QETH_DBF_TEXT_(SETUP, 2, "5err%04x", rc);
3120 netif_tx_disable(card->dev);
3122 rc = qeth_init_qdio_queues(card);
3124 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
3128 card->state = CARD_STATE_SOFTSETUP;
3130 qeth_set_allowed_threads(card, 0xffffffff, 0);
3131 qeth_l3_recover_ip(card);
3132 if (card->lan_online)
3133 netif_carrier_on(card->dev);
3135 netif_carrier_off(card->dev);
3136 if (recover_flag == CARD_STATE_RECOVER) {
3139 __qeth_l3_open(card->dev);
3141 dev_open(card->dev);
3142 qeth_l3_set_multicast_list(card->dev);
3143 qeth_recover_features(card->dev);
3146 qeth_trace_features(card);
3147 /* let user_space know that device is online */
3148 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
3149 mutex_unlock(&card->conf_mutex);
3150 mutex_unlock(&card->discipline_mutex);
3153 qeth_l3_stop_card(card, 0);
3154 ccw_device_set_offline(CARD_DDEV(card));
3155 ccw_device_set_offline(CARD_WDEV(card));
3156 ccw_device_set_offline(CARD_RDEV(card));
3157 qdio_free(CARD_DDEV(card));
3158 if (recover_flag == CARD_STATE_RECOVER)
3159 card->state = CARD_STATE_RECOVER;
3161 card->state = CARD_STATE_DOWN;
3162 mutex_unlock(&card->conf_mutex);
3163 mutex_unlock(&card->discipline_mutex);
3167 static int qeth_l3_set_online(struct ccwgroup_device *gdev)
3169 return __qeth_l3_set_online(gdev, 0);
3172 static int __qeth_l3_set_offline(struct ccwgroup_device *cgdev,
3175 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
3176 int rc = 0, rc2 = 0, rc3 = 0;
3177 enum qeth_card_states recover_flag;
3179 mutex_lock(&card->discipline_mutex);
3180 mutex_lock(&card->conf_mutex);
3181 QETH_DBF_TEXT(SETUP, 3, "setoffl");
3182 QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
3184 if (card->dev && netif_carrier_ok(card->dev))
3185 netif_carrier_off(card->dev);
3186 recover_flag = card->state;
3187 if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
3188 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
3189 card->info.hwtrap = 1;
3191 qeth_l3_stop_card(card, recovery_mode);
3192 if ((card->options.cq == QETH_CQ_ENABLED) && card->dev) {
3194 call_netdevice_notifiers(NETDEV_REBOOT, card->dev);
3197 rc = ccw_device_set_offline(CARD_DDEV(card));
3198 rc2 = ccw_device_set_offline(CARD_WDEV(card));
3199 rc3 = ccw_device_set_offline(CARD_RDEV(card));
3201 rc = (rc2) ? rc2 : rc3;
3203 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
3204 qdio_free(CARD_DDEV(card));
3205 if (recover_flag == CARD_STATE_UP)
3206 card->state = CARD_STATE_RECOVER;
3207 /* let user_space know that device is offline */
3208 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
3209 mutex_unlock(&card->conf_mutex);
3210 mutex_unlock(&card->discipline_mutex);
3214 static int qeth_l3_set_offline(struct ccwgroup_device *cgdev)
3216 return __qeth_l3_set_offline(cgdev, 0);
3219 static int qeth_l3_recover(void *ptr)
3221 struct qeth_card *card;
3224 card = (struct qeth_card *) ptr;
3225 QETH_CARD_TEXT(card, 2, "recover1");
3226 QETH_CARD_HEX(card, 2, &card, sizeof(void *));
3227 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
3229 QETH_CARD_TEXT(card, 2, "recover2");
3230 dev_warn(&card->gdev->dev,
3231 "A recovery process has been started for the device\n");
3232 qeth_set_recovery_task(card);
3233 __qeth_l3_set_offline(card->gdev, 1);
3234 rc = __qeth_l3_set_online(card->gdev, 1);
3236 dev_info(&card->gdev->dev,
3237 "Device successfully recovered!\n");
3239 qeth_close_dev(card);
3240 dev_warn(&card->gdev->dev, "The qeth device driver "
3241 "failed to recover an error on the device\n");
3243 qeth_clear_recovery_task(card);
3244 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
3245 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
3249 static int qeth_l3_pm_suspend(struct ccwgroup_device *gdev)
3251 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3254 netif_device_detach(card->dev);
3255 qeth_set_allowed_threads(card, 0, 1);
3256 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
3257 if (gdev->state == CCWGROUP_OFFLINE)
3259 if (card->state == CARD_STATE_UP) {
3260 if (card->info.hwtrap)
3261 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
3262 __qeth_l3_set_offline(card->gdev, 1);
3264 __qeth_l3_set_offline(card->gdev, 0);
3268 static int qeth_l3_pm_resume(struct ccwgroup_device *gdev)
3270 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3273 if (gdev->state == CCWGROUP_OFFLINE)
3276 if (card->state == CARD_STATE_RECOVER) {
3277 rc = __qeth_l3_set_online(card->gdev, 1);
3280 dev_close(card->dev);
3284 rc = __qeth_l3_set_online(card->gdev, 0);
3286 qeth_set_allowed_threads(card, 0xffffffff, 0);
3288 netif_device_attach(card->dev);
3290 dev_warn(&card->gdev->dev, "The qeth device driver "
3291 "failed to recover an error on the device\n");
3295 /* Returns zero if the command is successfully "consumed" */
3296 static int qeth_l3_control_event(struct qeth_card *card,
3297 struct qeth_ipa_cmd *cmd)
3302 struct qeth_discipline qeth_l3_discipline = {
3303 .devtype = &qeth_l3_devtype,
3304 .start_poll = qeth_qdio_start_poll,
3305 .input_handler = (qdio_handler_t *) qeth_qdio_input_handler,
3306 .output_handler = (qdio_handler_t *) qeth_qdio_output_handler,
3307 .process_rx_buffer = qeth_l3_process_inbound_buffer,
3308 .recover = qeth_l3_recover,
3309 .setup = qeth_l3_probe_device,
3310 .remove = qeth_l3_remove_device,
3311 .set_online = qeth_l3_set_online,
3312 .set_offline = qeth_l3_set_offline,
3313 .freeze = qeth_l3_pm_suspend,
3314 .thaw = qeth_l3_pm_resume,
3315 .restore = qeth_l3_pm_resume,
3316 .do_ioctl = qeth_l3_do_ioctl,
3317 .control_event_handler = qeth_l3_control_event,
3319 EXPORT_SYMBOL_GPL(qeth_l3_discipline);
3321 static int qeth_l3_ip_event(struct notifier_block *this,
3322 unsigned long event, void *ptr)
3325 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
3326 struct net_device *dev = (struct net_device *)ifa->ifa_dev->dev;
3327 struct qeth_ipaddr *addr;
3328 struct qeth_card *card;
3330 if (dev_net(dev) != &init_net)
3333 card = qeth_l3_get_card_from_dev(dev);
3336 QETH_CARD_TEXT(card, 3, "ipevent");
3338 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
3340 addr->u.a4.addr = be32_to_cpu(ifa->ifa_address);
3341 addr->u.a4.mask = be32_to_cpu(ifa->ifa_mask);
3342 addr->type = QETH_IP_TYPE_NORMAL;
3348 spin_lock_bh(&card->ip_lock);
3349 qeth_l3_add_ip(card, addr);
3350 spin_unlock_bh(&card->ip_lock);
3353 spin_lock_bh(&card->ip_lock);
3354 qeth_l3_delete_ip(card, addr);
3355 spin_unlock_bh(&card->ip_lock);
3363 static struct notifier_block qeth_l3_ip_notifier = {
3368 #ifdef CONFIG_QETH_IPV6
3370 * IPv6 event handler
3372 static int qeth_l3_ip6_event(struct notifier_block *this,
3373 unsigned long event, void *ptr)
3375 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
3376 struct net_device *dev = (struct net_device *)ifa->idev->dev;
3377 struct qeth_ipaddr *addr;
3378 struct qeth_card *card;
3380 card = qeth_l3_get_card_from_dev(dev);
3383 QETH_CARD_TEXT(card, 3, "ip6event");
3384 if (!qeth_is_supported(card, IPA_IPV6))
3387 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
3389 memcpy(&addr->u.a6.addr, &ifa->addr, sizeof(struct in6_addr));
3390 addr->u.a6.pfxlen = ifa->prefix_len;
3391 addr->type = QETH_IP_TYPE_NORMAL;
3397 spin_lock_bh(&card->ip_lock);
3398 qeth_l3_add_ip(card, addr);
3399 spin_unlock_bh(&card->ip_lock);
3402 spin_lock_bh(&card->ip_lock);
3403 qeth_l3_delete_ip(card, addr);
3404 spin_unlock_bh(&card->ip_lock);
3412 static struct notifier_block qeth_l3_ip6_notifier = {
3418 static int qeth_l3_register_notifiers(void)
3422 QETH_DBF_TEXT(SETUP, 5, "regnotif");
3423 rc = register_inetaddr_notifier(&qeth_l3_ip_notifier);
3426 #ifdef CONFIG_QETH_IPV6
3427 rc = register_inet6addr_notifier(&qeth_l3_ip6_notifier);
3429 unregister_inetaddr_notifier(&qeth_l3_ip_notifier);
3433 pr_warn("There is no IPv6 support for the layer 3 discipline\n");
3438 static void qeth_l3_unregister_notifiers(void)
3441 QETH_DBF_TEXT(SETUP, 5, "unregnot");
3442 WARN_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier));
3443 #ifdef CONFIG_QETH_IPV6
3444 WARN_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier));
3445 #endif /* QETH_IPV6 */
3448 static int __init qeth_l3_init(void)
3452 pr_info("register layer 3 discipline\n");
3453 rc = qeth_l3_register_notifiers();
3457 static void __exit qeth_l3_exit(void)
3459 qeth_l3_unregister_notifiers();
3460 pr_info("unregister layer 3 discipline\n");
3463 module_init(qeth_l3_init);
3464 module_exit(qeth_l3_exit);
3465 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
3466 MODULE_DESCRIPTION("qeth layer 3 discipline");
3467 MODULE_LICENSE("GPL");