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>
29 #include <asm/s390_rdev.h>
32 #include "qeth_core_offl.h"
34 static int qeth_l3_set_offline(struct ccwgroup_device *);
35 static int qeth_l3_recover(void *);
36 static int qeth_l3_stop(struct net_device *);
37 static void qeth_l3_set_multicast_list(struct net_device *);
38 static int qeth_l3_neigh_setup(struct net_device *, struct neigh_parms *);
39 static int qeth_l3_register_addr_entry(struct qeth_card *,
40 struct qeth_ipaddr *);
41 static int qeth_l3_deregister_addr_entry(struct qeth_card *,
42 struct qeth_ipaddr *);
43 static int __qeth_l3_set_online(struct ccwgroup_device *, int);
44 static int __qeth_l3_set_offline(struct ccwgroup_device *, int);
47 static int qeth_l3_isxdigit(char *buf)
50 if (!isxdigit(*buf++))
56 void qeth_l3_ipaddr4_to_string(const __u8 *addr, char *buf)
58 sprintf(buf, "%i.%i.%i.%i", addr[0], addr[1], addr[2], addr[3]);
61 int qeth_l3_string_to_ipaddr4(const char *buf, __u8 *addr)
63 int count = 0, rc = 0;
67 rc = sscanf(buf, "%u.%u.%u.%u%c",
68 &in[0], &in[1], &in[2], &in[3], &c);
69 if (rc != 4 && (rc != 5 || c != '\n'))
71 for (count = 0; count < 4; count++) {
74 addr[count] = in[count];
79 void qeth_l3_ipaddr6_to_string(const __u8 *addr, char *buf)
81 sprintf(buf, "%02x%02x:%02x%02x:%02x%02x:%02x%02x"
82 ":%02x%02x:%02x%02x:%02x%02x:%02x%02x",
83 addr[0], addr[1], addr[2], addr[3],
84 addr[4], addr[5], addr[6], addr[7],
85 addr[8], addr[9], addr[10], addr[11],
86 addr[12], addr[13], addr[14], addr[15]);
89 int qeth_l3_string_to_ipaddr6(const char *buf, __u8 *addr)
91 const char *end, *end_tmp, *start;
94 int num2, cnt, out, found, save_cnt;
95 unsigned short in_tmp[8] = {0, };
97 cnt = out = found = save_cnt = num2 = 0;
102 end = strchr(start, ':');
104 end = buf + strlen(buf);
105 end_tmp = strchr(start, '\n');
112 if ((end - start) > 4)
114 memcpy(num, start, end - start);
115 if (!qeth_l3_isxdigit(num))
117 sscanf(start, "%x", &num2);
119 in_tmp[save_cnt++] = num2;
131 if (cnt + save_cnt > 8)
135 in[cnt--] = in_tmp[--save_cnt];
139 void qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto, const __u8 *addr,
142 if (proto == QETH_PROT_IPV4)
143 qeth_l3_ipaddr4_to_string(addr, buf);
144 else if (proto == QETH_PROT_IPV6)
145 qeth_l3_ipaddr6_to_string(addr, buf);
148 int qeth_l3_string_to_ipaddr(const char *buf, enum qeth_prot_versions proto,
151 if (proto == QETH_PROT_IPV4)
152 return qeth_l3_string_to_ipaddr4(buf, addr);
153 else if (proto == QETH_PROT_IPV6)
154 return qeth_l3_string_to_ipaddr6(buf, addr);
159 static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
164 for (i = 0; i < len; ++i) {
166 for (j = 7; j >= 0; --j) {
167 bits[i*8 + j] = octet & 1;
173 static int qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
174 struct qeth_ipaddr *addr)
176 struct qeth_ipato_entry *ipatoe;
177 u8 addr_bits[128] = {0, };
178 u8 ipatoe_bits[128] = {0, };
181 if (!card->ipato.enabled)
184 qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits,
185 (addr->proto == QETH_PROT_IPV4)? 4:16);
186 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
187 if (addr->proto != ipatoe->proto)
189 qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits,
190 (ipatoe->proto == QETH_PROT_IPV4) ?
192 if (addr->proto == QETH_PROT_IPV4)
193 rc = !memcmp(addr_bits, ipatoe_bits,
194 min(32, ipatoe->mask_bits));
196 rc = !memcmp(addr_bits, ipatoe_bits,
197 min(128, ipatoe->mask_bits));
202 if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
204 else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
211 * Add IP to be added to todo list. If there is already an "add todo"
212 * in this list we just incremenent the reference count.
213 * Returns 0 if we just incremented reference count.
215 static int __qeth_l3_insert_ip_todo(struct qeth_card *card,
216 struct qeth_ipaddr *addr, int add)
218 struct qeth_ipaddr *tmp, *t;
221 list_for_each_entry_safe(tmp, t, card->ip_tbd_list, entry) {
222 if ((addr->type == QETH_IP_TYPE_DEL_ALL_MC) &&
223 (tmp->type == QETH_IP_TYPE_DEL_ALL_MC))
225 if ((tmp->proto == QETH_PROT_IPV4) &&
226 (addr->proto == QETH_PROT_IPV4) &&
227 (tmp->type == addr->type) &&
228 (tmp->is_multicast == addr->is_multicast) &&
229 (tmp->u.a4.addr == addr->u.a4.addr) &&
230 (tmp->u.a4.mask == addr->u.a4.mask)) {
234 if ((tmp->proto == QETH_PROT_IPV6) &&
235 (addr->proto == QETH_PROT_IPV6) &&
236 (tmp->type == addr->type) &&
237 (tmp->is_multicast == addr->is_multicast) &&
238 (tmp->u.a6.pfxlen == addr->u.a6.pfxlen) &&
239 (memcmp(&tmp->u.a6.addr, &addr->u.a6.addr,
240 sizeof(struct in6_addr)) == 0)) {
246 if (addr->users != 0)
247 tmp->users += addr->users;
249 tmp->users += add ? 1 : -1;
250 if (tmp->users == 0) {
251 list_del(&tmp->entry);
256 if (addr->type == QETH_IP_TYPE_DEL_ALL_MC)
257 list_add(&addr->entry, card->ip_tbd_list);
259 if (addr->users == 0)
260 addr->users += add ? 1 : -1;
261 if (add && (addr->type == QETH_IP_TYPE_NORMAL) &&
262 qeth_l3_is_addr_covered_by_ipato(card, addr)) {
263 QETH_DBF_TEXT(TRACE, 2, "tkovaddr");
264 addr->set_flags |= QETH_IPA_SETIP_TAKEOVER_FLAG;
266 list_add_tail(&addr->entry, card->ip_tbd_list);
272 static int qeth_l3_delete_ip(struct qeth_card *card, struct qeth_ipaddr *addr)
277 QETH_DBF_TEXT(TRACE, 4, "delip");
279 if (addr->proto == QETH_PROT_IPV4)
280 QETH_DBF_HEX(TRACE, 4, &addr->u.a4.addr, 4);
282 QETH_DBF_HEX(TRACE, 4, &addr->u.a6.addr, 8);
283 QETH_DBF_HEX(TRACE, 4, ((char *)&addr->u.a6.addr) + 8, 8);
285 spin_lock_irqsave(&card->ip_lock, flags);
286 rc = __qeth_l3_insert_ip_todo(card, addr, 0);
287 spin_unlock_irqrestore(&card->ip_lock, flags);
291 static int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *addr)
296 QETH_DBF_TEXT(TRACE, 4, "addip");
297 if (addr->proto == QETH_PROT_IPV4)
298 QETH_DBF_HEX(TRACE, 4, &addr->u.a4.addr, 4);
300 QETH_DBF_HEX(TRACE, 4, &addr->u.a6.addr, 8);
301 QETH_DBF_HEX(TRACE, 4, ((char *)&addr->u.a6.addr) + 8, 8);
303 spin_lock_irqsave(&card->ip_lock, flags);
304 rc = __qeth_l3_insert_ip_todo(card, addr, 1);
305 spin_unlock_irqrestore(&card->ip_lock, flags);
310 static struct qeth_ipaddr *qeth_l3_get_addr_buffer(
311 enum qeth_prot_versions prot)
313 struct qeth_ipaddr *addr;
315 addr = kzalloc(sizeof(struct qeth_ipaddr), GFP_ATOMIC);
319 addr->type = QETH_IP_TYPE_NORMAL;
324 static void qeth_l3_delete_mc_addresses(struct qeth_card *card)
326 struct qeth_ipaddr *iptodo;
329 QETH_DBF_TEXT(TRACE, 4, "delmc");
330 iptodo = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
332 QETH_DBF_TEXT(TRACE, 2, "dmcnomem");
335 iptodo->type = QETH_IP_TYPE_DEL_ALL_MC;
336 spin_lock_irqsave(&card->ip_lock, flags);
337 if (!__qeth_l3_insert_ip_todo(card, iptodo, 0))
339 spin_unlock_irqrestore(&card->ip_lock, flags);
343 * Add/remove address to/from card's ip list, i.e. try to add or remove
344 * reference to/from an IP address that is already registered on the card.
346 * 0 address was on card and its reference count has been adjusted,
347 * but is still > 0, so nothing has to be done
348 * also returns 0 if card was not on card and the todo was to delete
349 * the address -> there is also nothing to be done
350 * 1 address was not on card and the todo is to add it to the card's ip
352 * -1 address was on card and its reference count has been decremented
353 * to <= 0 by the todo -> address must be removed from card
355 static int __qeth_l3_ref_ip_on_card(struct qeth_card *card,
356 struct qeth_ipaddr *todo, struct qeth_ipaddr **__addr)
358 struct qeth_ipaddr *addr;
361 list_for_each_entry(addr, &card->ip_list, entry) {
362 if ((addr->proto == QETH_PROT_IPV4) &&
363 (todo->proto == QETH_PROT_IPV4) &&
364 (addr->type == todo->type) &&
365 (addr->u.a4.addr == todo->u.a4.addr) &&
366 (addr->u.a4.mask == todo->u.a4.mask)) {
370 if ((addr->proto == QETH_PROT_IPV6) &&
371 (todo->proto == QETH_PROT_IPV6) &&
372 (addr->type == todo->type) &&
373 (addr->u.a6.pfxlen == todo->u.a6.pfxlen) &&
374 (memcmp(&addr->u.a6.addr, &todo->u.a6.addr,
375 sizeof(struct in6_addr)) == 0)) {
381 addr->users += todo->users;
382 if (addr->users <= 0) {
386 /* for VIPA and RXIP limit refcount to 1 */
387 if (addr->type != QETH_IP_TYPE_NORMAL)
392 if (todo->users > 0) {
393 /* for VIPA and RXIP limit refcount to 1 */
394 if (todo->type != QETH_IP_TYPE_NORMAL)
401 static void __qeth_l3_delete_all_mc(struct qeth_card *card,
402 unsigned long *flags)
404 struct list_head fail_list;
405 struct qeth_ipaddr *addr, *tmp;
408 INIT_LIST_HEAD(&fail_list);
410 list_for_each_entry_safe(addr, tmp, &card->ip_list, entry) {
411 if (addr->is_multicast) {
412 list_del(&addr->entry);
413 spin_unlock_irqrestore(&card->ip_lock, *flags);
414 rc = qeth_l3_deregister_addr_entry(card, addr);
415 spin_lock_irqsave(&card->ip_lock, *flags);
416 if (!rc || (rc == IPA_RC_MC_ADDR_NOT_FOUND))
419 list_add_tail(&addr->entry, &fail_list);
423 list_splice(&fail_list, &card->ip_list);
426 static void qeth_l3_set_ip_addr_list(struct qeth_card *card)
428 struct list_head *tbd_list;
429 struct qeth_ipaddr *todo, *addr;
433 QETH_DBF_TEXT(TRACE, 2, "sdiplist");
434 QETH_DBF_HEX(TRACE, 2, &card, sizeof(void *));
436 spin_lock_irqsave(&card->ip_lock, flags);
437 tbd_list = card->ip_tbd_list;
438 card->ip_tbd_list = kmalloc(sizeof(struct list_head), GFP_ATOMIC);
439 if (!card->ip_tbd_list) {
440 QETH_DBF_TEXT(TRACE, 0, "silnomem");
441 card->ip_tbd_list = tbd_list;
442 spin_unlock_irqrestore(&card->ip_lock, flags);
445 INIT_LIST_HEAD(card->ip_tbd_list);
447 while (!list_empty(tbd_list)) {
448 todo = list_entry(tbd_list->next, struct qeth_ipaddr, entry);
449 list_del(&todo->entry);
450 if (todo->type == QETH_IP_TYPE_DEL_ALL_MC) {
451 __qeth_l3_delete_all_mc(card, &flags);
455 rc = __qeth_l3_ref_ip_on_card(card, todo, &addr);
457 /* nothing to be done; only adjusted refcount */
459 } else if (rc == 1) {
460 /* new entry to be added to on-card list */
461 spin_unlock_irqrestore(&card->ip_lock, flags);
462 rc = qeth_l3_register_addr_entry(card, todo);
463 spin_lock_irqsave(&card->ip_lock, flags);
464 if (!rc || (rc == IPA_RC_LAN_OFFLINE))
465 list_add_tail(&todo->entry, &card->ip_list);
468 } else if (rc == -1) {
469 /* on-card entry to be removed */
470 list_del_init(&addr->entry);
471 spin_unlock_irqrestore(&card->ip_lock, flags);
472 rc = qeth_l3_deregister_addr_entry(card, addr);
473 spin_lock_irqsave(&card->ip_lock, flags);
474 if (!rc || (rc == IPA_RC_PRIMARY_ALREADY_DEFINED))
477 list_add_tail(&addr->entry, &card->ip_list);
481 spin_unlock_irqrestore(&card->ip_lock, flags);
485 static void qeth_l3_clear_ip_list(struct qeth_card *card, int clean,
488 struct qeth_ipaddr *addr, *tmp;
491 QETH_DBF_TEXT(TRACE, 4, "clearip");
492 spin_lock_irqsave(&card->ip_lock, flags);
493 /* clear todo list */
494 list_for_each_entry_safe(addr, tmp, card->ip_tbd_list, entry) {
495 list_del(&addr->entry);
499 while (!list_empty(&card->ip_list)) {
500 addr = list_entry(card->ip_list.next,
501 struct qeth_ipaddr, entry);
502 list_del_init(&addr->entry);
504 spin_unlock_irqrestore(&card->ip_lock, flags);
505 qeth_l3_deregister_addr_entry(card, addr);
506 spin_lock_irqsave(&card->ip_lock, flags);
508 if (!recover || addr->is_multicast) {
512 list_add_tail(&addr->entry, card->ip_tbd_list);
514 spin_unlock_irqrestore(&card->ip_lock, flags);
517 static int qeth_l3_address_exists_in_list(struct list_head *list,
518 struct qeth_ipaddr *addr, int same_type)
520 struct qeth_ipaddr *tmp;
522 list_for_each_entry(tmp, list, entry) {
523 if ((tmp->proto == QETH_PROT_IPV4) &&
524 (addr->proto == QETH_PROT_IPV4) &&
525 ((same_type && (tmp->type == addr->type)) ||
526 (!same_type && (tmp->type != addr->type))) &&
527 (tmp->u.a4.addr == addr->u.a4.addr))
530 if ((tmp->proto == QETH_PROT_IPV6) &&
531 (addr->proto == QETH_PROT_IPV6) &&
532 ((same_type && (tmp->type == addr->type)) ||
533 (!same_type && (tmp->type != addr->type))) &&
534 (memcmp(&tmp->u.a6.addr, &addr->u.a6.addr,
535 sizeof(struct in6_addr)) == 0))
542 static int qeth_l3_send_setdelmc(struct qeth_card *card,
543 struct qeth_ipaddr *addr, int ipacmd)
546 struct qeth_cmd_buffer *iob;
547 struct qeth_ipa_cmd *cmd;
549 QETH_DBF_TEXT(TRACE, 4, "setdelmc");
551 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
552 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
553 memcpy(&cmd->data.setdelipm.mac, addr->mac, OSA_ADDR_LEN);
554 if (addr->proto == QETH_PROT_IPV6)
555 memcpy(cmd->data.setdelipm.ip6, &addr->u.a6.addr,
556 sizeof(struct in6_addr));
558 memcpy(&cmd->data.setdelipm.ip4, &addr->u.a4.addr, 4);
560 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
565 static void qeth_l3_fill_netmask(u8 *netmask, unsigned int len)
568 for (i = 0; i < 16; i++) {
573 netmask[i] = (u8)(0xFF00 >> j);
579 static int qeth_l3_send_setdelip(struct qeth_card *card,
580 struct qeth_ipaddr *addr, int ipacmd, unsigned int flags)
583 struct qeth_cmd_buffer *iob;
584 struct qeth_ipa_cmd *cmd;
587 QETH_DBF_TEXT(TRACE, 4, "setdelip");
588 QETH_DBF_TEXT_(TRACE, 4, "flags%02X", flags);
590 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
591 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
592 if (addr->proto == QETH_PROT_IPV6) {
593 memcpy(cmd->data.setdelip6.ip_addr, &addr->u.a6.addr,
594 sizeof(struct in6_addr));
595 qeth_l3_fill_netmask(netmask, addr->u.a6.pfxlen);
596 memcpy(cmd->data.setdelip6.mask, netmask,
597 sizeof(struct in6_addr));
598 cmd->data.setdelip6.flags = flags;
600 memcpy(cmd->data.setdelip4.ip_addr, &addr->u.a4.addr, 4);
601 memcpy(cmd->data.setdelip4.mask, &addr->u.a4.mask, 4);
602 cmd->data.setdelip4.flags = flags;
605 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
610 static int qeth_l3_send_setrouting(struct qeth_card *card,
611 enum qeth_routing_types type, enum qeth_prot_versions prot)
614 struct qeth_ipa_cmd *cmd;
615 struct qeth_cmd_buffer *iob;
617 QETH_DBF_TEXT(TRACE, 4, "setroutg");
618 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETRTG, prot);
619 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
620 cmd->data.setrtg.type = (type);
621 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
626 static void qeth_l3_correct_routing_type(struct qeth_card *card,
627 enum qeth_routing_types *type, enum qeth_prot_versions prot)
629 if (card->info.type == QETH_CARD_TYPE_IQD) {
632 case PRIMARY_CONNECTOR:
633 case SECONDARY_CONNECTOR:
634 case MULTICAST_ROUTER:
643 case SECONDARY_ROUTER:
645 case MULTICAST_ROUTER:
646 if (qeth_is_ipafunc_supported(card, prot,
657 int qeth_l3_setrouting_v4(struct qeth_card *card)
661 QETH_DBF_TEXT(TRACE, 3, "setrtg4");
663 qeth_l3_correct_routing_type(card, &card->options.route4.type,
666 rc = qeth_l3_send_setrouting(card, card->options.route4.type,
669 card->options.route4.type = NO_ROUTER;
670 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
671 " on %s. Type set to 'no router'.\n", rc,
672 QETH_CARD_IFNAME(card));
677 int qeth_l3_setrouting_v6(struct qeth_card *card)
681 QETH_DBF_TEXT(TRACE, 3, "setrtg6");
682 #ifdef CONFIG_QETH_IPV6
684 if (!qeth_is_supported(card, IPA_IPV6))
686 qeth_l3_correct_routing_type(card, &card->options.route6.type,
689 rc = qeth_l3_send_setrouting(card, card->options.route6.type,
692 card->options.route6.type = NO_ROUTER;
693 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
694 " on %s. Type set to 'no router'.\n", rc,
695 QETH_CARD_IFNAME(card));
702 * IP address takeover related functions
704 static void qeth_l3_clear_ipato_list(struct qeth_card *card)
707 struct qeth_ipato_entry *ipatoe, *tmp;
710 spin_lock_irqsave(&card->ip_lock, flags);
711 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
712 list_del(&ipatoe->entry);
715 spin_unlock_irqrestore(&card->ip_lock, flags);
718 int qeth_l3_add_ipato_entry(struct qeth_card *card,
719 struct qeth_ipato_entry *new)
721 struct qeth_ipato_entry *ipatoe;
725 QETH_DBF_TEXT(TRACE, 2, "addipato");
726 spin_lock_irqsave(&card->ip_lock, flags);
727 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
728 if (ipatoe->proto != new->proto)
730 if (!memcmp(ipatoe->addr, new->addr,
731 (ipatoe->proto == QETH_PROT_IPV4)? 4:16) &&
732 (ipatoe->mask_bits == new->mask_bits)) {
738 list_add_tail(&new->entry, &card->ipato.entries);
740 spin_unlock_irqrestore(&card->ip_lock, flags);
744 void qeth_l3_del_ipato_entry(struct qeth_card *card,
745 enum qeth_prot_versions proto, u8 *addr, int mask_bits)
747 struct qeth_ipato_entry *ipatoe, *tmp;
750 QETH_DBF_TEXT(TRACE, 2, "delipato");
751 spin_lock_irqsave(&card->ip_lock, flags);
752 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
753 if (ipatoe->proto != proto)
755 if (!memcmp(ipatoe->addr, addr,
756 (proto == QETH_PROT_IPV4)? 4:16) &&
757 (ipatoe->mask_bits == mask_bits)) {
758 list_del(&ipatoe->entry);
762 spin_unlock_irqrestore(&card->ip_lock, flags);
766 * VIPA related functions
768 int qeth_l3_add_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
771 struct qeth_ipaddr *ipaddr;
775 ipaddr = qeth_l3_get_addr_buffer(proto);
777 if (proto == QETH_PROT_IPV4) {
778 QETH_DBF_TEXT(TRACE, 2, "addvipa4");
779 memcpy(&ipaddr->u.a4.addr, addr, 4);
780 ipaddr->u.a4.mask = 0;
781 } else if (proto == QETH_PROT_IPV6) {
782 QETH_DBF_TEXT(TRACE, 2, "addvipa6");
783 memcpy(&ipaddr->u.a6.addr, addr, 16);
784 ipaddr->u.a6.pfxlen = 0;
786 ipaddr->type = QETH_IP_TYPE_VIPA;
787 ipaddr->set_flags = QETH_IPA_SETIP_VIPA_FLAG;
788 ipaddr->del_flags = QETH_IPA_DELIP_VIPA_FLAG;
791 spin_lock_irqsave(&card->ip_lock, flags);
792 if (qeth_l3_address_exists_in_list(&card->ip_list, ipaddr, 0) ||
793 qeth_l3_address_exists_in_list(card->ip_tbd_list, ipaddr, 0))
795 spin_unlock_irqrestore(&card->ip_lock, flags);
799 if (!qeth_l3_add_ip(card, ipaddr))
801 qeth_l3_set_ip_addr_list(card);
805 void qeth_l3_del_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
808 struct qeth_ipaddr *ipaddr;
810 ipaddr = qeth_l3_get_addr_buffer(proto);
812 if (proto == QETH_PROT_IPV4) {
813 QETH_DBF_TEXT(TRACE, 2, "delvipa4");
814 memcpy(&ipaddr->u.a4.addr, addr, 4);
815 ipaddr->u.a4.mask = 0;
816 } else if (proto == QETH_PROT_IPV6) {
817 QETH_DBF_TEXT(TRACE, 2, "delvipa6");
818 memcpy(&ipaddr->u.a6.addr, addr, 16);
819 ipaddr->u.a6.pfxlen = 0;
821 ipaddr->type = QETH_IP_TYPE_VIPA;
824 if (!qeth_l3_delete_ip(card, ipaddr))
826 qeth_l3_set_ip_addr_list(card);
830 * proxy ARP related functions
832 int qeth_l3_add_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
835 struct qeth_ipaddr *ipaddr;
839 ipaddr = qeth_l3_get_addr_buffer(proto);
841 if (proto == QETH_PROT_IPV4) {
842 QETH_DBF_TEXT(TRACE, 2, "addrxip4");
843 memcpy(&ipaddr->u.a4.addr, addr, 4);
844 ipaddr->u.a4.mask = 0;
845 } else if (proto == QETH_PROT_IPV6) {
846 QETH_DBF_TEXT(TRACE, 2, "addrxip6");
847 memcpy(&ipaddr->u.a6.addr, addr, 16);
848 ipaddr->u.a6.pfxlen = 0;
850 ipaddr->type = QETH_IP_TYPE_RXIP;
851 ipaddr->set_flags = QETH_IPA_SETIP_TAKEOVER_FLAG;
852 ipaddr->del_flags = 0;
855 spin_lock_irqsave(&card->ip_lock, flags);
856 if (qeth_l3_address_exists_in_list(&card->ip_list, ipaddr, 0) ||
857 qeth_l3_address_exists_in_list(card->ip_tbd_list, ipaddr, 0))
859 spin_unlock_irqrestore(&card->ip_lock, flags);
863 if (!qeth_l3_add_ip(card, ipaddr))
865 qeth_l3_set_ip_addr_list(card);
869 void qeth_l3_del_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
872 struct qeth_ipaddr *ipaddr;
874 ipaddr = qeth_l3_get_addr_buffer(proto);
876 if (proto == QETH_PROT_IPV4) {
877 QETH_DBF_TEXT(TRACE, 2, "addrxip4");
878 memcpy(&ipaddr->u.a4.addr, addr, 4);
879 ipaddr->u.a4.mask = 0;
880 } else if (proto == QETH_PROT_IPV6) {
881 QETH_DBF_TEXT(TRACE, 2, "addrxip6");
882 memcpy(&ipaddr->u.a6.addr, addr, 16);
883 ipaddr->u.a6.pfxlen = 0;
885 ipaddr->type = QETH_IP_TYPE_RXIP;
888 if (!qeth_l3_delete_ip(card, ipaddr))
890 qeth_l3_set_ip_addr_list(card);
893 static int qeth_l3_register_addr_entry(struct qeth_card *card,
894 struct qeth_ipaddr *addr)
900 if (addr->proto == QETH_PROT_IPV4) {
901 QETH_DBF_TEXT(TRACE, 2, "setaddr4");
902 QETH_DBF_HEX(TRACE, 3, &addr->u.a4.addr, sizeof(int));
903 } else if (addr->proto == QETH_PROT_IPV6) {
904 QETH_DBF_TEXT(TRACE, 2, "setaddr6");
905 QETH_DBF_HEX(TRACE, 3, &addr->u.a6.addr, 8);
906 QETH_DBF_HEX(TRACE, 3, ((char *)&addr->u.a6.addr) + 8, 8);
908 QETH_DBF_TEXT(TRACE, 2, "setaddr?");
909 QETH_DBF_HEX(TRACE, 3, addr, sizeof(struct qeth_ipaddr));
912 if (addr->is_multicast)
913 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
915 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP,
918 QETH_DBF_TEXT(TRACE, 2, "failed");
919 } while ((--cnt > 0) && rc);
921 QETH_DBF_TEXT(TRACE, 2, "FAILED");
922 qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
923 dev_warn(&card->gdev->dev,
924 "Registering IP address %s failed\n", buf);
929 static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
930 struct qeth_ipaddr *addr)
934 if (addr->proto == QETH_PROT_IPV4) {
935 QETH_DBF_TEXT(TRACE, 2, "deladdr4");
936 QETH_DBF_HEX(TRACE, 3, &addr->u.a4.addr, sizeof(int));
937 } else if (addr->proto == QETH_PROT_IPV6) {
938 QETH_DBF_TEXT(TRACE, 2, "deladdr6");
939 QETH_DBF_HEX(TRACE, 3, &addr->u.a6.addr, 8);
940 QETH_DBF_HEX(TRACE, 3, ((char *)&addr->u.a6.addr) + 8, 8);
942 QETH_DBF_TEXT(TRACE, 2, "deladdr?");
943 QETH_DBF_HEX(TRACE, 3, addr, sizeof(struct qeth_ipaddr));
945 if (addr->is_multicast)
946 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
948 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP,
951 QETH_DBF_TEXT(TRACE, 2, "failed");
956 static inline u8 qeth_l3_get_qeth_hdr_flags4(int cast_type)
958 if (cast_type == RTN_MULTICAST)
959 return QETH_CAST_MULTICAST;
960 if (cast_type == RTN_BROADCAST)
961 return QETH_CAST_BROADCAST;
962 return QETH_CAST_UNICAST;
965 static inline u8 qeth_l3_get_qeth_hdr_flags6(int cast_type)
967 u8 ct = QETH_HDR_PASSTHRU | QETH_HDR_IPV6;
968 if (cast_type == RTN_MULTICAST)
969 return ct | QETH_CAST_MULTICAST;
970 if (cast_type == RTN_ANYCAST)
971 return ct | QETH_CAST_ANYCAST;
972 if (cast_type == RTN_BROADCAST)
973 return ct | QETH_CAST_BROADCAST;
974 return ct | QETH_CAST_UNICAST;
977 static int qeth_l3_send_setadp_mode(struct qeth_card *card, __u32 command,
981 struct qeth_cmd_buffer *iob;
982 struct qeth_ipa_cmd *cmd;
984 QETH_DBF_TEXT(TRACE, 4, "adpmode");
986 iob = qeth_get_adapter_cmd(card, command,
987 sizeof(struct qeth_ipacmd_setadpparms));
988 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
989 cmd->data.setadapterparms.data.mode = mode;
990 rc = qeth_send_ipa_cmd(card, iob, qeth_default_setadapterparms_cb,
995 static int qeth_l3_setadapter_hstr(struct qeth_card *card)
999 QETH_DBF_TEXT(TRACE, 4, "adphstr");
1001 if (qeth_adp_supported(card, IPA_SETADP_SET_BROADCAST_MODE)) {
1002 rc = qeth_l3_send_setadp_mode(card,
1003 IPA_SETADP_SET_BROADCAST_MODE,
1004 card->options.broadcast_mode);
1006 QETH_DBF_MESSAGE(2, "couldn't set broadcast mode on "
1008 CARD_BUS_ID(card), rc);
1009 rc = qeth_l3_send_setadp_mode(card,
1010 IPA_SETADP_ALTER_MAC_ADDRESS,
1011 card->options.macaddr_mode);
1013 QETH_DBF_MESSAGE(2, "couldn't set macaddr mode on "
1014 "device %s: x%x\n", CARD_BUS_ID(card), rc);
1017 if (card->options.broadcast_mode == QETH_TR_BROADCAST_LOCAL)
1018 QETH_DBF_MESSAGE(2, "set adapter parameters not available "
1019 "to set broadcast mode, using ALLRINGS "
1020 "on device %s:\n", CARD_BUS_ID(card));
1021 if (card->options.macaddr_mode == QETH_TR_MACADDR_CANONICAL)
1022 QETH_DBF_MESSAGE(2, "set adapter parameters not available "
1023 "to set macaddr mode, using NONCANONICAL "
1024 "on device %s:\n", CARD_BUS_ID(card));
1028 static int qeth_l3_setadapter_parms(struct qeth_card *card)
1032 QETH_DBF_TEXT(SETUP, 2, "setadprm");
1034 if (!qeth_is_supported(card, IPA_SETADAPTERPARMS)) {
1035 dev_info(&card->gdev->dev,
1036 "set adapter parameters not supported.\n");
1037 QETH_DBF_TEXT(SETUP, 2, " notsupp");
1040 rc = qeth_query_setadapterparms(card);
1042 QETH_DBF_MESSAGE(2, "%s couldn't set adapter parameters: "
1043 "0x%x\n", card->gdev->dev.bus_id, rc);
1046 if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
1047 rc = qeth_setadpparms_change_macaddr(card);
1049 dev_warn(&card->gdev->dev, "Reading the adapter MAC"
1050 " address failed\n");
1053 if ((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
1054 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))
1055 rc = qeth_l3_setadapter_hstr(card);
1060 static int qeth_l3_default_setassparms_cb(struct qeth_card *card,
1061 struct qeth_reply *reply, unsigned long data)
1063 struct qeth_ipa_cmd *cmd;
1065 QETH_DBF_TEXT(TRACE, 4, "defadpcb");
1067 cmd = (struct qeth_ipa_cmd *) data;
1068 if (cmd->hdr.return_code == 0) {
1069 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
1070 if (cmd->hdr.prot_version == QETH_PROT_IPV4)
1071 card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
1072 if (cmd->hdr.prot_version == QETH_PROT_IPV6)
1073 card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
1075 if (cmd->data.setassparms.hdr.assist_no == IPA_INBOUND_CHECKSUM &&
1076 cmd->data.setassparms.hdr.command_code == IPA_CMD_ASS_START) {
1077 card->info.csum_mask = cmd->data.setassparms.data.flags_32bit;
1078 QETH_DBF_TEXT_(TRACE, 3, "csum:%d", card->info.csum_mask);
1083 static struct qeth_cmd_buffer *qeth_l3_get_setassparms_cmd(
1084 struct qeth_card *card, enum qeth_ipa_funcs ipa_func, __u16 cmd_code,
1085 __u16 len, enum qeth_prot_versions prot)
1087 struct qeth_cmd_buffer *iob;
1088 struct qeth_ipa_cmd *cmd;
1090 QETH_DBF_TEXT(TRACE, 4, "getasscm");
1091 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETASSPARMS, prot);
1093 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1094 cmd->data.setassparms.hdr.assist_no = ipa_func;
1095 cmd->data.setassparms.hdr.length = 8 + len;
1096 cmd->data.setassparms.hdr.command_code = cmd_code;
1097 cmd->data.setassparms.hdr.return_code = 0;
1098 cmd->data.setassparms.hdr.seq_no = 0;
1103 static int qeth_l3_send_setassparms(struct qeth_card *card,
1104 struct qeth_cmd_buffer *iob, __u16 len, long data,
1105 int (*reply_cb)(struct qeth_card *, struct qeth_reply *,
1110 struct qeth_ipa_cmd *cmd;
1112 QETH_DBF_TEXT(TRACE, 4, "sendassp");
1114 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1115 if (len <= sizeof(__u32))
1116 cmd->data.setassparms.data.flags_32bit = (__u32) data;
1117 else /* (len > sizeof(__u32)) */
1118 memcpy(&cmd->data.setassparms.data, (void *) data, len);
1120 rc = qeth_send_ipa_cmd(card, iob, reply_cb, reply_param);
1124 #ifdef CONFIG_QETH_IPV6
1125 static int qeth_l3_send_simple_setassparms_ipv6(struct qeth_card *card,
1126 enum qeth_ipa_funcs ipa_func, __u16 cmd_code)
1129 struct qeth_cmd_buffer *iob;
1131 QETH_DBF_TEXT(TRACE, 4, "simassp6");
1132 iob = qeth_l3_get_setassparms_cmd(card, ipa_func, cmd_code,
1134 rc = qeth_l3_send_setassparms(card, iob, 0, 0,
1135 qeth_l3_default_setassparms_cb, NULL);
1140 static int qeth_l3_send_simple_setassparms(struct qeth_card *card,
1141 enum qeth_ipa_funcs ipa_func, __u16 cmd_code, long data)
1145 struct qeth_cmd_buffer *iob;
1147 QETH_DBF_TEXT(TRACE, 4, "simassp4");
1149 length = sizeof(__u32);
1150 iob = qeth_l3_get_setassparms_cmd(card, ipa_func, cmd_code,
1151 length, QETH_PROT_IPV4);
1152 rc = qeth_l3_send_setassparms(card, iob, length, data,
1153 qeth_l3_default_setassparms_cb, NULL);
1157 static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
1161 QETH_DBF_TEXT(TRACE, 3, "ipaarp");
1163 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1164 dev_info(&card->gdev->dev,
1165 "ARP processing not supported on %s!\n",
1166 QETH_CARD_IFNAME(card));
1169 rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
1170 IPA_CMD_ASS_START, 0);
1172 dev_warn(&card->gdev->dev,
1173 "Starting ARP processing support for %s failed\n",
1174 QETH_CARD_IFNAME(card));
1179 static int qeth_l3_start_ipa_ip_fragmentation(struct qeth_card *card)
1183 QETH_DBF_TEXT(TRACE, 3, "ipaipfrg");
1185 if (!qeth_is_supported(card, IPA_IP_FRAGMENTATION)) {
1186 dev_info(&card->gdev->dev,
1187 "Hardware IP fragmentation not supported on %s\n",
1188 QETH_CARD_IFNAME(card));
1192 rc = qeth_l3_send_simple_setassparms(card, IPA_IP_FRAGMENTATION,
1193 IPA_CMD_ASS_START, 0);
1195 dev_warn(&card->gdev->dev,
1196 "Starting IP fragmentation support for %s failed\n",
1197 QETH_CARD_IFNAME(card));
1199 dev_info(&card->gdev->dev,
1200 "Hardware IP fragmentation enabled \n");
1204 static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
1208 QETH_DBF_TEXT(TRACE, 3, "stsrcmac");
1210 if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
1211 dev_info(&card->gdev->dev,
1212 "Inbound source MAC-address not supported on %s\n",
1213 QETH_CARD_IFNAME(card));
1217 rc = qeth_l3_send_simple_setassparms(card, IPA_SOURCE_MAC,
1218 IPA_CMD_ASS_START, 0);
1220 dev_warn(&card->gdev->dev,
1221 "Starting source MAC-address support for %s failed\n",
1222 QETH_CARD_IFNAME(card));
1226 static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
1230 QETH_DBF_TEXT(TRACE, 3, "strtvlan");
1232 if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
1233 dev_info(&card->gdev->dev,
1234 "VLAN not supported on %s\n", QETH_CARD_IFNAME(card));
1238 rc = qeth_l3_send_simple_setassparms(card, IPA_VLAN_PRIO,
1239 IPA_CMD_ASS_START, 0);
1241 dev_warn(&card->gdev->dev,
1242 "Starting VLAN support for %s failed\n",
1243 QETH_CARD_IFNAME(card));
1245 dev_info(&card->gdev->dev, "VLAN enabled\n");
1250 static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
1254 QETH_DBF_TEXT(TRACE, 3, "stmcast");
1256 if (!qeth_is_supported(card, IPA_MULTICASTING)) {
1257 dev_info(&card->gdev->dev,
1258 "Multicast not supported on %s\n",
1259 QETH_CARD_IFNAME(card));
1263 rc = qeth_l3_send_simple_setassparms(card, IPA_MULTICASTING,
1264 IPA_CMD_ASS_START, 0);
1266 dev_warn(&card->gdev->dev,
1267 "Starting multicast support for %s failed\n",
1268 QETH_CARD_IFNAME(card));
1270 dev_info(&card->gdev->dev, "Multicast enabled\n");
1271 card->dev->flags |= IFF_MULTICAST;
1276 static int qeth_l3_query_ipassists_cb(struct qeth_card *card,
1277 struct qeth_reply *reply, unsigned long data)
1279 struct qeth_ipa_cmd *cmd;
1281 QETH_DBF_TEXT(SETUP, 2, "qipasscb");
1283 cmd = (struct qeth_ipa_cmd *) data;
1284 if (cmd->hdr.prot_version == QETH_PROT_IPV4) {
1285 card->options.ipa4.supported_funcs = cmd->hdr.ipa_supported;
1286 card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
1288 card->options.ipa6.supported_funcs = cmd->hdr.ipa_supported;
1289 card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
1291 QETH_DBF_TEXT(SETUP, 2, "suppenbl");
1292 QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_supported);
1293 QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_enabled);
1297 static int qeth_l3_query_ipassists(struct qeth_card *card,
1298 enum qeth_prot_versions prot)
1301 struct qeth_cmd_buffer *iob;
1303 QETH_DBF_TEXT_(SETUP, 2, "qipassi%i", prot);
1304 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_QIPASSIST, prot);
1305 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_query_ipassists_cb, NULL);
1309 #ifdef CONFIG_QETH_IPV6
1310 static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
1314 QETH_DBF_TEXT(TRACE, 3, "softipv6");
1316 if (card->info.type == QETH_CARD_TYPE_IQD)
1319 rc = qeth_l3_query_ipassists(card, QETH_PROT_IPV6);
1321 dev_err(&card->gdev->dev,
1322 "Activating IPv6 support for %s failed\n",
1323 QETH_CARD_IFNAME(card));
1326 rc = qeth_l3_send_simple_setassparms(card, IPA_IPV6,
1327 IPA_CMD_ASS_START, 3);
1329 dev_err(&card->gdev->dev,
1330 "Activating IPv6 support for %s failed\n",
1331 QETH_CARD_IFNAME(card));
1334 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_IPV6,
1337 dev_err(&card->gdev->dev,
1338 "Activating IPv6 support for %s failed\n",
1339 QETH_CARD_IFNAME(card));
1342 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_PASSTHRU,
1345 dev_warn(&card->gdev->dev,
1346 "Enabling the passthrough mode for %s failed\n",
1347 QETH_CARD_IFNAME(card));
1351 dev_info(&card->gdev->dev, "IPV6 enabled\n");
1356 static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
1360 QETH_DBF_TEXT(TRACE, 3, "strtipv6");
1362 if (!qeth_is_supported(card, IPA_IPV6)) {
1363 dev_info(&card->gdev->dev,
1364 "IPv6 not supported on %s\n", QETH_CARD_IFNAME(card));
1367 #ifdef CONFIG_QETH_IPV6
1368 rc = qeth_l3_softsetup_ipv6(card);
1373 static int qeth_l3_start_ipa_broadcast(struct qeth_card *card)
1377 QETH_DBF_TEXT(TRACE, 3, "stbrdcst");
1378 card->info.broadcast_capable = 0;
1379 if (!qeth_is_supported(card, IPA_FILTERING)) {
1380 dev_info(&card->gdev->dev,
1381 "Broadcast not supported on %s\n",
1382 QETH_CARD_IFNAME(card));
1386 rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
1387 IPA_CMD_ASS_START, 0);
1389 dev_warn(&card->gdev->dev, "Enabling broadcast filtering for "
1390 "%s failed\n", QETH_CARD_IFNAME(card));
1394 rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
1395 IPA_CMD_ASS_CONFIGURE, 1);
1397 dev_warn(&card->gdev->dev,
1398 "Setting up broadcast filtering for %s failed\n",
1399 QETH_CARD_IFNAME(card));
1402 card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
1403 dev_info(&card->gdev->dev, "Broadcast enabled\n");
1404 rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
1405 IPA_CMD_ASS_ENABLE, 1);
1407 dev_warn(&card->gdev->dev, "Setting up broadcast echo "
1408 "filtering for %s failed\n", QETH_CARD_IFNAME(card));
1411 card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
1413 if (card->info.broadcast_capable)
1414 card->dev->flags |= IFF_BROADCAST;
1416 card->dev->flags &= ~IFF_BROADCAST;
1420 static int qeth_l3_send_checksum_command(struct qeth_card *card)
1424 rc = qeth_l3_send_simple_setassparms(card, IPA_INBOUND_CHECKSUM,
1425 IPA_CMD_ASS_START, 0);
1427 dev_warn(&card->gdev->dev, "Starting HW checksumming for %s "
1428 "failed, using SW checksumming\n",
1429 QETH_CARD_IFNAME(card));
1432 rc = qeth_l3_send_simple_setassparms(card, IPA_INBOUND_CHECKSUM,
1434 card->info.csum_mask);
1436 dev_warn(&card->gdev->dev, "Enabling HW checksumming for %s "
1437 "failed, using SW checksumming\n",
1438 QETH_CARD_IFNAME(card));
1444 static int qeth_l3_start_ipa_checksum(struct qeth_card *card)
1448 QETH_DBF_TEXT(TRACE, 3, "strtcsum");
1450 if (card->options.checksum_type == NO_CHECKSUMMING) {
1451 dev_info(&card->gdev->dev,
1452 "Using no checksumming on %s.\n",
1453 QETH_CARD_IFNAME(card));
1456 if (card->options.checksum_type == SW_CHECKSUMMING) {
1457 dev_info(&card->gdev->dev,
1458 "Using SW checksumming on %s.\n",
1459 QETH_CARD_IFNAME(card));
1462 if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM)) {
1463 dev_info(&card->gdev->dev,
1464 "Inbound HW Checksumming not "
1465 "supported on %s,\ncontinuing "
1466 "using Inbound SW Checksumming\n",
1467 QETH_CARD_IFNAME(card));
1468 card->options.checksum_type = SW_CHECKSUMMING;
1471 rc = qeth_l3_send_checksum_command(card);
1473 dev_info(&card->gdev->dev,
1474 "HW Checksumming (inbound) enabled\n");
1479 static int qeth_l3_start_ipa_tso(struct qeth_card *card)
1483 QETH_DBF_TEXT(TRACE, 3, "sttso");
1485 if (!qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
1486 dev_info(&card->gdev->dev,
1487 "Outbound TSO not supported on %s\n",
1488 QETH_CARD_IFNAME(card));
1491 rc = qeth_l3_send_simple_setassparms(card, IPA_OUTBOUND_TSO,
1492 IPA_CMD_ASS_START, 0);
1494 dev_warn(&card->gdev->dev, "Starting outbound TCP "
1495 "segmentation offload for %s failed\n",
1496 QETH_CARD_IFNAME(card));
1498 dev_info(&card->gdev->dev,
1499 "Outbound TSO enabled\n");
1501 if (rc && (card->options.large_send == QETH_LARGE_SEND_TSO)) {
1502 card->options.large_send = QETH_LARGE_SEND_NO;
1503 card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG);
1508 static int qeth_l3_start_ipassists(struct qeth_card *card)
1510 QETH_DBF_TEXT(TRACE, 3, "strtipas");
1511 qeth_l3_start_ipa_arp_processing(card); /* go on*/
1512 qeth_l3_start_ipa_ip_fragmentation(card); /* go on*/
1513 qeth_l3_start_ipa_source_mac(card); /* go on*/
1514 qeth_l3_start_ipa_vlan(card); /* go on*/
1515 qeth_l3_start_ipa_multicast(card); /* go on*/
1516 qeth_l3_start_ipa_ipv6(card); /* go on*/
1517 qeth_l3_start_ipa_broadcast(card); /* go on*/
1518 qeth_l3_start_ipa_checksum(card); /* go on*/
1519 qeth_l3_start_ipa_tso(card); /* go on*/
1523 static int qeth_l3_put_unique_id(struct qeth_card *card)
1527 struct qeth_cmd_buffer *iob;
1528 struct qeth_ipa_cmd *cmd;
1530 QETH_DBF_TEXT(TRACE, 2, "puniqeid");
1532 if ((card->info.unique_id & UNIQUE_ID_NOT_BY_CARD) ==
1533 UNIQUE_ID_NOT_BY_CARD)
1535 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_DESTROY_ADDR,
1537 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1538 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1539 card->info.unique_id;
1540 memcpy(&cmd->data.create_destroy_addr.unique_id[0],
1541 card->dev->dev_addr, OSA_ADDR_LEN);
1542 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
1546 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
1547 struct qeth_reply *reply, unsigned long data)
1549 struct qeth_ipa_cmd *cmd;
1551 cmd = (struct qeth_ipa_cmd *) data;
1552 if (cmd->hdr.return_code == 0)
1553 memcpy(card->dev->dev_addr,
1554 cmd->data.create_destroy_addr.unique_id, ETH_ALEN);
1556 random_ether_addr(card->dev->dev_addr);
1561 static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card)
1564 struct qeth_cmd_buffer *iob;
1565 struct qeth_ipa_cmd *cmd;
1567 QETH_DBF_TEXT(SETUP, 2, "hsrmac");
1569 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
1571 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1572 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1573 card->info.unique_id;
1575 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb,
1580 static int qeth_l3_get_unique_id_cb(struct qeth_card *card,
1581 struct qeth_reply *reply, unsigned long data)
1583 struct qeth_ipa_cmd *cmd;
1585 cmd = (struct qeth_ipa_cmd *) data;
1586 if (cmd->hdr.return_code == 0)
1587 card->info.unique_id = *((__u16 *)
1588 &cmd->data.create_destroy_addr.unique_id[6]);
1590 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1591 UNIQUE_ID_NOT_BY_CARD;
1592 dev_warn(&card->gdev->dev, "The network adapter failed to "
1593 "generate a unique ID\n");
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 = dev->ml_priv;
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 = dev->ml_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 = dev->ml_priv;
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 if (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_SRC_MAC_ADDR)
1922 card->dev->header_ops->create(skb, card->dev, prot,
1923 tg_addr, &hdr->hdr.l3.dest_addr[2],
1924 card->dev->addr_len);
1926 card->dev->header_ops->create(skb, card->dev, prot,
1927 tg_addr, "FAKELL", card->dev->addr_len);
1931 if (card->dev->type == ARPHRD_IEEE802_TR)
1932 skb->protocol = tr_type_trans(skb, card->dev);
1935 skb->protocol = eth_type_trans(skb, card->dev);
1937 if (hdr->hdr.l3.ext_flags &
1938 (QETH_HDR_EXT_VLAN_FRAME | QETH_HDR_EXT_INCLUDE_VLAN_TAG)) {
1939 vlan_id = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME)?
1940 hdr->hdr.l3.vlan_id : *((u16 *)&hdr->hdr.l3.dest_addr[12]);
1943 skb->ip_summed = card->options.checksum_type;
1944 if (card->options.checksum_type == HW_CHECKSUMMING) {
1945 if ((hdr->hdr.l3.ext_flags &
1946 (QETH_HDR_EXT_CSUM_HDR_REQ |
1947 QETH_HDR_EXT_CSUM_TRANSP_REQ)) ==
1948 (QETH_HDR_EXT_CSUM_HDR_REQ |
1949 QETH_HDR_EXT_CSUM_TRANSP_REQ))
1950 skb->ip_summed = CHECKSUM_UNNECESSARY;
1952 skb->ip_summed = SW_CHECKSUMMING;
1958 static void qeth_l3_process_inbound_buffer(struct qeth_card *card,
1959 struct qeth_qdio_buffer *buf, int index)
1961 struct qdio_buffer_element *element;
1962 struct sk_buff *skb;
1963 struct qeth_hdr *hdr;
1968 /* get first element of current buffer */
1969 element = (struct qdio_buffer_element *)&buf->buffer->element[0];
1971 if (card->options.performance_stats)
1972 card->perf_stats.bufs_rec++;
1973 while ((skb = qeth_core_get_next_skb(card, buf->buffer, &element,
1975 skb->dev = card->dev;
1976 /* is device UP ? */
1977 if (!(card->dev->flags & IFF_UP)) {
1978 dev_kfree_skb_any(skb);
1982 switch (hdr->hdr.l3.id) {
1983 case QETH_HEADER_TYPE_LAYER3:
1984 vlan_tag = qeth_l3_rebuild_skb(card, skb, hdr);
1988 vlan_hwaccel_rx(skb, card->vlangrp,
1991 dev_kfree_skb_any(skb);
1998 dev_kfree_skb_any(skb);
1999 QETH_DBF_TEXT(TRACE, 3, "inbunkno");
2000 QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN);
2004 card->dev->last_rx = jiffies;
2005 card->stats.rx_packets++;
2006 card->stats.rx_bytes += len;
2010 static int qeth_l3_verify_vlan_dev(struct net_device *dev,
2011 struct qeth_card *card)
2014 struct vlan_group *vg;
2021 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
2022 if (vlan_group_get_device(vg, i) == dev) {
2023 rc = QETH_VLAN_CARD;
2028 if (rc && !(vlan_dev_real_dev(dev)->ml_priv == (void *)card))
2034 static int qeth_l3_verify_dev(struct net_device *dev)
2036 struct qeth_card *card;
2037 unsigned long flags;
2040 read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
2041 list_for_each_entry(card, &qeth_core_card_list.list, list) {
2042 if (card->dev == dev) {
2043 rc = QETH_REAL_CARD;
2046 rc = qeth_l3_verify_vlan_dev(dev, card);
2050 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
2055 static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev)
2057 struct qeth_card *card = NULL;
2060 rc = qeth_l3_verify_dev(dev);
2061 if (rc == QETH_REAL_CARD)
2062 card = dev->ml_priv;
2063 else if (rc == QETH_VLAN_CARD)
2064 card = vlan_dev_real_dev(dev)->ml_priv;
2065 if (card && card->options.layer2)
2067 QETH_DBF_TEXT_(TRACE, 4, "%d", rc);
2071 static int qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
2075 QETH_DBF_TEXT(SETUP, 2, "stopcard");
2076 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
2078 qeth_set_allowed_threads(card, 0, 1);
2079 if (card->read.state == CH_STATE_UP &&
2080 card->write.state == CH_STATE_UP &&
2081 (card->state == CARD_STATE_UP)) {
2083 qeth_l3_stop(card->dev);
2087 dev_close(card->dev);
2091 if (!card->use_hard_stop) {
2092 rc = qeth_send_stoplan(card);
2094 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
2096 card->state = CARD_STATE_SOFTSETUP;
2098 if (card->state == CARD_STATE_SOFTSETUP) {
2099 qeth_l3_clear_ip_list(card, !card->use_hard_stop, 1);
2100 qeth_clear_ipacmd_list(card);
2101 card->state = CARD_STATE_HARDSETUP;
2103 if (card->state == CARD_STATE_HARDSETUP) {
2104 if (!card->use_hard_stop &&
2105 (card->info.type != QETH_CARD_TYPE_IQD)) {
2106 rc = qeth_l3_put_unique_id(card);
2108 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
2110 qeth_qdio_clear_card(card, 0);
2111 qeth_clear_qdio_buffers(card);
2112 qeth_clear_working_pool_list(card);
2113 card->state = CARD_STATE_DOWN;
2115 if (card->state == CARD_STATE_DOWN) {
2116 qeth_clear_cmd_buffers(&card->read);
2117 qeth_clear_cmd_buffers(&card->write);
2119 card->use_hard_stop = 0;
2123 static void qeth_l3_set_multicast_list(struct net_device *dev)
2125 struct qeth_card *card = dev->ml_priv;
2127 QETH_DBF_TEXT(TRACE, 3, "setmulti");
2128 qeth_l3_delete_mc_addresses(card);
2129 qeth_l3_add_multicast_ipv4(card);
2130 #ifdef CONFIG_QETH_IPV6
2131 qeth_l3_add_multicast_ipv6(card);
2133 qeth_l3_set_ip_addr_list(card);
2134 if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
2136 qeth_setadp_promisc_mode(card);
2139 static const char *qeth_l3_arp_get_error_cause(int *rc)
2142 case QETH_IPA_ARP_RC_FAILED:
2144 return "operation failed";
2145 case QETH_IPA_ARP_RC_NOTSUPP:
2147 return "operation not supported";
2148 case QETH_IPA_ARP_RC_OUT_OF_RANGE:
2150 return "argument out of range";
2151 case QETH_IPA_ARP_RC_Q_NOTSUPP:
2153 return "query operation not supported";
2154 case QETH_IPA_ARP_RC_Q_NO_DATA:
2156 return "no query data available";
2158 return "unknown error";
2162 static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
2167 QETH_DBF_TEXT(TRACE, 3, "arpstnoe");
2170 * currently GuestLAN only supports the ARP assist function
2171 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
2172 * thus we say EOPNOTSUPP for this ARP function
2174 if (card->info.guestlan)
2176 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2179 rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2180 IPA_CMD_ASS_ARP_SET_NO_ENTRIES,
2184 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on "
2185 "%s: %s (0x%x/%d)\n", QETH_CARD_IFNAME(card),
2186 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2191 static void qeth_l3_copy_arp_entries_stripped(struct qeth_arp_query_info *qinfo,
2192 struct qeth_arp_query_data *qdata, int entry_size,
2199 entry_ptr = (char *)&qdata->data;
2200 uentry_ptr = (char *)(qinfo->udata + qinfo->udata_offset);
2201 for (i = 0; i < qdata->no_entries; ++i) {
2202 /* strip off 32 bytes "media specific information" */
2203 memcpy(uentry_ptr, (entry_ptr + 32), entry_size - 32);
2204 entry_ptr += entry_size;
2205 uentry_ptr += uentry_size;
2209 static int qeth_l3_arp_query_cb(struct qeth_card *card,
2210 struct qeth_reply *reply, unsigned long data)
2212 struct qeth_ipa_cmd *cmd;
2213 struct qeth_arp_query_data *qdata;
2214 struct qeth_arp_query_info *qinfo;
2219 QETH_DBF_TEXT(TRACE, 4, "arpquecb");
2221 qinfo = (struct qeth_arp_query_info *) reply->param;
2222 cmd = (struct qeth_ipa_cmd *) data;
2223 if (cmd->hdr.return_code) {
2224 QETH_DBF_TEXT_(TRACE, 4, "qaer1%i", cmd->hdr.return_code);
2227 if (cmd->data.setassparms.hdr.return_code) {
2228 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
2229 QETH_DBF_TEXT_(TRACE, 4, "qaer2%i", cmd->hdr.return_code);
2232 qdata = &cmd->data.setassparms.data.query_arp;
2233 switch (qdata->reply_bits) {
2235 uentry_size = entry_size = sizeof(struct qeth_arp_qi_entry5);
2236 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
2237 uentry_size = sizeof(struct qeth_arp_qi_entry5_short);
2240 /* fall through to default */
2242 /* tr is the same as eth -> entry7 */
2243 uentry_size = entry_size = sizeof(struct qeth_arp_qi_entry7);
2244 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
2245 uentry_size = sizeof(struct qeth_arp_qi_entry7_short);
2248 /* check if there is enough room in userspace */
2249 if ((qinfo->udata_len - qinfo->udata_offset) <
2250 qdata->no_entries * uentry_size){
2251 QETH_DBF_TEXT_(TRACE, 4, "qaer3%i", -ENOMEM);
2252 cmd->hdr.return_code = -ENOMEM;
2255 QETH_DBF_TEXT_(TRACE, 4, "anore%i",
2256 cmd->data.setassparms.hdr.number_of_replies);
2257 QETH_DBF_TEXT_(TRACE, 4, "aseqn%i", cmd->data.setassparms.hdr.seq_no);
2258 QETH_DBF_TEXT_(TRACE, 4, "anoen%i", qdata->no_entries);
2260 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) {
2261 /* strip off "media specific information" */
2262 qeth_l3_copy_arp_entries_stripped(qinfo, qdata, entry_size,
2265 /*copy entries to user buffer*/
2266 memcpy(qinfo->udata + qinfo->udata_offset,
2267 (char *)&qdata->data, qdata->no_entries*uentry_size);
2269 qinfo->no_entries += qdata->no_entries;
2270 qinfo->udata_offset += (qdata->no_entries*uentry_size);
2271 /* check if all replies received ... */
2272 if (cmd->data.setassparms.hdr.seq_no <
2273 cmd->data.setassparms.hdr.number_of_replies)
2275 memcpy(qinfo->udata, &qinfo->no_entries, 4);
2276 /* keep STRIP_ENTRIES flag so the user program can distinguish
2277 * stripped entries from normal ones */
2278 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
2279 qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES;
2280 memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2);
2284 memcpy(qinfo->udata, &i, 4);
2288 static int qeth_l3_send_ipa_arp_cmd(struct qeth_card *card,
2289 struct qeth_cmd_buffer *iob, int len,
2290 int (*reply_cb)(struct qeth_card *, struct qeth_reply *,
2294 QETH_DBF_TEXT(TRACE, 4, "sendarp");
2296 memcpy(iob->data, IPA_PDU_HEADER, IPA_PDU_HEADER_SIZE);
2297 memcpy(QETH_IPA_CMD_DEST_ADDR(iob->data),
2298 &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH);
2299 return qeth_send_control_data(card, IPA_PDU_HEADER_SIZE + len, iob,
2300 reply_cb, reply_param);
2303 static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
2305 struct qeth_cmd_buffer *iob;
2306 struct qeth_arp_query_info qinfo = {0, };
2310 QETH_DBF_TEXT(TRACE, 3, "arpquery");
2312 if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
2313 IPA_ARP_PROCESSING)) {
2316 /* get size of userspace buffer and mask_bits -> 6 bytes */
2317 if (copy_from_user(&qinfo, udata, 6))
2319 qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL);
2322 qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
2323 iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2324 IPA_CMD_ASS_ARP_QUERY_INFO,
2325 sizeof(int), QETH_PROT_IPV4);
2327 rc = qeth_l3_send_ipa_arp_cmd(card, iob,
2328 QETH_SETASS_BASE_LEN+QETH_ARP_CMD_LEN,
2329 qeth_l3_arp_query_cb, (void *)&qinfo);
2332 QETH_DBF_MESSAGE(2, "Error while querying ARP cache on %s: %s "
2333 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2334 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2335 if (copy_to_user(udata, qinfo.udata, 4))
2338 if (copy_to_user(udata, qinfo.udata, qinfo.udata_len))
2345 static int qeth_l3_arp_add_entry(struct qeth_card *card,
2346 struct qeth_arp_cache_entry *entry)
2348 struct qeth_cmd_buffer *iob;
2353 QETH_DBF_TEXT(TRACE, 3, "arpadent");
2356 * currently GuestLAN only supports the ARP assist function
2357 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
2358 * thus we say EOPNOTSUPP for this ARP function
2360 if (card->info.guestlan)
2362 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2366 iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2367 IPA_CMD_ASS_ARP_ADD_ENTRY,
2368 sizeof(struct qeth_arp_cache_entry),
2370 rc = qeth_l3_send_setassparms(card, iob,
2371 sizeof(struct qeth_arp_cache_entry),
2372 (unsigned long) entry,
2373 qeth_l3_default_setassparms_cb, NULL);
2376 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
2377 QETH_DBF_MESSAGE(2, "Could not add ARP entry for address %s "
2378 "on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2379 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2384 static int qeth_l3_arp_remove_entry(struct qeth_card *card,
2385 struct qeth_arp_cache_entry *entry)
2387 struct qeth_cmd_buffer *iob;
2388 char buf[16] = {0, };
2392 QETH_DBF_TEXT(TRACE, 3, "arprment");
2395 * currently GuestLAN only supports the ARP assist function
2396 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_REMOVE_ENTRY;
2397 * thus we say EOPNOTSUPP for this ARP function
2399 if (card->info.guestlan)
2401 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2404 memcpy(buf, entry, 12);
2405 iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2406 IPA_CMD_ASS_ARP_REMOVE_ENTRY,
2409 rc = qeth_l3_send_setassparms(card, iob,
2410 12, (unsigned long)buf,
2411 qeth_l3_default_setassparms_cb, NULL);
2415 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
2416 QETH_DBF_MESSAGE(2, "Could not delete ARP entry for address %s"
2417 " on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2418 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2423 static int qeth_l3_arp_flush_cache(struct qeth_card *card)
2428 QETH_DBF_TEXT(TRACE, 3, "arpflush");
2431 * currently GuestLAN only supports the ARP assist function
2432 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
2433 * thus we say EOPNOTSUPP for this ARP function
2435 if (card->info.guestlan || (card->info.type == QETH_CARD_TYPE_IQD))
2437 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
2440 rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2441 IPA_CMD_ASS_ARP_FLUSH_CACHE, 0);
2444 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on %s: %s "
2445 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2446 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2451 static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2453 struct qeth_card *card = dev->ml_priv;
2454 struct qeth_arp_cache_entry arp_entry;
2455 struct mii_ioctl_data *mii_data;
2461 if ((card->state != CARD_STATE_UP) &&
2462 (card->state != CARD_STATE_SOFTSETUP))
2466 case SIOC_QETH_ARP_SET_NO_ENTRIES:
2467 if (!capable(CAP_NET_ADMIN)) {
2471 rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue);
2473 case SIOC_QETH_ARP_QUERY_INFO:
2474 if (!capable(CAP_NET_ADMIN)) {
2478 rc = qeth_l3_arp_query(card, rq->ifr_ifru.ifru_data);
2480 case SIOC_QETH_ARP_ADD_ENTRY:
2481 if (!capable(CAP_NET_ADMIN)) {
2485 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
2486 sizeof(struct qeth_arp_cache_entry)))
2489 rc = qeth_l3_arp_add_entry(card, &arp_entry);
2491 case SIOC_QETH_ARP_REMOVE_ENTRY:
2492 if (!capable(CAP_NET_ADMIN)) {
2496 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
2497 sizeof(struct qeth_arp_cache_entry)))
2500 rc = qeth_l3_arp_remove_entry(card, &arp_entry);
2502 case SIOC_QETH_ARP_FLUSH_CACHE:
2503 if (!capable(CAP_NET_ADMIN)) {
2507 rc = qeth_l3_arp_flush_cache(card);
2509 case SIOC_QETH_ADP_SET_SNMP_CONTROL:
2510 rc = qeth_snmp_command(card, rq->ifr_ifru.ifru_data);
2512 case SIOC_QETH_GET_CARD_TYPE:
2513 if ((card->info.type == QETH_CARD_TYPE_OSAE) &&
2514 !card->info.guestlan)
2519 mii_data = if_mii(rq);
2520 mii_data->phy_id = 0;
2523 mii_data = if_mii(rq);
2524 if (mii_data->phy_id != 0)
2527 mii_data->val_out = qeth_mdio_read(dev,
2535 QETH_DBF_TEXT_(TRACE, 2, "ioce%d", rc);
2539 static void qeth_l3_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
2540 struct sk_buff *skb, int ipv, int cast_type)
2542 memset(hdr, 0, sizeof(struct qeth_hdr));
2543 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
2544 hdr->hdr.l3.ext_flags = 0;
2547 * before we're going to overwrite this location with next hop ip.
2548 * v6 uses passthrough, v4 sets the tag in the QDIO header.
2550 if (card->vlangrp && vlan_tx_tag_present(skb)) {
2551 if ((ipv == 4) || (card->info.type == QETH_CARD_TYPE_IQD))
2552 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_VLAN_FRAME;
2554 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_INCLUDE_VLAN_TAG;
2555 hdr->hdr.l3.vlan_id = vlan_tx_tag_get(skb);
2558 hdr->hdr.l3.length = skb->len - sizeof(struct qeth_hdr);
2561 hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags4(cast_type);
2562 memset(hdr->hdr.l3.dest_addr, 0, 12);
2563 if ((skb->dst) && (skb->dst->neighbour)) {
2564 *((u32 *) (&hdr->hdr.l3.dest_addr[12])) =
2565 *((u32 *) skb->dst->neighbour->primary_key);
2567 /* fill in destination address used in ip header */
2568 *((u32 *) (&hdr->hdr.l3.dest_addr[12])) =
2571 } else if (ipv == 6) {
2573 hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags6(cast_type);
2574 if (card->info.type == QETH_CARD_TYPE_IQD)
2575 hdr->hdr.l3.flags &= ~QETH_HDR_PASSTHRU;
2576 if ((skb->dst) && (skb->dst->neighbour)) {
2577 memcpy(hdr->hdr.l3.dest_addr,
2578 skb->dst->neighbour->primary_key, 16);
2580 /* fill in destination address used in ip header */
2581 memcpy(hdr->hdr.l3.dest_addr,
2582 &ipv6_hdr(skb)->daddr, 16);
2586 if ((skb->dev->type == ARPHRD_IEEE802_TR) &&
2587 !memcmp(skb->data + sizeof(struct qeth_hdr) +
2588 sizeof(__u16), skb->dev->broadcast, 6)) {
2589 hdr->hdr.l3.flags = QETH_CAST_BROADCAST |
2591 } else if (!memcmp(skb->data + sizeof(struct qeth_hdr),
2592 skb->dev->broadcast, 6)) {
2594 hdr->hdr.l3.flags = QETH_CAST_BROADCAST |
2597 hdr->hdr.l3.flags = (cast_type == RTN_MULTICAST) ?
2598 QETH_CAST_MULTICAST | QETH_HDR_PASSTHRU :
2599 QETH_CAST_UNICAST | QETH_HDR_PASSTHRU;
2604 static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
2608 struct qeth_hdr *hdr = NULL;
2609 int elements_needed = 0;
2610 struct qeth_card *card = dev->ml_priv;
2611 struct sk_buff *new_skb = NULL;
2612 int ipv = qeth_get_ip_version(skb);
2613 int cast_type = qeth_get_cast_type(card, skb);
2614 struct qeth_qdio_out_q *queue = card->qdio.out_qs
2615 [qeth_get_priority_queue(card, skb, ipv, cast_type)];
2616 int tx_bytes = skb->len;
2617 enum qeth_large_send_types large_send = QETH_LARGE_SEND_NO;
2618 struct qeth_eddp_context *ctx = NULL;
2619 int data_offset = -1;
2621 if ((card->info.type == QETH_CARD_TYPE_IQD) &&
2622 (skb->protocol != htons(ETH_P_IPV6)) &&
2623 (skb->protocol != htons(ETH_P_IP)))
2626 if ((card->state != CARD_STATE_UP) || !card->lan_online) {
2627 card->stats.tx_carrier_errors++;
2631 if ((cast_type == RTN_BROADCAST) &&
2632 (card->info.broadcast_capable == 0))
2635 if (card->options.performance_stats) {
2636 card->perf_stats.outbound_cnt++;
2637 card->perf_stats.outbound_start_time = qeth_get_micros();
2640 if (skb_is_gso(skb))
2641 large_send = card->options.large_send;
2643 if ((card->info.type == QETH_CARD_TYPE_IQD) && (!large_send) &&
2644 (skb_shinfo(skb)->nr_frags == 0)) {
2646 data_offset = ETH_HLEN;
2647 hdr = kmem_cache_alloc(qeth_core_header_cache, GFP_ATOMIC);
2652 /* create a clone with writeable headroom */
2653 new_skb = skb_realloc_headroom(skb, sizeof(struct qeth_hdr_tso)
2659 if (card->info.type == QETH_CARD_TYPE_IQD) {
2660 if (data_offset < 0)
2661 skb_pull(new_skb, ETH_HLEN);
2663 if (new_skb->protocol == htons(ETH_P_IP)) {
2664 if (card->dev->type == ARPHRD_IEEE802_TR)
2665 skb_pull(new_skb, TR_HLEN);
2667 skb_pull(new_skb, ETH_HLEN);
2670 if (new_skb->protocol == ETH_P_IPV6 && card->vlangrp &&
2671 vlan_tx_tag_present(new_skb)) {
2672 skb_push(new_skb, VLAN_HLEN);
2673 skb_copy_to_linear_data(new_skb, new_skb->data + 4, 4);
2674 skb_copy_to_linear_data_offset(new_skb, 4,
2675 new_skb->data + 8, 4);
2676 skb_copy_to_linear_data_offset(new_skb, 8,
2677 new_skb->data + 12, 4);
2678 tag = (u16 *)(new_skb->data + 12);
2679 *tag = __constant_htons(ETH_P_8021Q);
2680 *(tag + 1) = htons(vlan_tx_tag_get(new_skb));
2681 new_skb->vlan_tci = 0;
2685 netif_stop_queue(dev);
2687 /* fix hardware limitation: as long as we do not have sbal
2688 * chaining we can not send long frag lists so we temporary
2691 if ((large_send == QETH_LARGE_SEND_TSO) &&
2692 ((skb_shinfo(new_skb)->nr_frags + 2) > 16))
2693 large_send = QETH_LARGE_SEND_EDDP;
2695 if ((large_send == QETH_LARGE_SEND_TSO) &&
2696 (cast_type == RTN_UNSPEC)) {
2697 hdr = (struct qeth_hdr *)skb_push(new_skb,
2698 sizeof(struct qeth_hdr_tso));
2699 memset(hdr, 0, sizeof(struct qeth_hdr_tso));
2700 qeth_l3_fill_header(card, hdr, new_skb, ipv, cast_type);
2701 qeth_tso_fill_header(card, hdr, new_skb);
2704 if (data_offset < 0) {
2705 hdr = (struct qeth_hdr *)skb_push(new_skb,
2706 sizeof(struct qeth_hdr));
2707 qeth_l3_fill_header(card, hdr, new_skb, ipv,
2710 qeth_l3_fill_header(card, hdr, new_skb, ipv,
2712 hdr->hdr.l3.length = new_skb->len - data_offset;
2716 if (large_send == QETH_LARGE_SEND_EDDP) {
2717 /* new_skb is not owned by a socket so we use skb to get
2720 ctx = qeth_eddp_create_context(card, new_skb, hdr,
2721 skb->sk->sk_protocol);
2723 QETH_DBF_MESSAGE(2, "could not create eddp context\n");
2727 int elems = qeth_get_elements_no(card, (void *)hdr, new_skb,
2730 if (data_offset >= 0)
2731 kmem_cache_free(qeth_core_header_cache, hdr);
2734 elements_needed += elems;
2737 if ((large_send == QETH_LARGE_SEND_NO) &&
2738 (new_skb->ip_summed == CHECKSUM_PARTIAL))
2739 qeth_tx_csum(new_skb);
2741 if (card->info.type != QETH_CARD_TYPE_IQD)
2742 rc = qeth_do_send_packet(card, queue, new_skb, hdr,
2743 elements_needed, ctx);
2745 rc = qeth_do_send_packet_fast(card, queue, new_skb, hdr,
2746 elements_needed, ctx, data_offset, 0);
2749 card->stats.tx_packets++;
2750 card->stats.tx_bytes += tx_bytes;
2752 dev_kfree_skb_any(skb);
2753 if (card->options.performance_stats) {
2754 if (large_send != QETH_LARGE_SEND_NO) {
2755 card->perf_stats.large_send_bytes += tx_bytes;
2756 card->perf_stats.large_send_cnt++;
2758 if (skb_shinfo(new_skb)->nr_frags > 0) {
2759 card->perf_stats.sg_skbs_sent++;
2760 /* nr_frags + skb->data */
2761 card->perf_stats.sg_frags_sent +=
2762 skb_shinfo(new_skb)->nr_frags + 1;
2767 qeth_eddp_put_context(ctx);
2768 dev_kfree_skb_any(new_skb);
2772 qeth_eddp_put_context(ctx);
2774 if (data_offset >= 0)
2775 kmem_cache_free(qeth_core_header_cache, hdr);
2779 dev_kfree_skb_any(new_skb);
2780 return NETDEV_TX_BUSY;
2785 netif_wake_queue(dev);
2786 if (card->options.performance_stats)
2787 card->perf_stats.outbound_time += qeth_get_micros() -
2788 card->perf_stats.outbound_start_time;
2792 card->stats.tx_dropped++;
2793 card->stats.tx_errors++;
2794 if ((new_skb != skb) && new_skb)
2795 dev_kfree_skb_any(new_skb);
2796 dev_kfree_skb_any(skb);
2797 netif_wake_queue(dev);
2798 return NETDEV_TX_OK;
2801 static int qeth_l3_open(struct net_device *dev)
2803 struct qeth_card *card = dev->ml_priv;
2805 QETH_DBF_TEXT(TRACE, 4, "qethopen");
2806 if (card->state != CARD_STATE_SOFTSETUP)
2808 card->data.state = CH_STATE_UP;
2809 card->state = CARD_STATE_UP;
2810 netif_start_queue(dev);
2812 if (!card->lan_online && netif_carrier_ok(dev))
2813 netif_carrier_off(dev);
2817 static int qeth_l3_stop(struct net_device *dev)
2819 struct qeth_card *card = dev->ml_priv;
2821 QETH_DBF_TEXT(TRACE, 4, "qethstop");
2822 netif_tx_disable(dev);
2823 if (card->state == CARD_STATE_UP)
2824 card->state = CARD_STATE_SOFTSETUP;
2828 static u32 qeth_l3_ethtool_get_rx_csum(struct net_device *dev)
2830 struct qeth_card *card = dev->ml_priv;
2832 return (card->options.checksum_type == HW_CHECKSUMMING);
2835 static int qeth_l3_ethtool_set_rx_csum(struct net_device *dev, u32 data)
2837 struct qeth_card *card = dev->ml_priv;
2838 enum qeth_card_states old_state;
2839 enum qeth_checksum_types csum_type;
2841 if ((card->state != CARD_STATE_UP) &&
2842 (card->state != CARD_STATE_DOWN))
2846 csum_type = HW_CHECKSUMMING;
2848 csum_type = SW_CHECKSUMMING;
2850 if (card->options.checksum_type != csum_type) {
2851 old_state = card->state;
2852 if (card->state == CARD_STATE_UP)
2853 __qeth_l3_set_offline(card->gdev, 1);
2854 card->options.checksum_type = csum_type;
2855 if (old_state == CARD_STATE_UP)
2856 __qeth_l3_set_online(card->gdev, 1);
2861 static int qeth_l3_ethtool_set_tso(struct net_device *dev, u32 data)
2863 struct qeth_card *card = dev->ml_priv;
2866 if (card->options.large_send == QETH_LARGE_SEND_NO) {
2867 if (card->info.type == QETH_CARD_TYPE_IQD)
2868 card->options.large_send = QETH_LARGE_SEND_EDDP;
2870 card->options.large_send = QETH_LARGE_SEND_TSO;
2871 dev->features |= NETIF_F_TSO;
2874 dev->features &= ~NETIF_F_TSO;
2875 card->options.large_send = QETH_LARGE_SEND_NO;
2880 static struct ethtool_ops qeth_l3_ethtool_ops = {
2881 .get_link = ethtool_op_get_link,
2882 .get_tx_csum = ethtool_op_get_tx_csum,
2883 .set_tx_csum = ethtool_op_set_tx_hw_csum,
2884 .get_rx_csum = qeth_l3_ethtool_get_rx_csum,
2885 .set_rx_csum = qeth_l3_ethtool_set_rx_csum,
2886 .get_sg = ethtool_op_get_sg,
2887 .set_sg = ethtool_op_set_sg,
2888 .get_tso = ethtool_op_get_tso,
2889 .set_tso = qeth_l3_ethtool_set_tso,
2890 .get_strings = qeth_core_get_strings,
2891 .get_ethtool_stats = qeth_core_get_ethtool_stats,
2892 .get_stats_count = qeth_core_get_stats_count,
2893 .get_drvinfo = qeth_core_get_drvinfo,
2894 .get_settings = qeth_core_ethtool_get_settings,
2898 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
2899 * NOARP on the netdevice is no option because it also turns off neighbor
2900 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
2901 * arp resolution but we want the hard header (packet socket will work
2904 static int qeth_l3_neigh_setup_noarp(struct neighbour *n)
2906 n->nud_state = NUD_NOARP;
2907 memcpy(n->ha, "FAKELL", 6);
2908 n->output = n->ops->connected_output;
2913 qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np)
2915 if (np->tbl->family == AF_INET)
2916 np->neigh_setup = qeth_l3_neigh_setup_noarp;
2921 static int qeth_l3_setup_netdev(struct qeth_card *card)
2923 if (card->info.type == QETH_CARD_TYPE_OSAE) {
2924 if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) ||
2925 (card->info.link_type == QETH_LINK_TYPE_HSTR)) {
2927 card->dev = alloc_trdev(0);
2932 card->dev = alloc_etherdev(0);
2935 card->dev->neigh_setup = qeth_l3_neigh_setup;
2937 /*IPv6 address autoconfiguration stuff*/
2938 qeth_l3_get_unique_id(card);
2939 if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
2940 card->dev->dev_id = card->info.unique_id &
2943 } else if (card->info.type == QETH_CARD_TYPE_IQD) {
2944 card->dev = alloc_netdev(0, "hsi%d", ether_setup);
2947 card->dev->flags |= IFF_NOARP;
2948 qeth_l3_iqd_read_initial_mac(card);
2952 card->dev->hard_start_xmit = qeth_l3_hard_start_xmit;
2953 card->dev->ml_priv = card;
2954 card->dev->tx_timeout = &qeth_tx_timeout;
2955 card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
2956 card->dev->open = qeth_l3_open;
2957 card->dev->stop = qeth_l3_stop;
2958 card->dev->do_ioctl = qeth_l3_do_ioctl;
2959 card->dev->get_stats = qeth_get_stats;
2960 card->dev->change_mtu = qeth_change_mtu;
2961 card->dev->set_multicast_list = qeth_l3_set_multicast_list;
2962 card->dev->vlan_rx_register = qeth_l3_vlan_rx_register;
2963 card->dev->vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid;
2964 card->dev->vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid;
2965 card->dev->mtu = card->info.initial_mtu;
2966 card->dev->set_mac_address = NULL;
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");