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 #define KMSG_COMPONENT "qeth"
12 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/string.h>
17 #include <linux/errno.h>
18 #include <linux/kernel.h>
19 #include <linux/etherdevice.h>
20 #include <linux/mii.h>
22 #include <linux/reboot.h>
23 #include <linux/inetdevice.h>
24 #include <linux/igmp.h>
30 #include "qeth_core_offl.h"
32 static int qeth_l3_set_offline(struct ccwgroup_device
*);
33 static int qeth_l3_recover(void *);
34 static int qeth_l3_stop(struct net_device
*);
35 static void qeth_l3_set_multicast_list(struct net_device
*);
36 static int qeth_l3_neigh_setup(struct net_device
*, struct neigh_parms
*);
37 static int qeth_l3_register_addr_entry(struct qeth_card
*,
38 struct qeth_ipaddr
*);
39 static int qeth_l3_deregister_addr_entry(struct qeth_card
*,
40 struct qeth_ipaddr
*);
41 static int __qeth_l3_set_online(struct ccwgroup_device
*, int);
42 static int __qeth_l3_set_offline(struct ccwgroup_device
*, int);
45 static int qeth_l3_isxdigit(char *buf
)
48 if (!isxdigit(*buf
++))
54 void qeth_l3_ipaddr4_to_string(const __u8
*addr
, char *buf
)
56 sprintf(buf
, "%i.%i.%i.%i", addr
[0], addr
[1], addr
[2], addr
[3]);
59 int qeth_l3_string_to_ipaddr4(const char *buf
, __u8
*addr
)
61 int count
= 0, rc
= 0;
65 rc
= sscanf(buf
, "%u.%u.%u.%u%c",
66 &in
[0], &in
[1], &in
[2], &in
[3], &c
);
67 if (rc
!= 4 && (rc
!= 5 || c
!= '\n'))
69 for (count
= 0; count
< 4; count
++) {
72 addr
[count
] = in
[count
];
77 void qeth_l3_ipaddr6_to_string(const __u8
*addr
, char *buf
)
79 sprintf(buf
, "%02x%02x:%02x%02x:%02x%02x:%02x%02x"
80 ":%02x%02x:%02x%02x:%02x%02x:%02x%02x",
81 addr
[0], addr
[1], addr
[2], addr
[3],
82 addr
[4], addr
[5], addr
[6], addr
[7],
83 addr
[8], addr
[9], addr
[10], addr
[11],
84 addr
[12], addr
[13], addr
[14], addr
[15]);
87 int qeth_l3_string_to_ipaddr6(const char *buf
, __u8
*addr
)
89 const char *end
, *end_tmp
, *start
;
92 int num2
, cnt
, out
, found
, save_cnt
;
93 unsigned short in_tmp
[8] = {0, };
95 cnt
= out
= found
= save_cnt
= num2
= 0;
100 end
= strchr(start
, ':');
102 end
= buf
+ strlen(buf
);
103 end_tmp
= strchr(start
, '\n');
110 if ((end
- start
) > 4)
112 memcpy(num
, start
, end
- start
);
113 if (!qeth_l3_isxdigit(num
))
115 sscanf(start
, "%x", &num2
);
117 in_tmp
[save_cnt
++] = num2
;
129 if (cnt
+ save_cnt
> 8)
133 in
[cnt
--] = in_tmp
[--save_cnt
];
137 void qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto
, const __u8
*addr
,
140 if (proto
== QETH_PROT_IPV4
)
141 qeth_l3_ipaddr4_to_string(addr
, buf
);
142 else if (proto
== QETH_PROT_IPV6
)
143 qeth_l3_ipaddr6_to_string(addr
, buf
);
146 int qeth_l3_string_to_ipaddr(const char *buf
, enum qeth_prot_versions proto
,
149 if (proto
== QETH_PROT_IPV4
)
150 return qeth_l3_string_to_ipaddr4(buf
, addr
);
151 else if (proto
== QETH_PROT_IPV6
)
152 return qeth_l3_string_to_ipaddr6(buf
, addr
);
157 static void qeth_l3_convert_addr_to_bits(u8
*addr
, u8
*bits
, int len
)
162 for (i
= 0; i
< len
; ++i
) {
164 for (j
= 7; j
>= 0; --j
) {
165 bits
[i
*8 + j
] = octet
& 1;
171 static int qeth_l3_is_addr_covered_by_ipato(struct qeth_card
*card
,
172 struct qeth_ipaddr
*addr
)
174 struct qeth_ipato_entry
*ipatoe
;
175 u8 addr_bits
[128] = {0, };
176 u8 ipatoe_bits
[128] = {0, };
179 if (!card
->ipato
.enabled
)
182 qeth_l3_convert_addr_to_bits((u8
*) &addr
->u
, addr_bits
,
183 (addr
->proto
== QETH_PROT_IPV4
)? 4:16);
184 list_for_each_entry(ipatoe
, &card
->ipato
.entries
, entry
) {
185 if (addr
->proto
!= ipatoe
->proto
)
187 qeth_l3_convert_addr_to_bits(ipatoe
->addr
, ipatoe_bits
,
188 (ipatoe
->proto
== QETH_PROT_IPV4
) ?
190 if (addr
->proto
== QETH_PROT_IPV4
)
191 rc
= !memcmp(addr_bits
, ipatoe_bits
,
192 min(32, ipatoe
->mask_bits
));
194 rc
= !memcmp(addr_bits
, ipatoe_bits
,
195 min(128, ipatoe
->mask_bits
));
200 if ((addr
->proto
== QETH_PROT_IPV4
) && card
->ipato
.invert4
)
202 else if ((addr
->proto
== QETH_PROT_IPV6
) && card
->ipato
.invert6
)
209 * Add IP to be added to todo list. If there is already an "add todo"
210 * in this list we just incremenent the reference count.
211 * Returns 0 if we just incremented reference count.
213 static int __qeth_l3_insert_ip_todo(struct qeth_card
*card
,
214 struct qeth_ipaddr
*addr
, int add
)
216 struct qeth_ipaddr
*tmp
, *t
;
219 list_for_each_entry_safe(tmp
, t
, card
->ip_tbd_list
, entry
) {
220 if ((addr
->type
== QETH_IP_TYPE_DEL_ALL_MC
) &&
221 (tmp
->type
== QETH_IP_TYPE_DEL_ALL_MC
))
223 if ((tmp
->proto
== QETH_PROT_IPV4
) &&
224 (addr
->proto
== QETH_PROT_IPV4
) &&
225 (tmp
->type
== addr
->type
) &&
226 (tmp
->is_multicast
== addr
->is_multicast
) &&
227 (tmp
->u
.a4
.addr
== addr
->u
.a4
.addr
) &&
228 (tmp
->u
.a4
.mask
== addr
->u
.a4
.mask
)) {
232 if ((tmp
->proto
== QETH_PROT_IPV6
) &&
233 (addr
->proto
== QETH_PROT_IPV6
) &&
234 (tmp
->type
== addr
->type
) &&
235 (tmp
->is_multicast
== addr
->is_multicast
) &&
236 (tmp
->u
.a6
.pfxlen
== addr
->u
.a6
.pfxlen
) &&
237 (memcmp(&tmp
->u
.a6
.addr
, &addr
->u
.a6
.addr
,
238 sizeof(struct in6_addr
)) == 0)) {
244 if (addr
->users
!= 0)
245 tmp
->users
+= addr
->users
;
247 tmp
->users
+= add
? 1 : -1;
248 if (tmp
->users
== 0) {
249 list_del(&tmp
->entry
);
254 if (addr
->type
== QETH_IP_TYPE_DEL_ALL_MC
)
255 list_add(&addr
->entry
, card
->ip_tbd_list
);
257 if (addr
->users
== 0)
258 addr
->users
+= add
? 1 : -1;
259 if (add
&& (addr
->type
== QETH_IP_TYPE_NORMAL
) &&
260 qeth_l3_is_addr_covered_by_ipato(card
, addr
)) {
261 QETH_DBF_TEXT(TRACE
, 2, "tkovaddr");
262 addr
->set_flags
|= QETH_IPA_SETIP_TAKEOVER_FLAG
;
264 list_add_tail(&addr
->entry
, card
->ip_tbd_list
);
270 static int qeth_l3_delete_ip(struct qeth_card
*card
, struct qeth_ipaddr
*addr
)
275 QETH_DBF_TEXT(TRACE
, 4, "delip");
277 if (addr
->proto
== QETH_PROT_IPV4
)
278 QETH_DBF_HEX(TRACE
, 4, &addr
->u
.a4
.addr
, 4);
280 QETH_DBF_HEX(TRACE
, 4, &addr
->u
.a6
.addr
, 8);
281 QETH_DBF_HEX(TRACE
, 4, ((char *)&addr
->u
.a6
.addr
) + 8, 8);
283 spin_lock_irqsave(&card
->ip_lock
, flags
);
284 rc
= __qeth_l3_insert_ip_todo(card
, addr
, 0);
285 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
289 static int qeth_l3_add_ip(struct qeth_card
*card
, struct qeth_ipaddr
*addr
)
294 QETH_DBF_TEXT(TRACE
, 4, "addip");
295 if (addr
->proto
== QETH_PROT_IPV4
)
296 QETH_DBF_HEX(TRACE
, 4, &addr
->u
.a4
.addr
, 4);
298 QETH_DBF_HEX(TRACE
, 4, &addr
->u
.a6
.addr
, 8);
299 QETH_DBF_HEX(TRACE
, 4, ((char *)&addr
->u
.a6
.addr
) + 8, 8);
301 spin_lock_irqsave(&card
->ip_lock
, flags
);
302 rc
= __qeth_l3_insert_ip_todo(card
, addr
, 1);
303 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
308 static struct qeth_ipaddr
*qeth_l3_get_addr_buffer(
309 enum qeth_prot_versions prot
)
311 struct qeth_ipaddr
*addr
;
313 addr
= kzalloc(sizeof(struct qeth_ipaddr
), GFP_ATOMIC
);
317 addr
->type
= QETH_IP_TYPE_NORMAL
;
322 static void qeth_l3_delete_mc_addresses(struct qeth_card
*card
)
324 struct qeth_ipaddr
*iptodo
;
327 QETH_DBF_TEXT(TRACE
, 4, "delmc");
328 iptodo
= qeth_l3_get_addr_buffer(QETH_PROT_IPV4
);
330 QETH_DBF_TEXT(TRACE
, 2, "dmcnomem");
333 iptodo
->type
= QETH_IP_TYPE_DEL_ALL_MC
;
334 spin_lock_irqsave(&card
->ip_lock
, flags
);
335 if (!__qeth_l3_insert_ip_todo(card
, iptodo
, 0))
337 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
341 * Add/remove address to/from card's ip list, i.e. try to add or remove
342 * reference to/from an IP address that is already registered on the card.
344 * 0 address was on card and its reference count has been adjusted,
345 * but is still > 0, so nothing has to be done
346 * also returns 0 if card was not on card and the todo was to delete
347 * the address -> there is also nothing to be done
348 * 1 address was not on card and the todo is to add it to the card's ip
350 * -1 address was on card and its reference count has been decremented
351 * to <= 0 by the todo -> address must be removed from card
353 static int __qeth_l3_ref_ip_on_card(struct qeth_card
*card
,
354 struct qeth_ipaddr
*todo
, struct qeth_ipaddr
**__addr
)
356 struct qeth_ipaddr
*addr
;
359 list_for_each_entry(addr
, &card
->ip_list
, entry
) {
360 if ((addr
->proto
== QETH_PROT_IPV4
) &&
361 (todo
->proto
== QETH_PROT_IPV4
) &&
362 (addr
->type
== todo
->type
) &&
363 (addr
->u
.a4
.addr
== todo
->u
.a4
.addr
) &&
364 (addr
->u
.a4
.mask
== todo
->u
.a4
.mask
)) {
368 if ((addr
->proto
== QETH_PROT_IPV6
) &&
369 (todo
->proto
== QETH_PROT_IPV6
) &&
370 (addr
->type
== todo
->type
) &&
371 (addr
->u
.a6
.pfxlen
== todo
->u
.a6
.pfxlen
) &&
372 (memcmp(&addr
->u
.a6
.addr
, &todo
->u
.a6
.addr
,
373 sizeof(struct in6_addr
)) == 0)) {
379 addr
->users
+= todo
->users
;
380 if (addr
->users
<= 0) {
384 /* for VIPA and RXIP limit refcount to 1 */
385 if (addr
->type
!= QETH_IP_TYPE_NORMAL
)
390 if (todo
->users
> 0) {
391 /* for VIPA and RXIP limit refcount to 1 */
392 if (todo
->type
!= QETH_IP_TYPE_NORMAL
)
399 static void __qeth_l3_delete_all_mc(struct qeth_card
*card
,
400 unsigned long *flags
)
402 struct list_head fail_list
;
403 struct qeth_ipaddr
*addr
, *tmp
;
406 INIT_LIST_HEAD(&fail_list
);
408 list_for_each_entry_safe(addr
, tmp
, &card
->ip_list
, entry
) {
409 if (addr
->is_multicast
) {
410 list_del(&addr
->entry
);
411 spin_unlock_irqrestore(&card
->ip_lock
, *flags
);
412 rc
= qeth_l3_deregister_addr_entry(card
, addr
);
413 spin_lock_irqsave(&card
->ip_lock
, *flags
);
414 if (!rc
|| (rc
== IPA_RC_MC_ADDR_NOT_FOUND
))
417 list_add_tail(&addr
->entry
, &fail_list
);
421 list_splice(&fail_list
, &card
->ip_list
);
424 static void qeth_l3_set_ip_addr_list(struct qeth_card
*card
)
426 struct list_head
*tbd_list
;
427 struct qeth_ipaddr
*todo
, *addr
;
431 QETH_DBF_TEXT(TRACE
, 2, "sdiplist");
432 QETH_DBF_HEX(TRACE
, 2, &card
, sizeof(void *));
434 spin_lock_irqsave(&card
->ip_lock
, flags
);
435 tbd_list
= card
->ip_tbd_list
;
436 card
->ip_tbd_list
= kmalloc(sizeof(struct list_head
), GFP_ATOMIC
);
437 if (!card
->ip_tbd_list
) {
438 QETH_DBF_TEXT(TRACE
, 0, "silnomem");
439 card
->ip_tbd_list
= tbd_list
;
440 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
443 INIT_LIST_HEAD(card
->ip_tbd_list
);
445 while (!list_empty(tbd_list
)) {
446 todo
= list_entry(tbd_list
->next
, struct qeth_ipaddr
, entry
);
447 list_del(&todo
->entry
);
448 if (todo
->type
== QETH_IP_TYPE_DEL_ALL_MC
) {
449 __qeth_l3_delete_all_mc(card
, &flags
);
453 rc
= __qeth_l3_ref_ip_on_card(card
, todo
, &addr
);
455 /* nothing to be done; only adjusted refcount */
457 } else if (rc
== 1) {
458 /* new entry to be added to on-card list */
459 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
460 rc
= qeth_l3_register_addr_entry(card
, todo
);
461 spin_lock_irqsave(&card
->ip_lock
, flags
);
462 if (!rc
|| (rc
== IPA_RC_LAN_OFFLINE
))
463 list_add_tail(&todo
->entry
, &card
->ip_list
);
466 } else if (rc
== -1) {
467 /* on-card entry to be removed */
468 list_del_init(&addr
->entry
);
469 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
470 rc
= qeth_l3_deregister_addr_entry(card
, addr
);
471 spin_lock_irqsave(&card
->ip_lock
, flags
);
472 if (!rc
|| (rc
== IPA_RC_PRIMARY_ALREADY_DEFINED
))
475 list_add_tail(&addr
->entry
, &card
->ip_list
);
479 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
483 static void qeth_l3_clear_ip_list(struct qeth_card
*card
, int clean
,
486 struct qeth_ipaddr
*addr
, *tmp
;
489 QETH_DBF_TEXT(TRACE
, 4, "clearip");
490 spin_lock_irqsave(&card
->ip_lock
, flags
);
491 /* clear todo list */
492 list_for_each_entry_safe(addr
, tmp
, card
->ip_tbd_list
, entry
) {
493 list_del(&addr
->entry
);
497 while (!list_empty(&card
->ip_list
)) {
498 addr
= list_entry(card
->ip_list
.next
,
499 struct qeth_ipaddr
, entry
);
500 list_del_init(&addr
->entry
);
502 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
503 qeth_l3_deregister_addr_entry(card
, addr
);
504 spin_lock_irqsave(&card
->ip_lock
, flags
);
506 if (!recover
|| addr
->is_multicast
) {
510 list_add_tail(&addr
->entry
, card
->ip_tbd_list
);
512 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
515 static int qeth_l3_address_exists_in_list(struct list_head
*list
,
516 struct qeth_ipaddr
*addr
, int same_type
)
518 struct qeth_ipaddr
*tmp
;
520 list_for_each_entry(tmp
, list
, entry
) {
521 if ((tmp
->proto
== QETH_PROT_IPV4
) &&
522 (addr
->proto
== QETH_PROT_IPV4
) &&
523 ((same_type
&& (tmp
->type
== addr
->type
)) ||
524 (!same_type
&& (tmp
->type
!= addr
->type
))) &&
525 (tmp
->u
.a4
.addr
== addr
->u
.a4
.addr
))
528 if ((tmp
->proto
== QETH_PROT_IPV6
) &&
529 (addr
->proto
== QETH_PROT_IPV6
) &&
530 ((same_type
&& (tmp
->type
== addr
->type
)) ||
531 (!same_type
&& (tmp
->type
!= addr
->type
))) &&
532 (memcmp(&tmp
->u
.a6
.addr
, &addr
->u
.a6
.addr
,
533 sizeof(struct in6_addr
)) == 0))
540 static int qeth_l3_send_setdelmc(struct qeth_card
*card
,
541 struct qeth_ipaddr
*addr
, int ipacmd
)
544 struct qeth_cmd_buffer
*iob
;
545 struct qeth_ipa_cmd
*cmd
;
547 QETH_DBF_TEXT(TRACE
, 4, "setdelmc");
549 iob
= qeth_get_ipacmd_buffer(card
, ipacmd
, addr
->proto
);
550 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
551 memcpy(&cmd
->data
.setdelipm
.mac
, addr
->mac
, OSA_ADDR_LEN
);
552 if (addr
->proto
== QETH_PROT_IPV6
)
553 memcpy(cmd
->data
.setdelipm
.ip6
, &addr
->u
.a6
.addr
,
554 sizeof(struct in6_addr
));
556 memcpy(&cmd
->data
.setdelipm
.ip4
, &addr
->u
.a4
.addr
, 4);
558 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
563 static void qeth_l3_fill_netmask(u8
*netmask
, unsigned int len
)
566 for (i
= 0; i
< 16; i
++) {
571 netmask
[i
] = (u8
)(0xFF00 >> j
);
577 static int qeth_l3_send_setdelip(struct qeth_card
*card
,
578 struct qeth_ipaddr
*addr
, int ipacmd
, unsigned int flags
)
581 struct qeth_cmd_buffer
*iob
;
582 struct qeth_ipa_cmd
*cmd
;
585 QETH_DBF_TEXT(TRACE
, 4, "setdelip");
586 QETH_DBF_TEXT_(TRACE
, 4, "flags%02X", flags
);
588 iob
= qeth_get_ipacmd_buffer(card
, ipacmd
, addr
->proto
);
589 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
590 if (addr
->proto
== QETH_PROT_IPV6
) {
591 memcpy(cmd
->data
.setdelip6
.ip_addr
, &addr
->u
.a6
.addr
,
592 sizeof(struct in6_addr
));
593 qeth_l3_fill_netmask(netmask
, addr
->u
.a6
.pfxlen
);
594 memcpy(cmd
->data
.setdelip6
.mask
, netmask
,
595 sizeof(struct in6_addr
));
596 cmd
->data
.setdelip6
.flags
= flags
;
598 memcpy(cmd
->data
.setdelip4
.ip_addr
, &addr
->u
.a4
.addr
, 4);
599 memcpy(cmd
->data
.setdelip4
.mask
, &addr
->u
.a4
.mask
, 4);
600 cmd
->data
.setdelip4
.flags
= flags
;
603 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
608 static int qeth_l3_send_setrouting(struct qeth_card
*card
,
609 enum qeth_routing_types type
, enum qeth_prot_versions prot
)
612 struct qeth_ipa_cmd
*cmd
;
613 struct qeth_cmd_buffer
*iob
;
615 QETH_DBF_TEXT(TRACE
, 4, "setroutg");
616 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_SETRTG
, prot
);
617 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
618 cmd
->data
.setrtg
.type
= (type
);
619 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
624 static void qeth_l3_correct_routing_type(struct qeth_card
*card
,
625 enum qeth_routing_types
*type
, enum qeth_prot_versions prot
)
627 if (card
->info
.type
== QETH_CARD_TYPE_IQD
) {
630 case PRIMARY_CONNECTOR
:
631 case SECONDARY_CONNECTOR
:
632 case MULTICAST_ROUTER
:
641 case SECONDARY_ROUTER
:
643 case MULTICAST_ROUTER
:
644 if (qeth_is_ipafunc_supported(card
, prot
,
655 int qeth_l3_setrouting_v4(struct qeth_card
*card
)
659 QETH_DBF_TEXT(TRACE
, 3, "setrtg4");
661 qeth_l3_correct_routing_type(card
, &card
->options
.route4
.type
,
664 rc
= qeth_l3_send_setrouting(card
, card
->options
.route4
.type
,
667 card
->options
.route4
.type
= NO_ROUTER
;
668 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
669 " on %s. Type set to 'no router'.\n", rc
,
670 QETH_CARD_IFNAME(card
));
675 int qeth_l3_setrouting_v6(struct qeth_card
*card
)
679 QETH_DBF_TEXT(TRACE
, 3, "setrtg6");
680 #ifdef CONFIG_QETH_IPV6
682 if (!qeth_is_supported(card
, IPA_IPV6
))
684 qeth_l3_correct_routing_type(card
, &card
->options
.route6
.type
,
687 rc
= qeth_l3_send_setrouting(card
, card
->options
.route6
.type
,
690 card
->options
.route6
.type
= NO_ROUTER
;
691 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
692 " on %s. Type set to 'no router'.\n", rc
,
693 QETH_CARD_IFNAME(card
));
700 * IP address takeover related functions
702 static void qeth_l3_clear_ipato_list(struct qeth_card
*card
)
705 struct qeth_ipato_entry
*ipatoe
, *tmp
;
708 spin_lock_irqsave(&card
->ip_lock
, flags
);
709 list_for_each_entry_safe(ipatoe
, tmp
, &card
->ipato
.entries
, entry
) {
710 list_del(&ipatoe
->entry
);
713 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
716 int qeth_l3_add_ipato_entry(struct qeth_card
*card
,
717 struct qeth_ipato_entry
*new)
719 struct qeth_ipato_entry
*ipatoe
;
723 QETH_DBF_TEXT(TRACE
, 2, "addipato");
724 spin_lock_irqsave(&card
->ip_lock
, flags
);
725 list_for_each_entry(ipatoe
, &card
->ipato
.entries
, entry
) {
726 if (ipatoe
->proto
!= new->proto
)
728 if (!memcmp(ipatoe
->addr
, new->addr
,
729 (ipatoe
->proto
== QETH_PROT_IPV4
)? 4:16) &&
730 (ipatoe
->mask_bits
== new->mask_bits
)) {
736 list_add_tail(&new->entry
, &card
->ipato
.entries
);
738 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
742 void qeth_l3_del_ipato_entry(struct qeth_card
*card
,
743 enum qeth_prot_versions proto
, u8
*addr
, int mask_bits
)
745 struct qeth_ipato_entry
*ipatoe
, *tmp
;
748 QETH_DBF_TEXT(TRACE
, 2, "delipato");
749 spin_lock_irqsave(&card
->ip_lock
, flags
);
750 list_for_each_entry_safe(ipatoe
, tmp
, &card
->ipato
.entries
, entry
) {
751 if (ipatoe
->proto
!= proto
)
753 if (!memcmp(ipatoe
->addr
, addr
,
754 (proto
== QETH_PROT_IPV4
)? 4:16) &&
755 (ipatoe
->mask_bits
== mask_bits
)) {
756 list_del(&ipatoe
->entry
);
760 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
764 * VIPA related functions
766 int qeth_l3_add_vipa(struct qeth_card
*card
, enum qeth_prot_versions proto
,
769 struct qeth_ipaddr
*ipaddr
;
773 ipaddr
= qeth_l3_get_addr_buffer(proto
);
775 if (proto
== QETH_PROT_IPV4
) {
776 QETH_DBF_TEXT(TRACE
, 2, "addvipa4");
777 memcpy(&ipaddr
->u
.a4
.addr
, addr
, 4);
778 ipaddr
->u
.a4
.mask
= 0;
779 } else if (proto
== QETH_PROT_IPV6
) {
780 QETH_DBF_TEXT(TRACE
, 2, "addvipa6");
781 memcpy(&ipaddr
->u
.a6
.addr
, addr
, 16);
782 ipaddr
->u
.a6
.pfxlen
= 0;
784 ipaddr
->type
= QETH_IP_TYPE_VIPA
;
785 ipaddr
->set_flags
= QETH_IPA_SETIP_VIPA_FLAG
;
786 ipaddr
->del_flags
= QETH_IPA_DELIP_VIPA_FLAG
;
789 spin_lock_irqsave(&card
->ip_lock
, flags
);
790 if (qeth_l3_address_exists_in_list(&card
->ip_list
, ipaddr
, 0) ||
791 qeth_l3_address_exists_in_list(card
->ip_tbd_list
, ipaddr
, 0))
793 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
797 if (!qeth_l3_add_ip(card
, ipaddr
))
799 qeth_l3_set_ip_addr_list(card
);
803 void qeth_l3_del_vipa(struct qeth_card
*card
, enum qeth_prot_versions proto
,
806 struct qeth_ipaddr
*ipaddr
;
808 ipaddr
= qeth_l3_get_addr_buffer(proto
);
810 if (proto
== QETH_PROT_IPV4
) {
811 QETH_DBF_TEXT(TRACE
, 2, "delvipa4");
812 memcpy(&ipaddr
->u
.a4
.addr
, addr
, 4);
813 ipaddr
->u
.a4
.mask
= 0;
814 } else if (proto
== QETH_PROT_IPV6
) {
815 QETH_DBF_TEXT(TRACE
, 2, "delvipa6");
816 memcpy(&ipaddr
->u
.a6
.addr
, addr
, 16);
817 ipaddr
->u
.a6
.pfxlen
= 0;
819 ipaddr
->type
= QETH_IP_TYPE_VIPA
;
822 if (!qeth_l3_delete_ip(card
, ipaddr
))
824 qeth_l3_set_ip_addr_list(card
);
828 * proxy ARP related functions
830 int qeth_l3_add_rxip(struct qeth_card
*card
, enum qeth_prot_versions proto
,
833 struct qeth_ipaddr
*ipaddr
;
837 ipaddr
= qeth_l3_get_addr_buffer(proto
);
839 if (proto
== QETH_PROT_IPV4
) {
840 QETH_DBF_TEXT(TRACE
, 2, "addrxip4");
841 memcpy(&ipaddr
->u
.a4
.addr
, addr
, 4);
842 ipaddr
->u
.a4
.mask
= 0;
843 } else if (proto
== QETH_PROT_IPV6
) {
844 QETH_DBF_TEXT(TRACE
, 2, "addrxip6");
845 memcpy(&ipaddr
->u
.a6
.addr
, addr
, 16);
846 ipaddr
->u
.a6
.pfxlen
= 0;
848 ipaddr
->type
= QETH_IP_TYPE_RXIP
;
849 ipaddr
->set_flags
= QETH_IPA_SETIP_TAKEOVER_FLAG
;
850 ipaddr
->del_flags
= 0;
853 spin_lock_irqsave(&card
->ip_lock
, flags
);
854 if (qeth_l3_address_exists_in_list(&card
->ip_list
, ipaddr
, 0) ||
855 qeth_l3_address_exists_in_list(card
->ip_tbd_list
, ipaddr
, 0))
857 spin_unlock_irqrestore(&card
->ip_lock
, flags
);
861 if (!qeth_l3_add_ip(card
, ipaddr
))
863 qeth_l3_set_ip_addr_list(card
);
867 void qeth_l3_del_rxip(struct qeth_card
*card
, enum qeth_prot_versions proto
,
870 struct qeth_ipaddr
*ipaddr
;
872 ipaddr
= qeth_l3_get_addr_buffer(proto
);
874 if (proto
== QETH_PROT_IPV4
) {
875 QETH_DBF_TEXT(TRACE
, 2, "addrxip4");
876 memcpy(&ipaddr
->u
.a4
.addr
, addr
, 4);
877 ipaddr
->u
.a4
.mask
= 0;
878 } else if (proto
== QETH_PROT_IPV6
) {
879 QETH_DBF_TEXT(TRACE
, 2, "addrxip6");
880 memcpy(&ipaddr
->u
.a6
.addr
, addr
, 16);
881 ipaddr
->u
.a6
.pfxlen
= 0;
883 ipaddr
->type
= QETH_IP_TYPE_RXIP
;
886 if (!qeth_l3_delete_ip(card
, ipaddr
))
888 qeth_l3_set_ip_addr_list(card
);
891 static int qeth_l3_register_addr_entry(struct qeth_card
*card
,
892 struct qeth_ipaddr
*addr
)
898 if (addr
->proto
== QETH_PROT_IPV4
) {
899 QETH_DBF_TEXT(TRACE
, 2, "setaddr4");
900 QETH_DBF_HEX(TRACE
, 3, &addr
->u
.a4
.addr
, sizeof(int));
901 } else if (addr
->proto
== QETH_PROT_IPV6
) {
902 QETH_DBF_TEXT(TRACE
, 2, "setaddr6");
903 QETH_DBF_HEX(TRACE
, 3, &addr
->u
.a6
.addr
, 8);
904 QETH_DBF_HEX(TRACE
, 3, ((char *)&addr
->u
.a6
.addr
) + 8, 8);
906 QETH_DBF_TEXT(TRACE
, 2, "setaddr?");
907 QETH_DBF_HEX(TRACE
, 3, addr
, sizeof(struct qeth_ipaddr
));
910 if (addr
->is_multicast
)
911 rc
= qeth_l3_send_setdelmc(card
, addr
, IPA_CMD_SETIPM
);
913 rc
= qeth_l3_send_setdelip(card
, addr
, IPA_CMD_SETIP
,
916 QETH_DBF_TEXT(TRACE
, 2, "failed");
917 } while ((--cnt
> 0) && rc
);
919 QETH_DBF_TEXT(TRACE
, 2, "FAILED");
920 qeth_l3_ipaddr_to_string(addr
->proto
, (u8
*)&addr
->u
, buf
);
921 dev_warn(&card
->gdev
->dev
,
922 "Registering IP address %s failed\n", buf
);
927 static int qeth_l3_deregister_addr_entry(struct qeth_card
*card
,
928 struct qeth_ipaddr
*addr
)
932 if (addr
->proto
== QETH_PROT_IPV4
) {
933 QETH_DBF_TEXT(TRACE
, 2, "deladdr4");
934 QETH_DBF_HEX(TRACE
, 3, &addr
->u
.a4
.addr
, sizeof(int));
935 } else if (addr
->proto
== QETH_PROT_IPV6
) {
936 QETH_DBF_TEXT(TRACE
, 2, "deladdr6");
937 QETH_DBF_HEX(TRACE
, 3, &addr
->u
.a6
.addr
, 8);
938 QETH_DBF_HEX(TRACE
, 3, ((char *)&addr
->u
.a6
.addr
) + 8, 8);
940 QETH_DBF_TEXT(TRACE
, 2, "deladdr?");
941 QETH_DBF_HEX(TRACE
, 3, addr
, sizeof(struct qeth_ipaddr
));
943 if (addr
->is_multicast
)
944 rc
= qeth_l3_send_setdelmc(card
, addr
, IPA_CMD_DELIPM
);
946 rc
= qeth_l3_send_setdelip(card
, addr
, IPA_CMD_DELIP
,
949 QETH_DBF_TEXT(TRACE
, 2, "failed");
954 static inline u8
qeth_l3_get_qeth_hdr_flags4(int cast_type
)
956 if (cast_type
== RTN_MULTICAST
)
957 return QETH_CAST_MULTICAST
;
958 if (cast_type
== RTN_BROADCAST
)
959 return QETH_CAST_BROADCAST
;
960 return QETH_CAST_UNICAST
;
963 static inline u8
qeth_l3_get_qeth_hdr_flags6(int cast_type
)
965 u8 ct
= QETH_HDR_PASSTHRU
| QETH_HDR_IPV6
;
966 if (cast_type
== RTN_MULTICAST
)
967 return ct
| QETH_CAST_MULTICAST
;
968 if (cast_type
== RTN_ANYCAST
)
969 return ct
| QETH_CAST_ANYCAST
;
970 if (cast_type
== RTN_BROADCAST
)
971 return ct
| QETH_CAST_BROADCAST
;
972 return ct
| QETH_CAST_UNICAST
;
975 static int qeth_l3_send_setadp_mode(struct qeth_card
*card
, __u32 command
,
979 struct qeth_cmd_buffer
*iob
;
980 struct qeth_ipa_cmd
*cmd
;
982 QETH_DBF_TEXT(TRACE
, 4, "adpmode");
984 iob
= qeth_get_adapter_cmd(card
, command
,
985 sizeof(struct qeth_ipacmd_setadpparms
));
986 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
987 cmd
->data
.setadapterparms
.data
.mode
= mode
;
988 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_default_setadapterparms_cb
,
993 static int qeth_l3_setadapter_hstr(struct qeth_card
*card
)
997 QETH_DBF_TEXT(TRACE
, 4, "adphstr");
999 if (qeth_adp_supported(card
, IPA_SETADP_SET_BROADCAST_MODE
)) {
1000 rc
= qeth_l3_send_setadp_mode(card
,
1001 IPA_SETADP_SET_BROADCAST_MODE
,
1002 card
->options
.broadcast_mode
);
1004 QETH_DBF_MESSAGE(2, "couldn't set broadcast mode on "
1006 CARD_BUS_ID(card
), rc
);
1007 rc
= qeth_l3_send_setadp_mode(card
,
1008 IPA_SETADP_ALTER_MAC_ADDRESS
,
1009 card
->options
.macaddr_mode
);
1011 QETH_DBF_MESSAGE(2, "couldn't set macaddr mode on "
1012 "device %s: x%x\n", CARD_BUS_ID(card
), rc
);
1015 if (card
->options
.broadcast_mode
== QETH_TR_BROADCAST_LOCAL
)
1016 QETH_DBF_MESSAGE(2, "set adapter parameters not available "
1017 "to set broadcast mode, using ALLRINGS "
1018 "on device %s:\n", CARD_BUS_ID(card
));
1019 if (card
->options
.macaddr_mode
== QETH_TR_MACADDR_CANONICAL
)
1020 QETH_DBF_MESSAGE(2, "set adapter parameters not available "
1021 "to set macaddr mode, using NONCANONICAL "
1022 "on device %s:\n", CARD_BUS_ID(card
));
1026 static int qeth_l3_setadapter_parms(struct qeth_card
*card
)
1030 QETH_DBF_TEXT(SETUP
, 2, "setadprm");
1032 if (!qeth_is_supported(card
, IPA_SETADAPTERPARMS
)) {
1033 dev_info(&card
->gdev
->dev
,
1034 "set adapter parameters not supported.\n");
1035 QETH_DBF_TEXT(SETUP
, 2, " notsupp");
1038 rc
= qeth_query_setadapterparms(card
);
1040 QETH_DBF_MESSAGE(2, "%s couldn't set adapter parameters: "
1041 "0x%x\n", dev_name(&card
->gdev
->dev
), rc
);
1044 if (qeth_adp_supported(card
, IPA_SETADP_ALTER_MAC_ADDRESS
)) {
1045 rc
= qeth_setadpparms_change_macaddr(card
);
1047 dev_warn(&card
->gdev
->dev
, "Reading the adapter MAC"
1048 " address failed\n");
1051 if ((card
->info
.link_type
== QETH_LINK_TYPE_HSTR
) ||
1052 (card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
))
1053 rc
= qeth_l3_setadapter_hstr(card
);
1058 static int qeth_l3_default_setassparms_cb(struct qeth_card
*card
,
1059 struct qeth_reply
*reply
, unsigned long data
)
1061 struct qeth_ipa_cmd
*cmd
;
1063 QETH_DBF_TEXT(TRACE
, 4, "defadpcb");
1065 cmd
= (struct qeth_ipa_cmd
*) data
;
1066 if (cmd
->hdr
.return_code
== 0) {
1067 cmd
->hdr
.return_code
= cmd
->data
.setassparms
.hdr
.return_code
;
1068 if (cmd
->hdr
.prot_version
== QETH_PROT_IPV4
)
1069 card
->options
.ipa4
.enabled_funcs
= cmd
->hdr
.ipa_enabled
;
1070 if (cmd
->hdr
.prot_version
== QETH_PROT_IPV6
)
1071 card
->options
.ipa6
.enabled_funcs
= cmd
->hdr
.ipa_enabled
;
1073 if (cmd
->data
.setassparms
.hdr
.assist_no
== IPA_INBOUND_CHECKSUM
&&
1074 cmd
->data
.setassparms
.hdr
.command_code
== IPA_CMD_ASS_START
) {
1075 card
->info
.csum_mask
= cmd
->data
.setassparms
.data
.flags_32bit
;
1076 QETH_DBF_TEXT_(TRACE
, 3, "csum:%d", card
->info
.csum_mask
);
1081 static struct qeth_cmd_buffer
*qeth_l3_get_setassparms_cmd(
1082 struct qeth_card
*card
, enum qeth_ipa_funcs ipa_func
, __u16 cmd_code
,
1083 __u16 len
, enum qeth_prot_versions prot
)
1085 struct qeth_cmd_buffer
*iob
;
1086 struct qeth_ipa_cmd
*cmd
;
1088 QETH_DBF_TEXT(TRACE
, 4, "getasscm");
1089 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_SETASSPARMS
, prot
);
1091 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
1092 cmd
->data
.setassparms
.hdr
.assist_no
= ipa_func
;
1093 cmd
->data
.setassparms
.hdr
.length
= 8 + len
;
1094 cmd
->data
.setassparms
.hdr
.command_code
= cmd_code
;
1095 cmd
->data
.setassparms
.hdr
.return_code
= 0;
1096 cmd
->data
.setassparms
.hdr
.seq_no
= 0;
1101 static int qeth_l3_send_setassparms(struct qeth_card
*card
,
1102 struct qeth_cmd_buffer
*iob
, __u16 len
, long data
,
1103 int (*reply_cb
)(struct qeth_card
*, struct qeth_reply
*,
1108 struct qeth_ipa_cmd
*cmd
;
1110 QETH_DBF_TEXT(TRACE
, 4, "sendassp");
1112 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
1113 if (len
<= sizeof(__u32
))
1114 cmd
->data
.setassparms
.data
.flags_32bit
= (__u32
) data
;
1115 else /* (len > sizeof(__u32)) */
1116 memcpy(&cmd
->data
.setassparms
.data
, (void *) data
, len
);
1118 rc
= qeth_send_ipa_cmd(card
, iob
, reply_cb
, reply_param
);
1122 #ifdef CONFIG_QETH_IPV6
1123 static int qeth_l3_send_simple_setassparms_ipv6(struct qeth_card
*card
,
1124 enum qeth_ipa_funcs ipa_func
, __u16 cmd_code
)
1127 struct qeth_cmd_buffer
*iob
;
1129 QETH_DBF_TEXT(TRACE
, 4, "simassp6");
1130 iob
= qeth_l3_get_setassparms_cmd(card
, ipa_func
, cmd_code
,
1132 rc
= qeth_l3_send_setassparms(card
, iob
, 0, 0,
1133 qeth_l3_default_setassparms_cb
, NULL
);
1138 static int qeth_l3_send_simple_setassparms(struct qeth_card
*card
,
1139 enum qeth_ipa_funcs ipa_func
, __u16 cmd_code
, long data
)
1143 struct qeth_cmd_buffer
*iob
;
1145 QETH_DBF_TEXT(TRACE
, 4, "simassp4");
1147 length
= sizeof(__u32
);
1148 iob
= qeth_l3_get_setassparms_cmd(card
, ipa_func
, cmd_code
,
1149 length
, QETH_PROT_IPV4
);
1150 rc
= qeth_l3_send_setassparms(card
, iob
, length
, data
,
1151 qeth_l3_default_setassparms_cb
, NULL
);
1155 static int qeth_l3_start_ipa_arp_processing(struct qeth_card
*card
)
1159 QETH_DBF_TEXT(TRACE
, 3, "ipaarp");
1161 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
1162 dev_info(&card
->gdev
->dev
,
1163 "ARP processing not supported on %s!\n",
1164 QETH_CARD_IFNAME(card
));
1167 rc
= qeth_l3_send_simple_setassparms(card
, IPA_ARP_PROCESSING
,
1168 IPA_CMD_ASS_START
, 0);
1170 dev_warn(&card
->gdev
->dev
,
1171 "Starting ARP processing support for %s failed\n",
1172 QETH_CARD_IFNAME(card
));
1177 static int qeth_l3_start_ipa_ip_fragmentation(struct qeth_card
*card
)
1181 QETH_DBF_TEXT(TRACE
, 3, "ipaipfrg");
1183 if (!qeth_is_supported(card
, IPA_IP_FRAGMENTATION
)) {
1184 dev_info(&card
->gdev
->dev
,
1185 "Hardware IP fragmentation not supported on %s\n",
1186 QETH_CARD_IFNAME(card
));
1190 rc
= qeth_l3_send_simple_setassparms(card
, IPA_IP_FRAGMENTATION
,
1191 IPA_CMD_ASS_START
, 0);
1193 dev_warn(&card
->gdev
->dev
,
1194 "Starting IP fragmentation support for %s failed\n",
1195 QETH_CARD_IFNAME(card
));
1197 dev_info(&card
->gdev
->dev
,
1198 "Hardware IP fragmentation enabled \n");
1202 static int qeth_l3_start_ipa_source_mac(struct qeth_card
*card
)
1206 QETH_DBF_TEXT(TRACE
, 3, "stsrcmac");
1208 if (!qeth_is_supported(card
, IPA_SOURCE_MAC
)) {
1209 dev_info(&card
->gdev
->dev
,
1210 "Inbound source MAC-address not supported on %s\n",
1211 QETH_CARD_IFNAME(card
));
1215 rc
= qeth_l3_send_simple_setassparms(card
, IPA_SOURCE_MAC
,
1216 IPA_CMD_ASS_START
, 0);
1218 dev_warn(&card
->gdev
->dev
,
1219 "Starting source MAC-address support for %s failed\n",
1220 QETH_CARD_IFNAME(card
));
1224 static int qeth_l3_start_ipa_vlan(struct qeth_card
*card
)
1228 QETH_DBF_TEXT(TRACE
, 3, "strtvlan");
1230 if (!qeth_is_supported(card
, IPA_FULL_VLAN
)) {
1231 dev_info(&card
->gdev
->dev
,
1232 "VLAN not supported on %s\n", QETH_CARD_IFNAME(card
));
1236 rc
= qeth_l3_send_simple_setassparms(card
, IPA_VLAN_PRIO
,
1237 IPA_CMD_ASS_START
, 0);
1239 dev_warn(&card
->gdev
->dev
,
1240 "Starting VLAN support for %s failed\n",
1241 QETH_CARD_IFNAME(card
));
1243 dev_info(&card
->gdev
->dev
, "VLAN enabled\n");
1248 static int qeth_l3_start_ipa_multicast(struct qeth_card
*card
)
1252 QETH_DBF_TEXT(TRACE
, 3, "stmcast");
1254 if (!qeth_is_supported(card
, IPA_MULTICASTING
)) {
1255 dev_info(&card
->gdev
->dev
,
1256 "Multicast not supported on %s\n",
1257 QETH_CARD_IFNAME(card
));
1261 rc
= qeth_l3_send_simple_setassparms(card
, IPA_MULTICASTING
,
1262 IPA_CMD_ASS_START
, 0);
1264 dev_warn(&card
->gdev
->dev
,
1265 "Starting multicast support for %s failed\n",
1266 QETH_CARD_IFNAME(card
));
1268 dev_info(&card
->gdev
->dev
, "Multicast enabled\n");
1269 card
->dev
->flags
|= IFF_MULTICAST
;
1274 static int qeth_l3_query_ipassists_cb(struct qeth_card
*card
,
1275 struct qeth_reply
*reply
, unsigned long data
)
1277 struct qeth_ipa_cmd
*cmd
;
1279 QETH_DBF_TEXT(SETUP
, 2, "qipasscb");
1281 cmd
= (struct qeth_ipa_cmd
*) data
;
1282 if (cmd
->hdr
.prot_version
== QETH_PROT_IPV4
) {
1283 card
->options
.ipa4
.supported_funcs
= cmd
->hdr
.ipa_supported
;
1284 card
->options
.ipa4
.enabled_funcs
= cmd
->hdr
.ipa_enabled
;
1286 card
->options
.ipa6
.supported_funcs
= cmd
->hdr
.ipa_supported
;
1287 card
->options
.ipa6
.enabled_funcs
= cmd
->hdr
.ipa_enabled
;
1289 QETH_DBF_TEXT(SETUP
, 2, "suppenbl");
1290 QETH_DBF_TEXT_(SETUP
, 2, "%x", cmd
->hdr
.ipa_supported
);
1291 QETH_DBF_TEXT_(SETUP
, 2, "%x", cmd
->hdr
.ipa_enabled
);
1295 static int qeth_l3_query_ipassists(struct qeth_card
*card
,
1296 enum qeth_prot_versions prot
)
1299 struct qeth_cmd_buffer
*iob
;
1301 QETH_DBF_TEXT_(SETUP
, 2, "qipassi%i", prot
);
1302 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_QIPASSIST
, prot
);
1303 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_l3_query_ipassists_cb
, NULL
);
1307 #ifdef CONFIG_QETH_IPV6
1308 static int qeth_l3_softsetup_ipv6(struct qeth_card
*card
)
1312 QETH_DBF_TEXT(TRACE
, 3, "softipv6");
1314 if (card
->info
.type
== QETH_CARD_TYPE_IQD
)
1317 rc
= qeth_l3_query_ipassists(card
, QETH_PROT_IPV6
);
1319 dev_err(&card
->gdev
->dev
,
1320 "Activating IPv6 support for %s failed\n",
1321 QETH_CARD_IFNAME(card
));
1324 rc
= qeth_l3_send_simple_setassparms(card
, IPA_IPV6
,
1325 IPA_CMD_ASS_START
, 3);
1327 dev_err(&card
->gdev
->dev
,
1328 "Activating IPv6 support for %s failed\n",
1329 QETH_CARD_IFNAME(card
));
1332 rc
= qeth_l3_send_simple_setassparms_ipv6(card
, IPA_IPV6
,
1335 dev_err(&card
->gdev
->dev
,
1336 "Activating IPv6 support for %s failed\n",
1337 QETH_CARD_IFNAME(card
));
1340 rc
= qeth_l3_send_simple_setassparms_ipv6(card
, IPA_PASSTHRU
,
1343 dev_warn(&card
->gdev
->dev
,
1344 "Enabling the passthrough mode for %s failed\n",
1345 QETH_CARD_IFNAME(card
));
1349 dev_info(&card
->gdev
->dev
, "IPV6 enabled\n");
1354 static int qeth_l3_start_ipa_ipv6(struct qeth_card
*card
)
1358 QETH_DBF_TEXT(TRACE
, 3, "strtipv6");
1360 if (!qeth_is_supported(card
, IPA_IPV6
)) {
1361 dev_info(&card
->gdev
->dev
,
1362 "IPv6 not supported on %s\n", QETH_CARD_IFNAME(card
));
1365 #ifdef CONFIG_QETH_IPV6
1366 rc
= qeth_l3_softsetup_ipv6(card
);
1371 static int qeth_l3_start_ipa_broadcast(struct qeth_card
*card
)
1375 QETH_DBF_TEXT(TRACE
, 3, "stbrdcst");
1376 card
->info
.broadcast_capable
= 0;
1377 if (!qeth_is_supported(card
, IPA_FILTERING
)) {
1378 dev_info(&card
->gdev
->dev
,
1379 "Broadcast not supported on %s\n",
1380 QETH_CARD_IFNAME(card
));
1384 rc
= qeth_l3_send_simple_setassparms(card
, IPA_FILTERING
,
1385 IPA_CMD_ASS_START
, 0);
1387 dev_warn(&card
->gdev
->dev
, "Enabling broadcast filtering for "
1388 "%s failed\n", QETH_CARD_IFNAME(card
));
1392 rc
= qeth_l3_send_simple_setassparms(card
, IPA_FILTERING
,
1393 IPA_CMD_ASS_CONFIGURE
, 1);
1395 dev_warn(&card
->gdev
->dev
,
1396 "Setting up broadcast filtering for %s failed\n",
1397 QETH_CARD_IFNAME(card
));
1400 card
->info
.broadcast_capable
= QETH_BROADCAST_WITH_ECHO
;
1401 dev_info(&card
->gdev
->dev
, "Broadcast enabled\n");
1402 rc
= qeth_l3_send_simple_setassparms(card
, IPA_FILTERING
,
1403 IPA_CMD_ASS_ENABLE
, 1);
1405 dev_warn(&card
->gdev
->dev
, "Setting up broadcast echo "
1406 "filtering for %s failed\n", QETH_CARD_IFNAME(card
));
1409 card
->info
.broadcast_capable
= QETH_BROADCAST_WITHOUT_ECHO
;
1411 if (card
->info
.broadcast_capable
)
1412 card
->dev
->flags
|= IFF_BROADCAST
;
1414 card
->dev
->flags
&= ~IFF_BROADCAST
;
1418 static int qeth_l3_send_checksum_command(struct qeth_card
*card
)
1422 rc
= qeth_l3_send_simple_setassparms(card
, IPA_INBOUND_CHECKSUM
,
1423 IPA_CMD_ASS_START
, 0);
1425 dev_warn(&card
->gdev
->dev
, "Starting HW checksumming for %s "
1426 "failed, using SW checksumming\n",
1427 QETH_CARD_IFNAME(card
));
1430 rc
= qeth_l3_send_simple_setassparms(card
, IPA_INBOUND_CHECKSUM
,
1432 card
->info
.csum_mask
);
1434 dev_warn(&card
->gdev
->dev
, "Enabling HW checksumming for %s "
1435 "failed, using SW checksumming\n",
1436 QETH_CARD_IFNAME(card
));
1442 static int qeth_l3_start_ipa_checksum(struct qeth_card
*card
)
1446 QETH_DBF_TEXT(TRACE
, 3, "strtcsum");
1448 if (card
->options
.checksum_type
== NO_CHECKSUMMING
) {
1449 dev_info(&card
->gdev
->dev
,
1450 "Using no checksumming on %s.\n",
1451 QETH_CARD_IFNAME(card
));
1454 if (card
->options
.checksum_type
== SW_CHECKSUMMING
) {
1455 dev_info(&card
->gdev
->dev
,
1456 "Using SW checksumming on %s.\n",
1457 QETH_CARD_IFNAME(card
));
1460 if (!qeth_is_supported(card
, IPA_INBOUND_CHECKSUM
)) {
1461 dev_info(&card
->gdev
->dev
,
1462 "Inbound HW Checksumming not "
1463 "supported on %s,\ncontinuing "
1464 "using Inbound SW Checksumming\n",
1465 QETH_CARD_IFNAME(card
));
1466 card
->options
.checksum_type
= SW_CHECKSUMMING
;
1469 rc
= qeth_l3_send_checksum_command(card
);
1471 dev_info(&card
->gdev
->dev
,
1472 "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 dev_info(&card
->gdev
->dev
,
1485 "Outbound TSO not supported on %s\n",
1486 QETH_CARD_IFNAME(card
));
1489 rc
= qeth_l3_send_simple_setassparms(card
, IPA_OUTBOUND_TSO
,
1490 IPA_CMD_ASS_START
, 0);
1492 dev_warn(&card
->gdev
->dev
, "Starting outbound TCP "
1493 "segmentation offload for %s failed\n",
1494 QETH_CARD_IFNAME(card
));
1496 dev_info(&card
->gdev
->dev
,
1497 "Outbound TSO enabled\n");
1499 if (rc
&& (card
->options
.large_send
== QETH_LARGE_SEND_TSO
)) {
1500 card
->options
.large_send
= QETH_LARGE_SEND_NO
;
1501 card
->dev
->features
&= ~(NETIF_F_TSO
| NETIF_F_SG
);
1506 static int qeth_l3_start_ipassists(struct qeth_card
*card
)
1508 QETH_DBF_TEXT(TRACE
, 3, "strtipas");
1509 qeth_l3_start_ipa_arp_processing(card
); /* go on*/
1510 qeth_l3_start_ipa_ip_fragmentation(card
); /* go on*/
1511 qeth_l3_start_ipa_source_mac(card
); /* go on*/
1512 qeth_l3_start_ipa_vlan(card
); /* go on*/
1513 qeth_l3_start_ipa_multicast(card
); /* go on*/
1514 qeth_l3_start_ipa_ipv6(card
); /* go on*/
1515 qeth_l3_start_ipa_broadcast(card
); /* go on*/
1516 qeth_l3_start_ipa_checksum(card
); /* go on*/
1517 qeth_l3_start_ipa_tso(card
); /* go on*/
1521 static int qeth_l3_put_unique_id(struct qeth_card
*card
)
1525 struct qeth_cmd_buffer
*iob
;
1526 struct qeth_ipa_cmd
*cmd
;
1528 QETH_DBF_TEXT(TRACE
, 2, "puniqeid");
1530 if ((card
->info
.unique_id
& UNIQUE_ID_NOT_BY_CARD
) ==
1531 UNIQUE_ID_NOT_BY_CARD
)
1533 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_DESTROY_ADDR
,
1535 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
1536 *((__u16
*) &cmd
->data
.create_destroy_addr
.unique_id
[6]) =
1537 card
->info
.unique_id
;
1538 memcpy(&cmd
->data
.create_destroy_addr
.unique_id
[0],
1539 card
->dev
->dev_addr
, OSA_ADDR_LEN
);
1540 rc
= qeth_send_ipa_cmd(card
, iob
, NULL
, NULL
);
1544 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card
*card
,
1545 struct qeth_reply
*reply
, unsigned long data
)
1547 struct qeth_ipa_cmd
*cmd
;
1549 cmd
= (struct qeth_ipa_cmd
*) data
;
1550 if (cmd
->hdr
.return_code
== 0)
1551 memcpy(card
->dev
->dev_addr
,
1552 cmd
->data
.create_destroy_addr
.unique_id
, ETH_ALEN
);
1554 random_ether_addr(card
->dev
->dev_addr
);
1559 static int qeth_l3_iqd_read_initial_mac(struct qeth_card
*card
)
1562 struct qeth_cmd_buffer
*iob
;
1563 struct qeth_ipa_cmd
*cmd
;
1565 QETH_DBF_TEXT(SETUP
, 2, "hsrmac");
1567 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_CREATE_ADDR
,
1569 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
1570 *((__u16
*) &cmd
->data
.create_destroy_addr
.unique_id
[6]) =
1571 card
->info
.unique_id
;
1573 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_l3_iqd_read_initial_mac_cb
,
1578 static int qeth_l3_get_unique_id_cb(struct qeth_card
*card
,
1579 struct qeth_reply
*reply
, unsigned long data
)
1581 struct qeth_ipa_cmd
*cmd
;
1583 cmd
= (struct qeth_ipa_cmd
*) data
;
1584 if (cmd
->hdr
.return_code
== 0)
1585 card
->info
.unique_id
= *((__u16
*)
1586 &cmd
->data
.create_destroy_addr
.unique_id
[6]);
1588 card
->info
.unique_id
= UNIQUE_ID_IF_CREATE_ADDR_FAILED
|
1589 UNIQUE_ID_NOT_BY_CARD
;
1590 dev_warn(&card
->gdev
->dev
, "The network adapter failed to "
1591 "generate a unique ID\n");
1596 static int qeth_l3_get_unique_id(struct qeth_card
*card
)
1599 struct qeth_cmd_buffer
*iob
;
1600 struct qeth_ipa_cmd
*cmd
;
1602 QETH_DBF_TEXT(SETUP
, 2, "guniqeid");
1604 if (!qeth_is_supported(card
, IPA_IPV6
)) {
1605 card
->info
.unique_id
= UNIQUE_ID_IF_CREATE_ADDR_FAILED
|
1606 UNIQUE_ID_NOT_BY_CARD
;
1610 iob
= qeth_get_ipacmd_buffer(card
, IPA_CMD_CREATE_ADDR
,
1612 cmd
= (struct qeth_ipa_cmd
*)(iob
->data
+IPA_PDU_HEADER_SIZE
);
1613 *((__u16
*) &cmd
->data
.create_destroy_addr
.unique_id
[6]) =
1614 card
->info
.unique_id
;
1616 rc
= qeth_send_ipa_cmd(card
, iob
, qeth_l3_get_unique_id_cb
, NULL
);
1620 static void qeth_l3_get_mac_for_ipm(__u32 ipm
, char *mac
,
1621 struct net_device
*dev
)
1623 if (dev
->type
== ARPHRD_IEEE802_TR
)
1624 ip_tr_mc_map(ipm
, mac
);
1626 ip_eth_mc_map(ipm
, mac
);
1629 static void qeth_l3_add_mc(struct qeth_card
*card
, struct in_device
*in4_dev
)
1631 struct qeth_ipaddr
*ipm
;
1632 struct ip_mc_list
*im4
;
1633 char buf
[MAX_ADDR_LEN
];
1635 QETH_DBF_TEXT(TRACE
, 4, "addmc");
1636 for (im4
= in4_dev
->mc_list
; im4
; im4
= im4
->next
) {
1637 qeth_l3_get_mac_for_ipm(im4
->multiaddr
, buf
, in4_dev
->dev
);
1638 ipm
= qeth_l3_get_addr_buffer(QETH_PROT_IPV4
);
1641 ipm
->u
.a4
.addr
= im4
->multiaddr
;
1642 memcpy(ipm
->mac
, buf
, OSA_ADDR_LEN
);
1643 ipm
->is_multicast
= 1;
1644 if (!qeth_l3_add_ip(card
, ipm
))
1649 static void qeth_l3_add_vlan_mc(struct qeth_card
*card
)
1651 struct in_device
*in_dev
;
1652 struct vlan_group
*vg
;
1655 QETH_DBF_TEXT(TRACE
, 4, "addmcvl");
1656 if (!qeth_is_supported(card
, IPA_FULL_VLAN
) || (card
->vlangrp
== NULL
))
1660 for (i
= 0; i
< VLAN_GROUP_ARRAY_LEN
; i
++) {
1661 struct net_device
*netdev
= vlan_group_get_device(vg
, i
);
1662 if (netdev
== NULL
||
1663 !(netdev
->flags
& IFF_UP
))
1665 in_dev
= in_dev_get(netdev
);
1668 read_lock(&in_dev
->mc_list_lock
);
1669 qeth_l3_add_mc(card
, in_dev
);
1670 read_unlock(&in_dev
->mc_list_lock
);
1675 static void qeth_l3_add_multicast_ipv4(struct qeth_card
*card
)
1677 struct in_device
*in4_dev
;
1679 QETH_DBF_TEXT(TRACE
, 4, "chkmcv4");
1680 in4_dev
= in_dev_get(card
->dev
);
1681 if (in4_dev
== NULL
)
1683 read_lock(&in4_dev
->mc_list_lock
);
1684 qeth_l3_add_mc(card
, in4_dev
);
1685 qeth_l3_add_vlan_mc(card
);
1686 read_unlock(&in4_dev
->mc_list_lock
);
1687 in_dev_put(in4_dev
);
1690 #ifdef CONFIG_QETH_IPV6
1691 static void qeth_l3_add_mc6(struct qeth_card
*card
, struct inet6_dev
*in6_dev
)
1693 struct qeth_ipaddr
*ipm
;
1694 struct ifmcaddr6
*im6
;
1695 char buf
[MAX_ADDR_LEN
];
1697 QETH_DBF_TEXT(TRACE
, 4, "addmc6");
1698 for (im6
= in6_dev
->mc_list
; im6
!= NULL
; im6
= im6
->next
) {
1699 ndisc_mc_map(&im6
->mca_addr
, buf
, in6_dev
->dev
, 0);
1700 ipm
= qeth_l3_get_addr_buffer(QETH_PROT_IPV6
);
1703 ipm
->is_multicast
= 1;
1704 memcpy(ipm
->mac
, buf
, OSA_ADDR_LEN
);
1705 memcpy(&ipm
->u
.a6
.addr
, &im6
->mca_addr
.s6_addr
,
1706 sizeof(struct in6_addr
));
1707 if (!qeth_l3_add_ip(card
, ipm
))
1712 static void qeth_l3_add_vlan_mc6(struct qeth_card
*card
)
1714 struct inet6_dev
*in_dev
;
1715 struct vlan_group
*vg
;
1718 QETH_DBF_TEXT(TRACE
, 4, "admc6vl");
1719 if (!qeth_is_supported(card
, IPA_FULL_VLAN
) || (card
->vlangrp
== NULL
))
1723 for (i
= 0; i
< VLAN_GROUP_ARRAY_LEN
; i
++) {
1724 struct net_device
*netdev
= vlan_group_get_device(vg
, i
);
1725 if (netdev
== NULL
||
1726 !(netdev
->flags
& IFF_UP
))
1728 in_dev
= in6_dev_get(netdev
);
1731 read_lock_bh(&in_dev
->lock
);
1732 qeth_l3_add_mc6(card
, in_dev
);
1733 read_unlock_bh(&in_dev
->lock
);
1734 in6_dev_put(in_dev
);
1738 static void qeth_l3_add_multicast_ipv6(struct qeth_card
*card
)
1740 struct inet6_dev
*in6_dev
;
1742 QETH_DBF_TEXT(TRACE
, 4, "chkmcv6");
1743 if (!qeth_is_supported(card
, IPA_IPV6
))
1745 in6_dev
= in6_dev_get(card
->dev
);
1746 if (in6_dev
== NULL
)
1748 read_lock_bh(&in6_dev
->lock
);
1749 qeth_l3_add_mc6(card
, in6_dev
);
1750 qeth_l3_add_vlan_mc6(card
);
1751 read_unlock_bh(&in6_dev
->lock
);
1752 in6_dev_put(in6_dev
);
1754 #endif /* CONFIG_QETH_IPV6 */
1756 static void qeth_l3_free_vlan_addresses4(struct qeth_card
*card
,
1759 struct in_device
*in_dev
;
1760 struct in_ifaddr
*ifa
;
1761 struct qeth_ipaddr
*addr
;
1763 QETH_DBF_TEXT(TRACE
, 4, "frvaddr4");
1765 in_dev
= in_dev_get(vlan_group_get_device(card
->vlangrp
, vid
));
1768 for (ifa
= in_dev
->ifa_list
; ifa
; ifa
= ifa
->ifa_next
) {
1769 addr
= qeth_l3_get_addr_buffer(QETH_PROT_IPV4
);
1771 addr
->u
.a4
.addr
= ifa
->ifa_address
;
1772 addr
->u
.a4
.mask
= ifa
->ifa_mask
;
1773 addr
->type
= QETH_IP_TYPE_NORMAL
;
1774 if (!qeth_l3_delete_ip(card
, addr
))
1781 static void qeth_l3_free_vlan_addresses6(struct qeth_card
*card
,
1784 #ifdef CONFIG_QETH_IPV6
1785 struct inet6_dev
*in6_dev
;
1786 struct inet6_ifaddr
*ifa
;
1787 struct qeth_ipaddr
*addr
;
1789 QETH_DBF_TEXT(TRACE
, 4, "frvaddr6");
1791 in6_dev
= in6_dev_get(vlan_group_get_device(card
->vlangrp
, vid
));
1794 for (ifa
= in6_dev
->addr_list
; ifa
; ifa
= ifa
->lst_next
) {
1795 addr
= qeth_l3_get_addr_buffer(QETH_PROT_IPV6
);
1797 memcpy(&addr
->u
.a6
.addr
, &ifa
->addr
,
1798 sizeof(struct in6_addr
));
1799 addr
->u
.a6
.pfxlen
= ifa
->prefix_len
;
1800 addr
->type
= QETH_IP_TYPE_NORMAL
;
1801 if (!qeth_l3_delete_ip(card
, addr
))
1805 in6_dev_put(in6_dev
);
1806 #endif /* CONFIG_QETH_IPV6 */
1809 static void qeth_l3_free_vlan_addresses(struct qeth_card
*card
,
1814 qeth_l3_free_vlan_addresses4(card
, vid
);
1815 qeth_l3_free_vlan_addresses6(card
, vid
);
1818 static void qeth_l3_vlan_rx_register(struct net_device
*dev
,
1819 struct vlan_group
*grp
)
1821 struct qeth_card
*card
= dev
->ml_priv
;
1822 unsigned long flags
;
1824 QETH_DBF_TEXT(TRACE
, 4, "vlanreg");
1825 spin_lock_irqsave(&card
->vlanlock
, flags
);
1826 card
->vlangrp
= grp
;
1827 spin_unlock_irqrestore(&card
->vlanlock
, flags
);
1830 static void qeth_l3_vlan_rx_add_vid(struct net_device
*dev
, unsigned short vid
)
1835 static void qeth_l3_vlan_rx_kill_vid(struct net_device
*dev
, unsigned short vid
)
1837 struct qeth_card
*card
= dev
->ml_priv
;
1838 unsigned long flags
;
1840 QETH_DBF_TEXT_(TRACE
, 4, "kid:%d", vid
);
1841 spin_lock_irqsave(&card
->vlanlock
, flags
);
1842 /* unregister IP addresses of vlan device */
1843 qeth_l3_free_vlan_addresses(card
, vid
);
1844 vlan_group_set_device(card
->vlangrp
, vid
, NULL
);
1845 spin_unlock_irqrestore(&card
->vlanlock
, flags
);
1846 qeth_l3_set_multicast_list(card
->dev
);
1849 static inline __u16
qeth_l3_rebuild_skb(struct qeth_card
*card
,
1850 struct sk_buff
*skb
, struct qeth_hdr
*hdr
)
1852 unsigned short vlan_id
= 0;
1854 struct iphdr
*ip_hdr
;
1855 unsigned char tg_addr
[MAX_ADDR_LEN
];
1857 if (!(hdr
->hdr
.l3
.flags
& QETH_HDR_PASSTHRU
)) {
1858 prot
= htons((hdr
->hdr
.l3
.flags
& QETH_HDR_IPV6
)? ETH_P_IPV6
:
1860 switch (hdr
->hdr
.l3
.flags
& QETH_HDR_CAST_MASK
) {
1861 case QETH_CAST_MULTICAST
:
1863 #ifdef CONFIG_QETH_IPV6
1864 case __constant_htons(ETH_P_IPV6
):
1865 ndisc_mc_map((struct in6_addr
*)
1867 tg_addr
, card
->dev
, 0);
1870 case __constant_htons(ETH_P_IP
):
1871 ip_hdr
= (struct iphdr
*)skb
->data
;
1872 (card
->dev
->type
== ARPHRD_IEEE802_TR
) ?
1873 ip_tr_mc_map(ip_hdr
->daddr
, tg_addr
):
1874 ip_eth_mc_map(ip_hdr
->daddr
, tg_addr
);
1877 memcpy(tg_addr
, card
->dev
->broadcast
,
1878 card
->dev
->addr_len
);
1880 card
->stats
.multicast
++;
1881 skb
->pkt_type
= PACKET_MULTICAST
;
1883 case QETH_CAST_BROADCAST
:
1884 memcpy(tg_addr
, card
->dev
->broadcast
,
1885 card
->dev
->addr_len
);
1886 card
->stats
.multicast
++;
1887 skb
->pkt_type
= PACKET_BROADCAST
;
1889 case QETH_CAST_UNICAST
:
1890 case QETH_CAST_ANYCAST
:
1891 case QETH_CAST_NOCAST
:
1893 skb
->pkt_type
= PACKET_HOST
;
1894 memcpy(tg_addr
, card
->dev
->dev_addr
,
1895 card
->dev
->addr_len
);
1897 if (hdr
->hdr
.l3
.ext_flags
& QETH_HDR_EXT_SRC_MAC_ADDR
)
1898 card
->dev
->header_ops
->create(skb
, card
->dev
, prot
,
1899 tg_addr
, &hdr
->hdr
.l3
.dest_addr
[2],
1900 card
->dev
->addr_len
);
1902 card
->dev
->header_ops
->create(skb
, card
->dev
, prot
,
1903 tg_addr
, "FAKELL", card
->dev
->addr_len
);
1907 if (card
->dev
->type
== ARPHRD_IEEE802_TR
)
1908 skb
->protocol
= tr_type_trans(skb
, card
->dev
);
1911 skb
->protocol
= eth_type_trans(skb
, card
->dev
);
1913 if (hdr
->hdr
.l3
.ext_flags
&
1914 (QETH_HDR_EXT_VLAN_FRAME
| QETH_HDR_EXT_INCLUDE_VLAN_TAG
)) {
1915 vlan_id
= (hdr
->hdr
.l3
.ext_flags
& QETH_HDR_EXT_VLAN_FRAME
)?
1916 hdr
->hdr
.l3
.vlan_id
: *((u16
*)&hdr
->hdr
.l3
.dest_addr
[12]);
1919 skb
->ip_summed
= card
->options
.checksum_type
;
1920 if (card
->options
.checksum_type
== HW_CHECKSUMMING
) {
1921 if ((hdr
->hdr
.l3
.ext_flags
&
1922 (QETH_HDR_EXT_CSUM_HDR_REQ
|
1923 QETH_HDR_EXT_CSUM_TRANSP_REQ
)) ==
1924 (QETH_HDR_EXT_CSUM_HDR_REQ
|
1925 QETH_HDR_EXT_CSUM_TRANSP_REQ
))
1926 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
1928 skb
->ip_summed
= SW_CHECKSUMMING
;
1934 static void qeth_l3_process_inbound_buffer(struct qeth_card
*card
,
1935 struct qeth_qdio_buffer
*buf
, int index
)
1937 struct qdio_buffer_element
*element
;
1938 struct sk_buff
*skb
;
1939 struct qeth_hdr
*hdr
;
1944 /* get first element of current buffer */
1945 element
= (struct qdio_buffer_element
*)&buf
->buffer
->element
[0];
1947 if (card
->options
.performance_stats
)
1948 card
->perf_stats
.bufs_rec
++;
1949 while ((skb
= qeth_core_get_next_skb(card
, buf
->buffer
, &element
,
1951 skb
->dev
= card
->dev
;
1952 /* is device UP ? */
1953 if (!(card
->dev
->flags
& IFF_UP
)) {
1954 dev_kfree_skb_any(skb
);
1958 switch (hdr
->hdr
.l3
.id
) {
1959 case QETH_HEADER_TYPE_LAYER3
:
1960 vlan_tag
= qeth_l3_rebuild_skb(card
, skb
, hdr
);
1964 vlan_hwaccel_rx(skb
, card
->vlangrp
,
1967 dev_kfree_skb_any(skb
);
1974 dev_kfree_skb_any(skb
);
1975 QETH_DBF_TEXT(TRACE
, 3, "inbunkno");
1976 QETH_DBF_HEX(CTRL
, 3, hdr
, QETH_DBF_CTRL_LEN
);
1980 card
->dev
->last_rx
= jiffies
;
1981 card
->stats
.rx_packets
++;
1982 card
->stats
.rx_bytes
+= len
;
1986 static int qeth_l3_verify_vlan_dev(struct net_device
*dev
,
1987 struct qeth_card
*card
)
1990 struct vlan_group
*vg
;
1997 for (i
= 0; i
< VLAN_GROUP_ARRAY_LEN
; i
++) {
1998 if (vlan_group_get_device(vg
, i
) == dev
) {
1999 rc
= QETH_VLAN_CARD
;
2004 if (rc
&& !(vlan_dev_real_dev(dev
)->ml_priv
== (void *)card
))
2010 static int qeth_l3_verify_dev(struct net_device
*dev
)
2012 struct qeth_card
*card
;
2013 unsigned long flags
;
2016 read_lock_irqsave(&qeth_core_card_list
.rwlock
, flags
);
2017 list_for_each_entry(card
, &qeth_core_card_list
.list
, list
) {
2018 if (card
->dev
== dev
) {
2019 rc
= QETH_REAL_CARD
;
2022 rc
= qeth_l3_verify_vlan_dev(dev
, card
);
2026 read_unlock_irqrestore(&qeth_core_card_list
.rwlock
, flags
);
2031 static struct qeth_card
*qeth_l3_get_card_from_dev(struct net_device
*dev
)
2033 struct qeth_card
*card
= NULL
;
2036 rc
= qeth_l3_verify_dev(dev
);
2037 if (rc
== QETH_REAL_CARD
)
2038 card
= dev
->ml_priv
;
2039 else if (rc
== QETH_VLAN_CARD
)
2040 card
= vlan_dev_real_dev(dev
)->ml_priv
;
2041 if (card
&& card
->options
.layer2
)
2043 QETH_DBF_TEXT_(TRACE
, 4, "%d", rc
);
2047 static int qeth_l3_stop_card(struct qeth_card
*card
, int recovery_mode
)
2051 QETH_DBF_TEXT(SETUP
, 2, "stopcard");
2052 QETH_DBF_HEX(SETUP
, 2, &card
, sizeof(void *));
2054 qeth_set_allowed_threads(card
, 0, 1);
2055 if (card
->read
.state
== CH_STATE_UP
&&
2056 card
->write
.state
== CH_STATE_UP
&&
2057 (card
->state
== CARD_STATE_UP
)) {
2059 qeth_l3_stop(card
->dev
);
2063 dev_close(card
->dev
);
2067 if (!card
->use_hard_stop
) {
2068 rc
= qeth_send_stoplan(card
);
2070 QETH_DBF_TEXT_(SETUP
, 2, "1err%d", rc
);
2072 card
->state
= CARD_STATE_SOFTSETUP
;
2074 if (card
->state
== CARD_STATE_SOFTSETUP
) {
2075 qeth_l3_clear_ip_list(card
, !card
->use_hard_stop
, 1);
2076 qeth_clear_ipacmd_list(card
);
2077 card
->state
= CARD_STATE_HARDSETUP
;
2079 if (card
->state
== CARD_STATE_HARDSETUP
) {
2080 if (!card
->use_hard_stop
&&
2081 (card
->info
.type
!= QETH_CARD_TYPE_IQD
)) {
2082 rc
= qeth_l3_put_unique_id(card
);
2084 QETH_DBF_TEXT_(SETUP
, 2, "2err%d", rc
);
2086 qeth_qdio_clear_card(card
, 0);
2087 qeth_clear_qdio_buffers(card
);
2088 qeth_clear_working_pool_list(card
);
2089 card
->state
= CARD_STATE_DOWN
;
2091 if (card
->state
== CARD_STATE_DOWN
) {
2092 qeth_clear_cmd_buffers(&card
->read
);
2093 qeth_clear_cmd_buffers(&card
->write
);
2095 card
->use_hard_stop
= 0;
2099 static void qeth_l3_set_multicast_list(struct net_device
*dev
)
2101 struct qeth_card
*card
= dev
->ml_priv
;
2103 QETH_DBF_TEXT(TRACE
, 3, "setmulti");
2104 qeth_l3_delete_mc_addresses(card
);
2105 qeth_l3_add_multicast_ipv4(card
);
2106 #ifdef CONFIG_QETH_IPV6
2107 qeth_l3_add_multicast_ipv6(card
);
2109 qeth_l3_set_ip_addr_list(card
);
2110 if (!qeth_adp_supported(card
, IPA_SETADP_SET_PROMISC_MODE
))
2112 qeth_setadp_promisc_mode(card
);
2115 static const char *qeth_l3_arp_get_error_cause(int *rc
)
2118 case QETH_IPA_ARP_RC_FAILED
:
2120 return "operation failed";
2121 case QETH_IPA_ARP_RC_NOTSUPP
:
2123 return "operation not supported";
2124 case QETH_IPA_ARP_RC_OUT_OF_RANGE
:
2126 return "argument out of range";
2127 case QETH_IPA_ARP_RC_Q_NOTSUPP
:
2129 return "query operation not supported";
2130 case QETH_IPA_ARP_RC_Q_NO_DATA
:
2132 return "no query data available";
2134 return "unknown error";
2138 static int qeth_l3_arp_set_no_entries(struct qeth_card
*card
, int no_entries
)
2143 QETH_DBF_TEXT(TRACE
, 3, "arpstnoe");
2146 * currently GuestLAN only supports the ARP assist function
2147 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
2148 * thus we say EOPNOTSUPP for this ARP function
2150 if (card
->info
.guestlan
)
2152 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
2155 rc
= qeth_l3_send_simple_setassparms(card
, IPA_ARP_PROCESSING
,
2156 IPA_CMD_ASS_ARP_SET_NO_ENTRIES
,
2160 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on "
2161 "%s: %s (0x%x/%d)\n", QETH_CARD_IFNAME(card
),
2162 qeth_l3_arp_get_error_cause(&rc
), tmp
, tmp
);
2167 static void qeth_l3_copy_arp_entries_stripped(struct qeth_arp_query_info
*qinfo
,
2168 struct qeth_arp_query_data
*qdata
, int entry_size
,
2175 entry_ptr
= (char *)&qdata
->data
;
2176 uentry_ptr
= (char *)(qinfo
->udata
+ qinfo
->udata_offset
);
2177 for (i
= 0; i
< qdata
->no_entries
; ++i
) {
2178 /* strip off 32 bytes "media specific information" */
2179 memcpy(uentry_ptr
, (entry_ptr
+ 32), entry_size
- 32);
2180 entry_ptr
+= entry_size
;
2181 uentry_ptr
+= uentry_size
;
2185 static int qeth_l3_arp_query_cb(struct qeth_card
*card
,
2186 struct qeth_reply
*reply
, unsigned long data
)
2188 struct qeth_ipa_cmd
*cmd
;
2189 struct qeth_arp_query_data
*qdata
;
2190 struct qeth_arp_query_info
*qinfo
;
2195 QETH_DBF_TEXT(TRACE
, 4, "arpquecb");
2197 qinfo
= (struct qeth_arp_query_info
*) reply
->param
;
2198 cmd
= (struct qeth_ipa_cmd
*) data
;
2199 if (cmd
->hdr
.return_code
) {
2200 QETH_DBF_TEXT_(TRACE
, 4, "qaer1%i", cmd
->hdr
.return_code
);
2203 if (cmd
->data
.setassparms
.hdr
.return_code
) {
2204 cmd
->hdr
.return_code
= cmd
->data
.setassparms
.hdr
.return_code
;
2205 QETH_DBF_TEXT_(TRACE
, 4, "qaer2%i", cmd
->hdr
.return_code
);
2208 qdata
= &cmd
->data
.setassparms
.data
.query_arp
;
2209 switch (qdata
->reply_bits
) {
2211 uentry_size
= entry_size
= sizeof(struct qeth_arp_qi_entry5
);
2212 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
)
2213 uentry_size
= sizeof(struct qeth_arp_qi_entry5_short
);
2216 /* fall through to default */
2218 /* tr is the same as eth -> entry7 */
2219 uentry_size
= entry_size
= sizeof(struct qeth_arp_qi_entry7
);
2220 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
)
2221 uentry_size
= sizeof(struct qeth_arp_qi_entry7_short
);
2224 /* check if there is enough room in userspace */
2225 if ((qinfo
->udata_len
- qinfo
->udata_offset
) <
2226 qdata
->no_entries
* uentry_size
){
2227 QETH_DBF_TEXT_(TRACE
, 4, "qaer3%i", -ENOMEM
);
2228 cmd
->hdr
.return_code
= -ENOMEM
;
2231 QETH_DBF_TEXT_(TRACE
, 4, "anore%i",
2232 cmd
->data
.setassparms
.hdr
.number_of_replies
);
2233 QETH_DBF_TEXT_(TRACE
, 4, "aseqn%i", cmd
->data
.setassparms
.hdr
.seq_no
);
2234 QETH_DBF_TEXT_(TRACE
, 4, "anoen%i", qdata
->no_entries
);
2236 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
) {
2237 /* strip off "media specific information" */
2238 qeth_l3_copy_arp_entries_stripped(qinfo
, qdata
, entry_size
,
2241 /*copy entries to user buffer*/
2242 memcpy(qinfo
->udata
+ qinfo
->udata_offset
,
2243 (char *)&qdata
->data
, qdata
->no_entries
*uentry_size
);
2245 qinfo
->no_entries
+= qdata
->no_entries
;
2246 qinfo
->udata_offset
+= (qdata
->no_entries
*uentry_size
);
2247 /* check if all replies received ... */
2248 if (cmd
->data
.setassparms
.hdr
.seq_no
<
2249 cmd
->data
.setassparms
.hdr
.number_of_replies
)
2251 memcpy(qinfo
->udata
, &qinfo
->no_entries
, 4);
2252 /* keep STRIP_ENTRIES flag so the user program can distinguish
2253 * stripped entries from normal ones */
2254 if (qinfo
->mask_bits
& QETH_QARP_STRIP_ENTRIES
)
2255 qdata
->reply_bits
|= QETH_QARP_STRIP_ENTRIES
;
2256 memcpy(qinfo
->udata
+ QETH_QARP_MASK_OFFSET
, &qdata
->reply_bits
, 2);
2260 memcpy(qinfo
->udata
, &i
, 4);
2264 static int qeth_l3_send_ipa_arp_cmd(struct qeth_card
*card
,
2265 struct qeth_cmd_buffer
*iob
, int len
,
2266 int (*reply_cb
)(struct qeth_card
*, struct qeth_reply
*,
2270 QETH_DBF_TEXT(TRACE
, 4, "sendarp");
2272 memcpy(iob
->data
, IPA_PDU_HEADER
, IPA_PDU_HEADER_SIZE
);
2273 memcpy(QETH_IPA_CMD_DEST_ADDR(iob
->data
),
2274 &card
->token
.ulp_connection_r
, QETH_MPC_TOKEN_LENGTH
);
2275 return qeth_send_control_data(card
, IPA_PDU_HEADER_SIZE
+ len
, iob
,
2276 reply_cb
, reply_param
);
2279 static int qeth_l3_arp_query(struct qeth_card
*card
, char __user
*udata
)
2281 struct qeth_cmd_buffer
*iob
;
2282 struct qeth_arp_query_info qinfo
= {0, };
2286 QETH_DBF_TEXT(TRACE
, 3, "arpquery");
2288 if (!qeth_is_supported(card
,/*IPA_QUERY_ARP_ADDR_INFO*/
2289 IPA_ARP_PROCESSING
)) {
2292 /* get size of userspace buffer and mask_bits -> 6 bytes */
2293 if (copy_from_user(&qinfo
, udata
, 6))
2295 qinfo
.udata
= kzalloc(qinfo
.udata_len
, GFP_KERNEL
);
2298 qinfo
.udata_offset
= QETH_QARP_ENTRIES_OFFSET
;
2299 iob
= qeth_l3_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
,
2300 IPA_CMD_ASS_ARP_QUERY_INFO
,
2301 sizeof(int), QETH_PROT_IPV4
);
2303 rc
= qeth_l3_send_ipa_arp_cmd(card
, iob
,
2304 QETH_SETASS_BASE_LEN
+QETH_ARP_CMD_LEN
,
2305 qeth_l3_arp_query_cb
, (void *)&qinfo
);
2308 QETH_DBF_MESSAGE(2, "Error while querying ARP cache on %s: %s "
2309 "(0x%x/%d)\n", QETH_CARD_IFNAME(card
),
2310 qeth_l3_arp_get_error_cause(&rc
), tmp
, tmp
);
2311 if (copy_to_user(udata
, qinfo
.udata
, 4))
2314 if (copy_to_user(udata
, qinfo
.udata
, qinfo
.udata_len
))
2321 static int qeth_l3_arp_add_entry(struct qeth_card
*card
,
2322 struct qeth_arp_cache_entry
*entry
)
2324 struct qeth_cmd_buffer
*iob
;
2329 QETH_DBF_TEXT(TRACE
, 3, "arpadent");
2332 * currently GuestLAN only supports the ARP assist function
2333 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
2334 * thus we say EOPNOTSUPP for this ARP function
2336 if (card
->info
.guestlan
)
2338 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
2342 iob
= qeth_l3_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
,
2343 IPA_CMD_ASS_ARP_ADD_ENTRY
,
2344 sizeof(struct qeth_arp_cache_entry
),
2346 rc
= qeth_l3_send_setassparms(card
, iob
,
2347 sizeof(struct qeth_arp_cache_entry
),
2348 (unsigned long) entry
,
2349 qeth_l3_default_setassparms_cb
, NULL
);
2352 qeth_l3_ipaddr4_to_string((u8
*)entry
->ipaddr
, buf
);
2353 QETH_DBF_MESSAGE(2, "Could not add ARP entry for address %s "
2354 "on %s: %s (0x%x/%d)\n", buf
, QETH_CARD_IFNAME(card
),
2355 qeth_l3_arp_get_error_cause(&rc
), tmp
, tmp
);
2360 static int qeth_l3_arp_remove_entry(struct qeth_card
*card
,
2361 struct qeth_arp_cache_entry
*entry
)
2363 struct qeth_cmd_buffer
*iob
;
2364 char buf
[16] = {0, };
2368 QETH_DBF_TEXT(TRACE
, 3, "arprment");
2371 * currently GuestLAN only supports the ARP assist function
2372 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_REMOVE_ENTRY;
2373 * thus we say EOPNOTSUPP for this ARP function
2375 if (card
->info
.guestlan
)
2377 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
2380 memcpy(buf
, entry
, 12);
2381 iob
= qeth_l3_get_setassparms_cmd(card
, IPA_ARP_PROCESSING
,
2382 IPA_CMD_ASS_ARP_REMOVE_ENTRY
,
2385 rc
= qeth_l3_send_setassparms(card
, iob
,
2386 12, (unsigned long)buf
,
2387 qeth_l3_default_setassparms_cb
, NULL
);
2391 qeth_l3_ipaddr4_to_string((u8
*)entry
->ipaddr
, buf
);
2392 QETH_DBF_MESSAGE(2, "Could not delete ARP entry for address %s"
2393 " on %s: %s (0x%x/%d)\n", buf
, QETH_CARD_IFNAME(card
),
2394 qeth_l3_arp_get_error_cause(&rc
), tmp
, tmp
);
2399 static int qeth_l3_arp_flush_cache(struct qeth_card
*card
)
2404 QETH_DBF_TEXT(TRACE
, 3, "arpflush");
2407 * currently GuestLAN only supports the ARP assist function
2408 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
2409 * thus we say EOPNOTSUPP for this ARP function
2411 if (card
->info
.guestlan
|| (card
->info
.type
== QETH_CARD_TYPE_IQD
))
2413 if (!qeth_is_supported(card
, IPA_ARP_PROCESSING
)) {
2416 rc
= qeth_l3_send_simple_setassparms(card
, IPA_ARP_PROCESSING
,
2417 IPA_CMD_ASS_ARP_FLUSH_CACHE
, 0);
2420 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on %s: %s "
2421 "(0x%x/%d)\n", QETH_CARD_IFNAME(card
),
2422 qeth_l3_arp_get_error_cause(&rc
), tmp
, tmp
);
2427 static int qeth_l3_do_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
2429 struct qeth_card
*card
= dev
->ml_priv
;
2430 struct qeth_arp_cache_entry arp_entry
;
2431 struct mii_ioctl_data
*mii_data
;
2437 if ((card
->state
!= CARD_STATE_UP
) &&
2438 (card
->state
!= CARD_STATE_SOFTSETUP
))
2442 case SIOC_QETH_ARP_SET_NO_ENTRIES
:
2443 if (!capable(CAP_NET_ADMIN
)) {
2447 rc
= qeth_l3_arp_set_no_entries(card
, rq
->ifr_ifru
.ifru_ivalue
);
2449 case SIOC_QETH_ARP_QUERY_INFO
:
2450 if (!capable(CAP_NET_ADMIN
)) {
2454 rc
= qeth_l3_arp_query(card
, rq
->ifr_ifru
.ifru_data
);
2456 case SIOC_QETH_ARP_ADD_ENTRY
:
2457 if (!capable(CAP_NET_ADMIN
)) {
2461 if (copy_from_user(&arp_entry
, rq
->ifr_ifru
.ifru_data
,
2462 sizeof(struct qeth_arp_cache_entry
)))
2465 rc
= qeth_l3_arp_add_entry(card
, &arp_entry
);
2467 case SIOC_QETH_ARP_REMOVE_ENTRY
:
2468 if (!capable(CAP_NET_ADMIN
)) {
2472 if (copy_from_user(&arp_entry
, rq
->ifr_ifru
.ifru_data
,
2473 sizeof(struct qeth_arp_cache_entry
)))
2476 rc
= qeth_l3_arp_remove_entry(card
, &arp_entry
);
2478 case SIOC_QETH_ARP_FLUSH_CACHE
:
2479 if (!capable(CAP_NET_ADMIN
)) {
2483 rc
= qeth_l3_arp_flush_cache(card
);
2485 case SIOC_QETH_ADP_SET_SNMP_CONTROL
:
2486 rc
= qeth_snmp_command(card
, rq
->ifr_ifru
.ifru_data
);
2488 case SIOC_QETH_GET_CARD_TYPE
:
2489 if ((card
->info
.type
== QETH_CARD_TYPE_OSAE
) &&
2490 !card
->info
.guestlan
)
2495 mii_data
= if_mii(rq
);
2496 mii_data
->phy_id
= 0;
2499 mii_data
= if_mii(rq
);
2500 if (mii_data
->phy_id
!= 0)
2503 mii_data
->val_out
= qeth_mdio_read(dev
,
2511 QETH_DBF_TEXT_(TRACE
, 2, "ioce%d", rc
);
2515 static void qeth_l3_fill_header(struct qeth_card
*card
, struct qeth_hdr
*hdr
,
2516 struct sk_buff
*skb
, int ipv
, int cast_type
)
2518 memset(hdr
, 0, sizeof(struct qeth_hdr
));
2519 hdr
->hdr
.l3
.id
= QETH_HEADER_TYPE_LAYER3
;
2520 hdr
->hdr
.l3
.ext_flags
= 0;
2523 * before we're going to overwrite this location with next hop ip.
2524 * v6 uses passthrough, v4 sets the tag in the QDIO header.
2526 if (card
->vlangrp
&& vlan_tx_tag_present(skb
)) {
2527 if ((ipv
== 4) || (card
->info
.type
== QETH_CARD_TYPE_IQD
))
2528 hdr
->hdr
.l3
.ext_flags
= QETH_HDR_EXT_VLAN_FRAME
;
2530 hdr
->hdr
.l3
.ext_flags
= QETH_HDR_EXT_INCLUDE_VLAN_TAG
;
2531 hdr
->hdr
.l3
.vlan_id
= vlan_tx_tag_get(skb
);
2534 hdr
->hdr
.l3
.length
= skb
->len
- sizeof(struct qeth_hdr
);
2537 hdr
->hdr
.l3
.flags
= qeth_l3_get_qeth_hdr_flags4(cast_type
);
2538 memset(hdr
->hdr
.l3
.dest_addr
, 0, 12);
2539 if ((skb
->dst
) && (skb
->dst
->neighbour
)) {
2540 *((u32
*) (&hdr
->hdr
.l3
.dest_addr
[12])) =
2541 *((u32
*) skb
->dst
->neighbour
->primary_key
);
2543 /* fill in destination address used in ip header */
2544 *((u32
*) (&hdr
->hdr
.l3
.dest_addr
[12])) =
2547 } else if (ipv
== 6) {
2549 hdr
->hdr
.l3
.flags
= qeth_l3_get_qeth_hdr_flags6(cast_type
);
2550 if (card
->info
.type
== QETH_CARD_TYPE_IQD
)
2551 hdr
->hdr
.l3
.flags
&= ~QETH_HDR_PASSTHRU
;
2552 if ((skb
->dst
) && (skb
->dst
->neighbour
)) {
2553 memcpy(hdr
->hdr
.l3
.dest_addr
,
2554 skb
->dst
->neighbour
->primary_key
, 16);
2556 /* fill in destination address used in ip header */
2557 memcpy(hdr
->hdr
.l3
.dest_addr
,
2558 &ipv6_hdr(skb
)->daddr
, 16);
2562 if ((skb
->dev
->type
== ARPHRD_IEEE802_TR
) &&
2563 !memcmp(skb
->data
+ sizeof(struct qeth_hdr
) +
2564 sizeof(__u16
), skb
->dev
->broadcast
, 6)) {
2565 hdr
->hdr
.l3
.flags
= QETH_CAST_BROADCAST
|
2567 } else if (!memcmp(skb
->data
+ sizeof(struct qeth_hdr
),
2568 skb
->dev
->broadcast
, 6)) {
2570 hdr
->hdr
.l3
.flags
= QETH_CAST_BROADCAST
|
2573 hdr
->hdr
.l3
.flags
= (cast_type
== RTN_MULTICAST
) ?
2574 QETH_CAST_MULTICAST
| QETH_HDR_PASSTHRU
:
2575 QETH_CAST_UNICAST
| QETH_HDR_PASSTHRU
;
2580 static int qeth_l3_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
2584 struct qeth_hdr
*hdr
= NULL
;
2585 int elements_needed
= 0;
2586 struct qeth_card
*card
= dev
->ml_priv
;
2587 struct sk_buff
*new_skb
= NULL
;
2588 int ipv
= qeth_get_ip_version(skb
);
2589 int cast_type
= qeth_get_cast_type(card
, skb
);
2590 struct qeth_qdio_out_q
*queue
= card
->qdio
.out_qs
2591 [qeth_get_priority_queue(card
, skb
, ipv
, cast_type
)];
2592 int tx_bytes
= skb
->len
;
2593 enum qeth_large_send_types large_send
= QETH_LARGE_SEND_NO
;
2594 struct qeth_eddp_context
*ctx
= NULL
;
2595 int data_offset
= -1;
2597 if ((card
->info
.type
== QETH_CARD_TYPE_IQD
) &&
2598 (skb
->protocol
!= htons(ETH_P_IPV6
)) &&
2599 (skb
->protocol
!= htons(ETH_P_IP
)))
2602 if ((card
->state
!= CARD_STATE_UP
) || !card
->lan_online
) {
2603 card
->stats
.tx_carrier_errors
++;
2607 if ((cast_type
== RTN_BROADCAST
) &&
2608 (card
->info
.broadcast_capable
== 0))
2611 if (card
->options
.performance_stats
) {
2612 card
->perf_stats
.outbound_cnt
++;
2613 card
->perf_stats
.outbound_start_time
= qeth_get_micros();
2616 if (skb_is_gso(skb
))
2617 large_send
= card
->options
.large_send
;
2619 if ((card
->info
.type
== QETH_CARD_TYPE_IQD
) && (!large_send
) &&
2620 (skb_shinfo(skb
)->nr_frags
== 0)) {
2622 data_offset
= ETH_HLEN
;
2623 hdr
= kmem_cache_alloc(qeth_core_header_cache
, GFP_ATOMIC
);
2628 /* create a clone with writeable headroom */
2629 new_skb
= skb_realloc_headroom(skb
, sizeof(struct qeth_hdr_tso
)
2635 if (card
->info
.type
== QETH_CARD_TYPE_IQD
) {
2636 if (data_offset
< 0)
2637 skb_pull(new_skb
, ETH_HLEN
);
2639 if (new_skb
->protocol
== htons(ETH_P_IP
)) {
2640 if (card
->dev
->type
== ARPHRD_IEEE802_TR
)
2641 skb_pull(new_skb
, TR_HLEN
);
2643 skb_pull(new_skb
, ETH_HLEN
);
2646 if (new_skb
->protocol
== ETH_P_IPV6
&& card
->vlangrp
&&
2647 vlan_tx_tag_present(new_skb
)) {
2648 skb_push(new_skb
, VLAN_HLEN
);
2649 skb_copy_to_linear_data(new_skb
, new_skb
->data
+ 4, 4);
2650 skb_copy_to_linear_data_offset(new_skb
, 4,
2651 new_skb
->data
+ 8, 4);
2652 skb_copy_to_linear_data_offset(new_skb
, 8,
2653 new_skb
->data
+ 12, 4);
2654 tag
= (u16
*)(new_skb
->data
+ 12);
2655 *tag
= __constant_htons(ETH_P_8021Q
);
2656 *(tag
+ 1) = htons(vlan_tx_tag_get(new_skb
));
2657 new_skb
->vlan_tci
= 0;
2661 netif_stop_queue(dev
);
2663 /* fix hardware limitation: as long as we do not have sbal
2664 * chaining we can not send long frag lists so we temporary
2667 if ((large_send
== QETH_LARGE_SEND_TSO
) &&
2668 ((skb_shinfo(new_skb
)->nr_frags
+ 2) > 16))
2669 large_send
= QETH_LARGE_SEND_EDDP
;
2671 if ((large_send
== QETH_LARGE_SEND_TSO
) &&
2672 (cast_type
== RTN_UNSPEC
)) {
2673 hdr
= (struct qeth_hdr
*)skb_push(new_skb
,
2674 sizeof(struct qeth_hdr_tso
));
2675 memset(hdr
, 0, sizeof(struct qeth_hdr_tso
));
2676 qeth_l3_fill_header(card
, hdr
, new_skb
, ipv
, cast_type
);
2677 qeth_tso_fill_header(card
, hdr
, new_skb
);
2680 if (data_offset
< 0) {
2681 hdr
= (struct qeth_hdr
*)skb_push(new_skb
,
2682 sizeof(struct qeth_hdr
));
2683 qeth_l3_fill_header(card
, hdr
, new_skb
, ipv
,
2686 qeth_l3_fill_header(card
, hdr
, new_skb
, ipv
,
2688 hdr
->hdr
.l3
.length
= new_skb
->len
- data_offset
;
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
,
2706 if (data_offset
>= 0)
2707 kmem_cache_free(qeth_core_header_cache
, hdr
);
2710 elements_needed
+= elems
;
2713 if ((large_send
== QETH_LARGE_SEND_NO
) &&
2714 (new_skb
->ip_summed
== CHECKSUM_PARTIAL
)) {
2715 qeth_tx_csum(new_skb
);
2716 if (card
->options
.performance_stats
)
2717 card
->perf_stats
.tx_csum
++;
2720 if (card
->info
.type
!= QETH_CARD_TYPE_IQD
)
2721 rc
= qeth_do_send_packet(card
, queue
, new_skb
, hdr
,
2722 elements_needed
, ctx
);
2724 rc
= qeth_do_send_packet_fast(card
, queue
, new_skb
, hdr
,
2725 elements_needed
, ctx
, data_offset
, 0);
2728 card
->stats
.tx_packets
++;
2729 card
->stats
.tx_bytes
+= tx_bytes
;
2731 dev_kfree_skb_any(skb
);
2732 if (card
->options
.performance_stats
) {
2733 if (large_send
!= QETH_LARGE_SEND_NO
) {
2734 card
->perf_stats
.large_send_bytes
+= tx_bytes
;
2735 card
->perf_stats
.large_send_cnt
++;
2737 if (skb_shinfo(new_skb
)->nr_frags
> 0) {
2738 card
->perf_stats
.sg_skbs_sent
++;
2739 /* nr_frags + skb->data */
2740 card
->perf_stats
.sg_frags_sent
+=
2741 skb_shinfo(new_skb
)->nr_frags
+ 1;
2746 qeth_eddp_put_context(ctx
);
2747 dev_kfree_skb_any(new_skb
);
2751 qeth_eddp_put_context(ctx
);
2753 if (data_offset
>= 0)
2754 kmem_cache_free(qeth_core_header_cache
, hdr
);
2758 dev_kfree_skb_any(new_skb
);
2759 return NETDEV_TX_BUSY
;
2764 netif_wake_queue(dev
);
2765 if (card
->options
.performance_stats
)
2766 card
->perf_stats
.outbound_time
+= qeth_get_micros() -
2767 card
->perf_stats
.outbound_start_time
;
2771 card
->stats
.tx_dropped
++;
2772 card
->stats
.tx_errors
++;
2773 if ((new_skb
!= skb
) && new_skb
)
2774 dev_kfree_skb_any(new_skb
);
2775 dev_kfree_skb_any(skb
);
2776 netif_wake_queue(dev
);
2777 return NETDEV_TX_OK
;
2780 static int qeth_l3_open(struct net_device
*dev
)
2782 struct qeth_card
*card
= dev
->ml_priv
;
2784 QETH_DBF_TEXT(TRACE
, 4, "qethopen");
2785 if (card
->state
!= CARD_STATE_SOFTSETUP
)
2787 card
->data
.state
= CH_STATE_UP
;
2788 card
->state
= CARD_STATE_UP
;
2789 netif_start_queue(dev
);
2791 if (!card
->lan_online
&& netif_carrier_ok(dev
))
2792 netif_carrier_off(dev
);
2796 static int qeth_l3_stop(struct net_device
*dev
)
2798 struct qeth_card
*card
= dev
->ml_priv
;
2800 QETH_DBF_TEXT(TRACE
, 4, "qethstop");
2801 netif_tx_disable(dev
);
2802 if (card
->state
== CARD_STATE_UP
)
2803 card
->state
= CARD_STATE_SOFTSETUP
;
2807 static u32
qeth_l3_ethtool_get_rx_csum(struct net_device
*dev
)
2809 struct qeth_card
*card
= dev
->ml_priv
;
2811 return (card
->options
.checksum_type
== HW_CHECKSUMMING
);
2814 static int qeth_l3_ethtool_set_rx_csum(struct net_device
*dev
, u32 data
)
2816 struct qeth_card
*card
= dev
->ml_priv
;
2817 enum qeth_card_states old_state
;
2818 enum qeth_checksum_types csum_type
;
2820 if ((card
->state
!= CARD_STATE_UP
) &&
2821 (card
->state
!= CARD_STATE_DOWN
))
2825 csum_type
= HW_CHECKSUMMING
;
2827 csum_type
= SW_CHECKSUMMING
;
2829 if (card
->options
.checksum_type
!= csum_type
) {
2830 old_state
= card
->state
;
2831 if (card
->state
== CARD_STATE_UP
)
2832 __qeth_l3_set_offline(card
->gdev
, 1);
2833 card
->options
.checksum_type
= csum_type
;
2834 if (old_state
== CARD_STATE_UP
)
2835 __qeth_l3_set_online(card
->gdev
, 1);
2840 static int qeth_l3_ethtool_set_tso(struct net_device
*dev
, u32 data
)
2842 struct qeth_card
*card
= dev
->ml_priv
;
2845 if (card
->options
.large_send
== QETH_LARGE_SEND_NO
) {
2846 if (card
->info
.type
== QETH_CARD_TYPE_IQD
)
2847 card
->options
.large_send
= QETH_LARGE_SEND_EDDP
;
2849 card
->options
.large_send
= QETH_LARGE_SEND_TSO
;
2850 dev
->features
|= NETIF_F_TSO
;
2853 dev
->features
&= ~NETIF_F_TSO
;
2854 card
->options
.large_send
= QETH_LARGE_SEND_NO
;
2859 static struct ethtool_ops qeth_l3_ethtool_ops
= {
2860 .get_link
= ethtool_op_get_link
,
2861 .get_tx_csum
= ethtool_op_get_tx_csum
,
2862 .set_tx_csum
= ethtool_op_set_tx_hw_csum
,
2863 .get_rx_csum
= qeth_l3_ethtool_get_rx_csum
,
2864 .set_rx_csum
= qeth_l3_ethtool_set_rx_csum
,
2865 .get_sg
= ethtool_op_get_sg
,
2866 .set_sg
= ethtool_op_set_sg
,
2867 .get_tso
= ethtool_op_get_tso
,
2868 .set_tso
= qeth_l3_ethtool_set_tso
,
2869 .get_strings
= qeth_core_get_strings
,
2870 .get_ethtool_stats
= qeth_core_get_ethtool_stats
,
2871 .get_stats_count
= qeth_core_get_stats_count
,
2872 .get_drvinfo
= qeth_core_get_drvinfo
,
2873 .get_settings
= qeth_core_ethtool_get_settings
,
2877 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
2878 * NOARP on the netdevice is no option because it also turns off neighbor
2879 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
2880 * arp resolution but we want the hard header (packet socket will work
2883 static int qeth_l3_neigh_setup_noarp(struct neighbour
*n
)
2885 n
->nud_state
= NUD_NOARP
;
2886 memcpy(n
->ha
, "FAKELL", 6);
2887 n
->output
= n
->ops
->connected_output
;
2892 qeth_l3_neigh_setup(struct net_device
*dev
, struct neigh_parms
*np
)
2894 if (np
->tbl
->family
== AF_INET
)
2895 np
->neigh_setup
= qeth_l3_neigh_setup_noarp
;
2900 static const struct net_device_ops qeth_l3_netdev_ops
= {
2901 .ndo_open
= qeth_l3_open
,
2902 .ndo_stop
= qeth_l3_stop
,
2903 .ndo_get_stats
= qeth_get_stats
,
2904 .ndo_start_xmit
= qeth_l3_hard_start_xmit
,
2905 .ndo_validate_addr
= eth_validate_addr
,
2906 .ndo_set_multicast_list
= qeth_l3_set_multicast_list
,
2907 .ndo_do_ioctl
= qeth_l3_do_ioctl
,
2908 .ndo_change_mtu
= qeth_change_mtu
,
2909 .ndo_vlan_rx_register
= qeth_l3_vlan_rx_register
,
2910 .ndo_vlan_rx_add_vid
= qeth_l3_vlan_rx_add_vid
,
2911 .ndo_vlan_rx_kill_vid
= qeth_l3_vlan_rx_kill_vid
,
2912 .ndo_tx_timeout
= qeth_tx_timeout
,
2915 static const struct net_device_ops qeth_l3_osa_netdev_ops
= {
2916 .ndo_open
= qeth_l3_open
,
2917 .ndo_stop
= qeth_l3_stop
,
2918 .ndo_get_stats
= qeth_get_stats
,
2919 .ndo_start_xmit
= qeth_l3_hard_start_xmit
,
2920 .ndo_validate_addr
= eth_validate_addr
,
2921 .ndo_set_multicast_list
= qeth_l3_set_multicast_list
,
2922 .ndo_do_ioctl
= qeth_l3_do_ioctl
,
2923 .ndo_change_mtu
= qeth_change_mtu
,
2924 .ndo_vlan_rx_register
= qeth_l3_vlan_rx_register
,
2925 .ndo_vlan_rx_add_vid
= qeth_l3_vlan_rx_add_vid
,
2926 .ndo_vlan_rx_kill_vid
= qeth_l3_vlan_rx_kill_vid
,
2927 .ndo_tx_timeout
= qeth_tx_timeout
,
2928 .ndo_neigh_setup
= qeth_l3_neigh_setup
,
2931 static int qeth_l3_setup_netdev(struct qeth_card
*card
)
2933 if (card
->info
.type
== QETH_CARD_TYPE_OSAE
) {
2934 if ((card
->info
.link_type
== QETH_LINK_TYPE_LANE_TR
) ||
2935 (card
->info
.link_type
== QETH_LINK_TYPE_HSTR
)) {
2937 card
->dev
= alloc_trdev(0);
2941 card
->dev
->netdev_ops
= &qeth_l3_netdev_ops
;
2943 card
->dev
= alloc_etherdev(0);
2946 card
->dev
->netdev_ops
= &qeth_l3_osa_netdev_ops
;
2948 /*IPv6 address autoconfiguration stuff*/
2949 qeth_l3_get_unique_id(card
);
2950 if (!(card
->info
.unique_id
& UNIQUE_ID_NOT_BY_CARD
))
2951 card
->dev
->dev_id
= card
->info
.unique_id
&
2954 } else if (card
->info
.type
== QETH_CARD_TYPE_IQD
) {
2955 card
->dev
= alloc_netdev(0, "hsi%d", ether_setup
);
2958 card
->dev
->flags
|= IFF_NOARP
;
2959 card
->dev
->netdev_ops
= &qeth_l3_netdev_ops
;
2960 qeth_l3_iqd_read_initial_mac(card
);
2964 card
->dev
->ml_priv
= card
;
2965 card
->dev
->watchdog_timeo
= QETH_TX_TIMEOUT
;
2966 card
->dev
->mtu
= card
->info
.initial_mtu
;
2967 SET_ETHTOOL_OPS(card
->dev
, &qeth_l3_ethtool_ops
);
2968 card
->dev
->features
|= NETIF_F_HW_VLAN_TX
|
2969 NETIF_F_HW_VLAN_RX
|
2970 NETIF_F_HW_VLAN_FILTER
;
2972 SET_NETDEV_DEV(card
->dev
, &card
->gdev
->dev
);
2973 return register_netdev(card
->dev
);
2976 static void qeth_l3_qdio_input_handler(struct ccw_device
*ccwdev
,
2977 unsigned int qdio_err
, unsigned int queue
, int first_element
,
2978 int count
, unsigned long card_ptr
)
2980 struct net_device
*net_dev
;
2981 struct qeth_card
*card
;
2982 struct qeth_qdio_buffer
*buffer
;
2986 card
= (struct qeth_card
*) card_ptr
;
2987 net_dev
= card
->dev
;
2988 if (card
->options
.performance_stats
) {
2989 card
->perf_stats
.inbound_cnt
++;
2990 card
->perf_stats
.inbound_start_time
= qeth_get_micros();
2992 if (qdio_err
& QDIO_ERROR_ACTIVATE_CHECK_CONDITION
) {
2993 QETH_DBF_TEXT(TRACE
, 1, "qdinchk");
2994 QETH_DBF_TEXT_(TRACE
, 1, "%s", CARD_BUS_ID(card
));
2995 QETH_DBF_TEXT_(TRACE
, 1, "%04X%04X",
2996 first_element
, count
);
2997 QETH_DBF_TEXT_(TRACE
, 1, "%04X", queue
);
2998 qeth_schedule_recovery(card
);
3001 for (i
= first_element
; i
< (first_element
+ count
); ++i
) {
3002 index
= i
% QDIO_MAX_BUFFERS_PER_Q
;
3003 buffer
= &card
->qdio
.in_q
->bufs
[index
];
3005 qeth_check_qdio_errors(buffer
->buffer
,
3006 qdio_err
, "qinerr")))
3007 qeth_l3_process_inbound_buffer(card
, buffer
, index
);
3008 /* clear buffer and give back to hardware */
3009 qeth_put_buffer_pool_entry(card
, buffer
->pool_entry
);
3010 qeth_queue_input_buffer(card
, index
);
3012 if (card
->options
.performance_stats
)
3013 card
->perf_stats
.inbound_time
+= qeth_get_micros() -
3014 card
->perf_stats
.inbound_start_time
;
3017 static int qeth_l3_probe_device(struct ccwgroup_device
*gdev
)
3019 struct qeth_card
*card
= dev_get_drvdata(&gdev
->dev
);
3021 qeth_l3_create_device_attributes(&gdev
->dev
);
3022 card
->options
.layer2
= 0;
3023 card
->discipline
.input_handler
= (qdio_handler_t
*)
3024 qeth_l3_qdio_input_handler
;
3025 card
->discipline
.output_handler
= (qdio_handler_t
*)
3026 qeth_qdio_output_handler
;
3027 card
->discipline
.recover
= qeth_l3_recover
;
3031 static void qeth_l3_remove_device(struct ccwgroup_device
*cgdev
)
3033 struct qeth_card
*card
= dev_get_drvdata(&cgdev
->dev
);
3035 wait_event(card
->wait_q
, qeth_threads_running(card
, 0xffffffff) == 0);
3037 if (cgdev
->state
== CCWGROUP_ONLINE
) {
3038 card
->use_hard_stop
= 1;
3039 qeth_l3_set_offline(cgdev
);
3043 unregister_netdev(card
->dev
);
3047 qeth_l3_remove_device_attributes(&cgdev
->dev
);
3048 qeth_l3_clear_ip_list(card
, 0, 0);
3049 qeth_l3_clear_ipato_list(card
);
3053 static int __qeth_l3_set_online(struct ccwgroup_device
*gdev
, int recovery_mode
)
3055 struct qeth_card
*card
= dev_get_drvdata(&gdev
->dev
);
3057 enum qeth_card_states recover_flag
;
3060 QETH_DBF_TEXT(SETUP
, 2, "setonlin");
3061 QETH_DBF_HEX(SETUP
, 2, &card
, sizeof(void *));
3063 qeth_set_allowed_threads(card
, QETH_RECOVER_THREAD
, 1);
3065 recover_flag
= card
->state
;
3066 rc
= ccw_device_set_online(CARD_RDEV(card
));
3068 QETH_DBF_TEXT_(SETUP
, 2, "1err%d", rc
);
3071 rc
= ccw_device_set_online(CARD_WDEV(card
));
3073 QETH_DBF_TEXT_(SETUP
, 2, "1err%d", rc
);
3076 rc
= ccw_device_set_online(CARD_DDEV(card
));
3078 QETH_DBF_TEXT_(SETUP
, 2, "1err%d", rc
);
3082 rc
= qeth_core_hardsetup_card(card
);
3084 QETH_DBF_TEXT_(SETUP
, 2, "2err%d", rc
);
3088 qeth_l3_query_ipassists(card
, QETH_PROT_IPV4
);
3090 if (!card
->dev
&& qeth_l3_setup_netdev(card
))
3093 card
->state
= CARD_STATE_HARDSETUP
;
3094 qeth_print_status_message(card
);
3097 QETH_DBF_TEXT(SETUP
, 2, "softsetp");
3099 rc
= qeth_send_startlan(card
);
3101 QETH_DBF_TEXT_(SETUP
, 2, "1err%d", rc
);
3103 dev_warn(&card
->gdev
->dev
,
3104 "The LAN is offline\n");
3105 card
->lan_online
= 0;
3109 card
->lan_online
= 1;
3110 qeth_set_large_send(card
, card
->options
.large_send
);
3112 rc
= qeth_l3_setadapter_parms(card
);
3114 QETH_DBF_TEXT_(SETUP
, 2, "2err%d", rc
);
3115 rc
= qeth_l3_start_ipassists(card
);
3117 QETH_DBF_TEXT_(SETUP
, 2, "3err%d", rc
);
3118 rc
= qeth_l3_setrouting_v4(card
);
3120 QETH_DBF_TEXT_(SETUP
, 2, "4err%d", rc
);
3121 rc
= qeth_l3_setrouting_v6(card
);
3123 QETH_DBF_TEXT_(SETUP
, 2, "5err%d", rc
);
3124 netif_tx_disable(card
->dev
);
3126 rc
= qeth_init_qdio_queues(card
);
3128 QETH_DBF_TEXT_(SETUP
, 2, "6err%d", rc
);
3131 card
->state
= CARD_STATE_SOFTSETUP
;
3132 netif_carrier_on(card
->dev
);
3134 qeth_set_allowed_threads(card
, 0xffffffff, 0);
3135 if (recover_flag
== CARD_STATE_RECOVER
) {
3137 qeth_l3_open(card
->dev
);
3140 dev_open(card
->dev
);
3143 qeth_l3_set_multicast_list(card
->dev
);
3145 /* let user_space know that device is online */
3146 kobject_uevent(&gdev
->dev
.kobj
, KOBJ_CHANGE
);
3149 card
->use_hard_stop
= 1;
3150 qeth_l3_stop_card(card
, 0);
3151 ccw_device_set_offline(CARD_DDEV(card
));
3152 ccw_device_set_offline(CARD_WDEV(card
));
3153 ccw_device_set_offline(CARD_RDEV(card
));
3154 if (recover_flag
== CARD_STATE_RECOVER
)
3155 card
->state
= CARD_STATE_RECOVER
;
3157 card
->state
= CARD_STATE_DOWN
;
3161 static int qeth_l3_set_online(struct ccwgroup_device
*gdev
)
3163 return __qeth_l3_set_online(gdev
, 0);
3166 static int __qeth_l3_set_offline(struct ccwgroup_device
*cgdev
,
3169 struct qeth_card
*card
= dev_get_drvdata(&cgdev
->dev
);
3170 int rc
= 0, rc2
= 0, rc3
= 0;
3171 enum qeth_card_states recover_flag
;
3173 QETH_DBF_TEXT(SETUP
, 3, "setoffl");
3174 QETH_DBF_HEX(SETUP
, 3, &card
, sizeof(void *));
3176 if (card
->dev
&& netif_carrier_ok(card
->dev
))
3177 netif_carrier_off(card
->dev
);
3178 recover_flag
= card
->state
;
3179 qeth_l3_stop_card(card
, recovery_mode
);
3180 rc
= ccw_device_set_offline(CARD_DDEV(card
));
3181 rc2
= ccw_device_set_offline(CARD_WDEV(card
));
3182 rc3
= ccw_device_set_offline(CARD_RDEV(card
));
3184 rc
= (rc2
) ? rc2
: rc3
;
3186 QETH_DBF_TEXT_(SETUP
, 2, "1err%d", rc
);
3187 if (recover_flag
== CARD_STATE_UP
)
3188 card
->state
= CARD_STATE_RECOVER
;
3189 /* let user_space know that device is offline */
3190 kobject_uevent(&cgdev
->dev
.kobj
, KOBJ_CHANGE
);
3194 static int qeth_l3_set_offline(struct ccwgroup_device
*cgdev
)
3196 return __qeth_l3_set_offline(cgdev
, 0);
3199 static int qeth_l3_recover(void *ptr
)
3201 struct qeth_card
*card
;
3204 card
= (struct qeth_card
*) ptr
;
3205 QETH_DBF_TEXT(TRACE
, 2, "recover1");
3206 QETH_DBF_HEX(TRACE
, 2, &card
, sizeof(void *));
3207 if (!qeth_do_run_thread(card
, QETH_RECOVER_THREAD
))
3209 QETH_DBF_TEXT(TRACE
, 2, "recover2");
3210 dev_warn(&card
->gdev
->dev
,
3211 "A recovery process has been started for the device\n");
3212 card
->use_hard_stop
= 1;
3213 __qeth_l3_set_offline(card
->gdev
, 1);
3214 rc
= __qeth_l3_set_online(card
->gdev
, 1);
3215 /* don't run another scheduled recovery */
3216 qeth_clear_thread_start_bit(card
, QETH_RECOVER_THREAD
);
3217 qeth_clear_thread_running_bit(card
, QETH_RECOVER_THREAD
);
3219 dev_info(&card
->gdev
->dev
,
3220 "Device successfully recovered!\n");
3223 dev_close(card
->dev
);
3225 dev_warn(&card
->gdev
->dev
, "The qeth device driver "
3226 "failed to recover an error on the device\n");
3231 static void qeth_l3_shutdown(struct ccwgroup_device
*gdev
)
3233 struct qeth_card
*card
= dev_get_drvdata(&gdev
->dev
);
3234 qeth_l3_clear_ip_list(card
, 0, 0);
3235 qeth_qdio_clear_card(card
, 0);
3236 qeth_clear_qdio_buffers(card
);
3239 struct ccwgroup_driver qeth_l3_ccwgroup_driver
= {
3240 .probe
= qeth_l3_probe_device
,
3241 .remove
= qeth_l3_remove_device
,
3242 .set_online
= qeth_l3_set_online
,
3243 .set_offline
= qeth_l3_set_offline
,
3244 .shutdown
= qeth_l3_shutdown
,
3246 EXPORT_SYMBOL_GPL(qeth_l3_ccwgroup_driver
);
3248 static int qeth_l3_ip_event(struct notifier_block
*this,
3249 unsigned long event
, void *ptr
)
3251 struct in_ifaddr
*ifa
= (struct in_ifaddr
*)ptr
;
3252 struct net_device
*dev
= (struct net_device
*)ifa
->ifa_dev
->dev
;
3253 struct qeth_ipaddr
*addr
;
3254 struct qeth_card
*card
;
3256 if (dev_net(dev
) != &init_net
)
3259 QETH_DBF_TEXT(TRACE
, 3, "ipevent");
3260 card
= qeth_l3_get_card_from_dev(dev
);
3264 addr
= qeth_l3_get_addr_buffer(QETH_PROT_IPV4
);
3266 addr
->u
.a4
.addr
= ifa
->ifa_address
;
3267 addr
->u
.a4
.mask
= ifa
->ifa_mask
;
3268 addr
->type
= QETH_IP_TYPE_NORMAL
;
3274 if (!qeth_l3_add_ip(card
, addr
))
3278 if (!qeth_l3_delete_ip(card
, addr
))
3284 qeth_l3_set_ip_addr_list(card
);
3289 static struct notifier_block qeth_l3_ip_notifier
= {
3294 #ifdef CONFIG_QETH_IPV6
3296 * IPv6 event handler
3298 static int qeth_l3_ip6_event(struct notifier_block
*this,
3299 unsigned long event
, void *ptr
)
3301 struct inet6_ifaddr
*ifa
= (struct inet6_ifaddr
*)ptr
;
3302 struct net_device
*dev
= (struct net_device
*)ifa
->idev
->dev
;
3303 struct qeth_ipaddr
*addr
;
3304 struct qeth_card
*card
;
3306 QETH_DBF_TEXT(TRACE
, 3, "ip6event");
3308 card
= qeth_l3_get_card_from_dev(dev
);
3311 if (!qeth_is_supported(card
, IPA_IPV6
))
3314 addr
= qeth_l3_get_addr_buffer(QETH_PROT_IPV6
);
3316 memcpy(&addr
->u
.a6
.addr
, &ifa
->addr
, sizeof(struct in6_addr
));
3317 addr
->u
.a6
.pfxlen
= ifa
->prefix_len
;
3318 addr
->type
= QETH_IP_TYPE_NORMAL
;
3324 if (!qeth_l3_add_ip(card
, addr
))
3328 if (!qeth_l3_delete_ip(card
, addr
))
3334 qeth_l3_set_ip_addr_list(card
);
3339 static struct notifier_block qeth_l3_ip6_notifier
= {
3345 static int qeth_l3_register_notifiers(void)
3349 QETH_DBF_TEXT(TRACE
, 5, "regnotif");
3350 rc
= register_inetaddr_notifier(&qeth_l3_ip_notifier
);
3353 #ifdef CONFIG_QETH_IPV6
3354 rc
= register_inet6addr_notifier(&qeth_l3_ip6_notifier
);
3356 unregister_inetaddr_notifier(&qeth_l3_ip_notifier
);
3360 pr_warning("There is no IPv6 support for the layer 3 discipline\n");
3365 static void qeth_l3_unregister_notifiers(void)
3368 QETH_DBF_TEXT(TRACE
, 5, "unregnot");
3369 BUG_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier
));
3370 #ifdef CONFIG_QETH_IPV6
3371 BUG_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier
));
3372 #endif /* QETH_IPV6 */
3375 static int __init
qeth_l3_init(void)
3379 pr_info("register layer 3 discipline\n");
3380 rc
= qeth_l3_register_notifiers();
3384 static void __exit
qeth_l3_exit(void)
3386 qeth_l3_unregister_notifiers();
3387 pr_info("unregister layer 3 discipline\n");
3390 module_init(qeth_l3_init
);
3391 module_exit(qeth_l3_exit
);
3392 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
3393 MODULE_DESCRIPTION("qeth layer 3 discipline");
3394 MODULE_LICENSE("GPL");