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