1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright IBM Corp. 2007, 2009
4 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
5 * Frank Pavlic <fpavlic@de.ibm.com>,
6 * Thomas Spatzier <tspat@de.ibm.com>,
7 * Frank Blaschka <frank.blaschka@de.ibm.com>
10 #define KMSG_COMPONENT "qeth"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/bitops.h>
16 #include <linux/string.h>
17 #include <linux/errno.h>
18 #include <linux/kernel.h>
19 #include <linux/etherdevice.h>
22 #include <linux/ipv6.h>
23 #include <linux/inetdevice.h>
24 #include <linux/igmp.h>
25 #include <linux/slab.h>
26 #include <linux/if_ether.h>
27 #include <linux/if_vlan.h>
28 #include <linux/skbuff.h>
32 #include <net/route.h>
34 #include <net/ip6_route.h>
35 #include <net/iucv/af_iucv.h>
36 #include <linux/hashtable.h>
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 int qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto
, const u8
*addr
,
48 if (proto
== QETH_PROT_IPV4
)
49 return sprintf(buf
, "%pI4", addr
);
51 return sprintf(buf
, "%pI6", addr
);
54 static struct qeth_ipaddr
*qeth_l3_find_addr_by_ip(struct qeth_card
*card
,
55 struct qeth_ipaddr
*query
)
57 u32 key
= qeth_l3_ipaddr_hash(query
);
58 struct qeth_ipaddr
*addr
;
60 if (query
->is_multicast
) {
61 hash_for_each_possible(card
->rx_mode_addrs
, addr
, hnode
, key
)
62 if (qeth_l3_addr_match_ip(addr
, query
))
65 hash_for_each_possible(card
->ip_htable
, addr
, hnode
, key
)
66 if (qeth_l3_addr_match_ip(addr
, query
))
72 static void qeth_l3_convert_addr_to_bits(u8
*addr
, u8
*bits
, int len
)
77 for (i
= 0; i
< len
; ++i
) {
79 for (j
= 7; j
>= 0; --j
) {
80 bits
[i
*8 + j
] = octet
& 1;
86 static bool qeth_l3_is_addr_covered_by_ipato(struct qeth_card
*card
,
87 struct qeth_ipaddr
*addr
)
89 struct qeth_ipato_entry
*ipatoe
;
90 u8 addr_bits
[128] = {0, };
91 u8 ipatoe_bits
[128] = {0, };
94 if (!card
->ipato
.enabled
)
96 if (addr
->type
!= QETH_IP_TYPE_NORMAL
)
99 qeth_l3_convert_addr_to_bits((u8
*) &addr
->u
, addr_bits
,
100 (addr
->proto
== QETH_PROT_IPV4
) ? 4 : 16);
101 list_for_each_entry(ipatoe
, &card
->ipato
.entries
, entry
) {
102 if (addr
->proto
!= ipatoe
->proto
)
104 qeth_l3_convert_addr_to_bits(ipatoe
->addr
, ipatoe_bits
,
105 (ipatoe
->proto
== QETH_PROT_IPV4
) ?
107 rc
= !memcmp(addr_bits
, ipatoe_bits
, ipatoe
->mask_bits
);
112 if ((addr
->proto
== QETH_PROT_IPV4
) && card
->ipato
.invert4
)
114 else if ((addr
->proto
== QETH_PROT_IPV6
) && card
->ipato
.invert6
)
120 static int qeth_l3_delete_ip(struct qeth_card
*card
,
121 struct qeth_ipaddr
*tmp_addr
)
124 struct qeth_ipaddr
*addr
;
126 if (tmp_addr
->type
== QETH_IP_TYPE_RXIP
)
127 QETH_CARD_TEXT(card
, 2, "delrxip");
128 else if (tmp_addr
->type
== QETH_IP_TYPE_VIPA
)
129 QETH_CARD_TEXT(card
, 2, "delvipa");
131 QETH_CARD_TEXT(card
, 2, "delip");
133 if (tmp_addr
->proto
== QETH_PROT_IPV4
)
134 QETH_CARD_HEX(card
, 4, &tmp_addr
->u
.a4
.addr
, 4);
136 QETH_CARD_HEX(card
, 4, &tmp_addr
->u
.a6
.addr
, 8);
137 QETH_CARD_HEX(card
, 4, ((char *)&tmp_addr
->u
.a6
.addr
) + 8, 8);
140 addr
= qeth_l3_find_addr_by_ip(card
, tmp_addr
);
141 if (!addr
|| !qeth_l3_addr_match_all(addr
, tmp_addr
))
145 if (addr
->type
== QETH_IP_TYPE_NORMAL
&& addr
->ref_counter
> 0)
148 if (qeth_card_hw_is_reachable(card
))
149 rc
= qeth_l3_deregister_addr_entry(card
, addr
);
151 hash_del(&addr
->hnode
);
157 static int qeth_l3_add_ip(struct qeth_card
*card
, struct qeth_ipaddr
*tmp_addr
)
160 struct qeth_ipaddr
*addr
;
163 if (tmp_addr
->type
== QETH_IP_TYPE_RXIP
)
164 QETH_CARD_TEXT(card
, 2, "addrxip");
165 else if (tmp_addr
->type
== QETH_IP_TYPE_VIPA
)
166 QETH_CARD_TEXT(card
, 2, "addvipa");
168 QETH_CARD_TEXT(card
, 2, "addip");
170 if (tmp_addr
->proto
== QETH_PROT_IPV4
)
171 QETH_CARD_HEX(card
, 4, &tmp_addr
->u
.a4
.addr
, 4);
173 QETH_CARD_HEX(card
, 4, &tmp_addr
->u
.a6
.addr
, 8);
174 QETH_CARD_HEX(card
, 4, ((char *)&tmp_addr
->u
.a6
.addr
) + 8, 8);
177 addr
= qeth_l3_find_addr_by_ip(card
, tmp_addr
);
179 if (tmp_addr
->type
!= QETH_IP_TYPE_NORMAL
)
181 if (qeth_l3_addr_match_all(addr
, tmp_addr
)) {
185 qeth_l3_ipaddr_to_string(tmp_addr
->proto
, (u8
*)&tmp_addr
->u
,
187 dev_warn(&card
->gdev
->dev
,
188 "Registering IP address %s failed\n", buf
);
191 addr
= kmemdup(tmp_addr
, sizeof(*tmp_addr
), GFP_KERNEL
);
195 if (qeth_l3_is_addr_covered_by_ipato(card
, addr
)) {
196 QETH_CARD_TEXT(card
, 2, "tkovaddr");
199 hash_add(card
->ip_htable
, &addr
->hnode
,
200 qeth_l3_ipaddr_hash(addr
));
202 if (!qeth_card_hw_is_reachable(card
)) {
203 addr
->disp_flag
= QETH_DISP_ADDR_ADD
;
207 rc
= qeth_l3_register_addr_entry(card
, addr
);
209 if (!rc
|| rc
== -EADDRINUSE
|| rc
== -ENETDOWN
) {
210 addr
->disp_flag
= QETH_DISP_ADDR_DO_NOTHING
;
212 hash_del(&addr
->hnode
);
219 static int qeth_l3_modify_ip(struct qeth_card
*card
, struct qeth_ipaddr
*addr
,
224 mutex_lock(&card
->ip_lock
);
225 rc
= add
? qeth_l3_add_ip(card
, addr
) : qeth_l3_delete_ip(card
, addr
);
226 mutex_unlock(&card
->ip_lock
);
231 static void qeth_l3_drain_rx_mode_cache(struct qeth_card
*card
)
233 struct qeth_ipaddr
*addr
;
234 struct hlist_node
*tmp
;
237 hash_for_each_safe(card
->rx_mode_addrs
, i
, tmp
, addr
, hnode
) {
238 hash_del(&addr
->hnode
);
243 static void qeth_l3_clear_ip_htable(struct qeth_card
*card
, int recover
)
245 struct qeth_ipaddr
*addr
;
246 struct hlist_node
*tmp
;
249 QETH_CARD_TEXT(card
, 4, "clearip");
251 mutex_lock(&card
->ip_lock
);
253 hash_for_each_safe(card
->ip_htable
, i
, tmp
, addr
, hnode
) {
255 hash_del(&addr
->hnode
);
259 addr
->disp_flag
= QETH_DISP_ADDR_ADD
;
262 mutex_unlock(&card
->ip_lock
);
265 static void qeth_l3_recover_ip(struct qeth_card
*card
)
267 struct qeth_ipaddr
*addr
;
268 struct hlist_node
*tmp
;
272 QETH_CARD_TEXT(card
, 4, "recovrip");
274 mutex_lock(&card
->ip_lock
);
276 hash_for_each_safe(card
->ip_htable
, i
, tmp
, addr
, hnode
) {
277 if (addr
->disp_flag
== QETH_DISP_ADDR_ADD
) {
278 rc
= qeth_l3_register_addr_entry(card
, addr
);
281 addr
->disp_flag
= QETH_DISP_ADDR_DO_NOTHING
;
283 hash_del(&addr
->hnode
);
289 mutex_unlock(&card
->ip_lock
);
292 static int qeth_l3_setdelip_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
295 struct qeth_ipa_cmd
*cmd
= (struct qeth_ipa_cmd
*) data
;
297 switch (cmd
->hdr
.return_code
) {
300 case IPA_RC_DUPLICATE_IP_ADDRESS
:
302 case IPA_RC_MC_ADDR_NOT_FOUND
:
304 case IPA_RC_LAN_OFFLINE
:
311 static int qeth_l3_send_setdelmc(struct qeth_card
*card
,
312 struct qeth_ipaddr
*addr
,
313 enum qeth_ipa_cmds ipacmd
)
315 struct qeth_cmd_buffer
*iob
;
316 struct qeth_ipa_cmd
*cmd
;
318 QETH_CARD_TEXT(card
, 4, "setdelmc");
320 iob
= qeth_ipa_alloc_cmd(card
, ipacmd
, addr
->proto
,
321 IPA_DATA_SIZEOF(setdelipm
));
324 cmd
= __ipa_cmd(iob
);
325 if (addr
->proto
== QETH_PROT_IPV6
) {
326 cmd
->data
.setdelipm
.ip
= addr
->u
.a6
.addr
;
327 ipv6_eth_mc_map(&addr
->u
.a6
.addr
, cmd
->data
.setdelipm
.mac
);
329 cmd
->data
.setdelipm
.ip
.s6_addr32
[3] = addr
->u
.a4
.addr
;
330 ip_eth_mc_map(addr
->u
.a4
.addr
, cmd
->data
.setdelipm
.mac
);
333 return qeth_send_ipa_cmd(card
, iob
, qeth_l3_setdelip_cb
, NULL
);
336 static void qeth_l3_set_ipv6_prefix(struct in6_addr
*prefix
, unsigned int len
)
340 while (len
&& i
< 4) {
341 int mask_len
= min_t(int, len
, 32);
343 prefix
->s6_addr32
[i
] = inet_make_mask(mask_len
);
349 static u32
qeth_l3_get_setdelip_flags(struct qeth_ipaddr
*addr
, bool set
)
351 switch (addr
->type
) {
352 case QETH_IP_TYPE_RXIP
:
353 return (set
) ? QETH_IPA_SETIP_TAKEOVER_FLAG
: 0;
354 case QETH_IP_TYPE_VIPA
:
355 return (set
) ? QETH_IPA_SETIP_VIPA_FLAG
:
356 QETH_IPA_DELIP_VIPA_FLAG
;
358 return (set
&& addr
->ipato
) ? QETH_IPA_SETIP_TAKEOVER_FLAG
: 0;
362 static int qeth_l3_send_setdelip(struct qeth_card
*card
,
363 struct qeth_ipaddr
*addr
,
364 enum qeth_ipa_cmds ipacmd
)
366 struct qeth_cmd_buffer
*iob
;
367 struct qeth_ipa_cmd
*cmd
;
370 QETH_CARD_TEXT(card
, 4, "setdelip");
372 iob
= qeth_ipa_alloc_cmd(card
, ipacmd
, addr
->proto
,
373 IPA_DATA_SIZEOF(setdelip6
));
376 cmd
= __ipa_cmd(iob
);
378 flags
= qeth_l3_get_setdelip_flags(addr
, ipacmd
== IPA_CMD_SETIP
);
379 QETH_CARD_TEXT_(card
, 4, "flags%02X", flags
);
381 if (addr
->proto
== QETH_PROT_IPV6
) {
382 cmd
->data
.setdelip6
.addr
= addr
->u
.a6
.addr
;
383 qeth_l3_set_ipv6_prefix(&cmd
->data
.setdelip6
.prefix
,
385 cmd
->data
.setdelip6
.flags
= flags
;
387 cmd
->data
.setdelip4
.addr
= addr
->u
.a4
.addr
;
388 cmd
->data
.setdelip4
.mask
= addr
->u
.a4
.mask
;
389 cmd
->data
.setdelip4
.flags
= flags
;
392 return qeth_send_ipa_cmd(card
, iob
, qeth_l3_setdelip_cb
, NULL
);
395 static int qeth_l3_send_setrouting(struct qeth_card
*card
,
396 enum qeth_routing_types type
, enum qeth_prot_versions prot
)
399 struct qeth_ipa_cmd
*cmd
;
400 struct qeth_cmd_buffer
*iob
;
402 QETH_CARD_TEXT(card
, 4, "setroutg");
403 iob
= qeth_ipa_alloc_cmd(card
, IPA_CMD_SETRTG
, prot
,
404 IPA_DATA_SIZEOF(setrtg
));
407 cmd
= __ipa_cmd(iob
);
408 cmd
->data
.setrtg
.type
= (type
);
409 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
414 static int qeth_l3_correct_routing_type(struct qeth_card
*card
,
415 enum qeth_routing_types
*type
, enum qeth_prot_versions prot
)
420 case PRIMARY_CONNECTOR
:
421 case SECONDARY_CONNECTOR
:
422 case MULTICAST_ROUTER
:
431 case SECONDARY_ROUTER
:
433 case MULTICAST_ROUTER
:
434 if (qeth_is_ipafunc_supported(card
, prot
,
447 int qeth_l3_setrouting_v4(struct qeth_card
*card
)
451 QETH_CARD_TEXT(card
, 3, "setrtg4");
453 rc
= qeth_l3_correct_routing_type(card
, &card
->options
.route4
.type
,
458 rc
= qeth_l3_send_setrouting(card
, card
->options
.route4
.type
,
461 card
->options
.route4
.type
= NO_ROUTER
;
462 QETH_DBF_MESSAGE(2, "Error (%#06x) while setting routing type on device %x. Type set to 'no router'.\n",
463 rc
, CARD_DEVID(card
));
468 int qeth_l3_setrouting_v6(struct qeth_card
*card
)
472 QETH_CARD_TEXT(card
, 3, "setrtg6");
474 if (!qeth_is_supported(card
, IPA_IPV6
))
476 rc
= qeth_l3_correct_routing_type(card
, &card
->options
.route6
.type
,
481 rc
= qeth_l3_send_setrouting(card
, card
->options
.route6
.type
,
484 card
->options
.route6
.type
= NO_ROUTER
;
485 QETH_DBF_MESSAGE(2, "Error (%#06x) while setting routing type on device %x. Type set to 'no router'.\n",
486 rc
, CARD_DEVID(card
));
492 * IP address takeover related functions
496 * qeth_l3_update_ipato() - Update 'takeover' property, for all NORMAL IPs.
498 * Caller must hold ip_lock.
500 void qeth_l3_update_ipato(struct qeth_card
*card
)
502 struct qeth_ipaddr
*addr
;
505 hash_for_each(card
->ip_htable
, i
, addr
, hnode
) {
506 if (addr
->type
!= QETH_IP_TYPE_NORMAL
)
508 addr
->ipato
= qeth_l3_is_addr_covered_by_ipato(card
, addr
);
512 static void qeth_l3_clear_ipato_list(struct qeth_card
*card
)
514 struct qeth_ipato_entry
*ipatoe
, *tmp
;
516 mutex_lock(&card
->ip_lock
);
518 list_for_each_entry_safe(ipatoe
, tmp
, &card
->ipato
.entries
, entry
) {
519 list_del(&ipatoe
->entry
);
523 qeth_l3_update_ipato(card
);
524 mutex_unlock(&card
->ip_lock
);
527 int qeth_l3_add_ipato_entry(struct qeth_card
*card
,
528 struct qeth_ipato_entry
*new)
530 struct qeth_ipato_entry
*ipatoe
;
533 QETH_CARD_TEXT(card
, 2, "addipato");
535 mutex_lock(&card
->ip_lock
);
537 list_for_each_entry(ipatoe
, &card
->ipato
.entries
, entry
) {
538 if (ipatoe
->proto
!= new->proto
)
540 if (!memcmp(ipatoe
->addr
, new->addr
,
541 (ipatoe
->proto
== QETH_PROT_IPV4
) ? 4 : 16) &&
542 (ipatoe
->mask_bits
== new->mask_bits
)) {
549 list_add_tail(&new->entry
, &card
->ipato
.entries
);
550 qeth_l3_update_ipato(card
);
553 mutex_unlock(&card
->ip_lock
);
558 int qeth_l3_del_ipato_entry(struct qeth_card
*card
,
559 enum qeth_prot_versions proto
, u8
*addr
,
560 unsigned int mask_bits
)
562 struct qeth_ipato_entry
*ipatoe
, *tmp
;
565 QETH_CARD_TEXT(card
, 2, "delipato");
567 mutex_lock(&card
->ip_lock
);
569 list_for_each_entry_safe(ipatoe
, tmp
, &card
->ipato
.entries
, entry
) {
570 if (ipatoe
->proto
!= proto
)
572 if (!memcmp(ipatoe
->addr
, addr
,
573 (proto
== QETH_PROT_IPV4
) ? 4 : 16) &&
574 (ipatoe
->mask_bits
== mask_bits
)) {
575 list_del(&ipatoe
->entry
);
576 qeth_l3_update_ipato(card
);
582 mutex_unlock(&card
->ip_lock
);
587 int qeth_l3_modify_rxip_vipa(struct qeth_card
*card
, bool add
, const u8
*ip
,
588 enum qeth_ip_types type
,
589 enum qeth_prot_versions proto
)
591 struct qeth_ipaddr addr
;
593 qeth_l3_init_ipaddr(&addr
, type
, proto
);
594 if (proto
== QETH_PROT_IPV4
)
595 memcpy(&addr
.u
.a4
.addr
, ip
, 4);
597 memcpy(&addr
.u
.a6
.addr
, ip
, 16);
599 return qeth_l3_modify_ip(card
, &addr
, add
);
602 int qeth_l3_modify_hsuid(struct qeth_card
*card
, bool add
)
604 struct qeth_ipaddr addr
;
607 qeth_l3_init_ipaddr(&addr
, QETH_IP_TYPE_NORMAL
, QETH_PROT_IPV6
);
608 addr
.u
.a6
.addr
.s6_addr
[0] = 0xfe;
609 addr
.u
.a6
.addr
.s6_addr
[1] = 0x80;
610 for (i
= 0; i
< 8; i
++)
611 addr
.u
.a6
.addr
.s6_addr
[8+i
] = card
->options
.hsuid
[i
];
613 return qeth_l3_modify_ip(card
, &addr
, add
);
616 static int qeth_l3_register_addr_entry(struct qeth_card
*card
,
617 struct qeth_ipaddr
*addr
)
623 if (card
->options
.sniffer
)
626 if (addr
->proto
== QETH_PROT_IPV4
) {
627 QETH_CARD_TEXT(card
, 2, "setaddr4");
628 QETH_CARD_HEX(card
, 3, &addr
->u
.a4
.addr
, sizeof(int));
629 } else if (addr
->proto
== QETH_PROT_IPV6
) {
630 QETH_CARD_TEXT(card
, 2, "setaddr6");
631 QETH_CARD_HEX(card
, 3, &addr
->u
.a6
.addr
, 8);
632 QETH_CARD_HEX(card
, 3, ((char *)&addr
->u
.a6
.addr
) + 8, 8);
634 QETH_CARD_TEXT(card
, 2, "setaddr?");
635 QETH_CARD_HEX(card
, 3, addr
, sizeof(struct qeth_ipaddr
));
638 if (addr
->is_multicast
)
639 rc
= qeth_l3_send_setdelmc(card
, addr
, IPA_CMD_SETIPM
);
641 rc
= qeth_l3_send_setdelip(card
, addr
, IPA_CMD_SETIP
);
643 QETH_CARD_TEXT(card
, 2, "failed");
644 } while ((--cnt
> 0) && rc
);
646 QETH_CARD_TEXT(card
, 2, "FAILED");
647 qeth_l3_ipaddr_to_string(addr
->proto
, (u8
*)&addr
->u
, buf
);
648 dev_warn(&card
->gdev
->dev
,
649 "Registering IP address %s failed\n", buf
);
654 static int qeth_l3_deregister_addr_entry(struct qeth_card
*card
,
655 struct qeth_ipaddr
*addr
)
659 if (card
->options
.sniffer
)
662 if (addr
->proto
== QETH_PROT_IPV4
) {
663 QETH_CARD_TEXT(card
, 2, "deladdr4");
664 QETH_CARD_HEX(card
, 3, &addr
->u
.a4
.addr
, sizeof(int));
665 } else if (addr
->proto
== QETH_PROT_IPV6
) {
666 QETH_CARD_TEXT(card
, 2, "deladdr6");
667 QETH_CARD_HEX(card
, 3, &addr
->u
.a6
.addr
, 8);
668 QETH_CARD_HEX(card
, 3, ((char *)&addr
->u
.a6
.addr
) + 8, 8);
670 QETH_CARD_TEXT(card
, 2, "deladdr?");
671 QETH_CARD_HEX(card
, 3, addr
, sizeof(struct qeth_ipaddr
));
673 if (addr
->is_multicast
)
674 rc
= qeth_l3_send_setdelmc(card
, addr
, IPA_CMD_DELIPM
);
676 rc
= qeth_l3_send_setdelip(card
, addr
, IPA_CMD_DELIP
);
678 QETH_CARD_TEXT(card
, 2, "failed");
683 static int qeth_l3_setadapter_parms(struct qeth_card
*card
)
687 QETH_CARD_TEXT(card
, 2, "setadprm");
689 if (qeth_adp_supported(card
, IPA_SETADP_ALTER_MAC_ADDRESS
)) {
690 rc
= qeth_setadpparms_change_macaddr(card
);
692 dev_warn(&card
->gdev
->dev
, "Reading the adapter MAC"
693 " address failed\n");
699 static int qeth_l3_start_ipa_arp_processing(struct qeth_card
*card
)
703 QETH_CARD_TEXT(card
, 3, "ipaarp");
705 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
706 dev_info(&card
->gdev
->dev
,
707 "ARP processing not supported on %s!\n",
708 netdev_name(card
->dev
));
711 rc
= qeth_send_simple_setassparms(card
, IPA_ARP_PROCESSING
,
712 IPA_CMD_ASS_START
, NULL
);
714 dev_warn(&card
->gdev
->dev
,
715 "Starting ARP processing support for %s failed\n",
716 netdev_name(card
->dev
));
721 static int qeth_l3_start_ipa_source_mac(struct qeth_card
*card
)
725 QETH_CARD_TEXT(card
, 3, "stsrcmac");
727 if (!qeth_is_supported(card
, IPA_SOURCE_MAC
)) {
728 dev_info(&card
->gdev
->dev
,
729 "Inbound source MAC-address not supported on %s\n",
730 netdev_name(card
->dev
));
734 rc
= qeth_send_simple_setassparms(card
, IPA_SOURCE_MAC
,
735 IPA_CMD_ASS_START
, NULL
);
737 dev_warn(&card
->gdev
->dev
,
738 "Starting source MAC-address support for %s failed\n",
739 netdev_name(card
->dev
));
743 static int qeth_l3_start_ipa_vlan(struct qeth_card
*card
)
747 QETH_CARD_TEXT(card
, 3, "strtvlan");
749 if (!qeth_is_supported(card
, IPA_FULL_VLAN
)) {
750 dev_info(&card
->gdev
->dev
,
751 "VLAN not supported on %s\n", netdev_name(card
->dev
));
755 rc
= qeth_send_simple_setassparms(card
, IPA_VLAN_PRIO
,
756 IPA_CMD_ASS_START
, NULL
);
758 dev_warn(&card
->gdev
->dev
,
759 "Starting VLAN support for %s failed\n",
760 netdev_name(card
->dev
));
762 dev_info(&card
->gdev
->dev
, "VLAN enabled\n");
767 static int qeth_l3_start_ipa_multicast(struct qeth_card
*card
)
771 QETH_CARD_TEXT(card
, 3, "stmcast");
773 if (!qeth_is_supported(card
, IPA_MULTICASTING
)) {
774 dev_info(&card
->gdev
->dev
,
775 "Multicast not supported on %s\n",
776 netdev_name(card
->dev
));
780 rc
= qeth_send_simple_setassparms(card
, IPA_MULTICASTING
,
781 IPA_CMD_ASS_START
, NULL
);
783 dev_warn(&card
->gdev
->dev
,
784 "Starting multicast support for %s failed\n",
785 netdev_name(card
->dev
));
787 dev_info(&card
->gdev
->dev
, "Multicast enabled\n");
788 card
->dev
->flags
|= IFF_MULTICAST
;
793 static int qeth_l3_softsetup_ipv6(struct qeth_card
*card
)
798 QETH_CARD_TEXT(card
, 3, "softipv6");
803 rc
= qeth_send_simple_setassparms(card
, IPA_IPV6
, IPA_CMD_ASS_START
,
806 dev_err(&card
->gdev
->dev
,
807 "Activating IPv6 support for %s failed\n",
808 netdev_name(card
->dev
));
811 rc
= qeth_send_simple_setassparms_v6(card
, IPA_IPV6
, IPA_CMD_ASS_START
,
814 dev_err(&card
->gdev
->dev
,
815 "Activating IPv6 support for %s failed\n",
816 netdev_name(card
->dev
));
819 rc
= qeth_send_simple_setassparms_v6(card
, IPA_PASSTHRU
,
820 IPA_CMD_ASS_START
, NULL
);
822 dev_warn(&card
->gdev
->dev
,
823 "Enabling the passthrough mode for %s failed\n",
824 netdev_name(card
->dev
));
828 dev_info(&card
->gdev
->dev
, "IPV6 enabled\n");
832 static int qeth_l3_start_ipa_ipv6(struct qeth_card
*card
)
834 QETH_CARD_TEXT(card
, 3, "strtipv6");
836 if (!qeth_is_supported(card
, IPA_IPV6
)) {
837 dev_info(&card
->gdev
->dev
,
838 "IPv6 not supported on %s\n", netdev_name(card
->dev
));
841 return qeth_l3_softsetup_ipv6(card
);
844 static int qeth_l3_start_ipa_broadcast(struct qeth_card
*card
)
849 QETH_CARD_TEXT(card
, 3, "stbrdcst");
850 card
->info
.broadcast_capable
= 0;
851 if (!qeth_is_supported(card
, IPA_FILTERING
)) {
852 dev_info(&card
->gdev
->dev
,
853 "Broadcast not supported on %s\n",
854 netdev_name(card
->dev
));
858 rc
= qeth_send_simple_setassparms(card
, IPA_FILTERING
,
859 IPA_CMD_ASS_START
, NULL
);
861 dev_warn(&card
->gdev
->dev
,
862 "Enabling broadcast filtering for %s failed\n",
863 netdev_name(card
->dev
));
867 rc
= qeth_send_simple_setassparms(card
, IPA_FILTERING
,
868 IPA_CMD_ASS_CONFIGURE
, &filter_data
);
870 dev_warn(&card
->gdev
->dev
,
871 "Setting up broadcast filtering for %s failed\n",
872 netdev_name(card
->dev
));
875 card
->info
.broadcast_capable
= QETH_BROADCAST_WITH_ECHO
;
876 dev_info(&card
->gdev
->dev
, "Broadcast enabled\n");
877 rc
= qeth_send_simple_setassparms(card
, IPA_FILTERING
,
878 IPA_CMD_ASS_ENABLE
, &filter_data
);
880 dev_warn(&card
->gdev
->dev
,
881 "Setting up broadcast echo filtering for %s failed\n",
882 netdev_name(card
->dev
));
885 card
->info
.broadcast_capable
= QETH_BROADCAST_WITHOUT_ECHO
;
887 if (card
->info
.broadcast_capable
)
888 card
->dev
->flags
|= IFF_BROADCAST
;
890 card
->dev
->flags
&= ~IFF_BROADCAST
;
894 static void qeth_l3_start_ipassists(struct qeth_card
*card
)
896 QETH_CARD_TEXT(card
, 3, "strtipas");
898 qeth_l3_start_ipa_arp_processing(card
); /* go on*/
899 qeth_l3_start_ipa_source_mac(card
); /* go on*/
900 qeth_l3_start_ipa_vlan(card
); /* go on*/
901 qeth_l3_start_ipa_multicast(card
); /* go on*/
902 qeth_l3_start_ipa_ipv6(card
); /* go on*/
903 qeth_l3_start_ipa_broadcast(card
); /* go on*/
906 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card
*card
,
907 struct qeth_reply
*reply
, unsigned long data
)
909 struct qeth_ipa_cmd
*cmd
= (struct qeth_ipa_cmd
*) data
;
911 if (cmd
->hdr
.return_code
)
913 if (!is_valid_ether_addr(cmd
->data
.create_destroy_addr
.mac_addr
))
914 return -EADDRNOTAVAIL
;
916 eth_hw_addr_set(card
->dev
, cmd
->data
.create_destroy_addr
.mac_addr
);
920 static int qeth_l3_iqd_read_initial_mac(struct qeth_card
*card
)
923 struct qeth_cmd_buffer
*iob
;
925 QETH_CARD_TEXT(card
, 2, "hsrmac");
927 iob
= qeth_ipa_alloc_cmd(card
, IPA_CMD_CREATE_ADDR
, QETH_PROT_IPV6
,
928 IPA_DATA_SIZEOF(create_destroy_addr
));
932 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_l3_iqd_read_initial_mac_cb
,
937 static int qeth_l3_get_unique_id_cb(struct qeth_card
*card
,
938 struct qeth_reply
*reply
, unsigned long data
)
940 struct qeth_ipa_cmd
*cmd
= (struct qeth_ipa_cmd
*) data
;
941 u16
*uid
= reply
->param
;
943 if (cmd
->hdr
.return_code
== 0) {
944 *uid
= cmd
->data
.create_destroy_addr
.uid
;
948 dev_warn(&card
->gdev
->dev
, "The network adapter failed to generate a unique ID\n");
952 static u16
qeth_l3_get_unique_id(struct qeth_card
*card
, u16 uid
)
954 struct qeth_cmd_buffer
*iob
;
956 QETH_CARD_TEXT(card
, 2, "guniqeid");
958 if (!qeth_is_supported(card
, IPA_IPV6
))
961 iob
= qeth_ipa_alloc_cmd(card
, IPA_CMD_CREATE_ADDR
, QETH_PROT_IPV6
,
962 IPA_DATA_SIZEOF(create_destroy_addr
));
966 __ipa_cmd(iob
)->data
.create_destroy_addr
.uid
= uid
;
967 qeth_send_ipa_cmd(card
, iob
, qeth_l3_get_unique_id_cb
, &uid
);
974 qeth_diags_trace_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
977 struct qeth_ipa_cmd
*cmd
;
980 QETH_CARD_TEXT(card
, 2, "diastrcb");
982 cmd
= (struct qeth_ipa_cmd
*)data
;
983 rc
= cmd
->hdr
.return_code
;
985 QETH_CARD_TEXT_(card
, 2, "dxter%x", rc
);
986 switch (cmd
->data
.diagass
.action
) {
987 case QETH_DIAGS_CMD_TRACE_QUERY
:
989 case QETH_DIAGS_CMD_TRACE_DISABLE
:
992 case IPA_RC_INVALID_SUBCMD
:
993 card
->info
.promisc_mode
= SET_PROMISC_MODE_OFF
;
994 dev_info(&card
->gdev
->dev
, "The HiperSockets network "
995 "traffic analyzer is deactivated\n");
1001 case QETH_DIAGS_CMD_TRACE_ENABLE
:
1004 card
->info
.promisc_mode
= SET_PROMISC_MODE_ON
;
1005 dev_info(&card
->gdev
->dev
, "The HiperSockets network "
1006 "traffic analyzer is activated\n");
1008 case IPA_RC_HARDWARE_AUTH_ERROR
:
1009 dev_warn(&card
->gdev
->dev
, "The device is not "
1010 "authorized to run as a HiperSockets network "
1011 "traffic analyzer\n");
1013 case IPA_RC_TRACE_ALREADY_ACTIVE
:
1014 dev_warn(&card
->gdev
->dev
, "A HiperSockets "
1015 "network traffic analyzer is already "
1016 "active in the HiperSockets LAN\n");
1023 QETH_DBF_MESSAGE(2, "Unknown sniffer action (%#06x) on device %x\n",
1024 cmd
->data
.diagass
.action
, CARD_DEVID(card
));
1027 return rc
? -EIO
: 0;
1031 qeth_diags_trace(struct qeth_card
*card
, enum qeth_diags_trace_cmds diags_cmd
)
1033 struct qeth_cmd_buffer
*iob
;
1034 struct qeth_ipa_cmd
*cmd
;
1036 QETH_CARD_TEXT(card
, 2, "diagtrac");
1038 iob
= qeth_get_diag_cmd(card
, QETH_DIAGS_CMD_TRACE
, 0);
1041 cmd
= __ipa_cmd(iob
);
1042 cmd
->data
.diagass
.type
= QETH_DIAGS_TYPE_HIPERSOCKET
;
1043 cmd
->data
.diagass
.action
= diags_cmd
;
1044 return qeth_send_ipa_cmd(card
, iob
, qeth_diags_trace_cb
, NULL
);
1047 static int qeth_l3_add_mcast_rtnl(struct net_device
*dev
, int vid
, void *arg
)
1049 struct qeth_card
*card
= arg
;
1050 struct inet6_dev
*in6_dev
;
1051 struct in_device
*in4_dev
;
1052 struct qeth_ipaddr
*ipm
;
1053 struct qeth_ipaddr tmp
;
1054 struct ip_mc_list
*im4
;
1055 struct ifmcaddr6
*im6
;
1057 QETH_CARD_TEXT(card
, 4, "addmc");
1059 if (!dev
|| !(dev
->flags
& IFF_UP
))
1062 in4_dev
= __in_dev_get_rtnl(dev
);
1066 qeth_l3_init_ipaddr(&tmp
, QETH_IP_TYPE_NORMAL
, QETH_PROT_IPV4
);
1067 tmp
.disp_flag
= QETH_DISP_ADDR_ADD
;
1068 tmp
.is_multicast
= 1;
1070 for (im4
= rtnl_dereference(in4_dev
->mc_list
); im4
!= NULL
;
1071 im4
= rtnl_dereference(im4
->next_rcu
)) {
1072 tmp
.u
.a4
.addr
= im4
->multiaddr
;
1074 ipm
= qeth_l3_find_addr_by_ip(card
, &tmp
);
1076 /* for mcast, by-IP match means full match */
1077 ipm
->disp_flag
= QETH_DISP_ADDR_DO_NOTHING
;
1081 ipm
= kmemdup(&tmp
, sizeof(tmp
), GFP_KERNEL
);
1085 hash_add(card
->rx_mode_addrs
, &ipm
->hnode
,
1086 qeth_l3_ipaddr_hash(ipm
));
1090 if (!qeth_is_supported(card
, IPA_IPV6
))
1093 in6_dev
= __in6_dev_get(dev
);
1097 qeth_l3_init_ipaddr(&tmp
, QETH_IP_TYPE_NORMAL
, QETH_PROT_IPV6
);
1098 tmp
.disp_flag
= QETH_DISP_ADDR_ADD
;
1099 tmp
.is_multicast
= 1;
1101 for (im6
= rtnl_dereference(in6_dev
->mc_list
);
1103 im6
= rtnl_dereference(im6
->next
)) {
1104 tmp
.u
.a6
.addr
= im6
->mca_addr
;
1106 ipm
= qeth_l3_find_addr_by_ip(card
, &tmp
);
1108 /* for mcast, by-IP match means full match */
1109 ipm
->disp_flag
= QETH_DISP_ADDR_DO_NOTHING
;
1113 ipm
= kmemdup(&tmp
, sizeof(tmp
), GFP_ATOMIC
);
1117 hash_add(card
->rx_mode_addrs
, &ipm
->hnode
,
1118 qeth_l3_ipaddr_hash(ipm
));
1126 static void qeth_l3_set_promisc_mode(struct qeth_card
*card
)
1128 bool enable
= card
->dev
->flags
& IFF_PROMISC
;
1130 if (card
->info
.promisc_mode
== enable
)
1133 if (IS_VM_NIC(card
)) { /* Guestlan trace */
1134 if (qeth_adp_supported(card
, IPA_SETADP_SET_PROMISC_MODE
))
1135 qeth_setadp_promisc_mode(card
, enable
);
1136 } else if (card
->options
.sniffer
&& /* HiperSockets trace */
1137 qeth_adp_supported(card
, IPA_SETADP_SET_DIAG_ASSIST
)) {
1139 QETH_CARD_TEXT(card
, 3, "+promisc");
1140 qeth_diags_trace(card
, QETH_DIAGS_CMD_TRACE_ENABLE
);
1142 QETH_CARD_TEXT(card
, 3, "-promisc");
1143 qeth_diags_trace(card
, QETH_DIAGS_CMD_TRACE_DISABLE
);
1148 static void qeth_l3_rx_mode_work(struct work_struct
*work
)
1150 struct qeth_card
*card
= container_of(work
, struct qeth_card
,
1152 struct qeth_ipaddr
*addr
;
1153 struct hlist_node
*tmp
;
1156 QETH_CARD_TEXT(card
, 3, "setmulti");
1158 if (!card
->options
.sniffer
) {
1160 qeth_l3_add_mcast_rtnl(card
->dev
, 0, card
);
1161 if (qeth_is_supported(card
, IPA_FULL_VLAN
))
1162 vlan_for_each(card
->dev
, qeth_l3_add_mcast_rtnl
, card
);
1165 hash_for_each_safe(card
->rx_mode_addrs
, i
, tmp
, addr
, hnode
) {
1166 switch (addr
->disp_flag
) {
1167 case QETH_DISP_ADDR_DELETE
:
1168 rc
= qeth_l3_deregister_addr_entry(card
, addr
);
1169 if (!rc
|| rc
== -ENOENT
) {
1170 hash_del(&addr
->hnode
);
1174 case QETH_DISP_ADDR_ADD
:
1175 rc
= qeth_l3_register_addr_entry(card
, addr
);
1176 if (rc
&& rc
!= -ENETDOWN
) {
1177 hash_del(&addr
->hnode
);
1183 /* for next call to set_rx_mode(): */
1184 addr
->disp_flag
= QETH_DISP_ADDR_DELETE
;
1189 qeth_l3_set_promisc_mode(card
);
1192 static int qeth_l3_arp_makerc(u16 rc
)
1195 case IPA_RC_SUCCESS
:
1197 case QETH_IPA_ARP_RC_NOTSUPP
:
1198 case QETH_IPA_ARP_RC_Q_NOTSUPP
:
1200 case QETH_IPA_ARP_RC_OUT_OF_RANGE
:
1202 case QETH_IPA_ARP_RC_Q_NO_DATA
:
1209 static int qeth_l3_arp_cmd_cb(struct qeth_card
*card
, struct qeth_reply
*reply
,
1212 struct qeth_ipa_cmd
*cmd
= (struct qeth_ipa_cmd
*) data
;
1214 qeth_setassparms_cb(card
, reply
, data
);
1215 return qeth_l3_arp_makerc(cmd
->hdr
.return_code
);
1218 static int qeth_l3_arp_set_no_entries(struct qeth_card
*card
, int no_entries
)
1220 struct qeth_cmd_buffer
*iob
;
1223 QETH_CARD_TEXT(card
, 3, "arpstnoe");
1226 * currently GuestLAN only supports the ARP assist function
1227 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
1228 * thus we say EOPNOTSUPP for this ARP function
1230 if (IS_VM_NIC(card
))
1232 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
1236 iob
= qeth_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
,
1237 IPA_CMD_ASS_ARP_SET_NO_ENTRIES
,
1238 SETASS_DATA_SIZEOF(flags_32bit
),
1243 __ipa_cmd(iob
)->data
.setassparms
.data
.flags_32bit
= (u32
) no_entries
;
1244 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_l3_arp_cmd_cb
, NULL
);
1246 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on device %x: %#x\n",
1247 CARD_DEVID(card
), rc
);
1251 static __u32
get_arp_entry_size(struct qeth_card
*card
,
1252 struct qeth_arp_query_data
*qdata
,
1253 struct qeth_arp_entrytype
*type
, __u8 strip_entries
)
1258 is_hsi
= qdata
->reply_bits
== 5;
1259 if (type
->ip
== QETHARP_IP_ADDR_V4
) {
1260 QETH_CARD_TEXT(card
, 4, "arpev4");
1261 if (strip_entries
) {
1262 rc
= is_hsi
? sizeof(struct qeth_arp_qi_entry5_short
) :
1263 sizeof(struct qeth_arp_qi_entry7_short
);
1265 rc
= is_hsi
? sizeof(struct qeth_arp_qi_entry5
) :
1266 sizeof(struct qeth_arp_qi_entry7
);
1268 } else if (type
->ip
== QETHARP_IP_ADDR_V6
) {
1269 QETH_CARD_TEXT(card
, 4, "arpev6");
1270 if (strip_entries
) {
1272 sizeof(struct qeth_arp_qi_entry5_short_ipv6
) :
1273 sizeof(struct qeth_arp_qi_entry7_short_ipv6
);
1276 sizeof(struct qeth_arp_qi_entry5_ipv6
) :
1277 sizeof(struct qeth_arp_qi_entry7_ipv6
);
1280 QETH_CARD_TEXT(card
, 4, "arpinv");
1287 static int arpentry_matches_prot(struct qeth_arp_entrytype
*type
, __u16 prot
)
1289 return (type
->ip
== QETHARP_IP_ADDR_V4
&& prot
== QETH_PROT_IPV4
) ||
1290 (type
->ip
== QETHARP_IP_ADDR_V6
&& prot
== QETH_PROT_IPV6
);
1293 static int qeth_l3_arp_query_cb(struct qeth_card
*card
,
1294 struct qeth_reply
*reply
, unsigned long data
)
1296 struct qeth_ipa_cmd
*cmd
;
1297 struct qeth_arp_query_data
*qdata
;
1298 struct qeth_arp_query_info
*qinfo
;
1300 int entrybytes_done
;
1302 __u8 do_strip_entries
;
1304 QETH_CARD_TEXT(card
, 3, "arpquecb");
1306 qinfo
= (struct qeth_arp_query_info
*) reply
->param
;
1307 cmd
= (struct qeth_ipa_cmd
*) data
;
1308 QETH_CARD_TEXT_(card
, 4, "%i", cmd
->hdr
.prot_version
);
1309 if (cmd
->hdr
.return_code
) {
1310 QETH_CARD_TEXT(card
, 4, "arpcberr");
1311 QETH_CARD_TEXT_(card
, 4, "%i", cmd
->hdr
.return_code
);
1312 return qeth_l3_arp_makerc(cmd
->hdr
.return_code
);
1314 if (cmd
->data
.setassparms
.hdr
.return_code
) {
1315 cmd
->hdr
.return_code
= cmd
->data
.setassparms
.hdr
.return_code
;
1316 QETH_CARD_TEXT(card
, 4, "setaperr");
1317 QETH_CARD_TEXT_(card
, 4, "%i", cmd
->hdr
.return_code
);
1318 return qeth_l3_arp_makerc(cmd
->hdr
.return_code
);
1320 qdata
= &cmd
->data
.setassparms
.data
.query_arp
;
1321 QETH_CARD_TEXT_(card
, 4, "anoen%i", qdata
->no_entries
);
1323 do_strip_entries
= (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
) > 0;
1324 stripped_bytes
= do_strip_entries
? QETH_QARP_MEDIASPECIFIC_BYTES
: 0;
1325 entrybytes_done
= 0;
1326 for (e
= 0; e
< qdata
->no_entries
; ++e
) {
1329 struct qeth_arp_entrytype
*etype
;
1331 cur_entry
= &qdata
->data
+ entrybytes_done
;
1332 etype
= &((struct qeth_arp_qi_entry5
*) cur_entry
)->type
;
1333 if (!arpentry_matches_prot(etype
, cmd
->hdr
.prot_version
)) {
1334 QETH_CARD_TEXT(card
, 4, "pmis");
1335 QETH_CARD_TEXT_(card
, 4, "%i", etype
->ip
);
1338 esize
= get_arp_entry_size(card
, qdata
, etype
,
1340 QETH_CARD_TEXT_(card
, 5, "esz%i", esize
);
1344 if ((qinfo
->udata_len
- qinfo
->udata_offset
) < esize
) {
1345 QETH_CARD_TEXT_(card
, 4, "qaer3%i", -ENOSPC
);
1346 memset(qinfo
->udata
, 0, 4);
1350 memcpy(qinfo
->udata
+ qinfo
->udata_offset
,
1351 &qdata
->data
+ entrybytes_done
+ stripped_bytes
,
1353 entrybytes_done
+= esize
+ stripped_bytes
;
1354 qinfo
->udata_offset
+= esize
;
1355 ++qinfo
->no_entries
;
1357 /* check if all replies received ... */
1358 if (cmd
->data
.setassparms
.hdr
.seq_no
<
1359 cmd
->data
.setassparms
.hdr
.number_of_replies
)
1361 QETH_CARD_TEXT_(card
, 4, "nove%i", qinfo
->no_entries
);
1362 memcpy(qinfo
->udata
, &qinfo
->no_entries
, 4);
1363 /* keep STRIP_ENTRIES flag so the user program can distinguish
1364 * stripped entries from normal ones */
1365 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
)
1366 qdata
->reply_bits
|= QETH_QARP_STRIP_ENTRIES
;
1367 memcpy(qinfo
->udata
+ QETH_QARP_MASK_OFFSET
, &qdata
->reply_bits
, 2);
1368 QETH_CARD_TEXT_(card
, 4, "rc%i", 0);
1372 static int qeth_l3_query_arp_cache_info(struct qeth_card
*card
,
1373 enum qeth_prot_versions prot
,
1374 struct qeth_arp_query_info
*qinfo
)
1376 struct qeth_cmd_buffer
*iob
;
1377 struct qeth_ipa_cmd
*cmd
;
1380 QETH_CARD_TEXT_(card
, 3, "qarpipv%i", prot
);
1382 iob
= qeth_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
,
1383 IPA_CMD_ASS_ARP_QUERY_INFO
,
1384 SETASS_DATA_SIZEOF(query_arp
), prot
);
1387 cmd
= __ipa_cmd(iob
);
1388 cmd
->data
.setassparms
.data
.query_arp
.request_bits
= 0x000F;
1389 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_l3_arp_query_cb
, qinfo
);
1391 QETH_DBF_MESSAGE(2, "Error while querying ARP cache on device %x: %#x\n",
1392 CARD_DEVID(card
), rc
);
1396 static int qeth_l3_arp_query(struct qeth_card
*card
, char __user
*udata
)
1398 struct qeth_arp_query_info qinfo
= {0, };
1401 QETH_CARD_TEXT(card
, 3, "arpquery");
1403 if (!qeth_is_supported(card
,/*IPA_QUERY_ARP_ADDR_INFO*/
1404 IPA_ARP_PROCESSING
)) {
1405 QETH_CARD_TEXT(card
, 3, "arpqnsup");
1409 /* get size of userspace buffer and mask_bits -> 6 bytes */
1410 if (copy_from_user(&qinfo
, udata
, 6)) {
1414 qinfo
.udata
= kzalloc(qinfo
.udata_len
, GFP_KERNEL
);
1419 qinfo
.udata_offset
= QETH_QARP_ENTRIES_OFFSET
;
1420 rc
= qeth_l3_query_arp_cache_info(card
, QETH_PROT_IPV4
, &qinfo
);
1422 if (copy_to_user(udata
, qinfo
.udata
, 4))
1426 if (qinfo
.mask_bits
& QETH_QARP_WITH_IPV6
) {
1427 /* fails in case of GuestLAN QDIO mode */
1428 qeth_l3_query_arp_cache_info(card
, QETH_PROT_IPV6
, &qinfo
);
1430 if (copy_to_user(udata
, qinfo
.udata
, qinfo
.udata_len
)) {
1431 QETH_CARD_TEXT(card
, 4, "qactf");
1435 QETH_CARD_TEXT(card
, 4, "qacts");
1443 static int qeth_l3_arp_modify_entry(struct qeth_card
*card
,
1444 struct qeth_arp_cache_entry
*entry
,
1445 enum qeth_arp_process_subcmds arp_cmd
)
1447 struct qeth_arp_cache_entry
*cmd_entry
;
1448 struct qeth_cmd_buffer
*iob
;
1451 if (arp_cmd
== IPA_CMD_ASS_ARP_ADD_ENTRY
)
1452 QETH_CARD_TEXT(card
, 3, "arpadd");
1454 QETH_CARD_TEXT(card
, 3, "arpdel");
1457 * currently GuestLAN only supports the ARP assist function
1458 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
1459 * thus we say EOPNOTSUPP for this ARP function
1461 if (IS_VM_NIC(card
))
1463 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
1467 iob
= qeth_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
, arp_cmd
,
1468 SETASS_DATA_SIZEOF(arp_entry
),
1473 cmd_entry
= &__ipa_cmd(iob
)->data
.setassparms
.data
.arp_entry
;
1474 ether_addr_copy(cmd_entry
->macaddr
, entry
->macaddr
);
1475 memcpy(cmd_entry
->ipaddr
, entry
->ipaddr
, 4);
1476 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_l3_arp_cmd_cb
, NULL
);
1478 QETH_DBF_MESSAGE(2, "Could not modify (cmd: %#x) ARP entry on device %x: %#x\n",
1479 arp_cmd
, CARD_DEVID(card
), rc
);
1483 static int qeth_l3_arp_flush_cache(struct qeth_card
*card
)
1485 struct qeth_cmd_buffer
*iob
;
1488 QETH_CARD_TEXT(card
, 3, "arpflush");
1491 * currently GuestLAN only supports the ARP assist function
1492 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
1493 * thus we say EOPNOTSUPP for this ARP function
1495 if (IS_VM_NIC(card
) || IS_IQD(card
))
1497 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
1501 iob
= qeth_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
,
1502 IPA_CMD_ASS_ARP_FLUSH_CACHE
, 0,
1507 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_l3_arp_cmd_cb
, NULL
);
1509 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on device %x: %#x\n",
1510 CARD_DEVID(card
), rc
);
1514 static int qeth_l3_ndo_siocdevprivate(struct net_device
*dev
, struct ifreq
*rq
,
1515 void __user
*data
, int cmd
)
1517 struct qeth_card
*card
= dev
->ml_priv
;
1518 struct qeth_arp_cache_entry arp_entry
;
1519 enum qeth_arp_process_subcmds arp_cmd
;
1523 case SIOC_QETH_ARP_SET_NO_ENTRIES
:
1524 if (!capable(CAP_NET_ADMIN
)) {
1528 rc
= qeth_l3_arp_set_no_entries(card
, rq
->ifr_ifru
.ifru_ivalue
);
1530 case SIOC_QETH_ARP_QUERY_INFO
:
1531 if (!capable(CAP_NET_ADMIN
)) {
1535 rc
= qeth_l3_arp_query(card
, data
);
1537 case SIOC_QETH_ARP_ADD_ENTRY
:
1538 case SIOC_QETH_ARP_REMOVE_ENTRY
:
1539 if (!capable(CAP_NET_ADMIN
))
1541 if (copy_from_user(&arp_entry
, data
, sizeof(arp_entry
)))
1544 arp_cmd
= (cmd
== SIOC_QETH_ARP_ADD_ENTRY
) ?
1545 IPA_CMD_ASS_ARP_ADD_ENTRY
:
1546 IPA_CMD_ASS_ARP_REMOVE_ENTRY
;
1547 return qeth_l3_arp_modify_entry(card
, &arp_entry
, arp_cmd
);
1548 case SIOC_QETH_ARP_FLUSH_CACHE
:
1549 if (!capable(CAP_NET_ADMIN
)) {
1553 rc
= qeth_l3_arp_flush_cache(card
);
1556 rc
= qeth_siocdevprivate(dev
, rq
, data
, cmd
);
1561 static int qeth_l3_get_cast_type_rcu(struct sk_buff
*skb
, struct dst_entry
*dst
,
1564 struct neighbour
*n
= NULL
;
1567 n
= dst_neigh_lookup_skb(dst
, skb
);
1570 int cast_type
= n
->type
;
1573 if ((cast_type
== RTN_BROADCAST
) ||
1574 (cast_type
== RTN_MULTICAST
) ||
1575 (cast_type
== RTN_ANYCAST
))
1580 /* no neighbour (eg AF_PACKET), fall back to target's IP address ... */
1582 case htons(ETH_P_IP
):
1583 if (ipv4_is_lbcast(ip_hdr(skb
)->daddr
))
1584 return RTN_BROADCAST
;
1585 return ipv4_is_multicast(ip_hdr(skb
)->daddr
) ?
1586 RTN_MULTICAST
: RTN_UNICAST
;
1587 case htons(ETH_P_IPV6
):
1588 return ipv6_addr_is_multicast(&ipv6_hdr(skb
)->daddr
) ?
1589 RTN_MULTICAST
: RTN_UNICAST
;
1590 case htons(ETH_P_AF_IUCV
):
1593 /* OSA only: ... and MAC address */
1594 return qeth_get_ether_cast_type(skb
);
1598 static int qeth_l3_get_cast_type(struct sk_buff
*skb
, __be16 proto
)
1600 struct dst_entry
*dst
;
1604 dst
= qeth_dst_check_rcu(skb
, proto
);
1605 cast_type
= qeth_l3_get_cast_type_rcu(skb
, dst
, proto
);
1611 static u8
qeth_l3_cast_type_to_flag(int cast_type
)
1613 if (cast_type
== RTN_MULTICAST
)
1614 return QETH_CAST_MULTICAST
;
1615 if (cast_type
== RTN_ANYCAST
)
1616 return QETH_CAST_ANYCAST
;
1617 if (cast_type
== RTN_BROADCAST
)
1618 return QETH_CAST_BROADCAST
;
1619 return QETH_CAST_UNICAST
;
1622 static void qeth_l3_fill_header(struct qeth_qdio_out_q
*queue
,
1623 struct qeth_hdr
*hdr
, struct sk_buff
*skb
,
1624 __be16 proto
, unsigned int data_len
)
1626 struct qeth_hdr_layer3
*l3_hdr
= &hdr
->hdr
.l3
;
1627 struct vlan_ethhdr
*veth
= vlan_eth_hdr(skb
);
1628 struct qeth_card
*card
= queue
->card
;
1629 struct dst_entry
*dst
;
1632 hdr
->hdr
.l3
.length
= data_len
;
1634 if (skb_is_gso(skb
)) {
1635 hdr
->hdr
.l3
.id
= QETH_HEADER_TYPE_L3_TSO
;
1637 hdr
->hdr
.l3
.id
= QETH_HEADER_TYPE_LAYER3
;
1639 if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
1640 qeth_tx_csum(skb
, &hdr
->hdr
.l3
.ext_flags
, proto
);
1641 /* some HW requires combined L3+L4 csum offload: */
1642 if (proto
== htons(ETH_P_IP
))
1643 hdr
->hdr
.l3
.ext_flags
|= QETH_HDR_EXT_CSUM_HDR_REQ
;
1647 if (proto
== htons(ETH_P_IP
) || IS_IQD(card
)) {
1648 /* NETIF_F_HW_VLAN_CTAG_TX */
1649 if (skb_vlan_tag_present(skb
)) {
1650 hdr
->hdr
.l3
.ext_flags
|= QETH_HDR_EXT_VLAN_FRAME
;
1651 hdr
->hdr
.l3
.vlan_id
= skb_vlan_tag_get(skb
);
1653 } else if (veth
->h_vlan_proto
== htons(ETH_P_8021Q
)) {
1654 hdr
->hdr
.l3
.ext_flags
|= QETH_HDR_EXT_INCLUDE_VLAN_TAG
;
1655 hdr
->hdr
.l3
.vlan_id
= ntohs(veth
->h_vlan_TCI
);
1659 dst
= qeth_dst_check_rcu(skb
, proto
);
1661 if (IS_IQD(card
) && skb_get_queue_mapping(skb
) != QETH_IQD_MCAST_TXQ
)
1662 cast_type
= RTN_UNICAST
;
1664 cast_type
= qeth_l3_get_cast_type_rcu(skb
, dst
, proto
);
1665 l3_hdr
->flags
|= qeth_l3_cast_type_to_flag(cast_type
);
1668 case htons(ETH_P_IP
):
1669 l3_hdr
->next_hop
.addr
.s6_addr32
[3] =
1670 qeth_next_hop_v4_rcu(skb
, dst
);
1672 case htons(ETH_P_IPV6
):
1673 l3_hdr
->next_hop
.addr
= *qeth_next_hop_v6_rcu(skb
, dst
);
1675 hdr
->hdr
.l3
.flags
|= QETH_HDR_IPV6
;
1677 hdr
->hdr
.l3
.flags
|= QETH_HDR_PASSTHRU
;
1679 case htons(ETH_P_AF_IUCV
):
1680 l3_hdr
->next_hop
.addr
.s6_addr16
[0] = htons(0xfe80);
1681 memcpy(&l3_hdr
->next_hop
.addr
.s6_addr32
[2],
1682 iucv_trans_hdr(skb
)->destUserID
, 8);
1683 l3_hdr
->flags
|= QETH_HDR_IPV6
;
1687 l3_hdr
->flags
|= QETH_HDR_PASSTHRU
;
1692 static void qeth_l3_fixup_headers(struct sk_buff
*skb
)
1694 struct iphdr
*iph
= ip_hdr(skb
);
1696 /* this is safe, IPv6 traffic takes a different path */
1697 if (skb
->ip_summed
== CHECKSUM_PARTIAL
)
1699 if (skb_is_gso(skb
)) {
1701 tcp_hdr(skb
)->check
= ~tcp_v4_check(0, iph
->saddr
,
1706 static int qeth_l3_xmit(struct qeth_card
*card
, struct sk_buff
*skb
,
1707 struct qeth_qdio_out_q
*queue
, __be16 proto
)
1709 unsigned int hw_hdr_len
;
1712 /* re-use the L2 header area for the HW header: */
1713 hw_hdr_len
= skb_is_gso(skb
) ? sizeof(struct qeth_hdr_tso
) :
1714 sizeof(struct qeth_hdr
);
1715 rc
= skb_cow_head(skb
, hw_hdr_len
- ETH_HLEN
);
1718 skb_pull(skb
, ETH_HLEN
);
1720 qeth_l3_fixup_headers(skb
);
1721 return qeth_xmit(card
, skb
, queue
, proto
, qeth_l3_fill_header
);
1724 static netdev_tx_t
qeth_l3_hard_start_xmit(struct sk_buff
*skb
,
1725 struct net_device
*dev
)
1727 struct qeth_card
*card
= dev
->ml_priv
;
1728 __be16 proto
= vlan_get_protocol(skb
);
1729 u16 txq
= skb_get_queue_mapping(skb
);
1730 struct qeth_qdio_out_q
*queue
;
1733 if (!skb_is_gso(skb
))
1734 qdisc_skb_cb(skb
)->pkt_len
= skb
->len
;
1736 queue
= card
->qdio
.out_qs
[qeth_iqd_translate_txq(dev
, txq
)];
1738 if (card
->options
.sniffer
)
1742 case htons(ETH_P_AF_IUCV
):
1743 if (card
->options
.cq
!= QETH_CQ_ENABLED
)
1746 case htons(ETH_P_IP
):
1747 case htons(ETH_P_IPV6
):
1748 if (card
->options
.cq
== QETH_CQ_ENABLED
)
1755 queue
= card
->qdio
.out_qs
[txq
];
1758 if (!(dev
->flags
& IFF_BROADCAST
) &&
1759 qeth_l3_get_cast_type(skb
, proto
) == RTN_BROADCAST
)
1762 if (proto
== htons(ETH_P_IP
) || IS_IQD(card
))
1763 rc
= qeth_l3_xmit(card
, skb
, queue
, proto
);
1765 rc
= qeth_xmit(card
, skb
, queue
, proto
, qeth_l3_fill_header
);
1768 return NETDEV_TX_OK
;
1771 QETH_TXQ_STAT_INC(queue
, tx_dropped
);
1773 return NETDEV_TX_OK
;
1776 static void qeth_l3_set_rx_mode(struct net_device
*dev
)
1778 struct qeth_card
*card
= dev
->ml_priv
;
1780 schedule_work(&card
->rx_mode_work
);
1784 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
1785 * NOARP on the netdevice is no option because it also turns off neighbor
1786 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
1787 * arp resolution but we want the hard header (packet socket will work
1790 static int qeth_l3_neigh_setup_noarp(struct neighbour
*n
)
1792 n
->nud_state
= NUD_NOARP
;
1793 memcpy(n
->ha
, "FAKELL", 6);
1794 n
->output
= n
->ops
->connected_output
;
1799 qeth_l3_neigh_setup(struct net_device
*dev
, struct neigh_parms
*np
)
1801 if (np
->tbl
->family
== AF_INET
)
1802 np
->neigh_setup
= qeth_l3_neigh_setup_noarp
;
1807 static netdev_features_t
qeth_l3_osa_features_check(struct sk_buff
*skb
,
1808 struct net_device
*dev
,
1809 netdev_features_t features
)
1811 if (vlan_get_protocol(skb
) != htons(ETH_P_IP
))
1812 features
&= ~NETIF_F_HW_VLAN_CTAG_TX
;
1813 return qeth_features_check(skb
, dev
, features
);
1816 static u16
qeth_l3_iqd_select_queue(struct net_device
*dev
, struct sk_buff
*skb
,
1817 struct net_device
*sb_dev
)
1819 __be16 proto
= vlan_get_protocol(skb
);
1821 return qeth_iqd_select_queue(dev
, skb
,
1822 qeth_l3_get_cast_type(skb
, proto
), sb_dev
);
1825 static u16
qeth_l3_osa_select_queue(struct net_device
*dev
, struct sk_buff
*skb
,
1826 struct net_device
*sb_dev
)
1828 struct qeth_card
*card
= dev
->ml_priv
;
1830 if (qeth_uses_tx_prio_queueing(card
))
1831 return qeth_get_priority_queue(card
, skb
);
1833 return netdev_pick_tx(dev
, skb
, sb_dev
);
1836 static const struct net_device_ops qeth_l3_netdev_ops
= {
1837 .ndo_open
= qeth_open
,
1838 .ndo_stop
= qeth_stop
,
1839 .ndo_get_stats64
= qeth_get_stats64
,
1840 .ndo_start_xmit
= qeth_l3_hard_start_xmit
,
1841 .ndo_select_queue
= qeth_l3_iqd_select_queue
,
1842 .ndo_validate_addr
= eth_validate_addr
,
1843 .ndo_set_rx_mode
= qeth_l3_set_rx_mode
,
1844 .ndo_eth_ioctl
= qeth_do_ioctl
,
1845 .ndo_siocdevprivate
= qeth_l3_ndo_siocdevprivate
,
1846 .ndo_fix_features
= qeth_fix_features
,
1847 .ndo_set_features
= qeth_set_features
,
1848 .ndo_tx_timeout
= qeth_tx_timeout
,
1851 static const struct net_device_ops qeth_l3_osa_netdev_ops
= {
1852 .ndo_open
= qeth_open
,
1853 .ndo_stop
= qeth_stop
,
1854 .ndo_get_stats64
= qeth_get_stats64
,
1855 .ndo_start_xmit
= qeth_l3_hard_start_xmit
,
1856 .ndo_features_check
= qeth_l3_osa_features_check
,
1857 .ndo_select_queue
= qeth_l3_osa_select_queue
,
1858 .ndo_validate_addr
= eth_validate_addr
,
1859 .ndo_set_rx_mode
= qeth_l3_set_rx_mode
,
1860 .ndo_eth_ioctl
= qeth_do_ioctl
,
1861 .ndo_siocdevprivate
= qeth_l3_ndo_siocdevprivate
,
1862 .ndo_fix_features
= qeth_fix_features
,
1863 .ndo_set_features
= qeth_set_features
,
1864 .ndo_tx_timeout
= qeth_tx_timeout
,
1865 .ndo_neigh_setup
= qeth_l3_neigh_setup
,
1868 static int qeth_l3_setup_netdev(struct qeth_card
*card
)
1870 struct net_device
*dev
= card
->dev
;
1871 unsigned int headroom
;
1874 if (IS_OSD(card
) || IS_OSX(card
)) {
1875 card
->dev
->netdev_ops
= &qeth_l3_osa_netdev_ops
;
1877 /*IPv6 address autoconfiguration stuff*/
1878 dev
->dev_id
= qeth_l3_get_unique_id(card
, dev
->dev_id
);
1880 if (!IS_VM_NIC(card
)) {
1881 card
->dev
->features
|= NETIF_F_SG
;
1882 card
->dev
->hw_features
|= NETIF_F_TSO
|
1883 NETIF_F_RXCSUM
| NETIF_F_IP_CSUM
;
1884 card
->dev
->vlan_features
|= NETIF_F_TSO
|
1885 NETIF_F_RXCSUM
| NETIF_F_IP_CSUM
;
1888 if (qeth_is_supported6(card
, IPA_OUTBOUND_CHECKSUM_V6
)) {
1889 card
->dev
->hw_features
|= NETIF_F_IPV6_CSUM
;
1890 card
->dev
->vlan_features
|= NETIF_F_IPV6_CSUM
;
1892 if (qeth_is_supported6(card
, IPA_OUTBOUND_TSO
)) {
1893 card
->dev
->hw_features
|= NETIF_F_TSO6
;
1894 card
->dev
->vlan_features
|= NETIF_F_TSO6
;
1897 /* allow for de-acceleration of NETIF_F_HW_VLAN_CTAG_TX: */
1898 if (card
->dev
->hw_features
& NETIF_F_TSO6
)
1899 headroom
= sizeof(struct qeth_hdr_tso
) + VLAN_HLEN
;
1900 else if (card
->dev
->hw_features
& NETIF_F_TSO
)
1901 headroom
= sizeof(struct qeth_hdr_tso
);
1903 headroom
= sizeof(struct qeth_hdr
) + VLAN_HLEN
;
1904 } else if (IS_IQD(card
)) {
1905 card
->dev
->flags
|= IFF_NOARP
;
1906 card
->dev
->netdev_ops
= &qeth_l3_netdev_ops
;
1907 headroom
= sizeof(struct qeth_hdr
) - ETH_HLEN
;
1909 rc
= qeth_l3_iqd_read_initial_mac(card
);
1915 card
->dev
->needed_headroom
= headroom
;
1916 card
->dev
->features
|= NETIF_F_HW_VLAN_CTAG_TX
|
1917 NETIF_F_HW_VLAN_CTAG_RX
;
1919 netif_keep_dst(card
->dev
);
1920 if (card
->dev
->hw_features
& (NETIF_F_TSO
| NETIF_F_TSO6
))
1921 netif_set_gso_max_size(card
->dev
,
1922 PAGE_SIZE
* (QETH_MAX_BUFFER_ELEMENTS(card
) - 1));
1924 netif_napi_add(card
->dev
, &card
->napi
, qeth_poll
, QETH_NAPI_WEIGHT
);
1925 return register_netdev(card
->dev
);
1928 static const struct device_type qeth_l3_devtype
= {
1929 .name
= "qeth_layer3",
1930 .groups
= qeth_l3_attr_groups
,
1933 static int qeth_l3_probe_device(struct ccwgroup_device
*gdev
)
1935 struct qeth_card
*card
= dev_get_drvdata(&gdev
->dev
);
1938 hash_init(card
->ip_htable
);
1939 mutex_init(&card
->ip_lock
);
1940 card
->cmd_wq
= alloc_ordered_workqueue("%s_cmd", 0,
1941 dev_name(&gdev
->dev
));
1945 if (gdev
->dev
.type
) {
1946 rc
= device_add_groups(&gdev
->dev
, qeth_l3_attr_groups
);
1948 destroy_workqueue(card
->cmd_wq
);
1952 gdev
->dev
.type
= &qeth_l3_devtype
;
1955 INIT_WORK(&card
->rx_mode_work
, qeth_l3_rx_mode_work
);
1959 static void qeth_l3_remove_device(struct ccwgroup_device
*cgdev
)
1961 struct qeth_card
*card
= dev_get_drvdata(&cgdev
->dev
);
1963 if (cgdev
->dev
.type
!= &qeth_l3_devtype
)
1964 device_remove_groups(&cgdev
->dev
, qeth_l3_attr_groups
);
1966 qeth_set_allowed_threads(card
, 0, 1);
1967 wait_event(card
->wait_q
, qeth_threads_running(card
, 0xffffffff) == 0);
1969 if (cgdev
->state
== CCWGROUP_ONLINE
)
1970 qeth_set_offline(card
, card
->discipline
, false);
1972 if (card
->dev
->reg_state
== NETREG_REGISTERED
)
1973 unregister_netdev(card
->dev
);
1975 flush_workqueue(card
->cmd_wq
);
1976 destroy_workqueue(card
->cmd_wq
);
1977 qeth_l3_clear_ip_htable(card
, 0);
1978 qeth_l3_clear_ipato_list(card
);
1981 static int qeth_l3_set_online(struct qeth_card
*card
, bool carrier_ok
)
1983 struct net_device
*dev
= card
->dev
;
1987 QETH_CARD_TEXT(card
, 2, "softsetp");
1989 rc
= qeth_l3_setadapter_parms(card
);
1991 QETH_CARD_TEXT_(card
, 2, "2err%04x", rc
);
1992 if (!card
->options
.sniffer
) {
1993 qeth_l3_start_ipassists(card
);
1995 rc
= qeth_l3_setrouting_v4(card
);
1997 QETH_CARD_TEXT_(card
, 2, "4err%04x", rc
);
1998 rc
= qeth_l3_setrouting_v6(card
);
2000 QETH_CARD_TEXT_(card
, 2, "5err%04x", rc
);
2003 card
->state
= CARD_STATE_SOFTSETUP
;
2005 qeth_set_allowed_threads(card
, 0xffffffff, 0);
2006 qeth_l3_recover_ip(card
);
2008 if (dev
->reg_state
!= NETREG_REGISTERED
) {
2009 rc
= qeth_l3_setup_netdev(card
);
2014 netif_carrier_on(dev
);
2017 rc
= qeth_set_real_num_tx_queues(card
,
2018 qeth_tx_actual_queues(card
));
2021 goto err_set_queues
;
2025 netif_carrier_on(dev
);
2027 netif_carrier_off(dev
);
2029 netif_device_attach(dev
);
2030 qeth_enable_hw_features(dev
);
2032 if (card
->info
.open_when_online
) {
2033 card
->info
.open_when_online
= 0;
2034 dev_open(dev
, NULL
);
2042 qeth_set_allowed_threads(card
, 0, 1);
2043 card
->state
= CARD_STATE_DOWN
;
2044 qeth_l3_clear_ip_htable(card
, 1);
2048 static void qeth_l3_set_offline(struct qeth_card
*card
)
2050 qeth_set_allowed_threads(card
, 0, 1);
2051 qeth_l3_drain_rx_mode_cache(card
);
2053 if (card
->options
.sniffer
&&
2054 (card
->info
.promisc_mode
== SET_PROMISC_MODE_ON
))
2055 qeth_diags_trace(card
, QETH_DIAGS_CMD_TRACE_DISABLE
);
2057 if (card
->state
== CARD_STATE_SOFTSETUP
) {
2058 card
->state
= CARD_STATE_DOWN
;
2059 qeth_l3_clear_ip_htable(card
, 1);
2063 /* Returns zero if the command is successfully "consumed" */
2064 static int qeth_l3_control_event(struct qeth_card
*card
,
2065 struct qeth_ipa_cmd
*cmd
)
2070 const struct qeth_discipline qeth_l3_discipline
= {
2071 .setup
= qeth_l3_probe_device
,
2072 .remove
= qeth_l3_remove_device
,
2073 .set_online
= qeth_l3_set_online
,
2074 .set_offline
= qeth_l3_set_offline
,
2075 .control_event_handler
= qeth_l3_control_event
,
2077 EXPORT_SYMBOL_GPL(qeth_l3_discipline
);
2079 static int qeth_l3_handle_ip_event(struct qeth_card
*card
,
2080 struct qeth_ipaddr
*addr
,
2081 unsigned long event
)
2085 qeth_l3_modify_ip(card
, addr
, true);
2088 qeth_l3_modify_ip(card
, addr
, false);
2095 struct qeth_l3_ip_event_work
{
2096 struct work_struct work
;
2097 struct qeth_card
*card
;
2098 struct qeth_ipaddr addr
;
2101 #define to_ip_work(w) container_of((w), struct qeth_l3_ip_event_work, work)
2103 static void qeth_l3_add_ip_worker(struct work_struct
*work
)
2105 struct qeth_l3_ip_event_work
*ip_work
= to_ip_work(work
);
2107 qeth_l3_modify_ip(ip_work
->card
, &ip_work
->addr
, true);
2111 static void qeth_l3_delete_ip_worker(struct work_struct
*work
)
2113 struct qeth_l3_ip_event_work
*ip_work
= to_ip_work(work
);
2115 qeth_l3_modify_ip(ip_work
->card
, &ip_work
->addr
, false);
2119 static struct qeth_card
*qeth_l3_get_card_from_dev(struct net_device
*dev
)
2121 if (is_vlan_dev(dev
))
2122 dev
= vlan_dev_real_dev(dev
);
2123 if (dev
->netdev_ops
== &qeth_l3_osa_netdev_ops
||
2124 dev
->netdev_ops
== &qeth_l3_netdev_ops
)
2125 return (struct qeth_card
*) dev
->ml_priv
;
2129 static int qeth_l3_ip_event(struct notifier_block
*this,
2130 unsigned long event
, void *ptr
)
2132 struct in_ifaddr
*ifa
= (struct in_ifaddr
*)ptr
;
2133 struct net_device
*dev
= ifa
->ifa_dev
->dev
;
2134 struct qeth_ipaddr addr
;
2135 struct qeth_card
*card
;
2137 card
= qeth_l3_get_card_from_dev(dev
);
2140 QETH_CARD_TEXT(card
, 3, "ipevent");
2142 qeth_l3_init_ipaddr(&addr
, QETH_IP_TYPE_NORMAL
, QETH_PROT_IPV4
);
2143 addr
.u
.a4
.addr
= ifa
->ifa_address
;
2144 addr
.u
.a4
.mask
= ifa
->ifa_mask
;
2146 return qeth_l3_handle_ip_event(card
, &addr
, event
);
2149 static struct notifier_block qeth_l3_ip_notifier
= {
2154 static int qeth_l3_ip6_event(struct notifier_block
*this,
2155 unsigned long event
, void *ptr
)
2157 struct inet6_ifaddr
*ifa
= (struct inet6_ifaddr
*)ptr
;
2158 struct net_device
*dev
= ifa
->idev
->dev
;
2159 struct qeth_l3_ip_event_work
*ip_work
;
2160 struct qeth_card
*card
;
2162 if (event
!= NETDEV_UP
&& event
!= NETDEV_DOWN
)
2165 card
= qeth_l3_get_card_from_dev(dev
);
2168 QETH_CARD_TEXT(card
, 3, "ip6event");
2169 if (!qeth_is_supported(card
, IPA_IPV6
))
2172 ip_work
= kmalloc(sizeof(*ip_work
), GFP_ATOMIC
);
2176 if (event
== NETDEV_UP
)
2177 INIT_WORK(&ip_work
->work
, qeth_l3_add_ip_worker
);
2179 INIT_WORK(&ip_work
->work
, qeth_l3_delete_ip_worker
);
2181 ip_work
->card
= card
;
2182 qeth_l3_init_ipaddr(&ip_work
->addr
, QETH_IP_TYPE_NORMAL
,
2184 ip_work
->addr
.u
.a6
.addr
= ifa
->addr
;
2185 ip_work
->addr
.u
.a6
.pfxlen
= ifa
->prefix_len
;
2187 queue_work(card
->cmd_wq
, &ip_work
->work
);
2191 static struct notifier_block qeth_l3_ip6_notifier
= {
2196 static int qeth_l3_register_notifiers(void)
2200 QETH_DBF_TEXT(SETUP
, 5, "regnotif");
2201 rc
= register_inetaddr_notifier(&qeth_l3_ip_notifier
);
2204 rc
= register_inet6addr_notifier(&qeth_l3_ip6_notifier
);
2206 unregister_inetaddr_notifier(&qeth_l3_ip_notifier
);
2212 static void qeth_l3_unregister_notifiers(void)
2214 QETH_DBF_TEXT(SETUP
, 5, "unregnot");
2215 WARN_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier
));
2216 WARN_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier
));
2219 static int __init
qeth_l3_init(void)
2221 pr_info("register layer 3 discipline\n");
2222 return qeth_l3_register_notifiers();
2225 static void __exit
qeth_l3_exit(void)
2227 qeth_l3_unregister_notifiers();
2228 pr_info("unregister layer 3 discipline\n");
2231 module_init(qeth_l3_init
);
2232 module_exit(qeth_l3_exit
);
2233 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
2234 MODULE_DESCRIPTION("qeth layer 3 discipline");
2235 MODULE_LICENSE("GPL");