2 * drivers/s390/net/qeth_l3_main.c
4 * Copyright IBM Corp. 2007
5 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
6 * Frank Pavlic <fpavlic@de.ibm.com>,
7 * Thomas Spatzier <tspat@de.ibm.com>,
8 * Frank Blaschka <frank.blaschka@de.ibm.com>
11 #include <linux/module.h>
12 #include <linux/moduleparam.h>
13 #include <linux/string.h>
14 #include <linux/errno.h>
15 #include <linux/kernel.h>
16 #include <linux/etherdevice.h>
17 #include <linux/mii.h>
19 #include <linux/reboot.h>
20 #include <linux/inetdevice.h>
21 #include <linux/igmp.h>
26 #include <asm/s390_rdev.h>
29 #include "qeth_core_offl.h"
31 static int qeth_l3_set_offline(struct ccwgroup_device
*);
32 static int qeth_l3_recover(void *);
33 static int qeth_l3_stop(struct net_device
*);
34 static void qeth_l3_set_multicast_list(struct net_device
*);
35 static int qeth_l3_neigh_setup(struct net_device
*, struct neigh_parms
*);
36 static int qeth_l3_register_addr_entry(struct qeth_card
*,
37 struct qeth_ipaddr
*);
38 static int qeth_l3_deregister_addr_entry(struct qeth_card
*,
39 struct qeth_ipaddr
*);
40 static int __qeth_l3_set_online(struct ccwgroup_device
*, int);
41 static int __qeth_l3_set_offline(struct ccwgroup_device
*, int);
44 static int qeth_l3_isxdigit(char *buf
)
47 if (!isxdigit(*buf
++))
53 void qeth_l3_ipaddr4_to_string(const __u8
*addr
, char *buf
)
55 sprintf(buf
, "%i.%i.%i.%i", addr
[0], addr
[1], addr
[2], addr
[3]);
58 int qeth_l3_string_to_ipaddr4(const char *buf
, __u8
*addr
)
60 int count
= 0, rc
= 0;
64 rc
= sscanf(buf
, "%u.%u.%u.%u%c",
65 &in
[0], &in
[1], &in
[2], &in
[3], &c
);
66 if (rc
!= 4 && (rc
!= 5 || c
!= '\n'))
68 for (count
= 0; count
< 4; count
++) {
71 addr
[count
] = in
[count
];
76 void qeth_l3_ipaddr6_to_string(const __u8
*addr
, char *buf
)
78 sprintf(buf
, "%02x%02x:%02x%02x:%02x%02x:%02x%02x"
79 ":%02x%02x:%02x%02x:%02x%02x:%02x%02x",
80 addr
[0], addr
[1], addr
[2], addr
[3],
81 addr
[4], addr
[5], addr
[6], addr
[7],
82 addr
[8], addr
[9], addr
[10], addr
[11],
83 addr
[12], addr
[13], addr
[14], addr
[15]);
86 int qeth_l3_string_to_ipaddr6(const char *buf
, __u8
*addr
)
88 const char *end
, *end_tmp
, *start
;
91 int num2
, cnt
, out
, found
, save_cnt
;
92 unsigned short in_tmp
[8] = {0, };
94 cnt
= out
= found
= save_cnt
= num2
= 0;
99 end
= strchr(start
, ':');
101 end
= buf
+ strlen(buf
);
102 end_tmp
= strchr(start
, '\n');
109 if ((end
- start
) > 4)
111 memcpy(num
, start
, end
- start
);
112 if (!qeth_l3_isxdigit(num
))
114 sscanf(start
, "%x", &num2
);
116 in_tmp
[save_cnt
++] = num2
;
128 if (cnt
+ save_cnt
> 8)
132 in
[cnt
--] = in_tmp
[--save_cnt
];
136 void qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto
, const __u8
*addr
,
139 if (proto
== QETH_PROT_IPV4
)
140 qeth_l3_ipaddr4_to_string(addr
, buf
);
141 else if (proto
== QETH_PROT_IPV6
)
142 qeth_l3_ipaddr6_to_string(addr
, buf
);
145 int qeth_l3_string_to_ipaddr(const char *buf
, enum qeth_prot_versions proto
,
148 if (proto
== QETH_PROT_IPV4
)
149 return qeth_l3_string_to_ipaddr4(buf
, addr
);
150 else if (proto
== QETH_PROT_IPV6
)
151 return qeth_l3_string_to_ipaddr6(buf
, addr
);
156 static void qeth_l3_convert_addr_to_bits(u8
*addr
, u8
*bits
, int len
)
161 for (i
= 0; i
< len
; ++i
) {
163 for (j
= 7; j
>= 0; --j
) {
164 bits
[i
*8 + j
] = octet
& 1;
170 static int qeth_l3_is_addr_covered_by_ipato(struct qeth_card
*card
,
171 struct qeth_ipaddr
*addr
)
173 struct qeth_ipato_entry
*ipatoe
;
174 u8 addr_bits
[128] = {0, };
175 u8 ipatoe_bits
[128] = {0, };
178 if (!card
->ipato
.enabled
)
181 qeth_l3_convert_addr_to_bits((u8
*) &addr
->u
, addr_bits
,
182 (addr
->proto
== QETH_PROT_IPV4
)? 4:16);
183 list_for_each_entry(ipatoe
, &card
->ipato
.entries
, entry
) {
184 if (addr
->proto
!= ipatoe
->proto
)
186 qeth_l3_convert_addr_to_bits(ipatoe
->addr
, ipatoe_bits
,
187 (ipatoe
->proto
== QETH_PROT_IPV4
) ?
189 if (addr
->proto
== QETH_PROT_IPV4
)
190 rc
= !memcmp(addr_bits
, ipatoe_bits
,
191 min(32, ipatoe
->mask_bits
));
193 rc
= !memcmp(addr_bits
, ipatoe_bits
,
194 min(128, ipatoe
->mask_bits
));
199 if ((addr
->proto
== QETH_PROT_IPV4
) && card
->ipato
.invert4
)
201 else if ((addr
->proto
== QETH_PROT_IPV6
) && card
->ipato
.invert6
)
208 * Add IP to be added to todo list. If there is already an "add todo"
209 * in this list we just incremenent the reference count.
210 * Returns 0 if we just incremented reference count.
212 static int __qeth_l3_insert_ip_todo(struct qeth_card
*card
,
213 struct qeth_ipaddr
*addr
, int add
)
215 struct qeth_ipaddr
*tmp
, *t
;
218 list_for_each_entry_safe(tmp
, t
, card
->ip_tbd_list
, entry
) {
219 if ((addr
->type
== QETH_IP_TYPE_DEL_ALL_MC
) &&
220 (tmp
->type
== QETH_IP_TYPE_DEL_ALL_MC
))
222 if ((tmp
->proto
== QETH_PROT_IPV4
) &&
223 (addr
->proto
== QETH_PROT_IPV4
) &&
224 (tmp
->type
== addr
->type
) &&
225 (tmp
->is_multicast
== addr
->is_multicast
) &&
226 (tmp
->u
.a4
.addr
== addr
->u
.a4
.addr
) &&
227 (tmp
->u
.a4
.mask
== addr
->u
.a4
.mask
)) {
231 if ((tmp
->proto
== QETH_PROT_IPV6
) &&
232 (addr
->proto
== QETH_PROT_IPV6
) &&
233 (tmp
->type
== addr
->type
) &&
234 (tmp
->is_multicast
== addr
->is_multicast
) &&
235 (tmp
->u
.a6
.pfxlen
== addr
->u
.a6
.pfxlen
) &&
236 (memcmp(&tmp
->u
.a6
.addr
, &addr
->u
.a6
.addr
,
237 sizeof(struct in6_addr
)) == 0)) {
243 if (addr
->users
!= 0)
244 tmp
->users
+= addr
->users
;
246 tmp
->users
+= add
? 1 : -1;
247 if (tmp
->users
== 0) {
248 list_del(&tmp
->entry
);
253 if (addr
->type
== QETH_IP_TYPE_DEL_ALL_MC
)
254 list_add(&addr
->entry
, card
->ip_tbd_list
);
256 if (addr
->users
== 0)
257 addr
->users
+= add
? 1 : -1;
258 if (add
&& (addr
->type
== QETH_IP_TYPE_NORMAL
) &&
259 qeth_l3_is_addr_covered_by_ipato(card
, addr
)) {
260 QETH_DBF_TEXT(TRACE
, 2, "tkovaddr");
261 addr
->set_flags
|= QETH_IPA_SETIP_TAKEOVER_FLAG
;
263 list_add_tail(&addr
->entry
, card
->ip_tbd_list
);
269 static int qeth_l3_delete_ip(struct qeth_card
*card
, struct qeth_ipaddr
*addr
)
274 QETH_DBF_TEXT(TRACE
, 4, "delip");
276 if (addr
->proto
== QETH_PROT_IPV4
)
277 QETH_DBF_HEX(TRACE
, 4, &addr
->u
.a4
.addr
, 4);
279 QETH_DBF_HEX(TRACE
, 4, &addr
->u
.a6
.addr
, 8);
280 QETH_DBF_HEX(TRACE
, 4, ((char *)&addr
->u
.a6
.addr
) + 8, 8);
282 spin_lock_irqsave(&card
->ip_lock
, flags
);
283 rc
= __qeth_l3_insert_ip_todo(card
, addr
, 0);
284 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
288 static int qeth_l3_add_ip(struct qeth_card
*card
, struct qeth_ipaddr
*addr
)
293 QETH_DBF_TEXT(TRACE
, 4, "addip");
294 if (addr
->proto
== QETH_PROT_IPV4
)
295 QETH_DBF_HEX(TRACE
, 4, &addr
->u
.a4
.addr
, 4);
297 QETH_DBF_HEX(TRACE
, 4, &addr
->u
.a6
.addr
, 8);
298 QETH_DBF_HEX(TRACE
, 4, ((char *)&addr
->u
.a6
.addr
) + 8, 8);
300 spin_lock_irqsave(&card
->ip_lock
, flags
);
301 rc
= __qeth_l3_insert_ip_todo(card
, addr
, 1);
302 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
307 static struct qeth_ipaddr
*qeth_l3_get_addr_buffer(
308 enum qeth_prot_versions prot
)
310 struct qeth_ipaddr
*addr
;
312 addr
= kzalloc(sizeof(struct qeth_ipaddr
), GFP_ATOMIC
);
316 addr
->type
= QETH_IP_TYPE_NORMAL
;
321 static void qeth_l3_delete_mc_addresses(struct qeth_card
*card
)
323 struct qeth_ipaddr
*iptodo
;
326 QETH_DBF_TEXT(TRACE
, 4, "delmc");
327 iptodo
= qeth_l3_get_addr_buffer(QETH_PROT_IPV4
);
329 QETH_DBF_TEXT(TRACE
, 2, "dmcnomem");
332 iptodo
->type
= QETH_IP_TYPE_DEL_ALL_MC
;
333 spin_lock_irqsave(&card
->ip_lock
, flags
);
334 if (!__qeth_l3_insert_ip_todo(card
, iptodo
, 0))
336 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
340 * Add/remove address to/from card's ip list, i.e. try to add or remove
341 * reference to/from an IP address that is already registered on the card.
343 * 0 address was on card and its reference count has been adjusted,
344 * but is still > 0, so nothing has to be done
345 * also returns 0 if card was not on card and the todo was to delete
346 * the address -> there is also nothing to be done
347 * 1 address was not on card and the todo is to add it to the card's ip
349 * -1 address was on card and its reference count has been decremented
350 * to <= 0 by the todo -> address must be removed from card
352 static int __qeth_l3_ref_ip_on_card(struct qeth_card
*card
,
353 struct qeth_ipaddr
*todo
, struct qeth_ipaddr
**__addr
)
355 struct qeth_ipaddr
*addr
;
358 list_for_each_entry(addr
, &card
->ip_list
, entry
) {
359 if ((addr
->proto
== QETH_PROT_IPV4
) &&
360 (todo
->proto
== QETH_PROT_IPV4
) &&
361 (addr
->type
== todo
->type
) &&
362 (addr
->u
.a4
.addr
== todo
->u
.a4
.addr
) &&
363 (addr
->u
.a4
.mask
== todo
->u
.a4
.mask
)) {
367 if ((addr
->proto
== QETH_PROT_IPV6
) &&
368 (todo
->proto
== QETH_PROT_IPV6
) &&
369 (addr
->type
== todo
->type
) &&
370 (addr
->u
.a6
.pfxlen
== todo
->u
.a6
.pfxlen
) &&
371 (memcmp(&addr
->u
.a6
.addr
, &todo
->u
.a6
.addr
,
372 sizeof(struct in6_addr
)) == 0)) {
378 addr
->users
+= todo
->users
;
379 if (addr
->users
<= 0) {
383 /* for VIPA and RXIP limit refcount to 1 */
384 if (addr
->type
!= QETH_IP_TYPE_NORMAL
)
389 if (todo
->users
> 0) {
390 /* for VIPA and RXIP limit refcount to 1 */
391 if (todo
->type
!= QETH_IP_TYPE_NORMAL
)
398 static void __qeth_l3_delete_all_mc(struct qeth_card
*card
,
399 unsigned long *flags
)
401 struct list_head fail_list
;
402 struct qeth_ipaddr
*addr
, *tmp
;
405 INIT_LIST_HEAD(&fail_list
);
407 list_for_each_entry_safe(addr
, tmp
, &card
->ip_list
, entry
) {
408 if (addr
->is_multicast
) {
409 list_del(&addr
->entry
);
410 spin_unlock_irqrestore(&card
->ip_lock
, *flags
);
411 rc
= qeth_l3_deregister_addr_entry(card
, addr
);
412 spin_lock_irqsave(&card
->ip_lock
, *flags
);
413 if (!rc
|| (rc
== IPA_RC_MC_ADDR_NOT_FOUND
))
416 list_add_tail(&addr
->entry
, &fail_list
);
420 list_splice(&fail_list
, &card
->ip_list
);
423 static void qeth_l3_set_ip_addr_list(struct qeth_card
*card
)
425 struct list_head
*tbd_list
;
426 struct qeth_ipaddr
*todo
, *addr
;
430 QETH_DBF_TEXT(TRACE
, 2, "sdiplist");
431 QETH_DBF_HEX(TRACE
, 2, &card
, sizeof(void *));
433 spin_lock_irqsave(&card
->ip_lock
, flags
);
434 tbd_list
= card
->ip_tbd_list
;
435 card
->ip_tbd_list
= kmalloc(sizeof(struct list_head
), GFP_ATOMIC
);
436 if (!card
->ip_tbd_list
) {
437 QETH_DBF_TEXT(TRACE
, 0, "silnomem");
438 card
->ip_tbd_list
= tbd_list
;
439 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
442 INIT_LIST_HEAD(card
->ip_tbd_list
);
444 while (!list_empty(tbd_list
)) {
445 todo
= list_entry(tbd_list
->next
, struct qeth_ipaddr
, entry
);
446 list_del(&todo
->entry
);
447 if (todo
->type
== QETH_IP_TYPE_DEL_ALL_MC
) {
448 __qeth_l3_delete_all_mc(card
, &flags
);
452 rc
= __qeth_l3_ref_ip_on_card(card
, todo
, &addr
);
454 /* nothing to be done; only adjusted refcount */
456 } else if (rc
== 1) {
457 /* new entry to be added to on-card list */
458 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
459 rc
= qeth_l3_register_addr_entry(card
, todo
);
460 spin_lock_irqsave(&card
->ip_lock
, flags
);
461 if (!rc
|| (rc
== IPA_RC_LAN_OFFLINE
))
462 list_add_tail(&todo
->entry
, &card
->ip_list
);
465 } else if (rc
== -1) {
466 /* on-card entry to be removed */
467 list_del_init(&addr
->entry
);
468 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
469 rc
= qeth_l3_deregister_addr_entry(card
, addr
);
470 spin_lock_irqsave(&card
->ip_lock
, flags
);
471 if (!rc
|| (rc
== IPA_RC_PRIMARY_ALREADY_DEFINED
))
474 list_add_tail(&addr
->entry
, &card
->ip_list
);
478 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
482 static void qeth_l3_clear_ip_list(struct qeth_card
*card
, int clean
,
485 struct qeth_ipaddr
*addr
, *tmp
;
488 QETH_DBF_TEXT(TRACE
, 4, "clearip");
489 spin_lock_irqsave(&card
->ip_lock
, flags
);
490 /* clear todo list */
491 list_for_each_entry_safe(addr
, tmp
, card
->ip_tbd_list
, entry
) {
492 list_del(&addr
->entry
);
496 while (!list_empty(&card
->ip_list
)) {
497 addr
= list_entry(card
->ip_list
.next
,
498 struct qeth_ipaddr
, entry
);
499 list_del_init(&addr
->entry
);
501 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
502 qeth_l3_deregister_addr_entry(card
, addr
);
503 spin_lock_irqsave(&card
->ip_lock
, flags
);
505 if (!recover
|| addr
->is_multicast
) {
509 list_add_tail(&addr
->entry
, card
->ip_tbd_list
);
511 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
514 static int qeth_l3_address_exists_in_list(struct list_head
*list
,
515 struct qeth_ipaddr
*addr
, int same_type
)
517 struct qeth_ipaddr
*tmp
;
519 list_for_each_entry(tmp
, list
, entry
) {
520 if ((tmp
->proto
== QETH_PROT_IPV4
) &&
521 (addr
->proto
== QETH_PROT_IPV4
) &&
522 ((same_type
&& (tmp
->type
== addr
->type
)) ||
523 (!same_type
&& (tmp
->type
!= addr
->type
))) &&
524 (tmp
->u
.a4
.addr
== addr
->u
.a4
.addr
))
527 if ((tmp
->proto
== QETH_PROT_IPV6
) &&
528 (addr
->proto
== QETH_PROT_IPV6
) &&
529 ((same_type
&& (tmp
->type
== addr
->type
)) ||
530 (!same_type
&& (tmp
->type
!= addr
->type
))) &&
531 (memcmp(&tmp
->u
.a6
.addr
, &addr
->u
.a6
.addr
,
532 sizeof(struct in6_addr
)) == 0))
539 static int qeth_l3_send_setdelmc(struct qeth_card
*card
,
540 struct qeth_ipaddr
*addr
, int ipacmd
)
543 struct qeth_cmd_buffer
*iob
;
544 struct qeth_ipa_cmd
*cmd
;
546 QETH_DBF_TEXT(TRACE
, 4, "setdelmc");
548 iob
= qeth_get_ipacmd_buffer(card
, ipacmd
, addr
->proto
);
549 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
550 memcpy(&cmd
->data
.setdelipm
.mac
, addr
->mac
, OSA_ADDR_LEN
);
551 if (addr
->proto
== QETH_PROT_IPV6
)
552 memcpy(cmd
->data
.setdelipm
.ip6
, &addr
->u
.a6
.addr
,
553 sizeof(struct in6_addr
));
555 memcpy(&cmd
->data
.setdelipm
.ip4
, &addr
->u
.a4
.addr
, 4);
557 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
562 static void qeth_l3_fill_netmask(u8
*netmask
, unsigned int len
)
565 for (i
= 0; i
< 16; i
++) {
570 netmask
[i
] = (u8
)(0xFF00 >> j
);
576 static int qeth_l3_send_setdelip(struct qeth_card
*card
,
577 struct qeth_ipaddr
*addr
, int ipacmd
, unsigned int flags
)
580 struct qeth_cmd_buffer
*iob
;
581 struct qeth_ipa_cmd
*cmd
;
584 QETH_DBF_TEXT(TRACE
, 4, "setdelip");
585 QETH_DBF_TEXT_(TRACE
, 4, "flags%02X", flags
);
587 iob
= qeth_get_ipacmd_buffer(card
, ipacmd
, addr
->proto
);
588 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
589 if (addr
->proto
== QETH_PROT_IPV6
) {
590 memcpy(cmd
->data
.setdelip6
.ip_addr
, &addr
->u
.a6
.addr
,
591 sizeof(struct in6_addr
));
592 qeth_l3_fill_netmask(netmask
, addr
->u
.a6
.pfxlen
);
593 memcpy(cmd
->data
.setdelip6
.mask
, netmask
,
594 sizeof(struct in6_addr
));
595 cmd
->data
.setdelip6
.flags
= flags
;
597 memcpy(cmd
->data
.setdelip4
.ip_addr
, &addr
->u
.a4
.addr
, 4);
598 memcpy(cmd
->data
.setdelip4
.mask
, &addr
->u
.a4
.mask
, 4);
599 cmd
->data
.setdelip4
.flags
= flags
;
602 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
607 static int qeth_l3_send_setrouting(struct qeth_card
*card
,
608 enum qeth_routing_types type
, enum qeth_prot_versions prot
)
611 struct qeth_ipa_cmd
*cmd
;
612 struct qeth_cmd_buffer
*iob
;
614 QETH_DBF_TEXT(TRACE
, 4, "setroutg");
615 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_SETRTG
, prot
);
616 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
617 cmd
->data
.setrtg
.type
= (type
);
618 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
623 static void qeth_l3_correct_routing_type(struct qeth_card
*card
,
624 enum qeth_routing_types
*type
, enum qeth_prot_versions prot
)
626 if (card
->info
.type
== QETH_CARD_TYPE_IQD
) {
629 case PRIMARY_CONNECTOR
:
630 case SECONDARY_CONNECTOR
:
631 case MULTICAST_ROUTER
:
640 case SECONDARY_ROUTER
:
642 case MULTICAST_ROUTER
:
643 if (qeth_is_ipafunc_supported(card
, prot
,
654 int qeth_l3_setrouting_v4(struct qeth_card
*card
)
658 QETH_DBF_TEXT(TRACE
, 3, "setrtg4");
660 qeth_l3_correct_routing_type(card
, &card
->options
.route4
.type
,
663 rc
= qeth_l3_send_setrouting(card
, card
->options
.route4
.type
,
666 card
->options
.route4
.type
= NO_ROUTER
;
667 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
668 " on %s. Type set to 'no router'.\n", rc
,
669 QETH_CARD_IFNAME(card
));
674 int qeth_l3_setrouting_v6(struct qeth_card
*card
)
678 QETH_DBF_TEXT(TRACE
, 3, "setrtg6");
679 #ifdef CONFIG_QETH_IPV6
681 if (!qeth_is_supported(card
, IPA_IPV6
))
683 qeth_l3_correct_routing_type(card
, &card
->options
.route6
.type
,
686 rc
= qeth_l3_send_setrouting(card
, card
->options
.route6
.type
,
689 card
->options
.route6
.type
= NO_ROUTER
;
690 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
691 " on %s. Type set to 'no router'.\n", rc
,
692 QETH_CARD_IFNAME(card
));
699 * IP address takeover related functions
701 static void qeth_l3_clear_ipato_list(struct qeth_card
*card
)
704 struct qeth_ipato_entry
*ipatoe
, *tmp
;
707 spin_lock_irqsave(&card
->ip_lock
, flags
);
708 list_for_each_entry_safe(ipatoe
, tmp
, &card
->ipato
.entries
, entry
) {
709 list_del(&ipatoe
->entry
);
712 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
715 int qeth_l3_add_ipato_entry(struct qeth_card
*card
,
716 struct qeth_ipato_entry
*new)
718 struct qeth_ipato_entry
*ipatoe
;
722 QETH_DBF_TEXT(TRACE
, 2, "addipato");
723 spin_lock_irqsave(&card
->ip_lock
, flags
);
724 list_for_each_entry(ipatoe
, &card
->ipato
.entries
, entry
) {
725 if (ipatoe
->proto
!= new->proto
)
727 if (!memcmp(ipatoe
->addr
, new->addr
,
728 (ipatoe
->proto
== QETH_PROT_IPV4
)? 4:16) &&
729 (ipatoe
->mask_bits
== new->mask_bits
)) {
735 list_add_tail(&new->entry
, &card
->ipato
.entries
);
737 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
741 void qeth_l3_del_ipato_entry(struct qeth_card
*card
,
742 enum qeth_prot_versions proto
, u8
*addr
, int mask_bits
)
744 struct qeth_ipato_entry
*ipatoe
, *tmp
;
747 QETH_DBF_TEXT(TRACE
, 2, "delipato");
748 spin_lock_irqsave(&card
->ip_lock
, flags
);
749 list_for_each_entry_safe(ipatoe
, tmp
, &card
->ipato
.entries
, entry
) {
750 if (ipatoe
->proto
!= proto
)
752 if (!memcmp(ipatoe
->addr
, addr
,
753 (proto
== QETH_PROT_IPV4
)? 4:16) &&
754 (ipatoe
->mask_bits
== mask_bits
)) {
755 list_del(&ipatoe
->entry
);
759 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
763 * VIPA related functions
765 int qeth_l3_add_vipa(struct qeth_card
*card
, enum qeth_prot_versions proto
,
768 struct qeth_ipaddr
*ipaddr
;
772 ipaddr
= qeth_l3_get_addr_buffer(proto
);
774 if (proto
== QETH_PROT_IPV4
) {
775 QETH_DBF_TEXT(TRACE
, 2, "addvipa4");
776 memcpy(&ipaddr
->u
.a4
.addr
, addr
, 4);
777 ipaddr
->u
.a4
.mask
= 0;
778 } else if (proto
== QETH_PROT_IPV6
) {
779 QETH_DBF_TEXT(TRACE
, 2, "addvipa6");
780 memcpy(&ipaddr
->u
.a6
.addr
, addr
, 16);
781 ipaddr
->u
.a6
.pfxlen
= 0;
783 ipaddr
->type
= QETH_IP_TYPE_VIPA
;
784 ipaddr
->set_flags
= QETH_IPA_SETIP_VIPA_FLAG
;
785 ipaddr
->del_flags
= QETH_IPA_DELIP_VIPA_FLAG
;
788 spin_lock_irqsave(&card
->ip_lock
, flags
);
789 if (qeth_l3_address_exists_in_list(&card
->ip_list
, ipaddr
, 0) ||
790 qeth_l3_address_exists_in_list(card
->ip_tbd_list
, ipaddr
, 0))
792 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
796 if (!qeth_l3_add_ip(card
, ipaddr
))
798 qeth_l3_set_ip_addr_list(card
);
802 void qeth_l3_del_vipa(struct qeth_card
*card
, enum qeth_prot_versions proto
,
805 struct qeth_ipaddr
*ipaddr
;
807 ipaddr
= qeth_l3_get_addr_buffer(proto
);
809 if (proto
== QETH_PROT_IPV4
) {
810 QETH_DBF_TEXT(TRACE
, 2, "delvipa4");
811 memcpy(&ipaddr
->u
.a4
.addr
, addr
, 4);
812 ipaddr
->u
.a4
.mask
= 0;
813 } else if (proto
== QETH_PROT_IPV6
) {
814 QETH_DBF_TEXT(TRACE
, 2, "delvipa6");
815 memcpy(&ipaddr
->u
.a6
.addr
, addr
, 16);
816 ipaddr
->u
.a6
.pfxlen
= 0;
818 ipaddr
->type
= QETH_IP_TYPE_VIPA
;
821 if (!qeth_l3_delete_ip(card
, ipaddr
))
823 qeth_l3_set_ip_addr_list(card
);
827 * proxy ARP related functions
829 int qeth_l3_add_rxip(struct qeth_card
*card
, enum qeth_prot_versions proto
,
832 struct qeth_ipaddr
*ipaddr
;
836 ipaddr
= qeth_l3_get_addr_buffer(proto
);
838 if (proto
== QETH_PROT_IPV4
) {
839 QETH_DBF_TEXT(TRACE
, 2, "addrxip4");
840 memcpy(&ipaddr
->u
.a4
.addr
, addr
, 4);
841 ipaddr
->u
.a4
.mask
= 0;
842 } else if (proto
== QETH_PROT_IPV6
) {
843 QETH_DBF_TEXT(TRACE
, 2, "addrxip6");
844 memcpy(&ipaddr
->u
.a6
.addr
, addr
, 16);
845 ipaddr
->u
.a6
.pfxlen
= 0;
847 ipaddr
->type
= QETH_IP_TYPE_RXIP
;
848 ipaddr
->set_flags
= QETH_IPA_SETIP_TAKEOVER_FLAG
;
849 ipaddr
->del_flags
= 0;
852 spin_lock_irqsave(&card
->ip_lock
, flags
);
853 if (qeth_l3_address_exists_in_list(&card
->ip_list
, ipaddr
, 0) ||
854 qeth_l3_address_exists_in_list(card
->ip_tbd_list
, ipaddr
, 0))
856 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
860 if (!qeth_l3_add_ip(card
, ipaddr
))
862 qeth_l3_set_ip_addr_list(card
);
866 void qeth_l3_del_rxip(struct qeth_card
*card
, enum qeth_prot_versions proto
,
869 struct qeth_ipaddr
*ipaddr
;
871 ipaddr
= qeth_l3_get_addr_buffer(proto
);
873 if (proto
== QETH_PROT_IPV4
) {
874 QETH_DBF_TEXT(TRACE
, 2, "addrxip4");
875 memcpy(&ipaddr
->u
.a4
.addr
, addr
, 4);
876 ipaddr
->u
.a4
.mask
= 0;
877 } else if (proto
== QETH_PROT_IPV6
) {
878 QETH_DBF_TEXT(TRACE
, 2, "addrxip6");
879 memcpy(&ipaddr
->u
.a6
.addr
, addr
, 16);
880 ipaddr
->u
.a6
.pfxlen
= 0;
882 ipaddr
->type
= QETH_IP_TYPE_RXIP
;
885 if (!qeth_l3_delete_ip(card
, ipaddr
))
887 qeth_l3_set_ip_addr_list(card
);
890 static int qeth_l3_register_addr_entry(struct qeth_card
*card
,
891 struct qeth_ipaddr
*addr
)
897 if (addr
->proto
== QETH_PROT_IPV4
) {
898 QETH_DBF_TEXT(TRACE
, 2, "setaddr4");
899 QETH_DBF_HEX(TRACE
, 3, &addr
->u
.a4
.addr
, sizeof(int));
900 } else if (addr
->proto
== QETH_PROT_IPV6
) {
901 QETH_DBF_TEXT(TRACE
, 2, "setaddr6");
902 QETH_DBF_HEX(TRACE
, 3, &addr
->u
.a6
.addr
, 8);
903 QETH_DBF_HEX(TRACE
, 3, ((char *)&addr
->u
.a6
.addr
) + 8, 8);
905 QETH_DBF_TEXT(TRACE
, 2, "setaddr?");
906 QETH_DBF_HEX(TRACE
, 3, addr
, sizeof(struct qeth_ipaddr
));
909 if (addr
->is_multicast
)
910 rc
= qeth_l3_send_setdelmc(card
, addr
, IPA_CMD_SETIPM
);
912 rc
= qeth_l3_send_setdelip(card
, addr
, IPA_CMD_SETIP
,
915 QETH_DBF_TEXT(TRACE
, 2, "failed");
916 } while ((--cnt
> 0) && rc
);
918 QETH_DBF_TEXT(TRACE
, 2, "FAILED");
919 qeth_l3_ipaddr_to_string(addr
->proto
, (u8
*)&addr
->u
, buf
);
920 PRINT_WARN("Could not register IP address %s (rc=0x%x/%d)\n",
926 static int qeth_l3_deregister_addr_entry(struct qeth_card
*card
,
927 struct qeth_ipaddr
*addr
)
931 if (addr
->proto
== QETH_PROT_IPV4
) {
932 QETH_DBF_TEXT(TRACE
, 2, "deladdr4");
933 QETH_DBF_HEX(TRACE
, 3, &addr
->u
.a4
.addr
, sizeof(int));
934 } else if (addr
->proto
== QETH_PROT_IPV6
) {
935 QETH_DBF_TEXT(TRACE
, 2, "deladdr6");
936 QETH_DBF_HEX(TRACE
, 3, &addr
->u
.a6
.addr
, 8);
937 QETH_DBF_HEX(TRACE
, 3, ((char *)&addr
->u
.a6
.addr
) + 8, 8);
939 QETH_DBF_TEXT(TRACE
, 2, "deladdr?");
940 QETH_DBF_HEX(TRACE
, 3, addr
, sizeof(struct qeth_ipaddr
));
942 if (addr
->is_multicast
)
943 rc
= qeth_l3_send_setdelmc(card
, addr
, IPA_CMD_DELIPM
);
945 rc
= qeth_l3_send_setdelip(card
, addr
, IPA_CMD_DELIP
,
948 QETH_DBF_TEXT(TRACE
, 2, "failed");
949 /* TODO: re-activate this warning as soon as we have a
951 qeth_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
952 PRINT_WARN("Could not deregister IP address %s (rc=%x)\n",
960 static inline u8
qeth_l3_get_qeth_hdr_flags4(int cast_type
)
962 if (cast_type
== RTN_MULTICAST
)
963 return QETH_CAST_MULTICAST
;
964 if (cast_type
== RTN_BROADCAST
)
965 return QETH_CAST_BROADCAST
;
966 return QETH_CAST_UNICAST
;
969 static inline u8
qeth_l3_get_qeth_hdr_flags6(int cast_type
)
971 u8 ct
= QETH_HDR_PASSTHRU
| QETH_HDR_IPV6
;
972 if (cast_type
== RTN_MULTICAST
)
973 return ct
| QETH_CAST_MULTICAST
;
974 if (cast_type
== RTN_ANYCAST
)
975 return ct
| QETH_CAST_ANYCAST
;
976 if (cast_type
== RTN_BROADCAST
)
977 return ct
| QETH_CAST_BROADCAST
;
978 return ct
| QETH_CAST_UNICAST
;
981 static int qeth_l3_send_setadp_mode(struct qeth_card
*card
, __u32 command
,
985 struct qeth_cmd_buffer
*iob
;
986 struct qeth_ipa_cmd
*cmd
;
988 QETH_DBF_TEXT(TRACE
, 4, "adpmode");
990 iob
= qeth_get_adapter_cmd(card
, command
,
991 sizeof(struct qeth_ipacmd_setadpparms
));
992 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
993 cmd
->data
.setadapterparms
.data
.mode
= mode
;
994 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_default_setadapterparms_cb
,
999 static int qeth_l3_setadapter_hstr(struct qeth_card
*card
)
1003 QETH_DBF_TEXT(TRACE
, 4, "adphstr");
1005 if (qeth_adp_supported(card
, IPA_SETADP_SET_BROADCAST_MODE
)) {
1006 rc
= qeth_l3_send_setadp_mode(card
,
1007 IPA_SETADP_SET_BROADCAST_MODE
,
1008 card
->options
.broadcast_mode
);
1010 QETH_DBF_MESSAGE(2, "couldn't set broadcast mode on "
1012 CARD_BUS_ID(card
), rc
);
1013 rc
= qeth_l3_send_setadp_mode(card
,
1014 IPA_SETADP_ALTER_MAC_ADDRESS
,
1015 card
->options
.macaddr_mode
);
1017 QETH_DBF_MESSAGE(2, "couldn't set macaddr mode on "
1018 "device %s: x%x\n", CARD_BUS_ID(card
), rc
);
1021 if (card
->options
.broadcast_mode
== QETH_TR_BROADCAST_LOCAL
)
1022 QETH_DBF_MESSAGE(2, "set adapter parameters not available "
1023 "to set broadcast mode, using ALLRINGS "
1024 "on device %s:\n", CARD_BUS_ID(card
));
1025 if (card
->options
.macaddr_mode
== QETH_TR_MACADDR_CANONICAL
)
1026 QETH_DBF_MESSAGE(2, "set adapter parameters not available "
1027 "to set macaddr mode, using NONCANONICAL "
1028 "on device %s:\n", CARD_BUS_ID(card
));
1032 static int qeth_l3_setadapter_parms(struct qeth_card
*card
)
1036 QETH_DBF_TEXT(SETUP
, 2, "setadprm");
1038 if (!qeth_is_supported(card
, IPA_SETADAPTERPARMS
)) {
1039 PRINT_WARN("set adapter parameters not supported "
1042 QETH_DBF_TEXT(SETUP
, 2, " notsupp");
1045 rc
= qeth_query_setadapterparms(card
);
1047 PRINT_WARN("couldn't set adapter parameters on device %s: "
1048 "x%x\n", CARD_BUS_ID(card
), rc
);
1051 if (qeth_adp_supported(card
, IPA_SETADP_ALTER_MAC_ADDRESS
)) {
1052 rc
= qeth_setadpparms_change_macaddr(card
);
1054 PRINT_WARN("couldn't get MAC address on "
1056 CARD_BUS_ID(card
), rc
);
1059 if ((card
->info
.link_type
== QETH_LINK_TYPE_HSTR
) ||
1060 (card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
))
1061 rc
= qeth_l3_setadapter_hstr(card
);
1066 static int qeth_l3_default_setassparms_cb(struct qeth_card
*card
,
1067 struct qeth_reply
*reply
, unsigned long data
)
1069 struct qeth_ipa_cmd
*cmd
;
1071 QETH_DBF_TEXT(TRACE
, 4, "defadpcb");
1073 cmd
= (struct qeth_ipa_cmd
*) data
;
1074 if (cmd
->hdr
.return_code
== 0) {
1075 cmd
->hdr
.return_code
= cmd
->data
.setassparms
.hdr
.return_code
;
1076 if (cmd
->hdr
.prot_version
== QETH_PROT_IPV4
)
1077 card
->options
.ipa4
.enabled_funcs
= cmd
->hdr
.ipa_enabled
;
1078 if (cmd
->hdr
.prot_version
== QETH_PROT_IPV6
)
1079 card
->options
.ipa6
.enabled_funcs
= cmd
->hdr
.ipa_enabled
;
1081 if (cmd
->data
.setassparms
.hdr
.assist_no
== IPA_INBOUND_CHECKSUM
&&
1082 cmd
->data
.setassparms
.hdr
.command_code
== IPA_CMD_ASS_START
) {
1083 card
->info
.csum_mask
= cmd
->data
.setassparms
.data
.flags_32bit
;
1084 QETH_DBF_TEXT_(TRACE
, 3, "csum:%d", card
->info
.csum_mask
);
1089 static struct qeth_cmd_buffer
*qeth_l3_get_setassparms_cmd(
1090 struct qeth_card
*card
, enum qeth_ipa_funcs ipa_func
, __u16 cmd_code
,
1091 __u16 len
, enum qeth_prot_versions prot
)
1093 struct qeth_cmd_buffer
*iob
;
1094 struct qeth_ipa_cmd
*cmd
;
1096 QETH_DBF_TEXT(TRACE
, 4, "getasscm");
1097 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_SETASSPARMS
, prot
);
1099 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
1100 cmd
->data
.setassparms
.hdr
.assist_no
= ipa_func
;
1101 cmd
->data
.setassparms
.hdr
.length
= 8 + len
;
1102 cmd
->data
.setassparms
.hdr
.command_code
= cmd_code
;
1103 cmd
->data
.setassparms
.hdr
.return_code
= 0;
1104 cmd
->data
.setassparms
.hdr
.seq_no
= 0;
1109 static int qeth_l3_send_setassparms(struct qeth_card
*card
,
1110 struct qeth_cmd_buffer
*iob
, __u16 len
, long data
,
1111 int (*reply_cb
)(struct qeth_card
*, struct qeth_reply
*,
1116 struct qeth_ipa_cmd
*cmd
;
1118 QETH_DBF_TEXT(TRACE
, 4, "sendassp");
1120 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
1121 if (len
<= sizeof(__u32
))
1122 cmd
->data
.setassparms
.data
.flags_32bit
= (__u32
) data
;
1123 else /* (len > sizeof(__u32)) */
1124 memcpy(&cmd
->data
.setassparms
.data
, (void *) data
, len
);
1126 rc
= qeth_send_ipa_cmd(card
, iob
, reply_cb
, reply_param
);
1130 #ifdef CONFIG_QETH_IPV6
1131 static int qeth_l3_send_simple_setassparms_ipv6(struct qeth_card
*card
,
1132 enum qeth_ipa_funcs ipa_func
, __u16 cmd_code
)
1135 struct qeth_cmd_buffer
*iob
;
1137 QETH_DBF_TEXT(TRACE
, 4, "simassp6");
1138 iob
= qeth_l3_get_setassparms_cmd(card
, ipa_func
, cmd_code
,
1140 rc
= qeth_l3_send_setassparms(card
, iob
, 0, 0,
1141 qeth_l3_default_setassparms_cb
, NULL
);
1146 static int qeth_l3_send_simple_setassparms(struct qeth_card
*card
,
1147 enum qeth_ipa_funcs ipa_func
, __u16 cmd_code
, long data
)
1151 struct qeth_cmd_buffer
*iob
;
1153 QETH_DBF_TEXT(TRACE
, 4, "simassp4");
1155 length
= sizeof(__u32
);
1156 iob
= qeth_l3_get_setassparms_cmd(card
, ipa_func
, cmd_code
,
1157 length
, QETH_PROT_IPV4
);
1158 rc
= qeth_l3_send_setassparms(card
, iob
, length
, data
,
1159 qeth_l3_default_setassparms_cb
, NULL
);
1163 static int qeth_l3_start_ipa_arp_processing(struct qeth_card
*card
)
1167 QETH_DBF_TEXT(TRACE
, 3, "ipaarp");
1169 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
1170 PRINT_WARN("ARP processing not supported "
1171 "on %s!\n", QETH_CARD_IFNAME(card
));
1174 rc
= qeth_l3_send_simple_setassparms(card
, IPA_ARP_PROCESSING
,
1175 IPA_CMD_ASS_START
, 0);
1177 PRINT_WARN("Could not start ARP processing "
1178 "assist on %s: 0x%x\n",
1179 QETH_CARD_IFNAME(card
), rc
);
1184 static int qeth_l3_start_ipa_ip_fragmentation(struct qeth_card
*card
)
1188 QETH_DBF_TEXT(TRACE
, 3, "ipaipfrg");
1190 if (!qeth_is_supported(card
, IPA_IP_FRAGMENTATION
)) {
1191 PRINT_INFO("Hardware IP fragmentation not supported on %s\n",
1192 QETH_CARD_IFNAME(card
));
1196 rc
= qeth_l3_send_simple_setassparms(card
, IPA_IP_FRAGMENTATION
,
1197 IPA_CMD_ASS_START
, 0);
1199 PRINT_WARN("Could not start Hardware IP fragmentation "
1200 "assist on %s: 0x%x\n",
1201 QETH_CARD_IFNAME(card
), rc
);
1203 PRINT_INFO("Hardware IP fragmentation enabled \n");
1207 static int qeth_l3_start_ipa_source_mac(struct qeth_card
*card
)
1211 QETH_DBF_TEXT(TRACE
, 3, "stsrcmac");
1213 if (!card
->options
.fake_ll
)
1216 if (!qeth_is_supported(card
, IPA_SOURCE_MAC
)) {
1217 PRINT_INFO("Inbound source address not "
1218 "supported on %s\n", QETH_CARD_IFNAME(card
));
1222 rc
= qeth_l3_send_simple_setassparms(card
, IPA_SOURCE_MAC
,
1223 IPA_CMD_ASS_START
, 0);
1225 PRINT_WARN("Could not start inbound source "
1226 "assist on %s: 0x%x\n",
1227 QETH_CARD_IFNAME(card
), rc
);
1231 static int qeth_l3_start_ipa_vlan(struct qeth_card
*card
)
1235 QETH_DBF_TEXT(TRACE
, 3, "strtvlan");
1237 if (!qeth_is_supported(card
, IPA_FULL_VLAN
)) {
1238 PRINT_WARN("VLAN not supported on %s\n",
1239 QETH_CARD_IFNAME(card
));
1243 rc
= qeth_l3_send_simple_setassparms(card
, IPA_VLAN_PRIO
,
1244 IPA_CMD_ASS_START
, 0);
1246 PRINT_WARN("Could not start vlan "
1247 "assist on %s: 0x%x\n",
1248 QETH_CARD_IFNAME(card
), rc
);
1250 PRINT_INFO("VLAN enabled \n");
1255 static int qeth_l3_start_ipa_multicast(struct qeth_card
*card
)
1259 QETH_DBF_TEXT(TRACE
, 3, "stmcast");
1261 if (!qeth_is_supported(card
, IPA_MULTICASTING
)) {
1262 PRINT_WARN("Multicast not supported on %s\n",
1263 QETH_CARD_IFNAME(card
));
1267 rc
= qeth_l3_send_simple_setassparms(card
, IPA_MULTICASTING
,
1268 IPA_CMD_ASS_START
, 0);
1270 PRINT_WARN("Could not start multicast "
1271 "assist on %s: rc=%i\n",
1272 QETH_CARD_IFNAME(card
), rc
);
1274 PRINT_INFO("Multicast enabled\n");
1275 card
->dev
->flags
|= IFF_MULTICAST
;
1280 static int qeth_l3_query_ipassists_cb(struct qeth_card
*card
,
1281 struct qeth_reply
*reply
, unsigned long data
)
1283 struct qeth_ipa_cmd
*cmd
;
1285 QETH_DBF_TEXT(SETUP
, 2, "qipasscb");
1287 cmd
= (struct qeth_ipa_cmd
*) data
;
1288 if (cmd
->hdr
.prot_version
== QETH_PROT_IPV4
) {
1289 card
->options
.ipa4
.supported_funcs
= cmd
->hdr
.ipa_supported
;
1290 card
->options
.ipa4
.enabled_funcs
= cmd
->hdr
.ipa_enabled
;
1292 card
->options
.ipa6
.supported_funcs
= cmd
->hdr
.ipa_supported
;
1293 card
->options
.ipa6
.enabled_funcs
= cmd
->hdr
.ipa_enabled
;
1295 QETH_DBF_TEXT(SETUP
, 2, "suppenbl");
1296 QETH_DBF_TEXT_(SETUP
, 2, "%x", cmd
->hdr
.ipa_supported
);
1297 QETH_DBF_TEXT_(SETUP
, 2, "%x", cmd
->hdr
.ipa_enabled
);
1301 static int qeth_l3_query_ipassists(struct qeth_card
*card
,
1302 enum qeth_prot_versions prot
)
1305 struct qeth_cmd_buffer
*iob
;
1307 QETH_DBF_TEXT_(SETUP
, 2, "qipassi%i", prot
);
1308 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_QIPASSIST
, prot
);
1309 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_l3_query_ipassists_cb
, NULL
);
1313 #ifdef CONFIG_QETH_IPV6
1314 static int qeth_l3_softsetup_ipv6(struct qeth_card
*card
)
1318 QETH_DBF_TEXT(TRACE
, 3, "softipv6");
1320 if (card
->info
.type
== QETH_CARD_TYPE_IQD
)
1323 rc
= qeth_l3_query_ipassists(card
, QETH_PROT_IPV6
);
1325 PRINT_ERR("IPv6 query ipassist failed on %s\n",
1326 QETH_CARD_IFNAME(card
));
1329 rc
= qeth_l3_send_simple_setassparms(card
, IPA_IPV6
,
1330 IPA_CMD_ASS_START
, 3);
1332 PRINT_WARN("IPv6 start assist (version 4) failed "
1334 QETH_CARD_IFNAME(card
), rc
);
1337 rc
= qeth_l3_send_simple_setassparms_ipv6(card
, IPA_IPV6
,
1340 PRINT_WARN("IPV6 start assist (version 6) failed "
1342 QETH_CARD_IFNAME(card
), rc
);
1345 rc
= qeth_l3_send_simple_setassparms_ipv6(card
, IPA_PASSTHRU
,
1348 PRINT_WARN("Could not enable passthrough "
1350 QETH_CARD_IFNAME(card
), rc
);
1354 PRINT_INFO("IPV6 enabled \n");
1359 static int qeth_l3_start_ipa_ipv6(struct qeth_card
*card
)
1363 QETH_DBF_TEXT(TRACE
, 3, "strtipv6");
1365 if (!qeth_is_supported(card
, IPA_IPV6
)) {
1366 PRINT_WARN("IPv6 not supported on %s\n",
1367 QETH_CARD_IFNAME(card
));
1370 #ifdef CONFIG_QETH_IPV6
1371 rc
= qeth_l3_softsetup_ipv6(card
);
1376 static int qeth_l3_start_ipa_broadcast(struct qeth_card
*card
)
1380 QETH_DBF_TEXT(TRACE
, 3, "stbrdcst");
1381 card
->info
.broadcast_capable
= 0;
1382 if (!qeth_is_supported(card
, IPA_FILTERING
)) {
1383 PRINT_WARN("Broadcast not supported on %s\n",
1384 QETH_CARD_IFNAME(card
));
1388 rc
= qeth_l3_send_simple_setassparms(card
, IPA_FILTERING
,
1389 IPA_CMD_ASS_START
, 0);
1391 PRINT_WARN("Could not enable broadcasting filtering "
1393 QETH_CARD_IFNAME(card
), rc
);
1397 rc
= qeth_l3_send_simple_setassparms(card
, IPA_FILTERING
,
1398 IPA_CMD_ASS_CONFIGURE
, 1);
1400 PRINT_WARN("Could not set up broadcast filtering on %s: 0x%x\n",
1401 QETH_CARD_IFNAME(card
), rc
);
1404 card
->info
.broadcast_capable
= QETH_BROADCAST_WITH_ECHO
;
1405 PRINT_INFO("Broadcast enabled \n");
1406 rc
= qeth_l3_send_simple_setassparms(card
, IPA_FILTERING
,
1407 IPA_CMD_ASS_ENABLE
, 1);
1409 PRINT_WARN("Could not set up broadcast echo filtering on "
1410 "%s: 0x%x\n", QETH_CARD_IFNAME(card
), rc
);
1413 card
->info
.broadcast_capable
= QETH_BROADCAST_WITHOUT_ECHO
;
1415 if (card
->info
.broadcast_capable
)
1416 card
->dev
->flags
|= IFF_BROADCAST
;
1418 card
->dev
->flags
&= ~IFF_BROADCAST
;
1422 static int qeth_l3_send_checksum_command(struct qeth_card
*card
)
1426 rc
= qeth_l3_send_simple_setassparms(card
, IPA_INBOUND_CHECKSUM
,
1427 IPA_CMD_ASS_START
, 0);
1429 PRINT_WARN("Starting Inbound HW Checksumming failed on %s: "
1430 "0x%x,\ncontinuing using Inbound SW Checksumming\n",
1431 QETH_CARD_IFNAME(card
), rc
);
1434 rc
= qeth_l3_send_simple_setassparms(card
, IPA_INBOUND_CHECKSUM
,
1436 card
->info
.csum_mask
);
1438 PRINT_WARN("Enabling Inbound HW Checksumming failed on %s: "
1439 "0x%x,\ncontinuing using Inbound SW Checksumming\n",
1440 QETH_CARD_IFNAME(card
), rc
);
1446 static int qeth_l3_start_ipa_checksum(struct qeth_card
*card
)
1450 QETH_DBF_TEXT(TRACE
, 3, "strtcsum");
1452 if (card
->options
.checksum_type
== NO_CHECKSUMMING
) {
1453 PRINT_WARN("Using no checksumming on %s.\n",
1454 QETH_CARD_IFNAME(card
));
1457 if (card
->options
.checksum_type
== SW_CHECKSUMMING
) {
1458 PRINT_WARN("Using SW checksumming on %s.\n",
1459 QETH_CARD_IFNAME(card
));
1462 if (!qeth_is_supported(card
, IPA_INBOUND_CHECKSUM
)) {
1463 PRINT_WARN("Inbound HW Checksumming not "
1464 "supported on %s,\ncontinuing "
1465 "using Inbound SW Checksumming\n",
1466 QETH_CARD_IFNAME(card
));
1467 card
->options
.checksum_type
= SW_CHECKSUMMING
;
1470 rc
= qeth_l3_send_checksum_command(card
);
1472 PRINT_INFO("HW Checksumming (inbound) enabled \n");
1477 static int qeth_l3_start_ipa_tso(struct qeth_card
*card
)
1481 QETH_DBF_TEXT(TRACE
, 3, "sttso");
1483 if (!qeth_is_supported(card
, IPA_OUTBOUND_TSO
)) {
1484 PRINT_WARN("Outbound TSO not supported on %s\n",
1485 QETH_CARD_IFNAME(card
));
1488 rc
= qeth_l3_send_simple_setassparms(card
, IPA_OUTBOUND_TSO
,
1489 IPA_CMD_ASS_START
, 0);
1491 PRINT_WARN("Could not start outbound TSO "
1492 "assist on %s: rc=%i\n",
1493 QETH_CARD_IFNAME(card
), rc
);
1495 PRINT_INFO("Outbound TSO enabled\n");
1497 if (rc
&& (card
->options
.large_send
== QETH_LARGE_SEND_TSO
)) {
1498 card
->options
.large_send
= QETH_LARGE_SEND_NO
;
1499 card
->dev
->features
&= ~(NETIF_F_TSO
| NETIF_F_SG
);
1504 static int qeth_l3_start_ipassists(struct qeth_card
*card
)
1506 QETH_DBF_TEXT(TRACE
, 3, "strtipas");
1507 qeth_l3_start_ipa_arp_processing(card
); /* go on*/
1508 qeth_l3_start_ipa_ip_fragmentation(card
); /* go on*/
1509 qeth_l3_start_ipa_source_mac(card
); /* go on*/
1510 qeth_l3_start_ipa_vlan(card
); /* go on*/
1511 qeth_l3_start_ipa_multicast(card
); /* go on*/
1512 qeth_l3_start_ipa_ipv6(card
); /* go on*/
1513 qeth_l3_start_ipa_broadcast(card
); /* go on*/
1514 qeth_l3_start_ipa_checksum(card
); /* go on*/
1515 qeth_l3_start_ipa_tso(card
); /* go on*/
1519 static int qeth_l3_put_unique_id(struct qeth_card
*card
)
1523 struct qeth_cmd_buffer
*iob
;
1524 struct qeth_ipa_cmd
*cmd
;
1526 QETH_DBF_TEXT(TRACE
, 2, "puniqeid");
1528 if ((card
->info
.unique_id
& UNIQUE_ID_NOT_BY_CARD
) ==
1529 UNIQUE_ID_NOT_BY_CARD
)
1531 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_DESTROY_ADDR
,
1533 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
1534 *((__u16
*) &cmd
->data
.create_destroy_addr
.unique_id
[6]) =
1535 card
->info
.unique_id
;
1536 memcpy(&cmd
->data
.create_destroy_addr
.unique_id
[0],
1537 card
->dev
->dev_addr
, OSA_ADDR_LEN
);
1538 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
1542 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card
*card
,
1543 struct qeth_reply
*reply
, unsigned long data
)
1545 struct qeth_ipa_cmd
*cmd
;
1547 cmd
= (struct qeth_ipa_cmd
*) data
;
1548 if (cmd
->hdr
.return_code
== 0)
1549 memcpy(card
->dev
->dev_addr
,
1550 cmd
->data
.create_destroy_addr
.unique_id
, ETH_ALEN
);
1552 random_ether_addr(card
->dev
->dev_addr
);
1557 static int qeth_l3_iqd_read_initial_mac(struct qeth_card
*card
)
1560 struct qeth_cmd_buffer
*iob
;
1561 struct qeth_ipa_cmd
*cmd
;
1563 QETH_DBF_TEXT(SETUP
, 2, "hsrmac");
1565 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_CREATE_ADDR
,
1567 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
1568 *((__u16
*) &cmd
->data
.create_destroy_addr
.unique_id
[6]) =
1569 card
->info
.unique_id
;
1571 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_l3_iqd_read_initial_mac_cb
,
1576 static int qeth_l3_get_unique_id_cb(struct qeth_card
*card
,
1577 struct qeth_reply
*reply
, unsigned long data
)
1579 struct qeth_ipa_cmd
*cmd
;
1581 cmd
= (struct qeth_ipa_cmd
*) data
;
1582 if (cmd
->hdr
.return_code
== 0)
1583 card
->info
.unique_id
= *((__u16
*)
1584 &cmd
->data
.create_destroy_addr
.unique_id
[6]);
1586 card
->info
.unique_id
= UNIQUE_ID_IF_CREATE_ADDR_FAILED
|
1587 UNIQUE_ID_NOT_BY_CARD
;
1588 PRINT_WARN("couldn't get a unique id from the card on device "
1589 "%s (result=x%x), using default id. ipv6 "
1590 "autoconfig on other lpars may lead to duplicate "
1591 "ip addresses. please use manually "
1592 "configured ones.\n",
1593 CARD_BUS_ID(card
), cmd
->hdr
.return_code
);
1598 static int qeth_l3_get_unique_id(struct qeth_card
*card
)
1601 struct qeth_cmd_buffer
*iob
;
1602 struct qeth_ipa_cmd
*cmd
;
1604 QETH_DBF_TEXT(SETUP
, 2, "guniqeid");
1606 if (!qeth_is_supported(card
, IPA_IPV6
)) {
1607 card
->info
.unique_id
= UNIQUE_ID_IF_CREATE_ADDR_FAILED
|
1608 UNIQUE_ID_NOT_BY_CARD
;
1612 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_CREATE_ADDR
,
1614 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
1615 *((__u16
*) &cmd
->data
.create_destroy_addr
.unique_id
[6]) =
1616 card
->info
.unique_id
;
1618 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_l3_get_unique_id_cb
, NULL
);
1622 static void qeth_l3_get_mac_for_ipm(__u32 ipm
, char *mac
,
1623 struct net_device
*dev
)
1625 if (dev
->type
== ARPHRD_IEEE802_TR
)
1626 ip_tr_mc_map(ipm
, mac
);
1628 ip_eth_mc_map(ipm
, mac
);
1631 static void qeth_l3_add_mc(struct qeth_card
*card
, struct in_device
*in4_dev
)
1633 struct qeth_ipaddr
*ipm
;
1634 struct ip_mc_list
*im4
;
1635 char buf
[MAX_ADDR_LEN
];
1637 QETH_DBF_TEXT(TRACE
, 4, "addmc");
1638 for (im4
= in4_dev
->mc_list
; im4
; im4
= im4
->next
) {
1639 qeth_l3_get_mac_for_ipm(im4
->multiaddr
, buf
, in4_dev
->dev
);
1640 ipm
= qeth_l3_get_addr_buffer(QETH_PROT_IPV4
);
1643 ipm
->u
.a4
.addr
= im4
->multiaddr
;
1644 memcpy(ipm
->mac
, buf
, OSA_ADDR_LEN
);
1645 ipm
->is_multicast
= 1;
1646 if (!qeth_l3_add_ip(card
, ipm
))
1651 static void qeth_l3_add_vlan_mc(struct qeth_card
*card
)
1653 struct in_device
*in_dev
;
1654 struct vlan_group
*vg
;
1657 QETH_DBF_TEXT(TRACE
, 4, "addmcvl");
1658 if (!qeth_is_supported(card
, IPA_FULL_VLAN
) || (card
->vlangrp
== NULL
))
1662 for (i
= 0; i
< VLAN_GROUP_ARRAY_LEN
; i
++) {
1663 struct net_device
*netdev
= vlan_group_get_device(vg
, i
);
1664 if (netdev
== NULL
||
1665 !(netdev
->flags
& IFF_UP
))
1667 in_dev
= in_dev_get(netdev
);
1670 read_lock(&in_dev
->mc_list_lock
);
1671 qeth_l3_add_mc(card
, in_dev
);
1672 read_unlock(&in_dev
->mc_list_lock
);
1677 static void qeth_l3_add_multicast_ipv4(struct qeth_card
*card
)
1679 struct in_device
*in4_dev
;
1681 QETH_DBF_TEXT(TRACE
, 4, "chkmcv4");
1682 in4_dev
= in_dev_get(card
->dev
);
1683 if (in4_dev
== NULL
)
1685 read_lock(&in4_dev
->mc_list_lock
);
1686 qeth_l3_add_mc(card
, in4_dev
);
1687 qeth_l3_add_vlan_mc(card
);
1688 read_unlock(&in4_dev
->mc_list_lock
);
1689 in_dev_put(in4_dev
);
1692 #ifdef CONFIG_QETH_IPV6
1693 static void qeth_l3_add_mc6(struct qeth_card
*card
, struct inet6_dev
*in6_dev
)
1695 struct qeth_ipaddr
*ipm
;
1696 struct ifmcaddr6
*im6
;
1697 char buf
[MAX_ADDR_LEN
];
1699 QETH_DBF_TEXT(TRACE
, 4, "addmc6");
1700 for (im6
= in6_dev
->mc_list
; im6
!= NULL
; im6
= im6
->next
) {
1701 ndisc_mc_map(&im6
->mca_addr
, buf
, in6_dev
->dev
, 0);
1702 ipm
= qeth_l3_get_addr_buffer(QETH_PROT_IPV6
);
1705 ipm
->is_multicast
= 1;
1706 memcpy(ipm
->mac
, buf
, OSA_ADDR_LEN
);
1707 memcpy(&ipm
->u
.a6
.addr
, &im6
->mca_addr
.s6_addr
,
1708 sizeof(struct in6_addr
));
1709 if (!qeth_l3_add_ip(card
, ipm
))
1714 static void qeth_l3_add_vlan_mc6(struct qeth_card
*card
)
1716 struct inet6_dev
*in_dev
;
1717 struct vlan_group
*vg
;
1720 QETH_DBF_TEXT(TRACE
, 4, "admc6vl");
1721 if (!qeth_is_supported(card
, IPA_FULL_VLAN
) || (card
->vlangrp
== NULL
))
1725 for (i
= 0; i
< VLAN_GROUP_ARRAY_LEN
; i
++) {
1726 struct net_device
*netdev
= vlan_group_get_device(vg
, i
);
1727 if (netdev
== NULL
||
1728 !(netdev
->flags
& IFF_UP
))
1730 in_dev
= in6_dev_get(netdev
);
1733 read_lock_bh(&in_dev
->lock
);
1734 qeth_l3_add_mc6(card
, in_dev
);
1735 read_unlock_bh(&in_dev
->lock
);
1736 in6_dev_put(in_dev
);
1740 static void qeth_l3_add_multicast_ipv6(struct qeth_card
*card
)
1742 struct inet6_dev
*in6_dev
;
1744 QETH_DBF_TEXT(TRACE
, 4, "chkmcv6");
1745 if (!qeth_is_supported(card
, IPA_IPV6
))
1747 in6_dev
= in6_dev_get(card
->dev
);
1748 if (in6_dev
== NULL
)
1750 read_lock_bh(&in6_dev
->lock
);
1751 qeth_l3_add_mc6(card
, in6_dev
);
1752 qeth_l3_add_vlan_mc6(card
);
1753 read_unlock_bh(&in6_dev
->lock
);
1754 in6_dev_put(in6_dev
);
1756 #endif /* CONFIG_QETH_IPV6 */
1758 static void qeth_l3_free_vlan_addresses4(struct qeth_card
*card
,
1761 struct in_device
*in_dev
;
1762 struct in_ifaddr
*ifa
;
1763 struct qeth_ipaddr
*addr
;
1765 QETH_DBF_TEXT(TRACE
, 4, "frvaddr4");
1767 in_dev
= in_dev_get(vlan_group_get_device(card
->vlangrp
, vid
));
1770 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1771 addr
= qeth_l3_get_addr_buffer(QETH_PROT_IPV4
);
1773 addr
->u
.a4
.addr
= ifa
->ifa_address
;
1774 addr
->u
.a4
.mask
= ifa
->ifa_mask
;
1775 addr
->type
= QETH_IP_TYPE_NORMAL
;
1776 if (!qeth_l3_delete_ip(card
, addr
))
1783 static void qeth_l3_free_vlan_addresses6(struct qeth_card
*card
,
1786 #ifdef CONFIG_QETH_IPV6
1787 struct inet6_dev
*in6_dev
;
1788 struct inet6_ifaddr
*ifa
;
1789 struct qeth_ipaddr
*addr
;
1791 QETH_DBF_TEXT(TRACE
, 4, "frvaddr6");
1793 in6_dev
= in6_dev_get(vlan_group_get_device(card
->vlangrp
, vid
));
1796 for (ifa
= in6_dev
->addr_list
; ifa
; ifa
= ifa
->lst_next
) {
1797 addr
= qeth_l3_get_addr_buffer(QETH_PROT_IPV6
);
1799 memcpy(&addr
->u
.a6
.addr
, &ifa
->addr
,
1800 sizeof(struct in6_addr
));
1801 addr
->u
.a6
.pfxlen
= ifa
->prefix_len
;
1802 addr
->type
= QETH_IP_TYPE_NORMAL
;
1803 if (!qeth_l3_delete_ip(card
, addr
))
1807 in6_dev_put(in6_dev
);
1808 #endif /* CONFIG_QETH_IPV6 */
1811 static void qeth_l3_free_vlan_addresses(struct qeth_card
*card
,
1816 qeth_l3_free_vlan_addresses4(card
, vid
);
1817 qeth_l3_free_vlan_addresses6(card
, vid
);
1820 static void qeth_l3_vlan_rx_register(struct net_device
*dev
,
1821 struct vlan_group
*grp
)
1823 struct qeth_card
*card
= netdev_priv(dev
);
1824 unsigned long flags
;
1826 QETH_DBF_TEXT(TRACE
, 4, "vlanreg");
1827 spin_lock_irqsave(&card
->vlanlock
, flags
);
1828 card
->vlangrp
= grp
;
1829 spin_unlock_irqrestore(&card
->vlanlock
, flags
);
1832 static void qeth_l3_vlan_rx_add_vid(struct net_device
*dev
, unsigned short vid
)
1834 struct net_device
*vlandev
;
1835 struct qeth_card
*card
= (struct qeth_card
*) dev
->priv
;
1836 struct in_device
*in_dev
;
1838 if (card
->info
.type
== QETH_CARD_TYPE_IQD
)
1841 vlandev
= vlan_group_get_device(card
->vlangrp
, vid
);
1842 vlandev
->neigh_setup
= qeth_l3_neigh_setup
;
1844 in_dev
= in_dev_get(vlandev
);
1845 #ifdef CONFIG_SYSCTL
1846 neigh_sysctl_unregister(in_dev
->arp_parms
);
1848 neigh_parms_release(&arp_tbl
, in_dev
->arp_parms
);
1850 in_dev
->arp_parms
= neigh_parms_alloc(vlandev
, &arp_tbl
);
1851 #ifdef CONFIG_SYSCTL
1852 neigh_sysctl_register(vlandev
, in_dev
->arp_parms
, NET_IPV4
,
1853 NET_IPV4_NEIGH
, "ipv4", NULL
, NULL
);
1859 static void qeth_l3_vlan_rx_kill_vid(struct net_device
*dev
, unsigned short vid
)
1861 struct qeth_card
*card
= netdev_priv(dev
);
1862 unsigned long flags
;
1864 QETH_DBF_TEXT_(TRACE
, 4, "kid:%d", vid
);
1865 spin_lock_irqsave(&card
->vlanlock
, flags
);
1866 /* unregister IP addresses of vlan device */
1867 qeth_l3_free_vlan_addresses(card
, vid
);
1868 vlan_group_set_device(card
->vlangrp
, vid
, NULL
);
1869 spin_unlock_irqrestore(&card
->vlanlock
, flags
);
1870 qeth_l3_set_multicast_list(card
->dev
);
1873 static inline __u16
qeth_l3_rebuild_skb(struct qeth_card
*card
,
1874 struct sk_buff
*skb
, struct qeth_hdr
*hdr
)
1876 unsigned short vlan_id
= 0;
1878 struct iphdr
*ip_hdr
;
1879 unsigned char tg_addr
[MAX_ADDR_LEN
];
1881 if (!(hdr
->hdr
.l3
.flags
& QETH_HDR_PASSTHRU
)) {
1882 prot
= htons((hdr
->hdr
.l3
.flags
& QETH_HDR_IPV6
)? ETH_P_IPV6
:
1884 switch (hdr
->hdr
.l3
.flags
& QETH_HDR_CAST_MASK
) {
1885 case QETH_CAST_MULTICAST
:
1887 #ifdef CONFIG_QETH_IPV6
1888 case __constant_htons(ETH_P_IPV6
):
1889 ndisc_mc_map((struct in6_addr
*)
1891 tg_addr
, card
->dev
, 0);
1894 case __constant_htons(ETH_P_IP
):
1895 ip_hdr
= (struct iphdr
*)skb
->data
;
1896 (card
->dev
->type
== ARPHRD_IEEE802_TR
) ?
1897 ip_tr_mc_map(ip_hdr
->daddr
, tg_addr
):
1898 ip_eth_mc_map(ip_hdr
->daddr
, tg_addr
);
1901 memcpy(tg_addr
, card
->dev
->broadcast
,
1902 card
->dev
->addr_len
);
1904 card
->stats
.multicast
++;
1905 skb
->pkt_type
= PACKET_MULTICAST
;
1907 case QETH_CAST_BROADCAST
:
1908 memcpy(tg_addr
, card
->dev
->broadcast
,
1909 card
->dev
->addr_len
);
1910 card
->stats
.multicast
++;
1911 skb
->pkt_type
= PACKET_BROADCAST
;
1913 case QETH_CAST_UNICAST
:
1914 case QETH_CAST_ANYCAST
:
1915 case QETH_CAST_NOCAST
:
1917 skb
->pkt_type
= PACKET_HOST
;
1918 memcpy(tg_addr
, card
->dev
->dev_addr
,
1919 card
->dev
->addr_len
);
1921 card
->dev
->header_ops
->create(skb
, card
->dev
, prot
, tg_addr
,
1922 "FAKELL", card
->dev
->addr_len
);
1926 if (card
->dev
->type
== ARPHRD_IEEE802_TR
)
1927 skb
->protocol
= tr_type_trans(skb
, card
->dev
);
1930 skb
->protocol
= eth_type_trans(skb
, card
->dev
);
1932 if (hdr
->hdr
.l3
.ext_flags
&
1933 (QETH_HDR_EXT_VLAN_FRAME
| QETH_HDR_EXT_INCLUDE_VLAN_TAG
)) {
1934 vlan_id
= (hdr
->hdr
.l3
.ext_flags
& QETH_HDR_EXT_VLAN_FRAME
)?
1935 hdr
->hdr
.l3
.vlan_id
: *((u16
*)&hdr
->hdr
.l3
.dest_addr
[12]);
1938 skb
->ip_summed
= card
->options
.checksum_type
;
1939 if (card
->options
.checksum_type
== HW_CHECKSUMMING
) {
1940 if ((hdr
->hdr
.l3
.ext_flags
&
1941 (QETH_HDR_EXT_CSUM_HDR_REQ
|
1942 QETH_HDR_EXT_CSUM_TRANSP_REQ
)) ==
1943 (QETH_HDR_EXT_CSUM_HDR_REQ
|
1944 QETH_HDR_EXT_CSUM_TRANSP_REQ
))
1945 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1947 skb
->ip_summed
= SW_CHECKSUMMING
;
1953 static void qeth_l3_process_inbound_buffer(struct qeth_card
*card
,
1954 struct qeth_qdio_buffer
*buf
, int index
)
1956 struct qdio_buffer_element
*element
;
1957 struct sk_buff
*skb
;
1958 struct qeth_hdr
*hdr
;
1963 /* get first element of current buffer */
1964 element
= (struct qdio_buffer_element
*)&buf
->buffer
->element
[0];
1966 if (card
->options
.performance_stats
)
1967 card
->perf_stats
.bufs_rec
++;
1968 while ((skb
= qeth_core_get_next_skb(card
, buf
->buffer
, &element
,
1970 skb
->dev
= card
->dev
;
1971 /* is device UP ? */
1972 if (!(card
->dev
->flags
& IFF_UP
)) {
1973 dev_kfree_skb_any(skb
);
1977 switch (hdr
->hdr
.l3
.id
) {
1978 case QETH_HEADER_TYPE_LAYER3
:
1979 vlan_tag
= qeth_l3_rebuild_skb(card
, skb
, hdr
);
1983 vlan_hwaccel_rx(skb
, card
->vlangrp
,
1986 dev_kfree_skb_any(skb
);
1993 dev_kfree_skb_any(skb
);
1994 QETH_DBF_TEXT(TRACE
, 3, "inbunkno");
1995 QETH_DBF_HEX(CTRL
, 3, hdr
, QETH_DBF_CTRL_LEN
);
1999 card
->dev
->last_rx
= jiffies
;
2000 card
->stats
.rx_packets
++;
2001 card
->stats
.rx_bytes
+= len
;
2005 static int qeth_l3_verify_vlan_dev(struct net_device
*dev
,
2006 struct qeth_card
*card
)
2009 struct vlan_group
*vg
;
2016 for (i
= 0; i
< VLAN_GROUP_ARRAY_LEN
; i
++) {
2017 if (vlan_group_get_device(vg
, i
) == dev
) {
2018 rc
= QETH_VLAN_CARD
;
2023 if (rc
&& !(netdev_priv(vlan_dev_real_dev(dev
)) == (void *)card
))
2029 static int qeth_l3_verify_dev(struct net_device
*dev
)
2031 struct qeth_card
*card
;
2032 unsigned long flags
;
2035 read_lock_irqsave(&qeth_core_card_list
.rwlock
, flags
);
2036 list_for_each_entry(card
, &qeth_core_card_list
.list
, list
) {
2037 if (card
->dev
== dev
) {
2038 rc
= QETH_REAL_CARD
;
2041 rc
= qeth_l3_verify_vlan_dev(dev
, card
);
2045 read_unlock_irqrestore(&qeth_core_card_list
.rwlock
, flags
);
2050 static struct qeth_card
*qeth_l3_get_card_from_dev(struct net_device
*dev
)
2052 struct qeth_card
*card
= NULL
;
2055 rc
= qeth_l3_verify_dev(dev
);
2056 if (rc
== QETH_REAL_CARD
)
2057 card
= netdev_priv(dev
);
2058 else if (rc
== QETH_VLAN_CARD
)
2059 card
= netdev_priv(vlan_dev_real_dev(dev
));
2060 if (card
&& card
->options
.layer2
)
2062 QETH_DBF_TEXT_(TRACE
, 4, "%d", rc
);
2066 static int qeth_l3_stop_card(struct qeth_card
*card
, int recovery_mode
)
2070 QETH_DBF_TEXT(SETUP
, 2, "stopcard");
2071 QETH_DBF_HEX(SETUP
, 2, &card
, sizeof(void *));
2073 qeth_set_allowed_threads(card
, 0, 1);
2074 if (qeth_wait_for_threads(card
, ~QETH_RECOVER_THREAD
))
2075 return -ERESTARTSYS
;
2076 if (card
->read
.state
== CH_STATE_UP
&&
2077 card
->write
.state
== CH_STATE_UP
&&
2078 (card
->state
== CARD_STATE_UP
)) {
2080 qeth_l3_stop(card
->dev
);
2083 dev_close(card
->dev
);
2086 if (!card
->use_hard_stop
) {
2087 rc
= qeth_send_stoplan(card
);
2089 QETH_DBF_TEXT_(SETUP
, 2, "1err%d", rc
);
2091 card
->state
= CARD_STATE_SOFTSETUP
;
2093 if (card
->state
== CARD_STATE_SOFTSETUP
) {
2094 qeth_l3_clear_ip_list(card
, !card
->use_hard_stop
, 1);
2095 qeth_clear_ipacmd_list(card
);
2096 card
->state
= CARD_STATE_HARDSETUP
;
2098 if (card
->state
== CARD_STATE_HARDSETUP
) {
2099 if (!card
->use_hard_stop
&&
2100 (card
->info
.type
!= QETH_CARD_TYPE_IQD
)) {
2101 rc
= qeth_l3_put_unique_id(card
);
2103 QETH_DBF_TEXT_(SETUP
, 2, "2err%d", rc
);
2105 qeth_qdio_clear_card(card
, 0);
2106 qeth_clear_qdio_buffers(card
);
2107 qeth_clear_working_pool_list(card
);
2108 card
->state
= CARD_STATE_DOWN
;
2110 if (card
->state
== CARD_STATE_DOWN
) {
2111 qeth_clear_cmd_buffers(&card
->read
);
2112 qeth_clear_cmd_buffers(&card
->write
);
2114 card
->use_hard_stop
= 0;
2118 static void qeth_l3_set_multicast_list(struct net_device
*dev
)
2120 struct qeth_card
*card
= netdev_priv(dev
);
2122 QETH_DBF_TEXT(TRACE
, 3, "setmulti");
2123 qeth_l3_delete_mc_addresses(card
);
2124 qeth_l3_add_multicast_ipv4(card
);
2125 #ifdef CONFIG_QETH_IPV6
2126 qeth_l3_add_multicast_ipv6(card
);
2128 qeth_l3_set_ip_addr_list(card
);
2129 if (!qeth_adp_supported(card
, IPA_SETADP_SET_PROMISC_MODE
))
2131 qeth_setadp_promisc_mode(card
);
2134 static const char *qeth_l3_arp_get_error_cause(int *rc
)
2137 case QETH_IPA_ARP_RC_FAILED
:
2139 return "operation failed";
2140 case QETH_IPA_ARP_RC_NOTSUPP
:
2142 return "operation not supported";
2143 case QETH_IPA_ARP_RC_OUT_OF_RANGE
:
2145 return "argument out of range";
2146 case QETH_IPA_ARP_RC_Q_NOTSUPP
:
2148 return "query operation not supported";
2149 case QETH_IPA_ARP_RC_Q_NO_DATA
:
2151 return "no query data available";
2153 return "unknown error";
2157 static int qeth_l3_arp_set_no_entries(struct qeth_card
*card
, int no_entries
)
2162 QETH_DBF_TEXT(TRACE
, 3, "arpstnoe");
2165 * currently GuestLAN only supports the ARP assist function
2166 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
2167 * thus we say EOPNOTSUPP for this ARP function
2169 if (card
->info
.guestlan
)
2171 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
2174 rc
= qeth_l3_send_simple_setassparms(card
, IPA_ARP_PROCESSING
,
2175 IPA_CMD_ASS_ARP_SET_NO_ENTRIES
,
2179 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on "
2180 "%s: %s (0x%x/%d)\n", QETH_CARD_IFNAME(card
),
2181 qeth_l3_arp_get_error_cause(&rc
), tmp
, tmp
);
2186 static void qeth_l3_copy_arp_entries_stripped(struct qeth_arp_query_info
*qinfo
,
2187 struct qeth_arp_query_data
*qdata
, int entry_size
,
2194 entry_ptr
= (char *)&qdata
->data
;
2195 uentry_ptr
= (char *)(qinfo
->udata
+ qinfo
->udata_offset
);
2196 for (i
= 0; i
< qdata
->no_entries
; ++i
) {
2197 /* strip off 32 bytes "media specific information" */
2198 memcpy(uentry_ptr
, (entry_ptr
+ 32), entry_size
- 32);
2199 entry_ptr
+= entry_size
;
2200 uentry_ptr
+= uentry_size
;
2204 static int qeth_l3_arp_query_cb(struct qeth_card
*card
,
2205 struct qeth_reply
*reply
, unsigned long data
)
2207 struct qeth_ipa_cmd
*cmd
;
2208 struct qeth_arp_query_data
*qdata
;
2209 struct qeth_arp_query_info
*qinfo
;
2214 QETH_DBF_TEXT(TRACE
, 4, "arpquecb");
2216 qinfo
= (struct qeth_arp_query_info
*) reply
->param
;
2217 cmd
= (struct qeth_ipa_cmd
*) data
;
2218 if (cmd
->hdr
.return_code
) {
2219 QETH_DBF_TEXT_(TRACE
, 4, "qaer1%i", cmd
->hdr
.return_code
);
2222 if (cmd
->data
.setassparms
.hdr
.return_code
) {
2223 cmd
->hdr
.return_code
= cmd
->data
.setassparms
.hdr
.return_code
;
2224 QETH_DBF_TEXT_(TRACE
, 4, "qaer2%i", cmd
->hdr
.return_code
);
2227 qdata
= &cmd
->data
.setassparms
.data
.query_arp
;
2228 switch (qdata
->reply_bits
) {
2230 uentry_size
= entry_size
= sizeof(struct qeth_arp_qi_entry5
);
2231 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
)
2232 uentry_size
= sizeof(struct qeth_arp_qi_entry5_short
);
2235 /* fall through to default */
2237 /* tr is the same as eth -> entry7 */
2238 uentry_size
= entry_size
= sizeof(struct qeth_arp_qi_entry7
);
2239 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
)
2240 uentry_size
= sizeof(struct qeth_arp_qi_entry7_short
);
2243 /* check if there is enough room in userspace */
2244 if ((qinfo
->udata_len
- qinfo
->udata_offset
) <
2245 qdata
->no_entries
* uentry_size
){
2246 QETH_DBF_TEXT_(TRACE
, 4, "qaer3%i", -ENOMEM
);
2247 cmd
->hdr
.return_code
= -ENOMEM
;
2250 QETH_DBF_TEXT_(TRACE
, 4, "anore%i",
2251 cmd
->data
.setassparms
.hdr
.number_of_replies
);
2252 QETH_DBF_TEXT_(TRACE
, 4, "aseqn%i", cmd
->data
.setassparms
.hdr
.seq_no
);
2253 QETH_DBF_TEXT_(TRACE
, 4, "anoen%i", qdata
->no_entries
);
2255 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
) {
2256 /* strip off "media specific information" */
2257 qeth_l3_copy_arp_entries_stripped(qinfo
, qdata
, entry_size
,
2260 /*copy entries to user buffer*/
2261 memcpy(qinfo
->udata
+ qinfo
->udata_offset
,
2262 (char *)&qdata
->data
, qdata
->no_entries
*uentry_size
);
2264 qinfo
->no_entries
+= qdata
->no_entries
;
2265 qinfo
->udata_offset
+= (qdata
->no_entries
*uentry_size
);
2266 /* check if all replies received ... */
2267 if (cmd
->data
.setassparms
.hdr
.seq_no
<
2268 cmd
->data
.setassparms
.hdr
.number_of_replies
)
2270 memcpy(qinfo
->udata
, &qinfo
->no_entries
, 4);
2271 /* keep STRIP_ENTRIES flag so the user program can distinguish
2272 * stripped entries from normal ones */
2273 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
)
2274 qdata
->reply_bits
|= QETH_QARP_STRIP_ENTRIES
;
2275 memcpy(qinfo
->udata
+ QETH_QARP_MASK_OFFSET
, &qdata
->reply_bits
, 2);
2279 memcpy(qinfo
->udata
, &i
, 4);
2283 static int qeth_l3_send_ipa_arp_cmd(struct qeth_card
*card
,
2284 struct qeth_cmd_buffer
*iob
, int len
,
2285 int (*reply_cb
)(struct qeth_card
*, struct qeth_reply
*,
2289 QETH_DBF_TEXT(TRACE
, 4, "sendarp");
2291 memcpy(iob
->data
, IPA_PDU_HEADER
, IPA_PDU_HEADER_SIZE
);
2292 memcpy(QETH_IPA_CMD_DEST_ADDR(iob
->data
),
2293 &card
->token
.ulp_connection_r
, QETH_MPC_TOKEN_LENGTH
);
2294 return qeth_send_control_data(card
, IPA_PDU_HEADER_SIZE
+ len
, iob
,
2295 reply_cb
, reply_param
);
2298 static int qeth_l3_arp_query(struct qeth_card
*card
, char __user
*udata
)
2300 struct qeth_cmd_buffer
*iob
;
2301 struct qeth_arp_query_info qinfo
= {0, };
2305 QETH_DBF_TEXT(TRACE
, 3, "arpquery");
2307 if (!qeth_is_supported(card
,/*IPA_QUERY_ARP_ADDR_INFO*/
2308 IPA_ARP_PROCESSING
)) {
2311 /* get size of userspace buffer and mask_bits -> 6 bytes */
2312 if (copy_from_user(&qinfo
, udata
, 6))
2314 qinfo
.udata
= kzalloc(qinfo
.udata_len
, GFP_KERNEL
);
2317 qinfo
.udata_offset
= QETH_QARP_ENTRIES_OFFSET
;
2318 iob
= qeth_l3_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
,
2319 IPA_CMD_ASS_ARP_QUERY_INFO
,
2320 sizeof(int), QETH_PROT_IPV4
);
2322 rc
= qeth_l3_send_ipa_arp_cmd(card
, iob
,
2323 QETH_SETASS_BASE_LEN
+QETH_ARP_CMD_LEN
,
2324 qeth_l3_arp_query_cb
, (void *)&qinfo
);
2327 QETH_DBF_MESSAGE(2, "Error while querying ARP cache on %s: %s "
2328 "(0x%x/%d)\n", QETH_CARD_IFNAME(card
),
2329 qeth_l3_arp_get_error_cause(&rc
), tmp
, tmp
);
2330 if (copy_to_user(udata
, qinfo
.udata
, 4))
2333 if (copy_to_user(udata
, qinfo
.udata
, qinfo
.udata_len
))
2340 static int qeth_l3_arp_add_entry(struct qeth_card
*card
,
2341 struct qeth_arp_cache_entry
*entry
)
2343 struct qeth_cmd_buffer
*iob
;
2348 QETH_DBF_TEXT(TRACE
, 3, "arpadent");
2351 * currently GuestLAN only supports the ARP assist function
2352 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
2353 * thus we say EOPNOTSUPP for this ARP function
2355 if (card
->info
.guestlan
)
2357 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
2361 iob
= qeth_l3_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
,
2362 IPA_CMD_ASS_ARP_ADD_ENTRY
,
2363 sizeof(struct qeth_arp_cache_entry
),
2365 rc
= qeth_l3_send_setassparms(card
, iob
,
2366 sizeof(struct qeth_arp_cache_entry
),
2367 (unsigned long) entry
,
2368 qeth_l3_default_setassparms_cb
, NULL
);
2371 qeth_l3_ipaddr4_to_string((u8
*)entry
->ipaddr
, buf
);
2372 QETH_DBF_MESSAGE(2, "Could not add ARP entry for address %s "
2373 "on %s: %s (0x%x/%d)\n", buf
, QETH_CARD_IFNAME(card
),
2374 qeth_l3_arp_get_error_cause(&rc
), tmp
, tmp
);
2379 static int qeth_l3_arp_remove_entry(struct qeth_card
*card
,
2380 struct qeth_arp_cache_entry
*entry
)
2382 struct qeth_cmd_buffer
*iob
;
2383 char buf
[16] = {0, };
2387 QETH_DBF_TEXT(TRACE
, 3, "arprment");
2390 * currently GuestLAN only supports the ARP assist function
2391 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_REMOVE_ENTRY;
2392 * thus we say EOPNOTSUPP for this ARP function
2394 if (card
->info
.guestlan
)
2396 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
2399 memcpy(buf
, entry
, 12);
2400 iob
= qeth_l3_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
,
2401 IPA_CMD_ASS_ARP_REMOVE_ENTRY
,
2404 rc
= qeth_l3_send_setassparms(card
, iob
,
2405 12, (unsigned long)buf
,
2406 qeth_l3_default_setassparms_cb
, NULL
);
2410 qeth_l3_ipaddr4_to_string((u8
*)entry
->ipaddr
, buf
);
2411 QETH_DBF_MESSAGE(2, "Could not delete ARP entry for address %s"
2412 " on %s: %s (0x%x/%d)\n", buf
, QETH_CARD_IFNAME(card
),
2413 qeth_l3_arp_get_error_cause(&rc
), tmp
, tmp
);
2418 static int qeth_l3_arp_flush_cache(struct qeth_card
*card
)
2423 QETH_DBF_TEXT(TRACE
, 3, "arpflush");
2426 * currently GuestLAN only supports the ARP assist function
2427 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
2428 * thus we say EOPNOTSUPP for this ARP function
2430 if (card
->info
.guestlan
|| (card
->info
.type
== QETH_CARD_TYPE_IQD
))
2432 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
2435 rc
= qeth_l3_send_simple_setassparms(card
, IPA_ARP_PROCESSING
,
2436 IPA_CMD_ASS_ARP_FLUSH_CACHE
, 0);
2439 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on %s: %s "
2440 "(0x%x/%d)\n", QETH_CARD_IFNAME(card
),
2441 qeth_l3_arp_get_error_cause(&rc
), tmp
, tmp
);
2446 static int qeth_l3_do_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
2448 struct qeth_card
*card
= netdev_priv(dev
);
2449 struct qeth_arp_cache_entry arp_entry
;
2450 struct mii_ioctl_data
*mii_data
;
2456 if ((card
->state
!= CARD_STATE_UP
) &&
2457 (card
->state
!= CARD_STATE_SOFTSETUP
))
2461 case SIOC_QETH_ARP_SET_NO_ENTRIES
:
2462 if (!capable(CAP_NET_ADMIN
)) {
2466 rc
= qeth_l3_arp_set_no_entries(card
, rq
->ifr_ifru
.ifru_ivalue
);
2468 case SIOC_QETH_ARP_QUERY_INFO
:
2469 if (!capable(CAP_NET_ADMIN
)) {
2473 rc
= qeth_l3_arp_query(card
, rq
->ifr_ifru
.ifru_data
);
2475 case SIOC_QETH_ARP_ADD_ENTRY
:
2476 if (!capable(CAP_NET_ADMIN
)) {
2480 if (copy_from_user(&arp_entry
, rq
->ifr_ifru
.ifru_data
,
2481 sizeof(struct qeth_arp_cache_entry
)))
2484 rc
= qeth_l3_arp_add_entry(card
, &arp_entry
);
2486 case SIOC_QETH_ARP_REMOVE_ENTRY
:
2487 if (!capable(CAP_NET_ADMIN
)) {
2491 if (copy_from_user(&arp_entry
, rq
->ifr_ifru
.ifru_data
,
2492 sizeof(struct qeth_arp_cache_entry
)))
2495 rc
= qeth_l3_arp_remove_entry(card
, &arp_entry
);
2497 case SIOC_QETH_ARP_FLUSH_CACHE
:
2498 if (!capable(CAP_NET_ADMIN
)) {
2502 rc
= qeth_l3_arp_flush_cache(card
);
2504 case SIOC_QETH_ADP_SET_SNMP_CONTROL
:
2505 rc
= qeth_snmp_command(card
, rq
->ifr_ifru
.ifru_data
);
2507 case SIOC_QETH_GET_CARD_TYPE
:
2508 if ((card
->info
.type
== QETH_CARD_TYPE_OSAE
) &&
2509 !card
->info
.guestlan
)
2514 mii_data
= if_mii(rq
);
2515 mii_data
->phy_id
= 0;
2518 mii_data
= if_mii(rq
);
2519 if (mii_data
->phy_id
!= 0)
2522 mii_data
->val_out
= qeth_mdio_read(dev
,
2530 QETH_DBF_TEXT_(TRACE
, 2, "ioce%d", rc
);
2534 static void qeth_l3_fill_header(struct qeth_card
*card
, struct qeth_hdr
*hdr
,
2535 struct sk_buff
*skb
, int ipv
, int cast_type
)
2537 memset(hdr
, 0, sizeof(struct qeth_hdr
));
2538 hdr
->hdr
.l3
.id
= QETH_HEADER_TYPE_LAYER3
;
2539 hdr
->hdr
.l3
.ext_flags
= 0;
2542 * before we're going to overwrite this location with next hop ip.
2543 * v6 uses passthrough, v4 sets the tag in the QDIO header.
2545 if (card
->vlangrp
&& vlan_tx_tag_present(skb
)) {
2546 if ((ipv
== 4) || (card
->info
.type
== QETH_CARD_TYPE_IQD
))
2547 hdr
->hdr
.l3
.ext_flags
= QETH_HDR_EXT_VLAN_FRAME
;
2549 hdr
->hdr
.l3
.ext_flags
= QETH_HDR_EXT_INCLUDE_VLAN_TAG
;
2550 hdr
->hdr
.l3
.vlan_id
= vlan_tx_tag_get(skb
);
2553 hdr
->hdr
.l3
.length
= skb
->len
- sizeof(struct qeth_hdr
);
2556 hdr
->hdr
.l3
.flags
= qeth_l3_get_qeth_hdr_flags4(cast_type
);
2557 memset(hdr
->hdr
.l3
.dest_addr
, 0, 12);
2558 if ((skb
->dst
) && (skb
->dst
->neighbour
)) {
2559 *((u32
*) (&hdr
->hdr
.l3
.dest_addr
[12])) =
2560 *((u32
*) skb
->dst
->neighbour
->primary_key
);
2562 /* fill in destination address used in ip header */
2563 *((u32
*) (&hdr
->hdr
.l3
.dest_addr
[12])) =
2566 } else if (ipv
== 6) {
2568 hdr
->hdr
.l3
.flags
= qeth_l3_get_qeth_hdr_flags6(cast_type
);
2569 if (card
->info
.type
== QETH_CARD_TYPE_IQD
)
2570 hdr
->hdr
.l3
.flags
&= ~QETH_HDR_PASSTHRU
;
2571 if ((skb
->dst
) && (skb
->dst
->neighbour
)) {
2572 memcpy(hdr
->hdr
.l3
.dest_addr
,
2573 skb
->dst
->neighbour
->primary_key
, 16);
2575 /* fill in destination address used in ip header */
2576 memcpy(hdr
->hdr
.l3
.dest_addr
,
2577 &ipv6_hdr(skb
)->daddr
, 16);
2581 if ((skb
->dev
->type
== ARPHRD_IEEE802_TR
) &&
2582 !memcmp(skb
->data
+ sizeof(struct qeth_hdr
) +
2583 sizeof(__u16
), skb
->dev
->broadcast
, 6)) {
2584 hdr
->hdr
.l3
.flags
= QETH_CAST_BROADCAST
|
2586 } else if (!memcmp(skb
->data
+ sizeof(struct qeth_hdr
),
2587 skb
->dev
->broadcast
, 6)) {
2589 hdr
->hdr
.l3
.flags
= QETH_CAST_BROADCAST
|
2592 hdr
->hdr
.l3
.flags
= (cast_type
== RTN_MULTICAST
) ?
2593 QETH_CAST_MULTICAST
| QETH_HDR_PASSTHRU
:
2594 QETH_CAST_UNICAST
| QETH_HDR_PASSTHRU
;
2599 static int qeth_l3_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
2603 struct qeth_hdr
*hdr
= NULL
;
2604 int elements_needed
= 0;
2605 struct qeth_card
*card
= netdev_priv(dev
);
2606 struct sk_buff
*new_skb
= NULL
;
2607 int ipv
= qeth_get_ip_version(skb
);
2608 int cast_type
= qeth_get_cast_type(card
, skb
);
2609 struct qeth_qdio_out_q
*queue
= card
->qdio
.out_qs
2610 [qeth_get_priority_queue(card
, skb
, ipv
, cast_type
)];
2611 int tx_bytes
= skb
->len
;
2612 enum qeth_large_send_types large_send
= QETH_LARGE_SEND_NO
;
2613 struct qeth_eddp_context
*ctx
= NULL
;
2615 if ((card
->info
.type
== QETH_CARD_TYPE_IQD
) &&
2616 (skb
->protocol
!= htons(ETH_P_IPV6
)) &&
2617 (skb
->protocol
!= htons(ETH_P_IP
)))
2620 if ((card
->state
!= CARD_STATE_UP
) || !card
->lan_online
) {
2621 card
->stats
.tx_carrier_errors
++;
2625 if ((cast_type
== RTN_BROADCAST
) &&
2626 (card
->info
.broadcast_capable
== 0))
2629 if (card
->options
.performance_stats
) {
2630 card
->perf_stats
.outbound_cnt
++;
2631 card
->perf_stats
.outbound_start_time
= qeth_get_micros();
2634 /* create a clone with writeable headroom */
2635 new_skb
= skb_realloc_headroom(skb
, sizeof(struct qeth_hdr_tso
) +
2640 if (card
->info
.type
== QETH_CARD_TYPE_IQD
) {
2641 skb_pull(new_skb
, ETH_HLEN
);
2643 if (new_skb
->protocol
== htons(ETH_P_IP
)) {
2644 if (card
->dev
->type
== ARPHRD_IEEE802_TR
)
2645 skb_pull(new_skb
, TR_HLEN
);
2647 skb_pull(new_skb
, ETH_HLEN
);
2650 if (new_skb
->protocol
== ETH_P_IPV6
&& card
->vlangrp
&&
2651 vlan_tx_tag_present(new_skb
)) {
2652 skb_push(new_skb
, VLAN_HLEN
);
2653 skb_copy_to_linear_data(new_skb
, new_skb
->data
+ 4, 4);
2654 skb_copy_to_linear_data_offset(new_skb
, 4,
2655 new_skb
->data
+ 8, 4);
2656 skb_copy_to_linear_data_offset(new_skb
, 8,
2657 new_skb
->data
+ 12, 4);
2658 tag
= (u16
*)(new_skb
->data
+ 12);
2659 *tag
= __constant_htons(ETH_P_8021Q
);
2660 *(tag
+ 1) = htons(vlan_tx_tag_get(new_skb
));
2661 VLAN_TX_SKB_CB(new_skb
)->magic
= 0;
2665 netif_stop_queue(dev
);
2667 if (skb_is_gso(new_skb
))
2668 large_send
= card
->options
.large_send
;
2670 /* fix hardware limitation: as long as we do not have sbal
2671 * chaining we can not send long frag lists so we temporary
2674 if ((large_send
== QETH_LARGE_SEND_TSO
) &&
2675 ((skb_shinfo(new_skb
)->nr_frags
+ 2) > 16))
2676 large_send
= QETH_LARGE_SEND_EDDP
;
2678 if ((large_send
== QETH_LARGE_SEND_TSO
) &&
2679 (cast_type
== RTN_UNSPEC
)) {
2680 hdr
= (struct qeth_hdr
*)skb_push(new_skb
,
2681 sizeof(struct qeth_hdr_tso
));
2682 memset(hdr
, 0, sizeof(struct qeth_hdr_tso
));
2683 qeth_l3_fill_header(card
, hdr
, new_skb
, ipv
, cast_type
);
2684 qeth_tso_fill_header(card
, hdr
, new_skb
);
2687 hdr
= (struct qeth_hdr
*)skb_push(new_skb
,
2688 sizeof(struct qeth_hdr
));
2689 qeth_l3_fill_header(card
, hdr
, new_skb
, ipv
, cast_type
);
2692 if (large_send
== QETH_LARGE_SEND_EDDP
) {
2693 /* new_skb is not owned by a socket so we use skb to get
2696 ctx
= qeth_eddp_create_context(card
, new_skb
, hdr
,
2697 skb
->sk
->sk_protocol
);
2699 QETH_DBF_MESSAGE(2, "could not create eddp context\n");
2703 int elems
= qeth_get_elements_no(card
, (void *)hdr
, new_skb
,
2707 elements_needed
+= elems
;
2710 if ((large_send
== QETH_LARGE_SEND_NO
) &&
2711 (new_skb
->ip_summed
== CHECKSUM_PARTIAL
))
2712 qeth_tx_csum(new_skb
);
2714 if (card
->info
.type
!= QETH_CARD_TYPE_IQD
)
2715 rc
= qeth_do_send_packet(card
, queue
, new_skb
, hdr
,
2716 elements_needed
, ctx
);
2718 rc
= qeth_do_send_packet_fast(card
, queue
, new_skb
, hdr
,
2719 elements_needed
, ctx
);
2722 card
->stats
.tx_packets
++;
2723 card
->stats
.tx_bytes
+= tx_bytes
;
2725 dev_kfree_skb_any(skb
);
2726 if (card
->options
.performance_stats
) {
2727 if (large_send
!= QETH_LARGE_SEND_NO
) {
2728 card
->perf_stats
.large_send_bytes
+= tx_bytes
;
2729 card
->perf_stats
.large_send_cnt
++;
2731 if (skb_shinfo(new_skb
)->nr_frags
> 0) {
2732 card
->perf_stats
.sg_skbs_sent
++;
2733 /* nr_frags + skb->data */
2734 card
->perf_stats
.sg_frags_sent
+=
2735 skb_shinfo(new_skb
)->nr_frags
+ 1;
2740 qeth_eddp_put_context(ctx
);
2741 dev_kfree_skb_any(new_skb
);
2745 qeth_eddp_put_context(ctx
);
2749 dev_kfree_skb_any(new_skb
);
2750 return NETDEV_TX_BUSY
;
2755 netif_wake_queue(dev
);
2756 if (card
->options
.performance_stats
)
2757 card
->perf_stats
.outbound_time
+= qeth_get_micros() -
2758 card
->perf_stats
.outbound_start_time
;
2762 card
->stats
.tx_dropped
++;
2763 card
->stats
.tx_errors
++;
2764 if ((new_skb
!= skb
) && new_skb
)
2765 dev_kfree_skb_any(new_skb
);
2766 dev_kfree_skb_any(skb
);
2767 netif_wake_queue(dev
);
2768 return NETDEV_TX_OK
;
2771 static int qeth_l3_open(struct net_device
*dev
)
2773 struct qeth_card
*card
= netdev_priv(dev
);
2775 QETH_DBF_TEXT(TRACE
, 4, "qethopen");
2776 if (card
->state
!= CARD_STATE_SOFTSETUP
)
2778 card
->data
.state
= CH_STATE_UP
;
2779 card
->state
= CARD_STATE_UP
;
2780 card
->dev
->flags
|= IFF_UP
;
2781 netif_start_queue(dev
);
2783 if (!card
->lan_online
&& netif_carrier_ok(dev
))
2784 netif_carrier_off(dev
);
2788 static int qeth_l3_stop(struct net_device
*dev
)
2790 struct qeth_card
*card
= netdev_priv(dev
);
2792 QETH_DBF_TEXT(TRACE
, 4, "qethstop");
2793 netif_tx_disable(dev
);
2794 card
->dev
->flags
&= ~IFF_UP
;
2795 if (card
->state
== CARD_STATE_UP
)
2796 card
->state
= CARD_STATE_SOFTSETUP
;
2800 static u32
qeth_l3_ethtool_get_rx_csum(struct net_device
*dev
)
2802 struct qeth_card
*card
= netdev_priv(dev
);
2804 return (card
->options
.checksum_type
== HW_CHECKSUMMING
);
2807 static int qeth_l3_ethtool_set_rx_csum(struct net_device
*dev
, u32 data
)
2809 struct qeth_card
*card
= netdev_priv(dev
);
2810 enum qeth_card_states old_state
;
2811 enum qeth_checksum_types csum_type
;
2813 if ((card
->state
!= CARD_STATE_UP
) &&
2814 (card
->state
!= CARD_STATE_DOWN
))
2818 csum_type
= HW_CHECKSUMMING
;
2820 csum_type
= SW_CHECKSUMMING
;
2822 if (card
->options
.checksum_type
!= csum_type
) {
2823 old_state
= card
->state
;
2824 if (card
->state
== CARD_STATE_UP
)
2825 __qeth_l3_set_offline(card
->gdev
, 1);
2826 card
->options
.checksum_type
= csum_type
;
2827 if (old_state
== CARD_STATE_UP
)
2828 __qeth_l3_set_online(card
->gdev
, 1);
2833 static int qeth_l3_ethtool_set_tso(struct net_device
*dev
, u32 data
)
2835 struct qeth_card
*card
= netdev_priv(dev
);
2838 if (card
->options
.large_send
== QETH_LARGE_SEND_NO
) {
2839 if (card
->info
.type
== QETH_CARD_TYPE_IQD
)
2840 card
->options
.large_send
= QETH_LARGE_SEND_EDDP
;
2842 card
->options
.large_send
= QETH_LARGE_SEND_TSO
;
2843 dev
->features
|= NETIF_F_TSO
;
2846 dev
->features
&= ~NETIF_F_TSO
;
2847 card
->options
.large_send
= QETH_LARGE_SEND_NO
;
2852 static struct ethtool_ops qeth_l3_ethtool_ops
= {
2853 .get_link
= ethtool_op_get_link
,
2854 .get_tx_csum
= ethtool_op_get_tx_csum
,
2855 .set_tx_csum
= ethtool_op_set_tx_hw_csum
,
2856 .get_rx_csum
= qeth_l3_ethtool_get_rx_csum
,
2857 .set_rx_csum
= qeth_l3_ethtool_set_rx_csum
,
2858 .get_sg
= ethtool_op_get_sg
,
2859 .set_sg
= ethtool_op_set_sg
,
2860 .get_tso
= ethtool_op_get_tso
,
2861 .set_tso
= qeth_l3_ethtool_set_tso
,
2862 .get_strings
= qeth_core_get_strings
,
2863 .get_ethtool_stats
= qeth_core_get_ethtool_stats
,
2864 .get_stats_count
= qeth_core_get_stats_count
,
2865 .get_drvinfo
= qeth_core_get_drvinfo
,
2866 .get_settings
= qeth_core_ethtool_get_settings
,
2870 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
2871 * NOARP on the netdevice is no option because it also turns off neighbor
2872 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
2873 * arp resolution but we want the hard header (packet socket will work
2876 static int qeth_l3_neigh_setup_noarp(struct neighbour
*n
)
2878 n
->nud_state
= NUD_NOARP
;
2879 memcpy(n
->ha
, "FAKELL", 6);
2880 n
->output
= n
->ops
->connected_output
;
2885 qeth_l3_neigh_setup(struct net_device
*dev
, struct neigh_parms
*np
)
2887 if (np
->tbl
->family
== AF_INET
)
2888 np
->neigh_setup
= qeth_l3_neigh_setup_noarp
;
2893 static int qeth_l3_setup_netdev(struct qeth_card
*card
)
2895 if (card
->info
.type
== QETH_CARD_TYPE_OSAE
) {
2896 if ((card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
) ||
2897 (card
->info
.link_type
== QETH_LINK_TYPE_HSTR
)) {
2899 card
->dev
= alloc_trdev(0);
2904 card
->dev
= alloc_etherdev(0);
2907 card
->dev
->neigh_setup
= qeth_l3_neigh_setup
;
2909 /*IPv6 address autoconfiguration stuff*/
2910 qeth_l3_get_unique_id(card
);
2911 if (!(card
->info
.unique_id
& UNIQUE_ID_NOT_BY_CARD
))
2912 card
->dev
->dev_id
= card
->info
.unique_id
&
2915 } else if (card
->info
.type
== QETH_CARD_TYPE_IQD
) {
2916 card
->dev
= alloc_netdev(0, "hsi%d", ether_setup
);
2919 card
->dev
->flags
|= IFF_NOARP
;
2920 qeth_l3_iqd_read_initial_mac(card
);
2924 card
->dev
->hard_start_xmit
= qeth_l3_hard_start_xmit
;
2925 card
->dev
->priv
= card
;
2926 card
->dev
->tx_timeout
= &qeth_tx_timeout
;
2927 card
->dev
->watchdog_timeo
= QETH_TX_TIMEOUT
;
2928 card
->dev
->open
= qeth_l3_open
;
2929 card
->dev
->stop
= qeth_l3_stop
;
2930 card
->dev
->do_ioctl
= qeth_l3_do_ioctl
;
2931 card
->dev
->get_stats
= qeth_get_stats
;
2932 card
->dev
->change_mtu
= qeth_change_mtu
;
2933 card
->dev
->set_multicast_list
= qeth_l3_set_multicast_list
;
2934 card
->dev
->vlan_rx_register
= qeth_l3_vlan_rx_register
;
2935 card
->dev
->vlan_rx_add_vid
= qeth_l3_vlan_rx_add_vid
;
2936 card
->dev
->vlan_rx_kill_vid
= qeth_l3_vlan_rx_kill_vid
;
2937 card
->dev
->mtu
= card
->info
.initial_mtu
;
2938 card
->dev
->set_mac_address
= NULL
;
2939 SET_ETHTOOL_OPS(card
->dev
, &qeth_l3_ethtool_ops
);
2940 card
->dev
->features
|= NETIF_F_HW_VLAN_TX
|
2941 NETIF_F_HW_VLAN_RX
|
2942 NETIF_F_HW_VLAN_FILTER
;
2944 SET_NETDEV_DEV(card
->dev
, &card
->gdev
->dev
);
2945 return register_netdev(card
->dev
);
2948 static void qeth_l3_qdio_input_handler(struct ccw_device
*ccwdev
,
2949 unsigned int status
, unsigned int qdio_err
,
2950 unsigned int siga_err
, unsigned int queue
, int first_element
,
2951 int count
, unsigned long card_ptr
)
2953 struct net_device
*net_dev
;
2954 struct qeth_card
*card
;
2955 struct qeth_qdio_buffer
*buffer
;
2959 card
= (struct qeth_card
*) card_ptr
;
2960 net_dev
= card
->dev
;
2961 if (card
->options
.performance_stats
) {
2962 card
->perf_stats
.inbound_cnt
++;
2963 card
->perf_stats
.inbound_start_time
= qeth_get_micros();
2965 if (status
& QDIO_STATUS_LOOK_FOR_ERROR
) {
2966 if (status
& QDIO_STATUS_ACTIVATE_CHECK_CONDITION
) {
2967 QETH_DBF_TEXT(TRACE
, 1, "qdinchk");
2968 QETH_DBF_TEXT_(TRACE
, 1, "%s", CARD_BUS_ID(card
));
2969 QETH_DBF_TEXT_(TRACE
, 1, "%04X%04X",
2970 first_element
, count
);
2971 QETH_DBF_TEXT_(TRACE
, 1, "%04X%04X", queue
, status
);
2972 qeth_schedule_recovery(card
);
2976 for (i
= first_element
; i
< (first_element
+ count
); ++i
) {
2977 index
= i
% QDIO_MAX_BUFFERS_PER_Q
;
2978 buffer
= &card
->qdio
.in_q
->bufs
[index
];
2979 if (!((status
& QDIO_STATUS_LOOK_FOR_ERROR
) &&
2980 qeth_check_qdio_errors(buffer
->buffer
,
2981 qdio_err
, siga_err
, "qinerr")))
2982 qeth_l3_process_inbound_buffer(card
, buffer
, index
);
2983 /* clear buffer and give back to hardware */
2984 qeth_put_buffer_pool_entry(card
, buffer
->pool_entry
);
2985 qeth_queue_input_buffer(card
, index
);
2987 if (card
->options
.performance_stats
)
2988 card
->perf_stats
.inbound_time
+= qeth_get_micros() -
2989 card
->perf_stats
.inbound_start_time
;
2992 static int qeth_l3_probe_device(struct ccwgroup_device
*gdev
)
2994 struct qeth_card
*card
= dev_get_drvdata(&gdev
->dev
);
2996 qeth_l3_create_device_attributes(&gdev
->dev
);
2997 card
->options
.layer2
= 0;
2998 card
->discipline
.input_handler
= (qdio_handler_t
*)
2999 qeth_l3_qdio_input_handler
;
3000 card
->discipline
.output_handler
= (qdio_handler_t
*)
3001 qeth_qdio_output_handler
;
3002 card
->discipline
.recover
= qeth_l3_recover
;
3006 static void qeth_l3_remove_device(struct ccwgroup_device
*cgdev
)
3008 struct qeth_card
*card
= dev_get_drvdata(&cgdev
->dev
);
3010 wait_event(card
->wait_q
, qeth_threads_running(card
, 0xffffffff) == 0);
3012 if (cgdev
->state
== CCWGROUP_ONLINE
) {
3013 card
->use_hard_stop
= 1;
3014 qeth_l3_set_offline(cgdev
);
3018 unregister_netdev(card
->dev
);
3022 qeth_l3_remove_device_attributes(&cgdev
->dev
);
3023 qeth_l3_clear_ip_list(card
, 0, 0);
3024 qeth_l3_clear_ipato_list(card
);
3028 static int __qeth_l3_set_online(struct ccwgroup_device
*gdev
, int recovery_mode
)
3030 struct qeth_card
*card
= dev_get_drvdata(&gdev
->dev
);
3032 enum qeth_card_states recover_flag
;
3035 QETH_DBF_TEXT(SETUP
, 2, "setonlin");
3036 QETH_DBF_HEX(SETUP
, 2, &card
, sizeof(void *));
3038 qeth_set_allowed_threads(card
, QETH_RECOVER_THREAD
, 1);
3039 if (qeth_wait_for_threads(card
, ~QETH_RECOVER_THREAD
)) {
3040 PRINT_WARN("set_online of card %s interrupted by user!\n",
3042 return -ERESTARTSYS
;
3045 recover_flag
= card
->state
;
3046 rc
= ccw_device_set_online(CARD_RDEV(card
));
3048 QETH_DBF_TEXT_(SETUP
, 2, "1err%d", rc
);
3051 rc
= ccw_device_set_online(CARD_WDEV(card
));
3053 QETH_DBF_TEXT_(SETUP
, 2, "1err%d", rc
);
3056 rc
= ccw_device_set_online(CARD_DDEV(card
));
3058 QETH_DBF_TEXT_(SETUP
, 2, "1err%d", rc
);
3062 rc
= qeth_core_hardsetup_card(card
);
3064 QETH_DBF_TEXT_(SETUP
, 2, "2err%d", rc
);
3068 qeth_l3_query_ipassists(card
, QETH_PROT_IPV4
);
3070 if (!card
->dev
&& qeth_l3_setup_netdev(card
))
3073 card
->state
= CARD_STATE_HARDSETUP
;
3074 qeth_print_status_message(card
);
3077 QETH_DBF_TEXT(SETUP
, 2, "softsetp");
3079 rc
= qeth_send_startlan(card
);
3081 QETH_DBF_TEXT_(SETUP
, 2, "1err%d", rc
);
3083 PRINT_WARN("LAN on card %s if offline! "
3084 "Waiting for STARTLAN from card.\n",
3086 card
->lan_online
= 0;
3090 card
->lan_online
= 1;
3091 qeth_set_large_send(card
, card
->options
.large_send
);
3093 rc
= qeth_l3_setadapter_parms(card
);
3095 QETH_DBF_TEXT_(SETUP
, 2, "2err%d", rc
);
3096 rc
= qeth_l3_start_ipassists(card
);
3098 QETH_DBF_TEXT_(SETUP
, 2, "3err%d", rc
);
3099 rc
= qeth_l3_setrouting_v4(card
);
3101 QETH_DBF_TEXT_(SETUP
, 2, "4err%d", rc
);
3102 rc
= qeth_l3_setrouting_v6(card
);
3104 QETH_DBF_TEXT_(SETUP
, 2, "5err%d", rc
);
3105 netif_tx_disable(card
->dev
);
3107 rc
= qeth_init_qdio_queues(card
);
3109 QETH_DBF_TEXT_(SETUP
, 2, "6err%d", rc
);
3112 card
->state
= CARD_STATE_SOFTSETUP
;
3113 netif_carrier_on(card
->dev
);
3115 qeth_set_allowed_threads(card
, 0xffffffff, 0);
3116 if (recover_flag
== CARD_STATE_RECOVER
) {
3118 qeth_l3_open(card
->dev
);
3121 dev_open(card
->dev
);
3124 qeth_l3_set_multicast_list(card
->dev
);
3126 /* let user_space know that device is online */
3127 kobject_uevent(&gdev
->dev
.kobj
, KOBJ_CHANGE
);
3130 card
->use_hard_stop
= 1;
3131 qeth_l3_stop_card(card
, 0);
3132 ccw_device_set_offline(CARD_DDEV(card
));
3133 ccw_device_set_offline(CARD_WDEV(card
));
3134 ccw_device_set_offline(CARD_RDEV(card
));
3135 if (recover_flag
== CARD_STATE_RECOVER
)
3136 card
->state
= CARD_STATE_RECOVER
;
3138 card
->state
= CARD_STATE_DOWN
;
3142 static int qeth_l3_set_online(struct ccwgroup_device
*gdev
)
3144 return __qeth_l3_set_online(gdev
, 0);
3147 static int __qeth_l3_set_offline(struct ccwgroup_device
*cgdev
,
3150 struct qeth_card
*card
= dev_get_drvdata(&cgdev
->dev
);
3151 int rc
= 0, rc2
= 0, rc3
= 0;
3152 enum qeth_card_states recover_flag
;
3154 QETH_DBF_TEXT(SETUP
, 3, "setoffl");
3155 QETH_DBF_HEX(SETUP
, 3, &card
, sizeof(void *));
3157 if (card
->dev
&& netif_carrier_ok(card
->dev
))
3158 netif_carrier_off(card
->dev
);
3159 recover_flag
= card
->state
;
3160 if (qeth_l3_stop_card(card
, recovery_mode
) == -ERESTARTSYS
) {
3161 PRINT_WARN("Stopping card %s interrupted by user!\n",
3163 return -ERESTARTSYS
;
3165 rc
= ccw_device_set_offline(CARD_DDEV(card
));
3166 rc2
= ccw_device_set_offline(CARD_WDEV(card
));
3167 rc3
= ccw_device_set_offline(CARD_RDEV(card
));
3169 rc
= (rc2
) ? rc2
: rc3
;
3171 QETH_DBF_TEXT_(SETUP
, 2, "1err%d", rc
);
3172 if (recover_flag
== CARD_STATE_UP
)
3173 card
->state
= CARD_STATE_RECOVER
;
3174 /* let user_space know that device is offline */
3175 kobject_uevent(&cgdev
->dev
.kobj
, KOBJ_CHANGE
);
3179 static int qeth_l3_set_offline(struct ccwgroup_device
*cgdev
)
3181 return __qeth_l3_set_offline(cgdev
, 0);
3184 static int qeth_l3_recover(void *ptr
)
3186 struct qeth_card
*card
;
3189 card
= (struct qeth_card
*) ptr
;
3190 QETH_DBF_TEXT(TRACE
, 2, "recover1");
3191 QETH_DBF_HEX(TRACE
, 2, &card
, sizeof(void *));
3192 if (!qeth_do_run_thread(card
, QETH_RECOVER_THREAD
))
3194 QETH_DBF_TEXT(TRACE
, 2, "recover2");
3195 PRINT_WARN("Recovery of device %s started ...\n",
3197 card
->use_hard_stop
= 1;
3198 __qeth_l3_set_offline(card
->gdev
, 1);
3199 rc
= __qeth_l3_set_online(card
->gdev
, 1);
3200 /* don't run another scheduled recovery */
3201 qeth_clear_thread_start_bit(card
, QETH_RECOVER_THREAD
);
3202 qeth_clear_thread_running_bit(card
, QETH_RECOVER_THREAD
);
3204 PRINT_INFO("Device %s successfully recovered!\n",
3207 PRINT_INFO("Device %s could not be recovered!\n",
3212 static void qeth_l3_shutdown(struct ccwgroup_device
*gdev
)
3214 struct qeth_card
*card
= dev_get_drvdata(&gdev
->dev
);
3215 qeth_l3_clear_ip_list(card
, 0, 0);
3216 qeth_qdio_clear_card(card
, 0);
3217 qeth_clear_qdio_buffers(card
);
3220 struct ccwgroup_driver qeth_l3_ccwgroup_driver
= {
3221 .probe
= qeth_l3_probe_device
,
3222 .remove
= qeth_l3_remove_device
,
3223 .set_online
= qeth_l3_set_online
,
3224 .set_offline
= qeth_l3_set_offline
,
3225 .shutdown
= qeth_l3_shutdown
,
3227 EXPORT_SYMBOL_GPL(qeth_l3_ccwgroup_driver
);
3229 static int qeth_l3_ip_event(struct notifier_block
*this,
3230 unsigned long event
, void *ptr
)
3232 struct in_ifaddr
*ifa
= (struct in_ifaddr
*)ptr
;
3233 struct net_device
*dev
= (struct net_device
*)ifa
->ifa_dev
->dev
;
3234 struct qeth_ipaddr
*addr
;
3235 struct qeth_card
*card
;
3237 if (dev_net(dev
) != &init_net
)
3240 QETH_DBF_TEXT(TRACE
, 3, "ipevent");
3241 card
= qeth_l3_get_card_from_dev(dev
);
3245 addr
= qeth_l3_get_addr_buffer(QETH_PROT_IPV4
);
3247 addr
->u
.a4
.addr
= ifa
->ifa_address
;
3248 addr
->u
.a4
.mask
= ifa
->ifa_mask
;
3249 addr
->type
= QETH_IP_TYPE_NORMAL
;
3255 if (!qeth_l3_add_ip(card
, addr
))
3259 if (!qeth_l3_delete_ip(card
, addr
))
3265 qeth_l3_set_ip_addr_list(card
);
3270 static struct notifier_block qeth_l3_ip_notifier
= {
3275 #ifdef CONFIG_QETH_IPV6
3277 * IPv6 event handler
3279 static int qeth_l3_ip6_event(struct notifier_block
*this,
3280 unsigned long event
, void *ptr
)
3282 struct inet6_ifaddr
*ifa
= (struct inet6_ifaddr
*)ptr
;
3283 struct net_device
*dev
= (struct net_device
*)ifa
->idev
->dev
;
3284 struct qeth_ipaddr
*addr
;
3285 struct qeth_card
*card
;
3287 QETH_DBF_TEXT(TRACE
, 3, "ip6event");
3289 card
= qeth_l3_get_card_from_dev(dev
);
3292 if (!qeth_is_supported(card
, IPA_IPV6
))
3295 addr
= qeth_l3_get_addr_buffer(QETH_PROT_IPV6
);
3297 memcpy(&addr
->u
.a6
.addr
, &ifa
->addr
, sizeof(struct in6_addr
));
3298 addr
->u
.a6
.pfxlen
= ifa
->prefix_len
;
3299 addr
->type
= QETH_IP_TYPE_NORMAL
;
3305 if (!qeth_l3_add_ip(card
, addr
))
3309 if (!qeth_l3_delete_ip(card
, addr
))
3315 qeth_l3_set_ip_addr_list(card
);
3320 static struct notifier_block qeth_l3_ip6_notifier
= {
3326 static int qeth_l3_register_notifiers(void)
3330 QETH_DBF_TEXT(TRACE
, 5, "regnotif");
3331 rc
= register_inetaddr_notifier(&qeth_l3_ip_notifier
);
3334 #ifdef CONFIG_QETH_IPV6
3335 rc
= register_inet6addr_notifier(&qeth_l3_ip6_notifier
);
3337 unregister_inetaddr_notifier(&qeth_l3_ip_notifier
);
3341 PRINT_WARN("layer 3 discipline no IPv6 support\n");
3346 static void qeth_l3_unregister_notifiers(void)
3349 QETH_DBF_TEXT(TRACE
, 5, "unregnot");
3350 BUG_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier
));
3351 #ifdef CONFIG_QETH_IPV6
3352 BUG_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier
));
3353 #endif /* QETH_IPV6 */
3356 static int __init
qeth_l3_init(void)
3360 PRINT_INFO("register layer 3 discipline\n");
3361 rc
= qeth_l3_register_notifiers();
3365 static void __exit
qeth_l3_exit(void)
3367 qeth_l3_unregister_notifiers();
3368 PRINT_INFO("unregister layer 3 discipline\n");
3371 module_init(qeth_l3_init
);
3372 module_exit(qeth_l3_exit
);
3373 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
3374 MODULE_DESCRIPTION("qeth layer 3 discipline");
3375 MODULE_LICENSE("GPL");