projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
syncookies: Make sure ECN is disabled
[linux-block.git] / drivers / s390 / net / qeth_l3_main.c
CommitLineData
4a71df50
FB		 1/*
2 * drivers/s390/net/qeth_l3_main.c
3 *
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>
9 */
10
11#include <linux/module.h>
12#include <linux/moduleparam.h>
13#include <linux/string.h>
14#include <linux/errno.h>
15#include <linux/kernel.h>
16#include <linux/etherdevice.h>
17#include <linux/mii.h>
18#include <linux/ip.h>
19#include <linux/reboot.h>
20#include <linux/inetdevice.h>
21#include <linux/igmp.h>
22
23#include <net/ip.h>
24#include <net/arp.h>
25
26#include <asm/s390_rdev.h>
27
28#include "qeth_l3.h"
29#include "qeth_core_offl.h"
30
4a71df50
FB		 31static int qeth_l3_set_offline(struct ccwgroup_device *);
32static int qeth_l3_recover(void *);
33static int qeth_l3_stop(struct net_device *);
34static void qeth_l3_set_multicast_list(struct net_device *);
35static int qeth_l3_neigh_setup(struct net_device *, struct neigh_parms *);
36static int qeth_l3_register_addr_entry(struct qeth_card *,
37 struct qeth_ipaddr *);
38static int qeth_l3_deregister_addr_entry(struct qeth_card *,
39 struct qeth_ipaddr *);
40static int __qeth_l3_set_online(struct ccwgroup_device *, int);
41static int __qeth_l3_set_offline(struct ccwgroup_device *, int);
42
43
44static int qeth_l3_isxdigit(char *buf)
45{
46 while (*buf) {
47 if (!isxdigit(*buf++))
48 return 0;
49 }
50 return 1;
51}
52
53void qeth_l3_ipaddr4_to_string(const __u8 *addr, char *buf)
54{
55 sprintf(buf, "%i.%i.%i.%i", addr[0], addr[1], addr[2], addr[3]);
56}
57
58int qeth_l3_string_to_ipaddr4(const char *buf, __u8 *addr)
59{
60 int count = 0, rc = 0;
61 int in[4];
62 char c;
63
64 rc = sscanf(buf, "%u.%u.%u.%u%c",
65 &in[0], &in[1], &in[2], &in[3], &c);
66 if (rc != 4 && (rc != 5 || c != '\n'))
67 return -EINVAL;
68 for (count = 0; count < 4; count++) {
69 if (in[count] > 255)
70 return -EINVAL;
71 addr[count] = in[count];
72 }
73 return 0;
74}
75
76void qeth_l3_ipaddr6_to_string(const __u8 *addr, char *buf)
77{
78 sprintf(buf, "%02x%02x:%02x%02x:%02x%02x:%02x%02x"
79 ":%02x%02x:%02x%02x:%02x%02x:%02x%02x",
80 addr[0], addr[1], addr[2], addr[3],
81 addr[4], addr[5], addr[6], addr[7],
82 addr[8], addr[9], addr[10], addr[11],
83 addr[12], addr[13], addr[14], addr[15]);
84}
85
86int qeth_l3_string_to_ipaddr6(const char *buf, __u8 *addr)
87{
88 const char *end, *end_tmp, *start;
89 __u16 *in;
90 char num[5];
91 int num2, cnt, out, found, save_cnt;
92 unsigned short in_tmp[8] = {0, };
93
94 cnt = out = found = save_cnt = num2 = 0;
95 end = start = buf;
96 in = (__u16 *) addr;
97 memset(in, 0, 16);
98 while (*end) {
99 end = strchr(start, ':');
100 if (end == NULL) {
101 end = buf + strlen(buf);
102 end_tmp = strchr(start, '\n');
103 if (end_tmp != NULL)
104 end = end_tmp;
105 out = 1;
106 }
107 if ((end - start)) {
108 memset(num, 0, 5);
109 if ((end - start) > 4)
110 return -EINVAL;
111 memcpy(num, start, end - start);
112 if (!qeth_l3_isxdigit(num))
113 return -EINVAL;
114 sscanf(start, "%x", &num2);
115 if (found)
116 in_tmp[save_cnt++] = num2;
117 else
118 in[cnt++] = num2;
119 if (out)
120 break;
121 } else {
122 if (found)
123 return -EINVAL;
124 found = 1;
125 }
126 start = ++end;
127 }
128 if (cnt + save_cnt > 8)
129 return -EINVAL;
130 cnt = 7;
131 while (save_cnt)
132 in[cnt--] = in_tmp[--save_cnt];
133 return 0;
134}
135
136void qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto, const __u8 *addr,
137 char *buf)
138{
139 if (proto == QETH_PROT_IPV4)
140 qeth_l3_ipaddr4_to_string(addr, buf);
141 else if (proto == QETH_PROT_IPV6)
142 qeth_l3_ipaddr6_to_string(addr, buf);
143}
144
145int qeth_l3_string_to_ipaddr(const char *buf, enum qeth_prot_versions proto,
146 __u8 *addr)
147{
148 if (proto == QETH_PROT_IPV4)
149 return qeth_l3_string_to_ipaddr4(buf, addr);
150 else if (proto == QETH_PROT_IPV6)
151 return qeth_l3_string_to_ipaddr6(buf, addr);
152 else
153 return -EINVAL;
154}
155
156static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
157{
158 int i, j;
159 u8 octet;
160
161 for (i = 0; i < len; ++i) {
162 octet = addr[i];
163 for (j = 7; j >= 0; --j) {
164 bits[i*8 + j] = octet & 1;
165 octet >>= 1;
166 }
167 }
168}
169
170static int qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
171 struct qeth_ipaddr *addr)
172{
173 struct qeth_ipato_entry *ipatoe;
174 u8 addr_bits[128] = {0, };
175 u8 ipatoe_bits[128] = {0, };
176 int rc = 0;
177
178 if (!card->ipato.enabled)
179 return 0;
180
181 qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits,
182 (addr->proto == QETH_PROT_IPV4)? 4:16);
183 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
184 if (addr->proto != ipatoe->proto)
185 continue;
186 qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits,
187 (ipatoe->proto == QETH_PROT_IPV4) ?
188 4 : 16);
189 if (addr->proto == QETH_PROT_IPV4)
190 rc = !memcmp(addr_bits, ipatoe_bits,
191 min(32, ipatoe->mask_bits));
192 else
193 rc = !memcmp(addr_bits, ipatoe_bits,
194 min(128, ipatoe->mask_bits));
195 if (rc)
196 break;
197 }
198 /* invert? */
199 if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
200 rc = !rc;
201 else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
202 rc = !rc;
203
204 return rc;
205}
206
207/*
208 * Add IP to be added to todo list. If there is already an "add todo"
209 * in this list we just incremenent the reference count.
210 * Returns 0 if we just incremented reference count.
211 */
212static int __qeth_l3_insert_ip_todo(struct qeth_card *card,
213 struct qeth_ipaddr *addr, int add)
214{
215 struct qeth_ipaddr *tmp, *t;
216 int found = 0;
217
218 list_for_each_entry_safe(tmp, t, card->ip_tbd_list, entry) {
219 if ((addr->type == QETH_IP_TYPE_DEL_ALL_MC) &&
220 (tmp->type == QETH_IP_TYPE_DEL_ALL_MC))
221 return 0;
222 if ((tmp->proto == QETH_PROT_IPV4) &&
223 (addr->proto == QETH_PROT_IPV4) &&
224 (tmp->type == addr->type) &&
225 (tmp->is_multicast == addr->is_multicast) &&
226 (tmp->u.a4.addr == addr->u.a4.addr) &&
227 (tmp->u.a4.mask == addr->u.a4.mask)) {
228 found = 1;
229 break;
230 }
231 if ((tmp->proto == QETH_PROT_IPV6) &&
232 (addr->proto == QETH_PROT_IPV6) &&
233 (tmp->type == addr->type) &&
234 (tmp->is_multicast == addr->is_multicast) &&
235 (tmp->u.a6.pfxlen == addr->u.a6.pfxlen) &&
236 (memcmp(&tmp->u.a6.addr, &addr->u.a6.addr,
237 sizeof(struct in6_addr)) == 0)) {
238 found = 1;
239 break;
240 }
241 }
242 if (found) {
243 if (addr->users != 0)
244 tmp->users += addr->users;
245 else
246 tmp->users += add ? 1 : -1;
247 if (tmp->users == 0) {
248 list_del(&tmp->entry);
249 kfree(tmp);
250 }
251 return 0;
252 } else {
253 if (addr->type == QETH_IP_TYPE_DEL_ALL_MC)
254 list_add(&addr->entry, card->ip_tbd_list);
255 else {
256 if (addr->users == 0)
257 addr->users += add ? 1 : -1;
258 if (add && (addr->type == QETH_IP_TYPE_NORMAL) &&
259 qeth_l3_is_addr_covered_by_ipato(card, addr)) {
d11ba0c4 260 QETH_DBF_TEXT(TRACE, 2, "tkovaddr");
4a71df50
FB		 261 addr->set_flags |= QETH_IPA_SETIP_TAKEOVER_FLAG;
262 }
263 list_add_tail(&addr->entry, card->ip_tbd_list);
264 }
265 return 1;
266 }
267}
268
269static int qeth_l3_delete_ip(struct qeth_card *card, struct qeth_ipaddr *addr)
270{
271 unsigned long flags;
272 int rc = 0;
273
d11ba0c4 274 QETH_DBF_TEXT(TRACE, 4, "delip");
4a71df50
FB		 275
276 if (addr->proto == QETH_PROT_IPV4)
d11ba0c4 277 QETH_DBF_HEX(TRACE, 4, &addr->u.a4.addr, 4);
4a71df50 278 else {
d11ba0c4
PT		 279 QETH_DBF_HEX(TRACE, 4, &addr->u.a6.addr, 8);
280 QETH_DBF_HEX(TRACE, 4, ((char *)&addr->u.a6.addr) + 8, 8);
4a71df50
FB		 281 }
282 spin_lock_irqsave(&card->ip_lock, flags);
283 rc = __qeth_l3_insert_ip_todo(card, addr, 0);
284 spin_unlock_irqrestore(&card->ip_lock, flags);
285 return rc;
286}
287
288static int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *addr)
289{
290 unsigned long flags;
291 int rc = 0;
292
d11ba0c4 293 QETH_DBF_TEXT(TRACE, 4, "addip");
4a71df50 294 if (addr->proto == QETH_PROT_IPV4)
d11ba0c4 295 QETH_DBF_HEX(TRACE, 4, &addr->u.a4.addr, 4);
4a71df50 296 else {
d11ba0c4
PT		 297 QETH_DBF_HEX(TRACE, 4, &addr->u.a6.addr, 8);
298 QETH_DBF_HEX(TRACE, 4, ((char *)&addr->u.a6.addr) + 8, 8);
4a71df50
FB		 299 }
300 spin_lock_irqsave(&card->ip_lock, flags);
301 rc = __qeth_l3_insert_ip_todo(card, addr, 1);
302 spin_unlock_irqrestore(&card->ip_lock, flags);
303 return rc;
304}
305
306
307static struct qeth_ipaddr *qeth_l3_get_addr_buffer(
308 enum qeth_prot_versions prot)
309{
310 struct qeth_ipaddr *addr;
311
312 addr = kzalloc(sizeof(struct qeth_ipaddr), GFP_ATOMIC);
313 if (addr == NULL) {
4a71df50
FB		 314 return NULL;
315 }
316 addr->type = QETH_IP_TYPE_NORMAL;
317 addr->proto = prot;
318 return addr;
319}
320
321static void qeth_l3_delete_mc_addresses(struct qeth_card *card)
322{
323 struct qeth_ipaddr *iptodo;
324 unsigned long flags;
325
d11ba0c4 326 QETH_DBF_TEXT(TRACE, 4, "delmc");
4a71df50
FB		 327 iptodo = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
328 if (!iptodo) {
d11ba0c4 329 QETH_DBF_TEXT(TRACE, 2, "dmcnomem");
4a71df50
FB		 330 return;
331 }
332 iptodo->type = QETH_IP_TYPE_DEL_ALL_MC;
333 spin_lock_irqsave(&card->ip_lock, flags);
334 if (!__qeth_l3_insert_ip_todo(card, iptodo, 0))
335 kfree(iptodo);
336 spin_unlock_irqrestore(&card->ip_lock, flags);
337}
338
339/*
340 * Add/remove address to/from card's ip list, i.e. try to add or remove
341 * reference to/from an IP address that is already registered on the card.
342 * Returns:
343 * 0 address was on card and its reference count has been adjusted,
344 * but is still > 0, so nothing has to be done
345 * also returns 0 if card was not on card and the todo was to delete
346 * the address -> there is also nothing to be done
347 * 1 address was not on card and the todo is to add it to the card's ip
348 * list
349 * -1 address was on card and its reference count has been decremented
350 * to <= 0 by the todo -> address must be removed from card
351 */
352static int __qeth_l3_ref_ip_on_card(struct qeth_card *card,
353 struct qeth_ipaddr *todo, struct qeth_ipaddr **__addr)
354{
355 struct qeth_ipaddr *addr;
356 int found = 0;
357
358 list_for_each_entry(addr, &card->ip_list, entry) {
359 if ((addr->proto == QETH_PROT_IPV4) &&
360 (todo->proto == QETH_PROT_IPV4) &&
361 (addr->type == todo->type) &&
362 (addr->u.a4.addr == todo->u.a4.addr) &&
363 (addr->u.a4.mask == todo->u.a4.mask)) {
364 found = 1;
365 break;
366 }
367 if ((addr->proto == QETH_PROT_IPV6) &&
368 (todo->proto == QETH_PROT_IPV6) &&
369 (addr->type == todo->type) &&
370 (addr->u.a6.pfxlen == todo->u.a6.pfxlen) &&
371 (memcmp(&addr->u.a6.addr, &todo->u.a6.addr,
372 sizeof(struct in6_addr)) == 0)) {
373 found = 1;
374 break;
375 }
376 }
377 if (found) {
378 addr->users += todo->users;
379 if (addr->users <= 0) {
380 *__addr = addr;
381 return -1;
382 } else {
383 /* for VIPA and RXIP limit refcount to 1 */
384 if (addr->type != QETH_IP_TYPE_NORMAL)
385 addr->users = 1;
386 return 0;
387 }
388 }
389 if (todo->users > 0) {
390 /* for VIPA and RXIP limit refcount to 1 */
391 if (todo->type != QETH_IP_TYPE_NORMAL)
392 todo->users = 1;
393 return 1;
394 } else
395 return 0;
396}
397
398static void __qeth_l3_delete_all_mc(struct qeth_card *card,
399 unsigned long *flags)
400{
2d921c32 401 struct list_head fail_list;
4a71df50
FB		 402 struct qeth_ipaddr *addr, *tmp;
403 int rc;
2d921c32
UB		 404
405 INIT_LIST_HEAD(&fail_list);
4a71df50
FB		 406again:
407 list_for_each_entry_safe(addr, tmp, &card->ip_list, entry) {
408 if (addr->is_multicast) {
409 list_del(&addr->entry);
410 spin_unlock_irqrestore(&card->ip_lock, *flags);
411 rc = qeth_l3_deregister_addr_entry(card, addr);
412 spin_lock_irqsave(&card->ip_lock, *flags);
2d921c32 413 if (!rc || (rc == IPA_RC_MC_ADDR_NOT_FOUND))
4a71df50 414 kfree(addr);
2d921c32
UB		 415 else
416 list_add_tail(&addr->entry, &fail_list);
417 goto again;
4a71df50
FB		 418 }
419 }
2d921c32 420 list_splice(&fail_list, &card->ip_list);
4a71df50
FB		 421}
422
423static void qeth_l3_set_ip_addr_list(struct qeth_card *card)
424{
425 struct list_head *tbd_list;
426 struct qeth_ipaddr *todo, *addr;
427 unsigned long flags;
428 int rc;
429
d11ba0c4
PT		 430 QETH_DBF_TEXT(TRACE, 2, "sdiplist");
431 QETH_DBF_HEX(TRACE, 2, &card, sizeof(void *));
4a71df50
FB		 432
433 spin_lock_irqsave(&card->ip_lock, flags);
434 tbd_list = card->ip_tbd_list;
435 card->ip_tbd_list = kmalloc(sizeof(struct list_head), GFP_ATOMIC);
436 if (!card->ip_tbd_list) {
d11ba0c4 437 QETH_DBF_TEXT(TRACE, 0, "silnomem");
4a71df50
FB		 438 card->ip_tbd_list = tbd_list;
439 spin_unlock_irqrestore(&card->ip_lock, flags);
440 return;
441 } else
442 INIT_LIST_HEAD(card->ip_tbd_list);
443
444 while (!list_empty(tbd_list)) {
445 todo = list_entry(tbd_list->next, struct qeth_ipaddr, entry);
446 list_del(&todo->entry);
447 if (todo->type == QETH_IP_TYPE_DEL_ALL_MC) {
448 __qeth_l3_delete_all_mc(card, &flags);
449 kfree(todo);
450 continue;
451 }
452 rc = __qeth_l3_ref_ip_on_card(card, todo, &addr);
453 if (rc == 0) {
454 /* nothing to be done; only adjusted refcount */
455 kfree(todo);
456 } else if (rc == 1) {
457 /* new entry to be added to on-card list */
458 spin_unlock_irqrestore(&card->ip_lock, flags);
459 rc = qeth_l3_register_addr_entry(card, todo);
460 spin_lock_irqsave(&card->ip_lock, flags);
3caa4af8 461 if (!rc || (rc == IPA_RC_LAN_OFFLINE))
4a71df50
FB		 462 list_add_tail(&todo->entry, &card->ip_list);
463 else
464 kfree(todo);
465 } else if (rc == -1) {
466 /* on-card entry to be removed */
467 list_del_init(&addr->entry);
468 spin_unlock_irqrestore(&card->ip_lock, flags);
469 rc = qeth_l3_deregister_addr_entry(card, addr);
470 spin_lock_irqsave(&card->ip_lock, flags);
2d921c32 471 if (!rc || (rc == IPA_RC_PRIMARY_ALREADY_DEFINED))
4a71df50
FB		 472 kfree(addr);
473 else
474 list_add_tail(&addr->entry, &card->ip_list);
475 kfree(todo);
476 }
477 }
478 spin_unlock_irqrestore(&card->ip_lock, flags);
479 kfree(tbd_list);
480}
481
482static void qeth_l3_clear_ip_list(struct qeth_card *card, int clean,
483 int recover)
484{
485 struct qeth_ipaddr *addr, *tmp;
486 unsigned long flags;
487
d11ba0c4 488 QETH_DBF_TEXT(TRACE, 4, "clearip");
4a71df50
FB		 489 spin_lock_irqsave(&card->ip_lock, flags);
490 /* clear todo list */
491 list_for_each_entry_safe(addr, tmp, card->ip_tbd_list, entry) {
492 list_del(&addr->entry);
493 kfree(addr);
494 }
495
496 while (!list_empty(&card->ip_list)) {
497 addr = list_entry(card->ip_list.next,
498 struct qeth_ipaddr, entry);
499 list_del_init(&addr->entry);
500 if (clean) {
501 spin_unlock_irqrestore(&card->ip_lock, flags);
502 qeth_l3_deregister_addr_entry(card, addr);
503 spin_lock_irqsave(&card->ip_lock, flags);
504 }
505 if (!recover || addr->is_multicast) {
506 kfree(addr);
507 continue;
508 }
509 list_add_tail(&addr->entry, card->ip_tbd_list);
510 }
511 spin_unlock_irqrestore(&card->ip_lock, flags);
512}
513
514static int qeth_l3_address_exists_in_list(struct list_head *list,
515 struct qeth_ipaddr *addr, int same_type)
516{
517 struct qeth_ipaddr *tmp;
518
519 list_for_each_entry(tmp, list, entry) {
520 if ((tmp->proto == QETH_PROT_IPV4) &&
521 (addr->proto == QETH_PROT_IPV4) &&
522 ((same_type && (tmp->type == addr->type)) ||
523 (!same_type && (tmp->type != addr->type))) &&
524 (tmp->u.a4.addr == addr->u.a4.addr))
525 return 1;
526
527 if ((tmp->proto == QETH_PROT_IPV6) &&
528 (addr->proto == QETH_PROT_IPV6) &&
529 ((same_type && (tmp->type == addr->type)) ||
530 (!same_type && (tmp->type != addr->type))) &&
531 (memcmp(&tmp->u.a6.addr, &addr->u.a6.addr,
532 sizeof(struct in6_addr)) == 0))
533 return 1;
534
535 }
536 return 0;
537}
538
539static int qeth_l3_send_setdelmc(struct qeth_card *card,
540 struct qeth_ipaddr *addr, int ipacmd)
541{
542 int rc;
543 struct qeth_cmd_buffer *iob;
544 struct qeth_ipa_cmd *cmd;
545
d11ba0c4 546 QETH_DBF_TEXT(TRACE, 4, "setdelmc");
4a71df50
FB		 547
548 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
549 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
550 memcpy(&cmd->data.setdelipm.mac, addr->mac, OSA_ADDR_LEN);
551 if (addr->proto == QETH_PROT_IPV6)
552 memcpy(cmd->data.setdelipm.ip6, &addr->u.a6.addr,
553 sizeof(struct in6_addr));
554 else
555 memcpy(&cmd->data.setdelipm.ip4, &addr->u.a4.addr, 4);
556
557 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
558
559 return rc;
560}
561
562static void qeth_l3_fill_netmask(u8 *netmask, unsigned int len)
563{
564 int i, j;
565 for (i = 0; i < 16; i++) {
566 j = (len) - (i * 8);
567 if (j >= 8)
568 netmask[i] = 0xff;
569 else if (j > 0)
570 netmask[i] = (u8)(0xFF00 >> j);
571 else
572 netmask[i] = 0;
573 }
574}
575
576static int qeth_l3_send_setdelip(struct qeth_card *card,
577 struct qeth_ipaddr *addr, int ipacmd, unsigned int flags)
578{
579 int rc;
580 struct qeth_cmd_buffer *iob;
581 struct qeth_ipa_cmd *cmd;
582 __u8 netmask[16];
583
d11ba0c4
PT		 584 QETH_DBF_TEXT(TRACE, 4, "setdelip");
585 QETH_DBF_TEXT_(TRACE, 4, "flags%02X", flags);
4a71df50
FB		 586
587 iob = qeth_get_ipacmd_buffer(card, ipacmd, addr->proto);
588 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
589 if (addr->proto == QETH_PROT_IPV6) {
590 memcpy(cmd->data.setdelip6.ip_addr, &addr->u.a6.addr,
591 sizeof(struct in6_addr));
592 qeth_l3_fill_netmask(netmask, addr->u.a6.pfxlen);
593 memcpy(cmd->data.setdelip6.mask, netmask,
594 sizeof(struct in6_addr));
595 cmd->data.setdelip6.flags = flags;
596 } else {
597 memcpy(cmd->data.setdelip4.ip_addr, &addr->u.a4.addr, 4);
598 memcpy(cmd->data.setdelip4.mask, &addr->u.a4.mask, 4);
599 cmd->data.setdelip4.flags = flags;
600 }
601
602 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
603
604 return rc;
605}
606
607static int qeth_l3_send_setrouting(struct qeth_card *card,
608 enum qeth_routing_types type, enum qeth_prot_versions prot)
609{
610 int rc;
611 struct qeth_ipa_cmd *cmd;
612 struct qeth_cmd_buffer *iob;
613
d11ba0c4 614 QETH_DBF_TEXT(TRACE, 4, "setroutg");
4a71df50
FB		 615 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETRTG, prot);
616 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
617 cmd->data.setrtg.type = (type);
618 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
619
620 return rc;
621}
622
623static void qeth_l3_correct_routing_type(struct qeth_card *card,
624 enum qeth_routing_types *type, enum qeth_prot_versions prot)
625{
626 if (card->info.type == QETH_CARD_TYPE_IQD) {
627 switch (*type) {
628 case NO_ROUTER:
629 case PRIMARY_CONNECTOR:
630 case SECONDARY_CONNECTOR:
631 case MULTICAST_ROUTER:
632 return;
633 default:
634 goto out_inval;
635 }
636 } else {
637 switch (*type) {
638 case NO_ROUTER:
639 case PRIMARY_ROUTER:
640 case SECONDARY_ROUTER:
641 return;
642 case MULTICAST_ROUTER:
643 if (qeth_is_ipafunc_supported(card, prot,
644 IPA_OSA_MC_ROUTER))
645 return;
646 default:
647 goto out_inval;
648 }
649 }
650out_inval:
4a71df50
FB		 651 *type = NO_ROUTER;
652}
653
654int qeth_l3_setrouting_v4(struct qeth_card *card)
655{
656 int rc;
657
d11ba0c4 658 QETH_DBF_TEXT(TRACE, 3, "setrtg4");
4a71df50
FB		 659
660 qeth_l3_correct_routing_type(card, &card->options.route4.type,
661 QETH_PROT_IPV4);
662
663 rc = qeth_l3_send_setrouting(card, card->options.route4.type,
664 QETH_PROT_IPV4);
665 if (rc) {
666 card->options.route4.type = NO_ROUTER;
14cc21b6
FB		 667 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
668 " on %s. Type set to 'no router'.\n", rc,
669 QETH_CARD_IFNAME(card));
4a71df50
FB		 670 }
671 return rc;
672}
673
674int qeth_l3_setrouting_v6(struct qeth_card *card)
675{
676 int rc = 0;
677
d11ba0c4 678 QETH_DBF_TEXT(TRACE, 3, "setrtg6");
4a71df50
FB		 679#ifdef CONFIG_QETH_IPV6
680
681 if (!qeth_is_supported(card, IPA_IPV6))
682 return 0;
683 qeth_l3_correct_routing_type(card, &card->options.route6.type,
684 QETH_PROT_IPV6);
685
686 rc = qeth_l3_send_setrouting(card, card->options.route6.type,
687 QETH_PROT_IPV6);
688 if (rc) {
689 card->options.route6.type = NO_ROUTER;
14cc21b6
FB		 690 QETH_DBF_MESSAGE(2, "Error (0x%04x) while setting routing type"
691 " on %s. Type set to 'no router'.\n", rc,
692 QETH_CARD_IFNAME(card));
4a71df50
FB		 693 }
694#endif
695 return rc;
696}
697
698/*
699 * IP address takeover related functions
700 */
701static void qeth_l3_clear_ipato_list(struct qeth_card *card)
702{
703
704 struct qeth_ipato_entry *ipatoe, *tmp;
705 unsigned long flags;
706
707 spin_lock_irqsave(&card->ip_lock, flags);
708 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
709 list_del(&ipatoe->entry);
710 kfree(ipatoe);
711 }
712 spin_unlock_irqrestore(&card->ip_lock, flags);
713}
714
715int qeth_l3_add_ipato_entry(struct qeth_card *card,
716 struct qeth_ipato_entry *new)
717{
718 struct qeth_ipato_entry *ipatoe;
719 unsigned long flags;
720 int rc = 0;
721
d11ba0c4 722 QETH_DBF_TEXT(TRACE, 2, "addipato");
4a71df50
FB		 723 spin_lock_irqsave(&card->ip_lock, flags);
724 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
725 if (ipatoe->proto != new->proto)
726 continue;
727 if (!memcmp(ipatoe->addr, new->addr,
728 (ipatoe->proto == QETH_PROT_IPV4)? 4:16) &&
729 (ipatoe->mask_bits == new->mask_bits)) {
4a71df50
FB		 730 rc = -EEXIST;
731 break;
732 }
733 }
734 if (!rc)
735 list_add_tail(&new->entry, &card->ipato.entries);
736
737 spin_unlock_irqrestore(&card->ip_lock, flags);
738 return rc;
739}
740
741void qeth_l3_del_ipato_entry(struct qeth_card *card,
742 enum qeth_prot_versions proto, u8 *addr, int mask_bits)
743{
744 struct qeth_ipato_entry *ipatoe, *tmp;
745 unsigned long flags;
746
d11ba0c4 747 QETH_DBF_TEXT(TRACE, 2, "delipato");
4a71df50
FB		 748 spin_lock_irqsave(&card->ip_lock, flags);
749 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
750 if (ipatoe->proto != proto)
751 continue;
752 if (!memcmp(ipatoe->addr, addr,
753 (proto == QETH_PROT_IPV4)? 4:16) &&
754 (ipatoe->mask_bits == mask_bits)) {
755 list_del(&ipatoe->entry);
756 kfree(ipatoe);
757 }
758 }
759 spin_unlock_irqrestore(&card->ip_lock, flags);
760}
761
762/*
763 * VIPA related functions
764 */
765int qeth_l3_add_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
766 const u8 *addr)
767{
768 struct qeth_ipaddr *ipaddr;
769 unsigned long flags;
770 int rc = 0;
771
772 ipaddr = qeth_l3_get_addr_buffer(proto);
773 if (ipaddr) {
774 if (proto == QETH_PROT_IPV4) {
d11ba0c4 775 QETH_DBF_TEXT(TRACE, 2, "addvipa4");
4a71df50
FB		 776 memcpy(&ipaddr->u.a4.addr, addr, 4);
777 ipaddr->u.a4.mask = 0;
778 } else if (proto == QETH_PROT_IPV6) {
d11ba0c4 779 QETH_DBF_TEXT(TRACE, 2, "addvipa6");
4a71df50
FB		 780 memcpy(&ipaddr->u.a6.addr, addr, 16);
781 ipaddr->u.a6.pfxlen = 0;
782 }
783 ipaddr->type = QETH_IP_TYPE_VIPA;
784 ipaddr->set_flags = QETH_IPA_SETIP_VIPA_FLAG;
785 ipaddr->del_flags = QETH_IPA_DELIP_VIPA_FLAG;
786 } else
787 return -ENOMEM;
788 spin_lock_irqsave(&card->ip_lock, flags);
789 if (qeth_l3_address_exists_in_list(&card->ip_list, ipaddr, 0) ||
790 qeth_l3_address_exists_in_list(card->ip_tbd_list, ipaddr, 0))
791 rc = -EEXIST;
792 spin_unlock_irqrestore(&card->ip_lock, flags);
793 if (rc) {
4a71df50
FB		 794 return rc;
795 }
796 if (!qeth_l3_add_ip(card, ipaddr))
797 kfree(ipaddr);
798 qeth_l3_set_ip_addr_list(card);
799 return rc;
800}
801
802void qeth_l3_del_vipa(struct qeth_card *card, enum qeth_prot_versions proto,
803 const u8 *addr)
804{
805 struct qeth_ipaddr *ipaddr;
806
807 ipaddr = qeth_l3_get_addr_buffer(proto);
808 if (ipaddr) {
809 if (proto == QETH_PROT_IPV4) {
d11ba0c4 810 QETH_DBF_TEXT(TRACE, 2, "delvipa4");
4a71df50
FB		 811 memcpy(&ipaddr->u.a4.addr, addr, 4);
812 ipaddr->u.a4.mask = 0;
813 } else if (proto == QETH_PROT_IPV6) {
d11ba0c4 814 QETH_DBF_TEXT(TRACE, 2, "delvipa6");
4a71df50
FB		 815 memcpy(&ipaddr->u.a6.addr, addr, 16);
816 ipaddr->u.a6.pfxlen = 0;
817 }
818 ipaddr->type = QETH_IP_TYPE_VIPA;
819 } else
820 return;
821 if (!qeth_l3_delete_ip(card, ipaddr))
822 kfree(ipaddr);
823 qeth_l3_set_ip_addr_list(card);
824}
825
826/*
827 * proxy ARP related functions
828 */
829int qeth_l3_add_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
830 const u8 *addr)
831{
832 struct qeth_ipaddr *ipaddr;
833 unsigned long flags;
834 int rc = 0;
835
836 ipaddr = qeth_l3_get_addr_buffer(proto);
837 if (ipaddr) {
838 if (proto == QETH_PROT_IPV4) {
d11ba0c4 839 QETH_DBF_TEXT(TRACE, 2, "addrxip4");
4a71df50
FB		 840 memcpy(&ipaddr->u.a4.addr, addr, 4);
841 ipaddr->u.a4.mask = 0;
842 } else if (proto == QETH_PROT_IPV6) {
d11ba0c4 843 QETH_DBF_TEXT(TRACE, 2, "addrxip6");
4a71df50
FB		 844 memcpy(&ipaddr->u.a6.addr, addr, 16);
845 ipaddr->u.a6.pfxlen = 0;
846 }
847 ipaddr->type = QETH_IP_TYPE_RXIP;
848 ipaddr->set_flags = QETH_IPA_SETIP_TAKEOVER_FLAG;
849 ipaddr->del_flags = 0;
850 } else
851 return -ENOMEM;
852 spin_lock_irqsave(&card->ip_lock, flags);
853 if (qeth_l3_address_exists_in_list(&card->ip_list, ipaddr, 0) ||
854 qeth_l3_address_exists_in_list(card->ip_tbd_list, ipaddr, 0))
855 rc = -EEXIST;
856 spin_unlock_irqrestore(&card->ip_lock, flags);
857 if (rc) {
4a71df50
FB		 858 return rc;
859 }
860 if (!qeth_l3_add_ip(card, ipaddr))
861 kfree(ipaddr);
862 qeth_l3_set_ip_addr_list(card);
863 return 0;
864}
865
866void qeth_l3_del_rxip(struct qeth_card *card, enum qeth_prot_versions proto,
867 const u8 *addr)
868{
869 struct qeth_ipaddr *ipaddr;
870
871 ipaddr = qeth_l3_get_addr_buffer(proto);
872 if (ipaddr) {
873 if (proto == QETH_PROT_IPV4) {
d11ba0c4 874 QETH_DBF_TEXT(TRACE, 2, "addrxip4");
4a71df50
FB		 875 memcpy(&ipaddr->u.a4.addr, addr, 4);
876 ipaddr->u.a4.mask = 0;
877 } else if (proto == QETH_PROT_IPV6) {
d11ba0c4 878 QETH_DBF_TEXT(TRACE, 2, "addrxip6");
4a71df50
FB		 879 memcpy(&ipaddr->u.a6.addr, addr, 16);
880 ipaddr->u.a6.pfxlen = 0;
881 }
882 ipaddr->type = QETH_IP_TYPE_RXIP;
883 } else
884 return;
885 if (!qeth_l3_delete_ip(card, ipaddr))
886 kfree(ipaddr);
887 qeth_l3_set_ip_addr_list(card);
888}
889
890static int qeth_l3_register_addr_entry(struct qeth_card *card,
891 struct qeth_ipaddr *addr)
892{
893 char buf[50];
894 int rc = 0;
895 int cnt = 3;
896
897 if (addr->proto == QETH_PROT_IPV4) {
d11ba0c4
PT		 898 QETH_DBF_TEXT(TRACE, 2, "setaddr4");
899 QETH_DBF_HEX(TRACE, 3, &addr->u.a4.addr, sizeof(int));
4a71df50 900 } else if (addr->proto == QETH_PROT_IPV6) {
d11ba0c4
PT		 901 QETH_DBF_TEXT(TRACE, 2, "setaddr6");
902 QETH_DBF_HEX(TRACE, 3, &addr->u.a6.addr, 8);
903 QETH_DBF_HEX(TRACE, 3, ((char *)&addr->u.a6.addr) + 8, 8);
4a71df50 904 } else {
d11ba0c4
PT		 905 QETH_DBF_TEXT(TRACE, 2, "setaddr?");
906 QETH_DBF_HEX(TRACE, 3, addr, sizeof(struct qeth_ipaddr));
4a71df50
FB		 907 }
908 do {
909 if (addr->is_multicast)
910 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
911 else
912 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP,
913 addr->set_flags);
914 if (rc)
d11ba0c4 915 QETH_DBF_TEXT(TRACE, 2, "failed");
4a71df50
FB		 916 } while ((--cnt > 0) && rc);
917 if (rc) {
d11ba0c4 918 QETH_DBF_TEXT(TRACE, 2, "FAILED");
4a71df50
FB		 919 qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
920 PRINT_WARN("Could not register IP address %s (rc=0x%x/%d)\n",
921 buf, rc, rc);
922 }
923 return rc;
924}
925
926static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
927 struct qeth_ipaddr *addr)
928{
929 int rc = 0;
930
931 if (addr->proto == QETH_PROT_IPV4) {
d11ba0c4
PT		 932 QETH_DBF_TEXT(TRACE, 2, "deladdr4");
933 QETH_DBF_HEX(TRACE, 3, &addr->u.a4.addr, sizeof(int));
4a71df50 934 } else if (addr->proto == QETH_PROT_IPV6) {
d11ba0c4
PT		 935 QETH_DBF_TEXT(TRACE, 2, "deladdr6");
936 QETH_DBF_HEX(TRACE, 3, &addr->u.a6.addr, 8);
937 QETH_DBF_HEX(TRACE, 3, ((char *)&addr->u.a6.addr) + 8, 8);
4a71df50 938 } else {
d11ba0c4
PT		 939 QETH_DBF_TEXT(TRACE, 2, "deladdr?");
940 QETH_DBF_HEX(TRACE, 3, addr, sizeof(struct qeth_ipaddr));
4a71df50
FB		 941 }
942 if (addr->is_multicast)
943 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
944 else
945 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP,
946 addr->del_flags);
c4cef07c 947 if (rc)
d11ba0c4 948 QETH_DBF_TEXT(TRACE, 2, "failed");
4a71df50
FB		 949
950 return rc;
951}
952
953static inline u8 qeth_l3_get_qeth_hdr_flags4(int cast_type)
954{
955 if (cast_type == RTN_MULTICAST)
956 return QETH_CAST_MULTICAST;
957 if (cast_type == RTN_BROADCAST)
958 return QETH_CAST_BROADCAST;
959 return QETH_CAST_UNICAST;
960}
961
962static inline u8 qeth_l3_get_qeth_hdr_flags6(int cast_type)
963{
964 u8 ct = QETH_HDR_PASSTHRU | QETH_HDR_IPV6;
965 if (cast_type == RTN_MULTICAST)
966 return ct | QETH_CAST_MULTICAST;
967 if (cast_type == RTN_ANYCAST)
968 return ct | QETH_CAST_ANYCAST;
969 if (cast_type == RTN_BROADCAST)
970 return ct | QETH_CAST_BROADCAST;
971 return ct | QETH_CAST_UNICAST;
972}
973
974static int qeth_l3_send_setadp_mode(struct qeth_card *card, __u32 command,
975 __u32 mode)
976{
977 int rc;
978 struct qeth_cmd_buffer *iob;
979 struct qeth_ipa_cmd *cmd;
980
d11ba0c4 981 QETH_DBF_TEXT(TRACE, 4, "adpmode");
4a71df50
FB		 982
983 iob = qeth_get_adapter_cmd(card, command,
984 sizeof(struct qeth_ipacmd_setadpparms));
985 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
986 cmd->data.setadapterparms.data.mode = mode;
987 rc = qeth_send_ipa_cmd(card, iob, qeth_default_setadapterparms_cb,
988 NULL);
989 return rc;
990}
991
992static int qeth_l3_setadapter_hstr(struct qeth_card *card)
993{
994 int rc;
995
d11ba0c4 996 QETH_DBF_TEXT(TRACE, 4, "adphstr");
4a71df50
FB		 997
998 if (qeth_adp_supported(card, IPA_SETADP_SET_BROADCAST_MODE)) {
999 rc = qeth_l3_send_setadp_mode(card,
1000 IPA_SETADP_SET_BROADCAST_MODE,
1001 card->options.broadcast_mode);
1002 if (rc)
14cc21b6 1003 QETH_DBF_MESSAGE(2, "couldn't set broadcast mode on "
4a71df50
FB		 1004 "device %s: x%x\n",
1005 CARD_BUS_ID(card), rc);
1006 rc = qeth_l3_send_setadp_mode(card,
1007 IPA_SETADP_ALTER_MAC_ADDRESS,
1008 card->options.macaddr_mode);
1009 if (rc)
14cc21b6 1010 QETH_DBF_MESSAGE(2, "couldn't set macaddr mode on "
4a71df50
FB		 1011 "device %s: x%x\n", CARD_BUS_ID(card), rc);
1012 return rc;
1013 }
1014 if (card->options.broadcast_mode == QETH_TR_BROADCAST_LOCAL)
14cc21b6 1015 QETH_DBF_MESSAGE(2, "set adapter parameters not available "
4a71df50
FB		 1016 "to set broadcast mode, using ALLRINGS "
1017 "on device %s:\n", CARD_BUS_ID(card));
1018 if (card->options.macaddr_mode == QETH_TR_MACADDR_CANONICAL)
14cc21b6 1019 QETH_DBF_MESSAGE(2, "set adapter parameters not available "
4a71df50
FB		 1020 "to set macaddr mode, using NONCANONICAL "
1021 "on device %s:\n", CARD_BUS_ID(card));
1022 return 0;
1023}
1024
1025static int qeth_l3_setadapter_parms(struct qeth_card *card)
1026{
1027 int rc;
1028
d11ba0c4 1029 QETH_DBF_TEXT(SETUP, 2, "setadprm");
4a71df50
FB		 1030
1031 if (!qeth_is_supported(card, IPA_SETADAPTERPARMS)) {
1032 PRINT_WARN("set adapter parameters not supported "
1033 "on device %s.\n",
1034 CARD_BUS_ID(card));
d11ba0c4 1035 QETH_DBF_TEXT(SETUP, 2, " notsupp");
4a71df50
FB		 1036 return 0;
1037 }
1038 rc = qeth_query_setadapterparms(card);
1039 if (rc) {
1040 PRINT_WARN("couldn't set adapter parameters on device %s: "
1041 "x%x\n", CARD_BUS_ID(card), rc);
1042 return rc;
1043 }
1044 if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
1045 rc = qeth_setadpparms_change_macaddr(card);
1046 if (rc)
1047 PRINT_WARN("couldn't get MAC address on "
1048 "device %s: x%x\n",
1049 CARD_BUS_ID(card), rc);
1050 }
1051
1052 if ((card->info.link_type == QETH_LINK_TYPE_HSTR) ||
1053 (card->info.link_type == QETH_LINK_TYPE_LANE_TR))
1054 rc = qeth_l3_setadapter_hstr(card);
1055
1056 return rc;
1057}
1058
1059static int qeth_l3_default_setassparms_cb(struct qeth_card *card,
1060 struct qeth_reply *reply, unsigned long data)
1061{
1062 struct qeth_ipa_cmd *cmd;
1063
d11ba0c4 1064 QETH_DBF_TEXT(TRACE, 4, "defadpcb");
4a71df50
FB		 1065
1066 cmd = (struct qeth_ipa_cmd *) data;
1067 if (cmd->hdr.return_code == 0) {
1068 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
1069 if (cmd->hdr.prot_version == QETH_PROT_IPV4)
1070 card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
1071 if (cmd->hdr.prot_version == QETH_PROT_IPV6)
1072 card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
1073 }
1074 if (cmd->data.setassparms.hdr.assist_no == IPA_INBOUND_CHECKSUM &&
1075 cmd->data.setassparms.hdr.command_code == IPA_CMD_ASS_START) {
1076 card->info.csum_mask = cmd->data.setassparms.data.flags_32bit;
d11ba0c4 1077 QETH_DBF_TEXT_(TRACE, 3, "csum:%d", card->info.csum_mask);
4a71df50
FB		 1078 }
1079 return 0;
1080}
1081
1082static struct qeth_cmd_buffer *qeth_l3_get_setassparms_cmd(
1083 struct qeth_card *card, enum qeth_ipa_funcs ipa_func, __u16 cmd_code,
1084 __u16 len, enum qeth_prot_versions prot)
1085{
1086 struct qeth_cmd_buffer *iob;
1087 struct qeth_ipa_cmd *cmd;
1088
d11ba0c4 1089 QETH_DBF_TEXT(TRACE, 4, "getasscm");
4a71df50
FB		 1090 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_SETASSPARMS, prot);
1091
1092 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1093 cmd->data.setassparms.hdr.assist_no = ipa_func;
1094 cmd->data.setassparms.hdr.length = 8 + len;
1095 cmd->data.setassparms.hdr.command_code = cmd_code;
1096 cmd->data.setassparms.hdr.return_code = 0;
1097 cmd->data.setassparms.hdr.seq_no = 0;
1098
1099 return iob;
1100}
1101
1102static int qeth_l3_send_setassparms(struct qeth_card *card,
1103 struct qeth_cmd_buffer *iob, __u16 len, long data,
1104 int (*reply_cb)(struct qeth_card *, struct qeth_reply *,
1105 unsigned long),
1106 void *reply_param)
1107{
1108 int rc;
1109 struct qeth_ipa_cmd *cmd;
1110
d11ba0c4 1111 QETH_DBF_TEXT(TRACE, 4, "sendassp");
4a71df50
FB		 1112
1113 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1114 if (len <= sizeof(__u32))
1115 cmd->data.setassparms.data.flags_32bit = (__u32) data;
1116 else /* (len > sizeof(__u32)) */
1117 memcpy(&cmd->data.setassparms.data, (void *) data, len);
1118
1119 rc = qeth_send_ipa_cmd(card, iob, reply_cb, reply_param);
1120 return rc;
1121}
1122
1123#ifdef CONFIG_QETH_IPV6
1124static int qeth_l3_send_simple_setassparms_ipv6(struct qeth_card *card,
1125 enum qeth_ipa_funcs ipa_func, __u16 cmd_code)
1126{
1127 int rc;
1128 struct qeth_cmd_buffer *iob;
1129
d11ba0c4 1130 QETH_DBF_TEXT(TRACE, 4, "simassp6");
4a71df50
FB		 1131 iob = qeth_l3_get_setassparms_cmd(card, ipa_func, cmd_code,
1132 0, QETH_PROT_IPV6);
1133 rc = qeth_l3_send_setassparms(card, iob, 0, 0,
1134 qeth_l3_default_setassparms_cb, NULL);
1135 return rc;
1136}
1137#endif
1138
1139static int qeth_l3_send_simple_setassparms(struct qeth_card *card,
1140 enum qeth_ipa_funcs ipa_func, __u16 cmd_code, long data)
1141{
1142 int rc;
1143 int length = 0;
1144 struct qeth_cmd_buffer *iob;
1145
d11ba0c4 1146 QETH_DBF_TEXT(TRACE, 4, "simassp4");
4a71df50
FB		 1147 if (data)
1148 length = sizeof(__u32);
1149 iob = qeth_l3_get_setassparms_cmd(card, ipa_func, cmd_code,
1150 length, QETH_PROT_IPV4);
1151 rc = qeth_l3_send_setassparms(card, iob, length, data,
1152 qeth_l3_default_setassparms_cb, NULL);
1153 return rc;
1154}
1155
1156static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
1157{
1158 int rc;
1159
d11ba0c4 1160 QETH_DBF_TEXT(TRACE, 3, "ipaarp");
4a71df50
FB		 1161
1162 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1163 PRINT_WARN("ARP processing not supported "
1164 "on %s!\n", QETH_CARD_IFNAME(card));
1165 return 0;
1166 }
1167 rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
1168 IPA_CMD_ASS_START, 0);
1169 if (rc) {
1170 PRINT_WARN("Could not start ARP processing "
1171 "assist on %s: 0x%x\n",
1172 QETH_CARD_IFNAME(card), rc);
1173 }
1174 return rc;
1175}
1176
1177static int qeth_l3_start_ipa_ip_fragmentation(struct qeth_card *card)
1178{
1179 int rc;
1180
d11ba0c4 1181 QETH_DBF_TEXT(TRACE, 3, "ipaipfrg");
4a71df50
FB		 1182
1183 if (!qeth_is_supported(card, IPA_IP_FRAGMENTATION)) {
1184 PRINT_INFO("Hardware IP fragmentation not supported on %s\n",
1185 QETH_CARD_IFNAME(card));
1186 return -EOPNOTSUPP;
1187 }
1188
1189 rc = qeth_l3_send_simple_setassparms(card, IPA_IP_FRAGMENTATION,
1190 IPA_CMD_ASS_START, 0);
1191 if (rc) {
1192 PRINT_WARN("Could not start Hardware IP fragmentation "
1193 "assist on %s: 0x%x\n",
1194 QETH_CARD_IFNAME(card), rc);
1195 } else
1196 PRINT_INFO("Hardware IP fragmentation enabled \n");
1197 return rc;
1198}
1199
1200static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
1201{
1202 int rc;
1203
d11ba0c4 1204 QETH_DBF_TEXT(TRACE, 3, "stsrcmac");
4a71df50
FB		 1205
1206 if (!card->options.fake_ll)
1207 return -EOPNOTSUPP;
1208
1209 if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
1210 PRINT_INFO("Inbound source address not "
1211 "supported on %s\n", QETH_CARD_IFNAME(card));
1212 return -EOPNOTSUPP;
1213 }
1214
1215 rc = qeth_l3_send_simple_setassparms(card, IPA_SOURCE_MAC,
1216 IPA_CMD_ASS_START, 0);
1217 if (rc)
1218 PRINT_WARN("Could not start inbound source "
1219 "assist on %s: 0x%x\n",
1220 QETH_CARD_IFNAME(card), rc);
1221 return rc;
1222}
1223
1224static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
1225{
1226 int rc = 0;
1227
d11ba0c4 1228 QETH_DBF_TEXT(TRACE, 3, "strtvlan");
4a71df50
FB		 1229
1230 if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
1231 PRINT_WARN("VLAN not supported on %s\n",
1232 QETH_CARD_IFNAME(card));
1233 return -EOPNOTSUPP;
1234 }
1235
1236 rc = qeth_l3_send_simple_setassparms(card, IPA_VLAN_PRIO,
1237 IPA_CMD_ASS_START, 0);
1238 if (rc) {
1239 PRINT_WARN("Could not start vlan "
1240 "assist on %s: 0x%x\n",
1241 QETH_CARD_IFNAME(card), rc);
1242 } else {
1243 PRINT_INFO("VLAN enabled \n");
1244 }
1245 return rc;
1246}
1247
1248static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
1249{
1250 int rc;
1251
d11ba0c4 1252 QETH_DBF_TEXT(TRACE, 3, "stmcast");
4a71df50
FB		 1253
1254 if (!qeth_is_supported(card, IPA_MULTICASTING)) {
1255 PRINT_WARN("Multicast not supported on %s\n",
1256 QETH_CARD_IFNAME(card));
1257 return -EOPNOTSUPP;
1258 }
1259
1260 rc = qeth_l3_send_simple_setassparms(card, IPA_MULTICASTING,
1261 IPA_CMD_ASS_START, 0);
1262 if (rc) {
1263 PRINT_WARN("Could not start multicast "
1264 "assist on %s: rc=%i\n",
1265 QETH_CARD_IFNAME(card), rc);
1266 } else {
1267 PRINT_INFO("Multicast enabled\n");
1268 card->dev->flags |= IFF_MULTICAST;
1269 }
1270 return rc;
1271}
1272
1273static int qeth_l3_query_ipassists_cb(struct qeth_card *card,
1274 struct qeth_reply *reply, unsigned long data)
1275{
1276 struct qeth_ipa_cmd *cmd;
1277
d11ba0c4 1278 QETH_DBF_TEXT(SETUP, 2, "qipasscb");
4a71df50
FB		 1279
1280 cmd = (struct qeth_ipa_cmd *) data;
1281 if (cmd->hdr.prot_version == QETH_PROT_IPV4) {
1282 card->options.ipa4.supported_funcs = cmd->hdr.ipa_supported;
1283 card->options.ipa4.enabled_funcs = cmd->hdr.ipa_enabled;
1284 } else {
1285 card->options.ipa6.supported_funcs = cmd->hdr.ipa_supported;
1286 card->options.ipa6.enabled_funcs = cmd->hdr.ipa_enabled;
1287 }
d11ba0c4
PT		 1288 QETH_DBF_TEXT(SETUP, 2, "suppenbl");
1289 QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_supported);
1290 QETH_DBF_TEXT_(SETUP, 2, "%x", cmd->hdr.ipa_enabled);
4a71df50
FB		 1291 return 0;
1292}
1293
1294static int qeth_l3_query_ipassists(struct qeth_card *card,
1295 enum qeth_prot_versions prot)
1296{
1297 int rc;
1298 struct qeth_cmd_buffer *iob;
1299
d11ba0c4 1300 QETH_DBF_TEXT_(SETUP, 2, "qipassi%i", prot);
4a71df50
FB		 1301 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_QIPASSIST, prot);
1302 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_query_ipassists_cb, NULL);
1303 return rc;
1304}
1305
1306#ifdef CONFIG_QETH_IPV6
1307static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
1308{
1309 int rc;
1310
d11ba0c4 1311 QETH_DBF_TEXT(TRACE, 3, "softipv6");
4a71df50
FB		 1312
1313 if (card->info.type == QETH_CARD_TYPE_IQD)
1314 goto out;
1315
1316 rc = qeth_l3_query_ipassists(card, QETH_PROT_IPV6);
1317 if (rc) {
1318 PRINT_ERR("IPv6 query ipassist failed on %s\n",
1319 QETH_CARD_IFNAME(card));
1320 return rc;
1321 }
1322 rc = qeth_l3_send_simple_setassparms(card, IPA_IPV6,
1323 IPA_CMD_ASS_START, 3);
1324 if (rc) {
1325 PRINT_WARN("IPv6 start assist (version 4) failed "
1326 "on %s: 0x%x\n",
1327 QETH_CARD_IFNAME(card), rc);
1328 return rc;
1329 }
1330 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_IPV6,
1331 IPA_CMD_ASS_START);
1332 if (rc) {
1333 PRINT_WARN("IPV6 start assist (version 6) failed "
1334 "on %s: 0x%x\n",
1335 QETH_CARD_IFNAME(card), rc);
1336 return rc;
1337 }
1338 rc = qeth_l3_send_simple_setassparms_ipv6(card, IPA_PASSTHRU,
1339 IPA_CMD_ASS_START);
1340 if (rc) {
1341 PRINT_WARN("Could not enable passthrough "
1342 "on %s: 0x%x\n",
1343 QETH_CARD_IFNAME(card), rc);
1344 return rc;
1345 }
1346out:
1347 PRINT_INFO("IPV6 enabled \n");
1348 return 0;
1349}
1350#endif
1351
1352static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
1353{
1354 int rc = 0;
1355
d11ba0c4 1356 QETH_DBF_TEXT(TRACE, 3, "strtipv6");
4a71df50
FB		 1357
1358 if (!qeth_is_supported(card, IPA_IPV6)) {
1359 PRINT_WARN("IPv6 not supported on %s\n",
1360 QETH_CARD_IFNAME(card));
1361 return 0;
1362 }
1363#ifdef CONFIG_QETH_IPV6
1364 rc = qeth_l3_softsetup_ipv6(card);
1365#endif
1366 return rc ;
1367}
1368
1369static int qeth_l3_start_ipa_broadcast(struct qeth_card *card)
1370{
1371 int rc;
1372
d11ba0c4 1373 QETH_DBF_TEXT(TRACE, 3, "stbrdcst");
4a71df50
FB		 1374 card->info.broadcast_capable = 0;
1375 if (!qeth_is_supported(card, IPA_FILTERING)) {
1376 PRINT_WARN("Broadcast not supported on %s\n",
1377 QETH_CARD_IFNAME(card));
1378 rc = -EOPNOTSUPP;
1379 goto out;
1380 }
1381 rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
1382 IPA_CMD_ASS_START, 0);
1383 if (rc) {
1384 PRINT_WARN("Could not enable broadcasting filtering "
1385 "on %s: 0x%x\n",
1386 QETH_CARD_IFNAME(card), rc);
1387 goto out;
1388 }
1389
1390 rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
1391 IPA_CMD_ASS_CONFIGURE, 1);
1392 if (rc) {
1393 PRINT_WARN("Could not set up broadcast filtering on %s: 0x%x\n",
1394 QETH_CARD_IFNAME(card), rc);
1395 goto out;
1396 }
1397 card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
1398 PRINT_INFO("Broadcast enabled \n");
1399 rc = qeth_l3_send_simple_setassparms(card, IPA_FILTERING,
1400 IPA_CMD_ASS_ENABLE, 1);
1401 if (rc) {
1402 PRINT_WARN("Could not set up broadcast echo filtering on "
1403 "%s: 0x%x\n", QETH_CARD_IFNAME(card), rc);
1404 goto out;
1405 }
1406 card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
1407out:
1408 if (card->info.broadcast_capable)
1409 card->dev->flags |= IFF_BROADCAST;
1410 else
1411 card->dev->flags &= ~IFF_BROADCAST;
1412 return rc;
1413}
1414
1415static int qeth_l3_send_checksum_command(struct qeth_card *card)
1416{
1417 int rc;
1418
1419 rc = qeth_l3_send_simple_setassparms(card, IPA_INBOUND_CHECKSUM,
1420 IPA_CMD_ASS_START, 0);
1421 if (rc) {
1422 PRINT_WARN("Starting Inbound HW Checksumming failed on %s: "
1423 "0x%x,\ncontinuing using Inbound SW Checksumming\n",
1424 QETH_CARD_IFNAME(card), rc);
1425 return rc;
1426 }
1427 rc = qeth_l3_send_simple_setassparms(card, IPA_INBOUND_CHECKSUM,
1428 IPA_CMD_ASS_ENABLE,
1429 card->info.csum_mask);
1430 if (rc) {
1431 PRINT_WARN("Enabling Inbound HW Checksumming failed on %s: "
1432 "0x%x,\ncontinuing using Inbound SW Checksumming\n",
1433 QETH_CARD_IFNAME(card), rc);
1434 return rc;
1435 }
1436 return 0;
1437}
1438
1439static int qeth_l3_start_ipa_checksum(struct qeth_card *card)
1440{
1441 int rc = 0;
1442
d11ba0c4 1443 QETH_DBF_TEXT(TRACE, 3, "strtcsum");
4a71df50
FB		 1444
1445 if (card->options.checksum_type == NO_CHECKSUMMING) {
1446 PRINT_WARN("Using no checksumming on %s.\n",
1447 QETH_CARD_IFNAME(card));
1448 return 0;
1449 }
1450 if (card->options.checksum_type == SW_CHECKSUMMING) {
1451 PRINT_WARN("Using SW checksumming on %s.\n",
1452 QETH_CARD_IFNAME(card));
1453 return 0;
1454 }
1455 if (!qeth_is_supported(card, IPA_INBOUND_CHECKSUM)) {
1456 PRINT_WARN("Inbound HW Checksumming not "
1457 "supported on %s,\ncontinuing "
1458 "using Inbound SW Checksumming\n",
1459 QETH_CARD_IFNAME(card));
1460 card->options.checksum_type = SW_CHECKSUMMING;
1461 return 0;
1462 }
1463 rc = qeth_l3_send_checksum_command(card);
1464 if (!rc)
1465 PRINT_INFO("HW Checksumming (inbound) enabled \n");
1466
1467 return rc;
1468}
1469
1470static int qeth_l3_start_ipa_tso(struct qeth_card *card)
1471{
1472 int rc;
1473
d11ba0c4 1474 QETH_DBF_TEXT(TRACE, 3, "sttso");
4a71df50
FB		 1475
1476 if (!qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
1477 PRINT_WARN("Outbound TSO not supported on %s\n",
1478 QETH_CARD_IFNAME(card));
1479 rc = -EOPNOTSUPP;
1480 } else {
1481 rc = qeth_l3_send_simple_setassparms(card, IPA_OUTBOUND_TSO,
1482 IPA_CMD_ASS_START, 0);
1483 if (rc)
1484 PRINT_WARN("Could not start outbound TSO "
1485 "assist on %s: rc=%i\n",
1486 QETH_CARD_IFNAME(card), rc);
1487 else
1488 PRINT_INFO("Outbound TSO enabled\n");
1489 }
1490 if (rc && (card->options.large_send == QETH_LARGE_SEND_TSO)) {
1491 card->options.large_send = QETH_LARGE_SEND_NO;
1492 card->dev->features &= ~(NETIF_F_TSO | NETIF_F_SG);
1493 }
1494 return rc;
1495}
1496
1497static int qeth_l3_start_ipassists(struct qeth_card *card)
1498{
d11ba0c4 1499 QETH_DBF_TEXT(TRACE, 3, "strtipas");
4a71df50
FB		 1500 qeth_l3_start_ipa_arp_processing(card); /* go on*/
1501 qeth_l3_start_ipa_ip_fragmentation(card); /* go on*/
1502 qeth_l3_start_ipa_source_mac(card); /* go on*/
1503 qeth_l3_start_ipa_vlan(card); /* go on*/
1504 qeth_l3_start_ipa_multicast(card); /* go on*/
1505 qeth_l3_start_ipa_ipv6(card); /* go on*/
1506 qeth_l3_start_ipa_broadcast(card); /* go on*/
1507 qeth_l3_start_ipa_checksum(card); /* go on*/
1508 qeth_l3_start_ipa_tso(card); /* go on*/
1509 return 0;
1510}
1511
1512static int qeth_l3_put_unique_id(struct qeth_card *card)
1513{
1514
1515 int rc = 0;
1516 struct qeth_cmd_buffer *iob;
1517 struct qeth_ipa_cmd *cmd;
1518
d11ba0c4 1519 QETH_DBF_TEXT(TRACE, 2, "puniqeid");
4a71df50
FB		 1520
1521 if ((card->info.unique_id & UNIQUE_ID_NOT_BY_CARD) ==
1522 UNIQUE_ID_NOT_BY_CARD)
1523 return -1;
1524 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_DESTROY_ADDR,
1525 QETH_PROT_IPV6);
1526 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1527 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1528 card->info.unique_id;
1529 memcpy(&cmd->data.create_destroy_addr.unique_id[0],
1530 card->dev->dev_addr, OSA_ADDR_LEN);
1531 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
1532 return rc;
1533}
1534
1535static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
1536 struct qeth_reply *reply, unsigned long data)
1537{
1538 struct qeth_ipa_cmd *cmd;
1539
1540 cmd = (struct qeth_ipa_cmd *) data;
1541 if (cmd->hdr.return_code == 0)
1542 memcpy(card->dev->dev_addr,
1543 cmd->data.create_destroy_addr.unique_id, ETH_ALEN);
1544 else
1545 random_ether_addr(card->dev->dev_addr);
1546
1547 return 0;
1548}
1549
1550static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card)
1551{
1552 int rc = 0;
1553 struct qeth_cmd_buffer *iob;
1554 struct qeth_ipa_cmd *cmd;
1555
d11ba0c4 1556 QETH_DBF_TEXT(SETUP, 2, "hsrmac");
4a71df50
FB		 1557
1558 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
1559 QETH_PROT_IPV6);
1560 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1561 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1562 card->info.unique_id;
1563
1564 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb,
1565 NULL);
1566 return rc;
1567}
1568
1569static int qeth_l3_get_unique_id_cb(struct qeth_card *card,
1570 struct qeth_reply *reply, unsigned long data)
1571{
1572 struct qeth_ipa_cmd *cmd;
1573
1574 cmd = (struct qeth_ipa_cmd *) data;
1575 if (cmd->hdr.return_code == 0)
1576 card->info.unique_id = *((__u16 *)
1577 &cmd->data.create_destroy_addr.unique_id[6]);
1578 else {
1579 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1580 UNIQUE_ID_NOT_BY_CARD;
1581 PRINT_WARN("couldn't get a unique id from the card on device "
1582 "%s (result=x%x), using default id. ipv6 "
1583 "autoconfig on other lpars may lead to duplicate "
1584 "ip addresses. please use manually "
1585 "configured ones.\n",
1586 CARD_BUS_ID(card), cmd->hdr.return_code);
1587 }
1588 return 0;
1589}
1590
1591static int qeth_l3_get_unique_id(struct qeth_card *card)
1592{
1593 int rc = 0;
1594 struct qeth_cmd_buffer *iob;
1595 struct qeth_ipa_cmd *cmd;
1596
d11ba0c4 1597 QETH_DBF_TEXT(SETUP, 2, "guniqeid");
4a71df50
FB		 1598
1599 if (!qeth_is_supported(card, IPA_IPV6)) {
1600 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1601 UNIQUE_ID_NOT_BY_CARD;
1602 return 0;
1603 }
1604
1605 iob = qeth_get_ipacmd_buffer(card, IPA_CMD_CREATE_ADDR,
1606 QETH_PROT_IPV6);
1607 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE);
1608 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1609 card->info.unique_id;
1610
1611 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_get_unique_id_cb, NULL);
1612 return rc;
1613}
1614
1615static void qeth_l3_get_mac_for_ipm(__u32 ipm, char *mac,
1616 struct net_device *dev)
1617{
1618 if (dev->type == ARPHRD_IEEE802_TR)
1619 ip_tr_mc_map(ipm, mac);
1620 else
1621 ip_eth_mc_map(ipm, mac);
1622}
1623
1624static void qeth_l3_add_mc(struct qeth_card *card, struct in_device *in4_dev)
1625{
1626 struct qeth_ipaddr *ipm;
1627 struct ip_mc_list *im4;
1628 char buf[MAX_ADDR_LEN];
1629
d11ba0c4 1630 QETH_DBF_TEXT(TRACE, 4, "addmc");
4a71df50
FB		 1631 for (im4 = in4_dev->mc_list; im4; im4 = im4->next) {
1632 qeth_l3_get_mac_for_ipm(im4->multiaddr, buf, in4_dev->dev);
1633 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1634 if (!ipm)
1635 continue;
1636 ipm->u.a4.addr = im4->multiaddr;
1637 memcpy(ipm->mac, buf, OSA_ADDR_LEN);
1638 ipm->is_multicast = 1;
1639 if (!qeth_l3_add_ip(card, ipm))
1640 kfree(ipm);
1641 }
1642}
1643
1644static void qeth_l3_add_vlan_mc(struct qeth_card *card)
1645{
1646 struct in_device *in_dev;
1647 struct vlan_group *vg;
1648 int i;
1649
d11ba0c4 1650 QETH_DBF_TEXT(TRACE, 4, "addmcvl");
4a71df50
FB		 1651 if (!qeth_is_supported(card, IPA_FULL_VLAN) || (card->vlangrp == NULL))
1652 return;
1653
1654 vg = card->vlangrp;
1655 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
1656 struct net_device *netdev = vlan_group_get_device(vg, i);
1657 if (netdev == NULL ||
1658 !(netdev->flags & IFF_UP))
1659 continue;
1660 in_dev = in_dev_get(netdev);
1661 if (!in_dev)
1662 continue;
1663 read_lock(&in_dev->mc_list_lock);
1664 qeth_l3_add_mc(card, in_dev);
1665 read_unlock(&in_dev->mc_list_lock);
1666 in_dev_put(in_dev);
1667 }
1668}
1669
1670static void qeth_l3_add_multicast_ipv4(struct qeth_card *card)
1671{
1672 struct in_device *in4_dev;
1673
d11ba0c4 1674 QETH_DBF_TEXT(TRACE, 4, "chkmcv4");
4a71df50
FB		 1675 in4_dev = in_dev_get(card->dev);
1676 if (in4_dev == NULL)
1677 return;
1678 read_lock(&in4_dev->mc_list_lock);
1679 qeth_l3_add_mc(card, in4_dev);
1680 qeth_l3_add_vlan_mc(card);
1681 read_unlock(&in4_dev->mc_list_lock);
1682 in_dev_put(in4_dev);
1683}
1684
1685#ifdef CONFIG_QETH_IPV6
1686static void qeth_l3_add_mc6(struct qeth_card *card, struct inet6_dev *in6_dev)
1687{
1688 struct qeth_ipaddr *ipm;
1689 struct ifmcaddr6 *im6;
1690 char buf[MAX_ADDR_LEN];
1691
d11ba0c4 1692 QETH_DBF_TEXT(TRACE, 4, "addmc6");
4a71df50
FB		 1693 for (im6 = in6_dev->mc_list; im6 != NULL; im6 = im6->next) {
1694 ndisc_mc_map(&im6->mca_addr, buf, in6_dev->dev, 0);
1695 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1696 if (!ipm)
1697 continue;
1698 ipm->is_multicast = 1;
1699 memcpy(ipm->mac, buf, OSA_ADDR_LEN);
1700 memcpy(&ipm->u.a6.addr, &im6->mca_addr.s6_addr,
1701 sizeof(struct in6_addr));
1702 if (!qeth_l3_add_ip(card, ipm))
1703 kfree(ipm);
1704 }
1705}
1706
1707static void qeth_l3_add_vlan_mc6(struct qeth_card *card)
1708{
1709 struct inet6_dev *in_dev;
1710 struct vlan_group *vg;
1711 int i;
1712
d11ba0c4 1713 QETH_DBF_TEXT(TRACE, 4, "admc6vl");
4a71df50
FB		 1714 if (!qeth_is_supported(card, IPA_FULL_VLAN) || (card->vlangrp == NULL))
1715 return;
1716
1717 vg = card->vlangrp;
1718 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
1719 struct net_device *netdev = vlan_group_get_device(vg, i);
1720 if (netdev == NULL ||
1721 !(netdev->flags & IFF_UP))
1722 continue;
1723 in_dev = in6_dev_get(netdev);
1724 if (!in_dev)
1725 continue;
1726 read_lock_bh(&in_dev->lock);
1727 qeth_l3_add_mc6(card, in_dev);
1728 read_unlock_bh(&in_dev->lock);
1729 in6_dev_put(in_dev);
1730 }
1731}
1732
1733static void qeth_l3_add_multicast_ipv6(struct qeth_card *card)
1734{
1735 struct inet6_dev *in6_dev;
1736
d11ba0c4 1737 QETH_DBF_TEXT(TRACE, 4, "chkmcv6");
4a71df50
FB		 1738 if (!qeth_is_supported(card, IPA_IPV6))
1739 return ;
1740 in6_dev = in6_dev_get(card->dev);
1741 if (in6_dev == NULL)
1742 return;
1743 read_lock_bh(&in6_dev->lock);
1744 qeth_l3_add_mc6(card, in6_dev);
1745 qeth_l3_add_vlan_mc6(card);
1746 read_unlock_bh(&in6_dev->lock);
1747 in6_dev_put(in6_dev);
1748}
1749#endif /* CONFIG_QETH_IPV6 */
1750
1751static void qeth_l3_free_vlan_addresses4(struct qeth_card *card,
1752 unsigned short vid)
1753{
1754 struct in_device *in_dev;
1755 struct in_ifaddr *ifa;
1756 struct qeth_ipaddr *addr;
1757
d11ba0c4 1758 QETH_DBF_TEXT(TRACE, 4, "frvaddr4");
4a71df50
FB		 1759
1760 in_dev = in_dev_get(vlan_group_get_device(card->vlangrp, vid));
1761 if (!in_dev)
1762 return;
1763 for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
1764 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1765 if (addr) {
1766 addr->u.a4.addr = ifa->ifa_address;
1767 addr->u.a4.mask = ifa->ifa_mask;
1768 addr->type = QETH_IP_TYPE_NORMAL;
1769 if (!qeth_l3_delete_ip(card, addr))
1770 kfree(addr);
1771 }
1772 }
1773 in_dev_put(in_dev);
1774}
1775
1776static void qeth_l3_free_vlan_addresses6(struct qeth_card *card,
1777 unsigned short vid)
1778{
1779#ifdef CONFIG_QETH_IPV6
1780 struct inet6_dev *in6_dev;
1781 struct inet6_ifaddr *ifa;
1782 struct qeth_ipaddr *addr;
1783
d11ba0c4 1784 QETH_DBF_TEXT(TRACE, 4, "frvaddr6");
4a71df50
FB		 1785
1786 in6_dev = in6_dev_get(vlan_group_get_device(card->vlangrp, vid));
1787 if (!in6_dev)
1788 return;
1789 for (ifa = in6_dev->addr_list; ifa; ifa = ifa->lst_next) {
1790 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1791 if (addr) {
1792 memcpy(&addr->u.a6.addr, &ifa->addr,
1793 sizeof(struct in6_addr));
1794 addr->u.a6.pfxlen = ifa->prefix_len;
1795 addr->type = QETH_IP_TYPE_NORMAL;
1796 if (!qeth_l3_delete_ip(card, addr))
1797 kfree(addr);
1798 }
1799 }
1800 in6_dev_put(in6_dev);
1801#endif /* CONFIG_QETH_IPV6 */
1802}
1803
1804static void qeth_l3_free_vlan_addresses(struct qeth_card *card,
1805 unsigned short vid)
1806{
1807 if (!card->vlangrp)
1808 return;
1809 qeth_l3_free_vlan_addresses4(card, vid);
1810 qeth_l3_free_vlan_addresses6(card, vid);
1811}
1812
1813static void qeth_l3_vlan_rx_register(struct net_device *dev,
1814 struct vlan_group *grp)
1815{
1816 struct qeth_card *card = netdev_priv(dev);
1817 unsigned long flags;
1818
d11ba0c4 1819 QETH_DBF_TEXT(TRACE, 4, "vlanreg");
4a71df50
FB		 1820 spin_lock_irqsave(&card->vlanlock, flags);
1821 card->vlangrp = grp;
1822 spin_unlock_irqrestore(&card->vlanlock, flags);
1823}
1824
1825static void qeth_l3_vlan_rx_add_vid(struct net_device *dev, unsigned short vid)
1826{
1827 struct net_device *vlandev;
1828 struct qeth_card *card = (struct qeth_card *) dev->priv;
1829 struct in_device *in_dev;
1830
1831 if (card->info.type == QETH_CARD_TYPE_IQD)
1832 return;
1833
1834 vlandev = vlan_group_get_device(card->vlangrp, vid);
1835 vlandev->neigh_setup = qeth_l3_neigh_setup;
1836
1837 in_dev = in_dev_get(vlandev);
1838#ifdef CONFIG_SYSCTL
1839 neigh_sysctl_unregister(in_dev->arp_parms);
1840#endif
1841 neigh_parms_release(&arp_tbl, in_dev->arp_parms);
1842
1843 in_dev->arp_parms = neigh_parms_alloc(vlandev, &arp_tbl);
1844#ifdef CONFIG_SYSCTL
1845 neigh_sysctl_register(vlandev, in_dev->arp_parms, NET_IPV4,
1846 NET_IPV4_NEIGH, "ipv4", NULL, NULL);
1847#endif
1848 in_dev_put(in_dev);
1849 return;
1850}
1851
1852static void qeth_l3_vlan_rx_kill_vid(struct net_device *dev, unsigned short vid)
1853{
1854 struct qeth_card *card = netdev_priv(dev);
1855 unsigned long flags;
1856
d11ba0c4 1857 QETH_DBF_TEXT_(TRACE, 4, "kid:%d", vid);
4a71df50
FB		 1858 spin_lock_irqsave(&card->vlanlock, flags);
1859 /* unregister IP addresses of vlan device */
1860 qeth_l3_free_vlan_addresses(card, vid);
1861 vlan_group_set_device(card->vlangrp, vid, NULL);
1862 spin_unlock_irqrestore(&card->vlanlock, flags);
1863 qeth_l3_set_multicast_list(card->dev);
1864}
1865
1866static inline __u16 qeth_l3_rebuild_skb(struct qeth_card *card,
1867 struct sk_buff *skb, struct qeth_hdr *hdr)
1868{
1869 unsigned short vlan_id = 0;
1870 __be16 prot;
1871 struct iphdr *ip_hdr;
1872 unsigned char tg_addr[MAX_ADDR_LEN];
1873
1874 if (!(hdr->hdr.l3.flags & QETH_HDR_PASSTHRU)) {
1875 prot = htons((hdr->hdr.l3.flags & QETH_HDR_IPV6)? ETH_P_IPV6 :
1876 ETH_P_IP);
1877 switch (hdr->hdr.l3.flags & QETH_HDR_CAST_MASK) {
1878 case QETH_CAST_MULTICAST:
1879 switch (prot) {
1880#ifdef CONFIG_QETH_IPV6
1881 case __constant_htons(ETH_P_IPV6):
1882 ndisc_mc_map((struct in6_addr *)
1883 skb->data + 24,
1884 tg_addr, card->dev, 0);
1885 break;
1886#endif
1887 case __constant_htons(ETH_P_IP):
1888 ip_hdr = (struct iphdr *)skb->data;
1889 (card->dev->type == ARPHRD_IEEE802_TR) ?
1890 ip_tr_mc_map(ip_hdr->daddr, tg_addr):
1891 ip_eth_mc_map(ip_hdr->daddr, tg_addr);
1892 break;
1893 default:
1894 memcpy(tg_addr, card->dev->broadcast,
1895 card->dev->addr_len);
1896 }
1897 card->stats.multicast++;
1898 skb->pkt_type = PACKET_MULTICAST;
1899 break;
1900 case QETH_CAST_BROADCAST:
1901 memcpy(tg_addr, card->dev->broadcast,
1902 card->dev->addr_len);
1903 card->stats.multicast++;
1904 skb->pkt_type = PACKET_BROADCAST;
1905 break;
1906 case QETH_CAST_UNICAST:
1907 case QETH_CAST_ANYCAST:
1908 case QETH_CAST_NOCAST:
1909 default:
1910 skb->pkt_type = PACKET_HOST;
1911 memcpy(tg_addr, card->dev->dev_addr,
1912 card->dev->addr_len);
1913 }
1914 card->dev->header_ops->create(skb, card->dev, prot, tg_addr,
1915 "FAKELL", card->dev->addr_len);
1916 }
1917
1918#ifdef CONFIG_TR
1919 if (card->dev->type == ARPHRD_IEEE802_TR)
1920 skb->protocol = tr_type_trans(skb, card->dev);
1921 else
1922#endif
1923 skb->protocol = eth_type_trans(skb, card->dev);
1924
1925 if (hdr->hdr.l3.ext_flags &
1926 (QETH_HDR_EXT_VLAN_FRAME | QETH_HDR_EXT_INCLUDE_VLAN_TAG)) {
1927 vlan_id = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME)?
1928 hdr->hdr.l3.vlan_id : *((u16 *)&hdr->hdr.l3.dest_addr[12]);
1929 }
1930
1931 skb->ip_summed = card->options.checksum_type;
1932 if (card->options.checksum_type == HW_CHECKSUMMING) {
1933 if ((hdr->hdr.l3.ext_flags &
1934 (QETH_HDR_EXT_CSUM_HDR_REQ |
1935 QETH_HDR_EXT_CSUM_TRANSP_REQ)) ==
1936 (QETH_HDR_EXT_CSUM_HDR_REQ |
1937 QETH_HDR_EXT_CSUM_TRANSP_REQ))
1938 skb->ip_summed = CHECKSUM_UNNECESSARY;
1939 else
1940 skb->ip_summed = SW_CHECKSUMMING;
1941 }
1942
1943 return vlan_id;
1944}
1945
1946static void qeth_l3_process_inbound_buffer(struct qeth_card *card,
1947 struct qeth_qdio_buffer *buf, int index)
1948{
1949 struct qdio_buffer_element *element;
1950 struct sk_buff *skb;
1951 struct qeth_hdr *hdr;
1952 int offset;
1953 __u16 vlan_tag = 0;
1954 unsigned int len;
1955
1956 /* get first element of current buffer */
1957 element = (struct qdio_buffer_element *)&buf->buffer->element[0];
1958 offset = 0;
1959 if (card->options.performance_stats)
1960 card->perf_stats.bufs_rec++;
1961 while ((skb = qeth_core_get_next_skb(card, buf->buffer, &element,
1962 &offset, &hdr))) {
1963 skb->dev = card->dev;
1964 /* is device UP ? */
1965 if (!(card->dev->flags & IFF_UP)) {
1966 dev_kfree_skb_any(skb);
1967 continue;
1968 }
1969
1970 switch (hdr->hdr.l3.id) {
1971 case QETH_HEADER_TYPE_LAYER3:
1972 vlan_tag = qeth_l3_rebuild_skb(card, skb, hdr);
1973 len = skb->len;
1974 if (vlan_tag)
1975 if (card->vlangrp)
1976 vlan_hwaccel_rx(skb, card->vlangrp,
1977 vlan_tag);
1978 else {
1979 dev_kfree_skb_any(skb);
1980 continue;
1981 }
1982 else
1983 netif_rx(skb);
1984 break;
1985 default:
1986 dev_kfree_skb_any(skb);
d11ba0c4
PT		 1987 QETH_DBF_TEXT(TRACE, 3, "inbunkno");
1988 QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN);
4a71df50
FB		 1989 continue;
1990 }
1991
1992 card->dev->last_rx = jiffies;
1993 card->stats.rx_packets++;
1994 card->stats.rx_bytes += len;
1995 }
1996}
1997
1998static int qeth_l3_verify_vlan_dev(struct net_device *dev,
1999 struct qeth_card *card)
2000{
2001 int rc = 0;
2002 struct vlan_group *vg;
2003 int i;
2004
2005 vg = card->vlangrp;
2006 if (!vg)
2007 return rc;
2008
2009 for (i = 0; i < VLAN_GROUP_ARRAY_LEN; i++) {
2010 if (vlan_group_get_device(vg, i) == dev) {
2011 rc = QETH_VLAN_CARD;
2012 break;
2013 }
2014 }
2015
22d1ba74 2016 if (rc && !(netdev_priv(vlan_dev_real_dev(dev)) == (void *)card))
4a71df50
FB		 2017 return 0;
2018
2019 return rc;
2020}
2021
2022static int qeth_l3_verify_dev(struct net_device *dev)
2023{
2024 struct qeth_card *card;
2025 unsigned long flags;
2026 int rc = 0;
2027
2028 read_lock_irqsave(&qeth_core_card_list.rwlock, flags);
2029 list_for_each_entry(card, &qeth_core_card_list.list, list) {
2030 if (card->dev == dev) {
2031 rc = QETH_REAL_CARD;
2032 break;
2033 }
2034 rc = qeth_l3_verify_vlan_dev(dev, card);
2035 if (rc)
2036 break;
2037 }
2038 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags);
2039
2040 return rc;
2041}
2042
2043static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev)
2044{
2045 struct qeth_card *card = NULL;
2046 int rc;
2047
2048 rc = qeth_l3_verify_dev(dev);
2049 if (rc == QETH_REAL_CARD)
2050 card = netdev_priv(dev);
2051 else if (rc == QETH_VLAN_CARD)
22d1ba74 2052 card = netdev_priv(vlan_dev_real_dev(dev));
e5bd7be5 2053 if (card && card->options.layer2)
4a71df50 2054 card = NULL;
d11ba0c4 2055 QETH_DBF_TEXT_(TRACE, 4, "%d", rc);
4a71df50
FB		 2056 return card ;
2057}
2058
2059static int qeth_l3_stop_card(struct qeth_card *card, int recovery_mode)
2060{
2061 int rc = 0;
2062
d11ba0c4
PT		 2063 QETH_DBF_TEXT(SETUP, 2, "stopcard");
2064 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
4a71df50
FB		 2065
2066 qeth_set_allowed_threads(card, 0, 1);
2067 if (qeth_wait_for_threads(card, ~QETH_RECOVER_THREAD))
2068 return -ERESTARTSYS;
2069 if (card->read.state == CH_STATE_UP &&
2070 card->write.state == CH_STATE_UP &&
2071 (card->state == CARD_STATE_UP)) {
2072 if (recovery_mode)
2073 qeth_l3_stop(card->dev);
8af7c5ae
FB		 2074 else {
2075 rtnl_lock();
2076 dev_close(card->dev);
2077 rtnl_unlock();
2078 }
4a71df50
FB		 2079 if (!card->use_hard_stop) {
2080 rc = qeth_send_stoplan(card);
2081 if (rc)
d11ba0c4 2082 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
4a71df50
FB		 2083 }
2084 card->state = CARD_STATE_SOFTSETUP;
2085 }
2086 if (card->state == CARD_STATE_SOFTSETUP) {
2087 qeth_l3_clear_ip_list(card, !card->use_hard_stop, 1);
2088 qeth_clear_ipacmd_list(card);
2089 card->state = CARD_STATE_HARDSETUP;
2090 }
2091 if (card->state == CARD_STATE_HARDSETUP) {
2092 if (!card->use_hard_stop &&
2093 (card->info.type != QETH_CARD_TYPE_IQD)) {
2094 rc = qeth_l3_put_unique_id(card);
2095 if (rc)
d11ba0c4 2096 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
4a71df50
FB		 2097 }
2098 qeth_qdio_clear_card(card, 0);
2099 qeth_clear_qdio_buffers(card);
2100 qeth_clear_working_pool_list(card);
2101 card->state = CARD_STATE_DOWN;
2102 }
2103 if (card->state == CARD_STATE_DOWN) {
2104 qeth_clear_cmd_buffers(&card->read);
2105 qeth_clear_cmd_buffers(&card->write);
2106 }
2107 card->use_hard_stop = 0;
2108 return rc;
2109}
2110
2111static void qeth_l3_set_multicast_list(struct net_device *dev)
2112{
2113 struct qeth_card *card = netdev_priv(dev);
2114
d11ba0c4 2115 QETH_DBF_TEXT(TRACE, 3, "setmulti");
4a71df50
FB		 2116 qeth_l3_delete_mc_addresses(card);
2117 qeth_l3_add_multicast_ipv4(card);
2118#ifdef CONFIG_QETH_IPV6
2119 qeth_l3_add_multicast_ipv6(card);
2120#endif
2121 qeth_l3_set_ip_addr_list(card);
2122 if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
2123 return;
2124 qeth_setadp_promisc_mode(card);
2125}
2126
2127static const char *qeth_l3_arp_get_error_cause(int *rc)
2128{
2129 switch (*rc) {
2130 case QETH_IPA_ARP_RC_FAILED:
2131 *rc = -EIO;
2132 return "operation failed";
2133 case QETH_IPA_ARP_RC_NOTSUPP:
2134 *rc = -EOPNOTSUPP;
2135 return "operation not supported";
2136 case QETH_IPA_ARP_RC_OUT_OF_RANGE:
2137 *rc = -EINVAL;
2138 return "argument out of range";
2139 case QETH_IPA_ARP_RC_Q_NOTSUPP:
2140 *rc = -EOPNOTSUPP;
2141 return "query operation not supported";
2142 case QETH_IPA_ARP_RC_Q_NO_DATA:
2143 *rc = -ENOENT;
2144 return "no query data available";
2145 default:
2146 return "unknown error";
2147 }
2148}
2149
2150static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
2151{
2152 int tmp;
2153 int rc;
2154
d11ba0c4 2155 QETH_DBF_TEXT(TRACE, 3, "arpstnoe");
4a71df50
FB		 2156
2157 /*
2158 * currently GuestLAN only supports the ARP assist function
2159 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
2160 * thus we say EOPNOTSUPP for this ARP function
2161 */
2162 if (card->info.guestlan)
2163 return -EOPNOTSUPP;
2164 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
4a71df50
FB		 2165 return -EOPNOTSUPP;
2166 }
2167 rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2168 IPA_CMD_ASS_ARP_SET_NO_ENTRIES,
2169 no_entries);
2170 if (rc) {
2171 tmp = rc;
14cc21b6
FB		 2172 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on "
2173 "%s: %s (0x%x/%d)\n", QETH_CARD_IFNAME(card),
4a71df50
FB		 2174 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2175 }
2176 return rc;
2177}
2178
2179static void qeth_l3_copy_arp_entries_stripped(struct qeth_arp_query_info *qinfo,
2180 struct qeth_arp_query_data *qdata, int entry_size,
2181 int uentry_size)
2182{
2183 char *entry_ptr;
2184 char *uentry_ptr;
2185 int i;
2186
2187 entry_ptr = (char *)&qdata->data;
2188 uentry_ptr = (char *)(qinfo->udata + qinfo->udata_offset);
2189 for (i = 0; i < qdata->no_entries; ++i) {
2190 /* strip off 32 bytes "media specific information" */
2191 memcpy(uentry_ptr, (entry_ptr + 32), entry_size - 32);
2192 entry_ptr += entry_size;
2193 uentry_ptr += uentry_size;
2194 }
2195}
2196
2197static int qeth_l3_arp_query_cb(struct qeth_card *card,
2198 struct qeth_reply *reply, unsigned long data)
2199{
2200 struct qeth_ipa_cmd *cmd;
2201 struct qeth_arp_query_data *qdata;
2202 struct qeth_arp_query_info *qinfo;
2203 int entry_size;
2204 int uentry_size;
2205 int i;
2206
d11ba0c4 2207 QETH_DBF_TEXT(TRACE, 4, "arpquecb");
4a71df50
FB		 2208
2209 qinfo = (struct qeth_arp_query_info *) reply->param;
2210 cmd = (struct qeth_ipa_cmd *) data;
2211 if (cmd->hdr.return_code) {
d11ba0c4 2212 QETH_DBF_TEXT_(TRACE, 4, "qaer1%i", cmd->hdr.return_code);
4a71df50
FB		 2213 return 0;
2214 }
2215 if (cmd->data.setassparms.hdr.return_code) {
2216 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
d11ba0c4 2217 QETH_DBF_TEXT_(TRACE, 4, "qaer2%i", cmd->hdr.return_code);
4a71df50
FB		 2218 return 0;
2219 }
2220 qdata = &cmd->data.setassparms.data.query_arp;
2221 switch (qdata->reply_bits) {
2222 case 5:
2223 uentry_size = entry_size = sizeof(struct qeth_arp_qi_entry5);
2224 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
2225 uentry_size = sizeof(struct qeth_arp_qi_entry5_short);
2226 break;
2227 case 7:
2228 /* fall through to default */
2229 default:
2230 /* tr is the same as eth -> entry7 */
2231 uentry_size = entry_size = sizeof(struct qeth_arp_qi_entry7);
2232 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
2233 uentry_size = sizeof(struct qeth_arp_qi_entry7_short);
2234 break;
2235 }
2236 /* check if there is enough room in userspace */
2237 if ((qinfo->udata_len - qinfo->udata_offset) <
2238 qdata->no_entries * uentry_size){
d11ba0c4 2239 QETH_DBF_TEXT_(TRACE, 4, "qaer3%i", -ENOMEM);
4a71df50 2240 cmd->hdr.return_code = -ENOMEM;
4a71df50
FB		 2241 goto out_error;
2242 }
d11ba0c4 2243 QETH_DBF_TEXT_(TRACE, 4, "anore%i",
4a71df50 2244 cmd->data.setassparms.hdr.number_of_replies);
d11ba0c4
PT		 2245 QETH_DBF_TEXT_(TRACE, 4, "aseqn%i", cmd->data.setassparms.hdr.seq_no);
2246 QETH_DBF_TEXT_(TRACE, 4, "anoen%i", qdata->no_entries);
4a71df50
FB		 2247
2248 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) {
2249 /* strip off "media specific information" */
2250 qeth_l3_copy_arp_entries_stripped(qinfo, qdata, entry_size,
2251 uentry_size);
2252 } else
2253 /*copy entries to user buffer*/
2254 memcpy(qinfo->udata + qinfo->udata_offset,
2255 (char *)&qdata->data, qdata->no_entries*uentry_size);
2256
2257 qinfo->no_entries += qdata->no_entries;
2258 qinfo->udata_offset += (qdata->no_entries*uentry_size);
2259 /* check if all replies received ... */
2260 if (cmd->data.setassparms.hdr.seq_no <
2261 cmd->data.setassparms.hdr.number_of_replies)
2262 return 1;
2263 memcpy(qinfo->udata, &qinfo->no_entries, 4);
2264 /* keep STRIP_ENTRIES flag so the user program can distinguish
2265 * stripped entries from normal ones */
2266 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
2267 qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES;
2268 memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2);
2269 return 0;
2270out_error:
2271 i = 0;
2272 memcpy(qinfo->udata, &i, 4);
2273 return 0;
2274}
2275
2276static int qeth_l3_send_ipa_arp_cmd(struct qeth_card *card,
2277 struct qeth_cmd_buffer *iob, int len,
2278 int (*reply_cb)(struct qeth_card *, struct qeth_reply *,
2279 unsigned long),
2280 void *reply_param)
2281{
d11ba0c4 2282 QETH_DBF_TEXT(TRACE, 4, "sendarp");
4a71df50
FB		 2283
2284 memcpy(iob->data, IPA_PDU_HEADER, IPA_PDU_HEADER_SIZE);
2285 memcpy(QETH_IPA_CMD_DEST_ADDR(iob->data),
2286 &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH);
2287 return qeth_send_control_data(card, IPA_PDU_HEADER_SIZE + len, iob,
2288 reply_cb, reply_param);
2289}
2290
2291static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
2292{
2293 struct qeth_cmd_buffer *iob;
2294 struct qeth_arp_query_info qinfo = {0, };
2295 int tmp;
2296 int rc;
2297
d11ba0c4 2298 QETH_DBF_TEXT(TRACE, 3, "arpquery");
4a71df50
FB		 2299
2300 if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
2301 IPA_ARP_PROCESSING)) {
4a71df50
FB		 2302 return -EOPNOTSUPP;
2303 }
2304 /* get size of userspace buffer and mask_bits -> 6 bytes */
2305 if (copy_from_user(&qinfo, udata, 6))
2306 return -EFAULT;
2307 qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL);
2308 if (!qinfo.udata)
2309 return -ENOMEM;
2310 qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
2311 iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2312 IPA_CMD_ASS_ARP_QUERY_INFO,
2313 sizeof(int), QETH_PROT_IPV4);
2314
2315 rc = qeth_l3_send_ipa_arp_cmd(card, iob,
2316 QETH_SETASS_BASE_LEN+QETH_ARP_CMD_LEN,
2317 qeth_l3_arp_query_cb, (void *)&qinfo);
2318 if (rc) {
2319 tmp = rc;
14cc21b6 2320 QETH_DBF_MESSAGE(2, "Error while querying ARP cache on %s: %s "
4a71df50
FB		 2321 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
2322 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2323 if (copy_to_user(udata, qinfo.udata, 4))
2324 rc = -EFAULT;
2325 } else {
2326 if (copy_to_user(udata, qinfo.udata, qinfo.udata_len))
2327 rc = -EFAULT;
2328 }
2329 kfree(qinfo.udata);
2330 return rc;
2331}
2332
2333static int qeth_l3_arp_add_entry(struct qeth_card *card,
2334 struct qeth_arp_cache_entry *entry)
2335{
2336 struct qeth_cmd_buffer *iob;
2337 char buf[16];
2338 int tmp;
2339 int rc;
2340
d11ba0c4 2341 QETH_DBF_TEXT(TRACE, 3, "arpadent");
4a71df50
FB		 2342
2343 /*
2344 * currently GuestLAN only supports the ARP assist function
2345 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
2346 * thus we say EOPNOTSUPP for this ARP function
2347 */
2348 if (card->info.guestlan)
2349 return -EOPNOTSUPP;
2350 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
4a71df50
FB		 2351 return -EOPNOTSUPP;
2352 }
2353
2354 iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2355 IPA_CMD_ASS_ARP_ADD_ENTRY,
2356 sizeof(struct qeth_arp_cache_entry),
2357 QETH_PROT_IPV4);
2358 rc = qeth_l3_send_setassparms(card, iob,
2359 sizeof(struct qeth_arp_cache_entry),
2360 (unsigned long) entry,
2361 qeth_l3_default_setassparms_cb, NULL);
2362 if (rc) {
2363 tmp = rc;
2364 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
14cc21b6
FB		 2365 QETH_DBF_MESSAGE(2, "Could not add ARP entry for address %s "
2366 "on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2367 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
4a71df50
FB		 2368 }
2369 return rc;
2370}
2371
2372static int qeth_l3_arp_remove_entry(struct qeth_card *card,
2373 struct qeth_arp_cache_entry *entry)
2374{
2375 struct qeth_cmd_buffer *iob;
2376 char buf[16] = {0, };
2377 int tmp;
2378 int rc;
2379
d11ba0c4 2380 QETH_DBF_TEXT(TRACE, 3, "arprment");
4a71df50
FB		 2381
2382 /*
2383 * currently GuestLAN only supports the ARP assist function
2384 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_REMOVE_ENTRY;
2385 * thus we say EOPNOTSUPP for this ARP function
2386 */
2387 if (card->info.guestlan)
2388 return -EOPNOTSUPP;
2389 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
4a71df50
FB		 2390 return -EOPNOTSUPP;
2391 }
2392 memcpy(buf, entry, 12);
2393 iob = qeth_l3_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
2394 IPA_CMD_ASS_ARP_REMOVE_ENTRY,
2395 12,
2396 QETH_PROT_IPV4);
2397 rc = qeth_l3_send_setassparms(card, iob,
2398 12, (unsigned long)buf,
2399 qeth_l3_default_setassparms_cb, NULL);
2400 if (rc) {
2401 tmp = rc;
2402 memset(buf, 0, 16);
2403 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf);
14cc21b6
FB		 2404 QETH_DBF_MESSAGE(2, "Could not delete ARP entry for address %s"
2405 " on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card),
2406 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
4a71df50
FB		 2407 }
2408 return rc;
2409}
2410
2411static int qeth_l3_arp_flush_cache(struct qeth_card *card)
2412{
2413 int rc;
2414 int tmp;
2415
d11ba0c4 2416 QETH_DBF_TEXT(TRACE, 3, "arpflush");
4a71df50
FB		 2417
2418 /*
2419 * currently GuestLAN only supports the ARP assist function
2420 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
2421 * thus we say EOPNOTSUPP for this ARP function
2422 */
2423 if (card->info.guestlan || (card->info.type == QETH_CARD_TYPE_IQD))
2424 return -EOPNOTSUPP;
2425 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
4a71df50
FB		 2426 return -EOPNOTSUPP;
2427 }
2428 rc = qeth_l3_send_simple_setassparms(card, IPA_ARP_PROCESSING,
2429 IPA_CMD_ASS_ARP_FLUSH_CACHE, 0);
2430 if (rc) {
2431 tmp = rc;
14cc21b6
FB		 2432 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on %s: %s "
2433 "(0x%x/%d)\n", QETH_CARD_IFNAME(card),
4a71df50
FB		 2434 qeth_l3_arp_get_error_cause(&rc), tmp, tmp);
2435 }
2436 return rc;
2437}
2438
2439static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
2440{
2441 struct qeth_card *card = netdev_priv(dev);
2442 struct qeth_arp_cache_entry arp_entry;
2443 struct mii_ioctl_data *mii_data;
2444 int rc = 0;
2445
2446 if (!card)
2447 return -ENODEV;
2448
2449 if ((card->state != CARD_STATE_UP) &&
2450 (card->state != CARD_STATE_SOFTSETUP))
2451 return -ENODEV;
2452
2453 switch (cmd) {
2454 case SIOC_QETH_ARP_SET_NO_ENTRIES:
2455 if (!capable(CAP_NET_ADMIN)) {
2456 rc = -EPERM;
2457 break;
2458 }
2459 rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue);
2460 break;
2461 case SIOC_QETH_ARP_QUERY_INFO:
2462 if (!capable(CAP_NET_ADMIN)) {
2463 rc = -EPERM;
2464 break;
2465 }
2466 rc = qeth_l3_arp_query(card, rq->ifr_ifru.ifru_data);
2467 break;
2468 case SIOC_QETH_ARP_ADD_ENTRY:
2469 if (!capable(CAP_NET_ADMIN)) {
2470 rc = -EPERM;
2471 break;
2472 }
2473 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
2474 sizeof(struct qeth_arp_cache_entry)))
2475 rc = -EFAULT;
2476 else
2477 rc = qeth_l3_arp_add_entry(card, &arp_entry);
2478 break;
2479 case SIOC_QETH_ARP_REMOVE_ENTRY:
2480 if (!capable(CAP_NET_ADMIN)) {
2481 rc = -EPERM;
2482 break;
2483 }
2484 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data,
2485 sizeof(struct qeth_arp_cache_entry)))
2486 rc = -EFAULT;
2487 else
2488 rc = qeth_l3_arp_remove_entry(card, &arp_entry);
2489 break;
2490 case SIOC_QETH_ARP_FLUSH_CACHE:
2491 if (!capable(CAP_NET_ADMIN)) {
2492 rc = -EPERM;
2493 break;
2494 }
2495 rc = qeth_l3_arp_flush_cache(card);
2496 break;
2497 case SIOC_QETH_ADP_SET_SNMP_CONTROL:
2498 rc = qeth_snmp_command(card, rq->ifr_ifru.ifru_data);
2499 break;
2500 case SIOC_QETH_GET_CARD_TYPE:
2501 if ((card->info.type == QETH_CARD_TYPE_OSAE) &&
2502 !card->info.guestlan)
2503 return 1;
2504 return 0;
2505 break;
2506 case SIOCGMIIPHY:
2507 mii_data = if_mii(rq);
2508 mii_data->phy_id = 0;
2509 break;
2510 case SIOCGMIIREG:
2511 mii_data = if_mii(rq);
2512 if (mii_data->phy_id != 0)
2513 rc = -EINVAL;
2514 else
2515 mii_data->val_out = qeth_mdio_read(dev,
2516 mii_data->phy_id,
2517 mii_data->reg_num);
2518 break;
2519 default:
2520 rc = -EOPNOTSUPP;
2521 }
2522 if (rc)
d11ba0c4 2523 QETH_DBF_TEXT_(TRACE, 2, "ioce%d", rc);
4a71df50
FB		 2524 return rc;
2525}
2526
2527static void qeth_l3_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
2528 struct sk_buff *skb, int ipv, int cast_type)
2529{
4a71df50
FB		 2530 memset(hdr, 0, sizeof(struct qeth_hdr));
2531 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
2532 hdr->hdr.l3.ext_flags = 0;
2533
2534 /*
2535 * before we're going to overwrite this location with next hop ip.
2536 * v6 uses passthrough, v4 sets the tag in the QDIO header.
2537 */
2538 if (card->vlangrp && vlan_tx_tag_present(skb)) {
213298f8
FB		 2539 if ((ipv == 4) || (card->info.type == QETH_CARD_TYPE_IQD))
2540 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_VLAN_FRAME;
2541 else
2542 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_INCLUDE_VLAN_TAG;
4a71df50
FB		 2543 hdr->hdr.l3.vlan_id = vlan_tx_tag_get(skb);
2544 }
2545
2546 hdr->hdr.l3.length = skb->len - sizeof(struct qeth_hdr);
2547 if (ipv == 4) {
2548 /* IPv4 */
2549 hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags4(cast_type);
2550 memset(hdr->hdr.l3.dest_addr, 0, 12);
2551 if ((skb->dst) && (skb->dst->neighbour)) {
2552 *((u32 *) (&hdr->hdr.l3.dest_addr[12])) =
2553 *((u32 *) skb->dst->neighbour->primary_key);
2554 } else {
2555 /* fill in destination address used in ip header */
2556 *((u32 *) (&hdr->hdr.l3.dest_addr[12])) =
2557 ip_hdr(skb)->daddr;
2558 }
2559 } else if (ipv == 6) {
2560 /* IPv6 */
2561 hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags6(cast_type);
2562 if (card->info.type == QETH_CARD_TYPE_IQD)
2563 hdr->hdr.l3.flags &= ~QETH_HDR_PASSTHRU;
2564 if ((skb->dst) && (skb->dst->neighbour)) {
2565 memcpy(hdr->hdr.l3.dest_addr,
2566 skb->dst->neighbour->primary_key, 16);
2567 } else {
2568 /* fill in destination address used in ip header */
2569 memcpy(hdr->hdr.l3.dest_addr,
2570 &ipv6_hdr(skb)->daddr, 16);
2571 }
2572 } else {
2573 /* passthrough */
2574 if ((skb->dev->type == ARPHRD_IEEE802_TR) &&
2575 !memcmp(skb->data + sizeof(struct qeth_hdr) +
2576 sizeof(__u16), skb->dev->broadcast, 6)) {
2577 hdr->hdr.l3.flags = QETH_CAST_BROADCAST |
2578 QETH_HDR_PASSTHRU;
2579 } else if (!memcmp(skb->data + sizeof(struct qeth_hdr),
2580 skb->dev->broadcast, 6)) {
2581 /* broadcast? */
2582 hdr->hdr.l3.flags = QETH_CAST_BROADCAST |
2583 QETH_HDR_PASSTHRU;
2584 } else {
2585 hdr->hdr.l3.flags = (cast_type == RTN_MULTICAST) ?
2586 QETH_CAST_MULTICAST | QETH_HDR_PASSTHRU :
2587 QETH_CAST_UNICAST | QETH_HDR_PASSTHRU;
2588 }
2589 }
2590}
2591
2592static int qeth_l3_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
2593{
2594 int rc;
2595 u16 *tag;
2596 struct qeth_hdr *hdr = NULL;
2597 int elements_needed = 0;
2598 struct qeth_card *card = netdev_priv(dev);
2599 struct sk_buff *new_skb = NULL;
2600 int ipv = qeth_get_ip_version(skb);
2601 int cast_type = qeth_get_cast_type(card, skb);
2602 struct qeth_qdio_out_q *queue = card->qdio.out_qs
2603 [qeth_get_priority_queue(card, skb, ipv, cast_type)];
2604 int tx_bytes = skb->len;
2605 enum qeth_large_send_types large_send = QETH_LARGE_SEND_NO;
2606 struct qeth_eddp_context *ctx = NULL;
2607
4a71df50
FB		 2608 if ((card->info.type == QETH_CARD_TYPE_IQD) &&
2609 (skb->protocol != htons(ETH_P_IPV6)) &&
2610 (skb->protocol != htons(ETH_P_IP)))
2611 goto tx_drop;
2612
2613 if ((card->state != CARD_STATE_UP) || !card->lan_online) {
2614 card->stats.tx_carrier_errors++;
2615 goto tx_drop;
2616 }
2617
2618 if ((cast_type == RTN_BROADCAST) &&
2619 (card->info.broadcast_capable == 0))
2620 goto tx_drop;
2621
2622 if (card->options.performance_stats) {
2623 card->perf_stats.outbound_cnt++;
2624 card->perf_stats.outbound_start_time = qeth_get_micros();
2625 }
2626
2627 /* create a clone with writeable headroom */
2628 new_skb = skb_realloc_headroom(skb, sizeof(struct qeth_hdr_tso) +
2629 VLAN_HLEN);
2630 if (!new_skb)
2631 goto tx_drop;
2632
2633 if (card->info.type == QETH_CARD_TYPE_IQD) {
2634 skb_pull(new_skb, ETH_HLEN);
2635 } else {
2636 if (new_skb->protocol == htons(ETH_P_IP)) {
2637 if (card->dev->type == ARPHRD_IEEE802_TR)
2638 skb_pull(new_skb, TR_HLEN);
2639 else
2640 skb_pull(new_skb, ETH_HLEN);
2641 }
2642
2643 if (new_skb->protocol == ETH_P_IPV6 && card->vlangrp &&
2644 vlan_tx_tag_present(new_skb)) {
2645 skb_push(new_skb, VLAN_HLEN);
2646 skb_copy_to_linear_data(new_skb, new_skb->data + 4, 4);
2647 skb_copy_to_linear_data_offset(new_skb, 4,
2648 new_skb->data + 8, 4);
2649 skb_copy_to_linear_data_offset(new_skb, 8,
2650 new_skb->data + 12, 4);
2651 tag = (u16 *)(new_skb->data + 12);
2652 *tag = __constant_htons(ETH_P_8021Q);
2653 *(tag + 1) = htons(vlan_tx_tag_get(new_skb));
2b4ff112 2654 new_skb->vlan_tci = 0;
4a71df50
FB		 2655 }
2656 }
2657
2658 netif_stop_queue(dev);
2659
2660 if (skb_is_gso(new_skb))
2661 large_send = card->options.large_send;
2662
2663 /* fix hardware limitation: as long as we do not have sbal
2664 * chaining we can not send long frag lists so we temporary
2665 * switch to EDDP
2666 */
2667 if ((large_send == QETH_LARGE_SEND_TSO) &&
2668 ((skb_shinfo(new_skb)->nr_frags + 2) > 16))
2669 large_send = QETH_LARGE_SEND_EDDP;
2670
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);
2678 elements_needed++;
2679 } else {
2680 hdr = (struct qeth_hdr *)skb_push(new_skb,
2681 sizeof(struct qeth_hdr));
2682 qeth_l3_fill_header(card, hdr, new_skb, ipv, cast_type);
2683 }
2684
2685 if (large_send == QETH_LARGE_SEND_EDDP) {
2686 /* new_skb is not owned by a socket so we use skb to get
2687 * the protocol
2688 */
2689 ctx = qeth_eddp_create_context(card, new_skb, hdr,
2690 skb->sk->sk_protocol);
2691 if (ctx == NULL) {
14cc21b6 2692 QETH_DBF_MESSAGE(2, "could not create eddp context\n");
4a71df50
FB		 2693 goto tx_drop;
2694 }
2695 } else {
2696 int elems = qeth_get_elements_no(card, (void *)hdr, new_skb,
2697 elements_needed);
2698 if (!elems)
2699 goto tx_drop;
2700 elements_needed += elems;
2701 }
2702
2703 if ((large_send == QETH_LARGE_SEND_NO) &&
2704 (new_skb->ip_summed == CHECKSUM_PARTIAL))
2705 qeth_tx_csum(new_skb);
2706
2707 if (card->info.type != QETH_CARD_TYPE_IQD)
2708 rc = qeth_do_send_packet(card, queue, new_skb, hdr,
2709 elements_needed, ctx);
2710 else
2711 rc = qeth_do_send_packet_fast(card, queue, new_skb, hdr,
2712 elements_needed, ctx);
2713
2714 if (!rc) {
2715 card->stats.tx_packets++;
2716 card->stats.tx_bytes += tx_bytes;
2717 if (new_skb != skb)
2718 dev_kfree_skb_any(skb);
2719 if (card->options.performance_stats) {
2720 if (large_send != QETH_LARGE_SEND_NO) {
2721 card->perf_stats.large_send_bytes += tx_bytes;
2722 card->perf_stats.large_send_cnt++;
2723 }
2724 if (skb_shinfo(new_skb)->nr_frags > 0) {
2725 card->perf_stats.sg_skbs_sent++;
2726 /* nr_frags + skb->data */
2727 card->perf_stats.sg_frags_sent +=
2728 skb_shinfo(new_skb)->nr_frags + 1;
2729 }
2730 }
2731
2732 if (ctx != NULL) {
2733 qeth_eddp_put_context(ctx);
2734 dev_kfree_skb_any(new_skb);
2735 }
2736 } else {
2737 if (ctx != NULL)
2738 qeth_eddp_put_context(ctx);
2739
2740 if (rc == -EBUSY) {
2741 if (new_skb != skb)
2742 dev_kfree_skb_any(new_skb);
2743 return NETDEV_TX_BUSY;
2744 } else
2745 goto tx_drop;
2746 }
2747
2748 netif_wake_queue(dev);
2749 if (card->options.performance_stats)
2750 card->perf_stats.outbound_time += qeth_get_micros() -
2751 card->perf_stats.outbound_start_time;
2752 return rc;
2753
2754tx_drop:
2755 card->stats.tx_dropped++;
2756 card->stats.tx_errors++;
2757 if ((new_skb != skb) && new_skb)
2758 dev_kfree_skb_any(new_skb);
2759 dev_kfree_skb_any(skb);
d0ec0f54 2760 netif_wake_queue(dev);
4a71df50
FB		 2761 return NETDEV_TX_OK;
2762}
2763
2764static int qeth_l3_open(struct net_device *dev)
2765{
2766 struct qeth_card *card = netdev_priv(dev);
2767
d11ba0c4 2768 QETH_DBF_TEXT(TRACE, 4, "qethopen");
4a71df50
FB		 2769 if (card->state != CARD_STATE_SOFTSETUP)
2770 return -ENODEV;
2771 card->data.state = CH_STATE_UP;
2772 card->state = CARD_STATE_UP;
2773 card->dev->flags |= IFF_UP;
2774 netif_start_queue(dev);
2775
2776 if (!card->lan_online && netif_carrier_ok(dev))
2777 netif_carrier_off(dev);
2778 return 0;
2779}
2780
2781static int qeth_l3_stop(struct net_device *dev)
2782{
2783 struct qeth_card *card = netdev_priv(dev);
2784
d11ba0c4 2785 QETH_DBF_TEXT(TRACE, 4, "qethstop");
4a71df50
FB		 2786 netif_tx_disable(dev);
2787 card->dev->flags &= ~IFF_UP;
2788 if (card->state == CARD_STATE_UP)
2789 card->state = CARD_STATE_SOFTSETUP;
2790 return 0;
2791}
2792
2793static u32 qeth_l3_ethtool_get_rx_csum(struct net_device *dev)
2794{
2795 struct qeth_card *card = netdev_priv(dev);
2796
2797 return (card->options.checksum_type == HW_CHECKSUMMING);
2798}
2799
2800static int qeth_l3_ethtool_set_rx_csum(struct net_device *dev, u32 data)
2801{
2802 struct qeth_card *card = netdev_priv(dev);
2803 enum qeth_card_states old_state;
2804 enum qeth_checksum_types csum_type;
2805
2806 if ((card->state != CARD_STATE_UP) &&
2807 (card->state != CARD_STATE_DOWN))
2808 return -EPERM;
2809
2810 if (data)
2811 csum_type = HW_CHECKSUMMING;
2812 else
2813 csum_type = SW_CHECKSUMMING;
2814
2815 if (card->options.checksum_type != csum_type) {
2816 old_state = card->state;
2817 if (card->state == CARD_STATE_UP)
2818 __qeth_l3_set_offline(card->gdev, 1);
2819 card->options.checksum_type = csum_type;
2820 if (old_state == CARD_STATE_UP)
2821 __qeth_l3_set_online(card->gdev, 1);
2822 }
2823 return 0;
2824}
2825
2826static int qeth_l3_ethtool_set_tso(struct net_device *dev, u32 data)
2827{
2828 struct qeth_card *card = netdev_priv(dev);
2829
2830 if (data) {
2831 if (card->options.large_send == QETH_LARGE_SEND_NO) {
2832 if (card->info.type == QETH_CARD_TYPE_IQD)
2833 card->options.large_send = QETH_LARGE_SEND_EDDP;
2834 else
2835 card->options.large_send = QETH_LARGE_SEND_TSO;
2836 dev->features |= NETIF_F_TSO;
2837 }
2838 } else {
2839 dev->features &= ~NETIF_F_TSO;
2840 card->options.large_send = QETH_LARGE_SEND_NO;
2841 }
2842 return 0;
2843}
2844
2845static struct ethtool_ops qeth_l3_ethtool_ops = {
2846 .get_link = ethtool_op_get_link,
2847 .get_tx_csum = ethtool_op_get_tx_csum,
2848 .set_tx_csum = ethtool_op_set_tx_hw_csum,
2849 .get_rx_csum = qeth_l3_ethtool_get_rx_csum,
2850 .set_rx_csum = qeth_l3_ethtool_set_rx_csum,
2851 .get_sg = ethtool_op_get_sg,
2852 .set_sg = ethtool_op_set_sg,
2853 .get_tso = ethtool_op_get_tso,
2854 .set_tso = qeth_l3_ethtool_set_tso,
2855 .get_strings = qeth_core_get_strings,
2856 .get_ethtool_stats = qeth_core_get_ethtool_stats,
2857 .get_stats_count = qeth_core_get_stats_count,
2858 .get_drvinfo = qeth_core_get_drvinfo,
3f9975aa 2859 .get_settings = qeth_core_ethtool_get_settings,
4a71df50
FB		 2860};
2861
2862/*
2863 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
2864 * NOARP on the netdevice is no option because it also turns off neighbor
2865 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
2866 * arp resolution but we want the hard header (packet socket will work
2867 * e.g. tcpdump)
2868 */
2869static int qeth_l3_neigh_setup_noarp(struct neighbour *n)
2870{
2871 n->nud_state = NUD_NOARP;
2872 memcpy(n->ha, "FAKELL", 6);
2873 n->output = n->ops->connected_output;
2874 return 0;
2875}
2876
2877static int
2878qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np)
2879{
2880 if (np->tbl->family == AF_INET)
2881 np->neigh_setup = qeth_l3_neigh_setup_noarp;
2882
2883 return 0;
2884}
2885
2886static int qeth_l3_setup_netdev(struct qeth_card *card)
2887{
2888 if (card->info.type == QETH_CARD_TYPE_OSAE) {
2889 if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) ||
2890 (card->info.link_type == QETH_LINK_TYPE_HSTR)) {
2891#ifdef CONFIG_TR
2892 card->dev = alloc_trdev(0);
2893#endif
2894 if (!card->dev)
2895 return -ENODEV;
2896 } else {
2897 card->dev = alloc_etherdev(0);
2898 if (!card->dev)
2899 return -ENODEV;
2900 card->dev->neigh_setup = qeth_l3_neigh_setup;
2901
2902 /*IPv6 address autoconfiguration stuff*/
2903 qeth_l3_get_unique_id(card);
2904 if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
2905 card->dev->dev_id = card->info.unique_id &
2906 0xffff;
2907 }
2908 } else if (card->info.type == QETH_CARD_TYPE_IQD) {
2909 card->dev = alloc_netdev(0, "hsi%d", ether_setup);
2910 if (!card->dev)
2911 return -ENODEV;
2912 card->dev->flags |= IFF_NOARP;
2913 qeth_l3_iqd_read_initial_mac(card);
2914 } else
2915 return -ENODEV;
2916
2917 card->dev->hard_start_xmit = qeth_l3_hard_start_xmit;
2918 card->dev->priv = card;
2919 card->dev->tx_timeout = &qeth_tx_timeout;
2920 card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
2921 card->dev->open = qeth_l3_open;
2922 card->dev->stop = qeth_l3_stop;
2923 card->dev->do_ioctl = qeth_l3_do_ioctl;
2924 card->dev->get_stats = qeth_get_stats;
2925 card->dev->change_mtu = qeth_change_mtu;
2926 card->dev->set_multicast_list = qeth_l3_set_multicast_list;
2927 card->dev->vlan_rx_register = qeth_l3_vlan_rx_register;
2928 card->dev->vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid;
2929 card->dev->vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid;
2930 card->dev->mtu = card->info.initial_mtu;
b7624ec1 2931 card->dev->set_mac_address = NULL;
4a71df50
FB		 2932 SET_ETHTOOL_OPS(card->dev, &qeth_l3_ethtool_ops);
2933 card->dev->features |= NETIF_F_HW_VLAN_TX |
2934 NETIF_F_HW_VLAN_RX |
2935 NETIF_F_HW_VLAN_FILTER;
2936
2937 SET_NETDEV_DEV(card->dev, &card->gdev->dev);
2938 return register_netdev(card->dev);
2939}
2940
2941static void qeth_l3_qdio_input_handler(struct ccw_device *ccwdev,
779e6e1c 2942 unsigned int qdio_err, unsigned int queue, int first_element,
4a71df50
FB		 2943 int count, unsigned long card_ptr)
2944{
2945 struct net_device *net_dev;
2946 struct qeth_card *card;
2947 struct qeth_qdio_buffer *buffer;
2948 int index;
2949 int i;
2950
4a71df50
FB		 2951 card = (struct qeth_card *) card_ptr;
2952 net_dev = card->dev;
2953 if (card->options.performance_stats) {
2954 card->perf_stats.inbound_cnt++;
2955 card->perf_stats.inbound_start_time = qeth_get_micros();
2956 }
779e6e1c
JG		 2957 if (qdio_err & QDIO_ERROR_ACTIVATE_CHECK_CONDITION) {
2958 QETH_DBF_TEXT(TRACE, 1, "qdinchk");
2959 QETH_DBF_TEXT_(TRACE, 1, "%s", CARD_BUS_ID(card));
2960 QETH_DBF_TEXT_(TRACE, 1, "%04X%04X",
2961 first_element, count);
2962 QETH_DBF_TEXT_(TRACE, 1, "%04X", queue);
2963 qeth_schedule_recovery(card);
2964 return;
4a71df50
FB		 2965 }
2966 for (i = first_element; i < (first_element + count); ++i) {
2967 index = i % QDIO_MAX_BUFFERS_PER_Q;
2968 buffer = &card->qdio.in_q->bufs[index];
779e6e1c 2969 if (!(qdio_err &&
4a71df50 2970 qeth_check_qdio_errors(buffer->buffer,
779e6e1c 2971 qdio_err, "qinerr")))
4a71df50
FB		 2972 qeth_l3_process_inbound_buffer(card, buffer, index);
2973 /* clear buffer and give back to hardware */
2974 qeth_put_buffer_pool_entry(card, buffer->pool_entry);
2975 qeth_queue_input_buffer(card, index);
2976 }
2977 if (card->options.performance_stats)
2978 card->perf_stats.inbound_time += qeth_get_micros() -
2979 card->perf_stats.inbound_start_time;
2980}
2981
2982static int qeth_l3_probe_device(struct ccwgroup_device *gdev)
2983{
2984 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2985
2986 qeth_l3_create_device_attributes(&gdev->dev);
2987 card->options.layer2 = 0;
2988 card->discipline.input_handler = (qdio_handler_t *)
2989 qeth_l3_qdio_input_handler;
2990 card->discipline.output_handler = (qdio_handler_t *)
2991 qeth_qdio_output_handler;
2992 card->discipline.recover = qeth_l3_recover;
2993 return 0;
2994}
2995
2996static void qeth_l3_remove_device(struct ccwgroup_device *cgdev)
2997{
2998 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
2999
3000 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
3001
3002 if (cgdev->state == CCWGROUP_ONLINE) {
3003 card->use_hard_stop = 1;
3004 qeth_l3_set_offline(cgdev);
3005 }
3006
3007 if (card->dev) {
3008 unregister_netdev(card->dev);
3009 card->dev = NULL;
3010 }
3011
3012 qeth_l3_remove_device_attributes(&cgdev->dev);
3013 qeth_l3_clear_ip_list(card, 0, 0);
3014 qeth_l3_clear_ipato_list(card);
3015 return;
3016}
3017
3018static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode)
3019{
3020 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3021 int rc = 0;
3022 enum qeth_card_states recover_flag;
3023
3024 BUG_ON(!card);
d11ba0c4
PT		 3025 QETH_DBF_TEXT(SETUP, 2, "setonlin");
3026 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
4a71df50
FB		 3027
3028 qeth_set_allowed_threads(card, QETH_RECOVER_THREAD, 1);
3029 if (qeth_wait_for_threads(card, ~QETH_RECOVER_THREAD)) {
3030 PRINT_WARN("set_online of card %s interrupted by user!\n",
3031 CARD_BUS_ID(card));
3032 return -ERESTARTSYS;
3033 }
3034
3035 recover_flag = card->state;
3036 rc = ccw_device_set_online(CARD_RDEV(card));
3037 if (rc) {
d11ba0c4 3038 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
4a71df50
FB		 3039 return -EIO;
3040 }
3041 rc = ccw_device_set_online(CARD_WDEV(card));
3042 if (rc) {
d11ba0c4 3043 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
4a71df50
FB		 3044 return -EIO;
3045 }
3046 rc = ccw_device_set_online(CARD_DDEV(card));
3047 if (rc) {
d11ba0c4 3048 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
4a71df50
FB		 3049 return -EIO;
3050 }
3051
3052 rc = qeth_core_hardsetup_card(card);
3053 if (rc) {
d11ba0c4 3054 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
4a71df50
FB		 3055 goto out_remove;
3056 }
3057
3058 qeth_l3_query_ipassists(card, QETH_PROT_IPV4);
3059
3060 if (!card->dev && qeth_l3_setup_netdev(card))
3061 goto out_remove;
3062
3063 card->state = CARD_STATE_HARDSETUP;
3064 qeth_print_status_message(card);
3065
3066 /* softsetup */
d11ba0c4 3067 QETH_DBF_TEXT(SETUP, 2, "softsetp");
4a71df50
FB		 3068
3069 rc = qeth_send_startlan(card);
3070 if (rc) {
d11ba0c4 3071 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
4a71df50
FB		 3072 if (rc == 0xe080) {
3073 PRINT_WARN("LAN on card %s if offline! "
3074 "Waiting for STARTLAN from card.\n",
3075 CARD_BUS_ID(card));
3076 card->lan_online = 0;
3077 }
3078 return rc;
3079 } else
3080 card->lan_online = 1;
3081 qeth_set_large_send(card, card->options.large_send);
3082
3083 rc = qeth_l3_setadapter_parms(card);
3084 if (rc)
d11ba0c4 3085 QETH_DBF_TEXT_(SETUP, 2, "2err%d", rc);
4a71df50
FB		 3086 rc = qeth_l3_start_ipassists(card);
3087 if (rc)
d11ba0c4 3088 QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc);
4a71df50
FB		 3089 rc = qeth_l3_setrouting_v4(card);
3090 if (rc)
d11ba0c4 3091 QETH_DBF_TEXT_(SETUP, 2, "4err%d", rc);
4a71df50
FB		 3092 rc = qeth_l3_setrouting_v6(card);
3093 if (rc)
d11ba0c4 3094 QETH_DBF_TEXT_(SETUP, 2, "5err%d", rc);
4a71df50
FB		 3095 netif_tx_disable(card->dev);
3096
3097 rc = qeth_init_qdio_queues(card);
3098 if (rc) {
d11ba0c4 3099 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
4a71df50
FB		 3100 goto out_remove;
3101 }
3102 card->state = CARD_STATE_SOFTSETUP;
3103 netif_carrier_on(card->dev);
3104
3105 qeth_set_allowed_threads(card, 0xffffffff, 0);
8af7c5ae
FB		 3106 if (recover_flag == CARD_STATE_RECOVER) {
3107 if (recovery_mode)
4a71df50 3108 qeth_l3_open(card->dev);
8af7c5ae
FB		 3109 else {
3110 rtnl_lock();
3111 dev_open(card->dev);
3112 rtnl_unlock();
3113 }
3114 qeth_l3_set_multicast_list(card->dev);
4a71df50
FB		 3115 }
3116 /* let user_space know that device is online */
3117 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
3118 return 0;
3119out_remove:
3120 card->use_hard_stop = 1;
3121 qeth_l3_stop_card(card, 0);
3122 ccw_device_set_offline(CARD_DDEV(card));
3123 ccw_device_set_offline(CARD_WDEV(card));
3124 ccw_device_set_offline(CARD_RDEV(card));
3125 if (recover_flag == CARD_STATE_RECOVER)
3126 card->state = CARD_STATE_RECOVER;
3127 else
3128 card->state = CARD_STATE_DOWN;
3129 return -ENODEV;
3130}
3131
3132static int qeth_l3_set_online(struct ccwgroup_device *gdev)
3133{
3134 return __qeth_l3_set_online(gdev, 0);
3135}
3136
3137static int __qeth_l3_set_offline(struct ccwgroup_device *cgdev,
3138 int recovery_mode)
3139{
3140 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
3141 int rc = 0, rc2 = 0, rc3 = 0;
3142 enum qeth_card_states recover_flag;
3143
d11ba0c4
PT		 3144 QETH_DBF_TEXT(SETUP, 3, "setoffl");
3145 QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
4a71df50
FB		 3146
3147 if (card->dev && netif_carrier_ok(card->dev))
3148 netif_carrier_off(card->dev);
3149 recover_flag = card->state;
3150 if (qeth_l3_stop_card(card, recovery_mode) == -ERESTARTSYS) {
3151 PRINT_WARN("Stopping card %s interrupted by user!\n",
3152 CARD_BUS_ID(card));
3153 return -ERESTARTSYS;
3154 }
3155 rc = ccw_device_set_offline(CARD_DDEV(card));
3156 rc2 = ccw_device_set_offline(CARD_WDEV(card));
3157 rc3 = ccw_device_set_offline(CARD_RDEV(card));
3158 if (!rc)
3159 rc = (rc2) ? rc2 : rc3;
3160 if (rc)
d11ba0c4 3161 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
4a71df50
FB		 3162 if (recover_flag == CARD_STATE_UP)
3163 card->state = CARD_STATE_RECOVER;
3164 /* let user_space know that device is offline */
3165 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
3166 return 0;
3167}
3168
3169static int qeth_l3_set_offline(struct ccwgroup_device *cgdev)
3170{
3171 return __qeth_l3_set_offline(cgdev, 0);
3172}
3173
3174static int qeth_l3_recover(void *ptr)
3175{
3176 struct qeth_card *card;
3177 int rc = 0;
3178
3179 card = (struct qeth_card *) ptr;
d11ba0c4
PT		 3180 QETH_DBF_TEXT(TRACE, 2, "recover1");
3181 QETH_DBF_HEX(TRACE, 2, &card, sizeof(void *));
4a71df50
FB		 3182 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
3183 return 0;
d11ba0c4 3184 QETH_DBF_TEXT(TRACE, 2, "recover2");
4a71df50
FB		 3185 PRINT_WARN("Recovery of device %s started ...\n",
3186 CARD_BUS_ID(card));
3187 card->use_hard_stop = 1;
3188 __qeth_l3_set_offline(card->gdev, 1);
3189 rc = __qeth_l3_set_online(card->gdev, 1);
3190 /* don't run another scheduled recovery */
3191 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
3192 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
3193 if (!rc)
3194 PRINT_INFO("Device %s successfully recovered!\n",
3195 CARD_BUS_ID(card));
3196 else
3197 PRINT_INFO("Device %s could not be recovered!\n",
3198 CARD_BUS_ID(card));
3199 return 0;
3200}
3201
3202static void qeth_l3_shutdown(struct ccwgroup_device *gdev)
3203{
3204 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
3205 qeth_l3_clear_ip_list(card, 0, 0);
3206 qeth_qdio_clear_card(card, 0);
3207 qeth_clear_qdio_buffers(card);
3208}
3209
3210struct ccwgroup_driver qeth_l3_ccwgroup_driver = {
3211 .probe = qeth_l3_probe_device,
3212 .remove = qeth_l3_remove_device,
3213 .set_online = qeth_l3_set_online,
3214 .set_offline = qeth_l3_set_offline,
3215 .shutdown = qeth_l3_shutdown,
3216};
3217EXPORT_SYMBOL_GPL(qeth_l3_ccwgroup_driver);
3218
3219static int qeth_l3_ip_event(struct notifier_block *this,
76fef2b6 3220 unsigned long event, void *ptr)
4a71df50
FB		 3221{
3222 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
3223 struct net_device *dev = (struct net_device *)ifa->ifa_dev->dev;
3224 struct qeth_ipaddr *addr;
3225 struct qeth_card *card;
3226
c346dca1 3227 if (dev_net(dev) != &init_net)
76fef2b6
DM		 3228 return NOTIFY_DONE;
3229
d11ba0c4 3230 QETH_DBF_TEXT(TRACE, 3, "ipevent");
4a71df50
FB		 3231 card = qeth_l3_get_card_from_dev(dev);
3232 if (!card)
3233 return NOTIFY_DONE;
3234
3235 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
3236 if (addr != NULL) {
3237 addr->u.a4.addr = ifa->ifa_address;
3238 addr->u.a4.mask = ifa->ifa_mask;
3239 addr->type = QETH_IP_TYPE_NORMAL;
3240 } else
3241 goto out;
3242
3243 switch (event) {
3244 case NETDEV_UP:
3245 if (!qeth_l3_add_ip(card, addr))
3246 kfree(addr);
3247 break;
3248 case NETDEV_DOWN:
3249 if (!qeth_l3_delete_ip(card, addr))
3250 kfree(addr);
3251 break;
3252 default:
3253 break;
3254 }
3255 qeth_l3_set_ip_addr_list(card);
3256out:
3257 return NOTIFY_DONE;
3258}
3259
3260static struct notifier_block qeth_l3_ip_notifier = {
3261 qeth_l3_ip_event,
3262 NULL,
3263};
3264
3265#ifdef CONFIG_QETH_IPV6
3266/**
3267 * IPv6 event handler
3268 */
3269static int qeth_l3_ip6_event(struct notifier_block *this,
76fef2b6 3270 unsigned long event, void *ptr)
4a71df50
FB		 3271{
3272 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
3273 struct net_device *dev = (struct net_device *)ifa->idev->dev;
3274 struct qeth_ipaddr *addr;
3275 struct qeth_card *card;
3276
d11ba0c4 3277 QETH_DBF_TEXT(TRACE, 3, "ip6event");
4a71df50
FB		 3278
3279 card = qeth_l3_get_card_from_dev(dev);
3280 if (!card)
3281 return NOTIFY_DONE;
3282 if (!qeth_is_supported(card, IPA_IPV6))
3283 return NOTIFY_DONE;
3284
3285 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
3286 if (addr != NULL) {
3287 memcpy(&addr->u.a6.addr, &ifa->addr, sizeof(struct in6_addr));
3288 addr->u.a6.pfxlen = ifa->prefix_len;
3289 addr->type = QETH_IP_TYPE_NORMAL;
3290 } else
3291 goto out;
3292
3293 switch (event) {
3294 case NETDEV_UP:
3295 if (!qeth_l3_add_ip(card, addr))
3296 kfree(addr);
3297 break;
3298 case NETDEV_DOWN:
3299 if (!qeth_l3_delete_ip(card, addr))
3300 kfree(addr);
3301 break;
3302 default:
3303 break;
3304 }
3305 qeth_l3_set_ip_addr_list(card);
3306out:
3307 return NOTIFY_DONE;
3308}
3309
3310static struct notifier_block qeth_l3_ip6_notifier = {
3311 qeth_l3_ip6_event,
3312 NULL,
3313};
3314#endif
3315
3316static int qeth_l3_register_notifiers(void)
3317{
3318 int rc;
3319
d11ba0c4 3320 QETH_DBF_TEXT(TRACE, 5, "regnotif");
4a71df50
FB		 3321 rc = register_inetaddr_notifier(&qeth_l3_ip_notifier);
3322 if (rc)
3323 return rc;
3324#ifdef CONFIG_QETH_IPV6
3325 rc = register_inet6addr_notifier(&qeth_l3_ip6_notifier);
3326 if (rc) {
3327 unregister_inetaddr_notifier(&qeth_l3_ip_notifier);
3328 return rc;
3329 }
3330#else
3331 PRINT_WARN("layer 3 discipline no IPv6 support\n");
3332#endif
3333 return 0;
3334}
3335
3336static void qeth_l3_unregister_notifiers(void)
3337{
3338
d11ba0c4 3339 QETH_DBF_TEXT(TRACE, 5, "unregnot");
4a71df50
FB		 3340 BUG_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier));
3341#ifdef CONFIG_QETH_IPV6
3342 BUG_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier));
3343#endif /* QETH_IPV6 */
3344}
3345
3346static int __init qeth_l3_init(void)
3347{
3348 int rc = 0;
3349
3350 PRINT_INFO("register layer 3 discipline\n");
3351 rc = qeth_l3_register_notifiers();
3352 return rc;
3353}
3354
3355static void __exit qeth_l3_exit(void)
3356{
3357 qeth_l3_unregister_notifiers();
3358 PRINT_INFO("unregister layer 3 discipline\n");
3359}
3360
3361module_init(qeth_l3_init);
3362module_exit(qeth_l3_exit);
3363MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
3364MODULE_DESCRIPTION("qeth layer 3 discipline");
3365MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)