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