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