]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - drivers/s390/net/qeth_l3_main.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:


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