1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright IBM Corp. 2007, 2009
4 * Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
5 * Frank Pavlic <fpavlic@de.ibm.com>,
6 * Thomas Spatzier <tspat@de.ibm.com>,
7 * Frank Blaschka <frank.blaschka@de.ibm.com>
8 */
9
10 #define KMSG_COMPONENT "qeth"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12
13 #include <linux/module.h>
14 #include <linux/moduleparam.h>
15 #include <linux/bitops.h>
16 #include <linux/string.h>
17 #include <linux/errno.h>
18 #include <linux/kernel.h>
19 #include <linux/etherdevice.h>
20 #include <linux/ip.h>
21 #include <linux/in.h>
22 #include <linux/ipv6.h>
23 #include <linux/inetdevice.h>
24 #include <linux/igmp.h>
25 #include <linux/slab.h>
26 #include <linux/if_ether.h>
27 #include <linux/if_vlan.h>
28 #include <linux/skbuff.h>
29
30 #include <net/ip.h>
31 #include <net/arp.h>
32 #include <net/route.h>
33 #include <net/ipv6.h>
34 #include <net/ip6_route.h>
35 #include <net/iucv/af_iucv.h>
36 #include <linux/hashtable.h>
37
38 #include "qeth_l3.h"
39
40
41 static int qeth_l3_set_offline(struct ccwgroup_device *);
42 static void qeth_l3_set_rx_mode(struct net_device *dev);
43 static int qeth_l3_register_addr_entry(struct qeth_card *,
44 struct qeth_ipaddr *);
45 static int qeth_l3_deregister_addr_entry(struct qeth_card *,
46 struct qeth_ipaddr *);
47
qeth_l3_ipaddr4_to_string(const __u8 * addr,char * buf)48 static void qeth_l3_ipaddr4_to_string(const __u8 *addr, char *buf)
49 {
50 sprintf(buf, "%pI4", addr);
51 }
52
qeth_l3_ipaddr6_to_string(const __u8 * addr,char * buf)53 static void qeth_l3_ipaddr6_to_string(const __u8 *addr, char *buf)
54 {
55 sprintf(buf, "%pI6", addr);
56 }
57
qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto,const __u8 * addr,char * buf)58 void qeth_l3_ipaddr_to_string(enum qeth_prot_versions proto, const __u8 *addr,
59 char *buf)
60 {
61 if (proto == QETH_PROT_IPV4)
62 qeth_l3_ipaddr4_to_string(addr, buf);
63 else if (proto == QETH_PROT_IPV6)
64 qeth_l3_ipaddr6_to_string(addr, buf);
65 }
66
qeth_l3_get_addr_buffer(enum qeth_prot_versions prot)67 static struct qeth_ipaddr *qeth_l3_get_addr_buffer(enum qeth_prot_versions prot)
68 {
69 struct qeth_ipaddr *addr = kmalloc(sizeof(*addr), GFP_ATOMIC);
70
71 if (addr)
72 qeth_l3_init_ipaddr(addr, QETH_IP_TYPE_NORMAL, prot);
73 return addr;
74 }
75
qeth_l3_find_addr_by_ip(struct qeth_card * card,struct qeth_ipaddr * query)76 static struct qeth_ipaddr *qeth_l3_find_addr_by_ip(struct qeth_card *card,
77 struct qeth_ipaddr *query)
78 {
79 u64 key = qeth_l3_ipaddr_hash(query);
80 struct qeth_ipaddr *addr;
81
82 if (query->is_multicast) {
83 hash_for_each_possible(card->ip_mc_htable, addr, hnode, key)
84 if (qeth_l3_addr_match_ip(addr, query))
85 return addr;
86 } else {
87 hash_for_each_possible(card->ip_htable, addr, hnode, key)
88 if (qeth_l3_addr_match_ip(addr, query))
89 return addr;
90 }
91 return NULL;
92 }
93
qeth_l3_convert_addr_to_bits(u8 * addr,u8 * bits,int len)94 static void qeth_l3_convert_addr_to_bits(u8 *addr, u8 *bits, int len)
95 {
96 int i, j;
97 u8 octet;
98
99 for (i = 0; i < len; ++i) {
100 octet = addr[i];
101 for (j = 7; j >= 0; --j) {
102 bits[i*8 + j] = octet & 1;
103 octet >>= 1;
104 }
105 }
106 }
107
qeth_l3_is_addr_covered_by_ipato(struct qeth_card * card,struct qeth_ipaddr * addr)108 static bool qeth_l3_is_addr_covered_by_ipato(struct qeth_card *card,
109 struct qeth_ipaddr *addr)
110 {
111 struct qeth_ipato_entry *ipatoe;
112 u8 addr_bits[128] = {0, };
113 u8 ipatoe_bits[128] = {0, };
114 int rc = 0;
115
116 if (!card->ipato.enabled)
117 return false;
118 if (addr->type != QETH_IP_TYPE_NORMAL)
119 return false;
120
121 qeth_l3_convert_addr_to_bits((u8 *) &addr->u, addr_bits,
122 (addr->proto == QETH_PROT_IPV4)? 4:16);
123 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
124 if (addr->proto != ipatoe->proto)
125 continue;
126 qeth_l3_convert_addr_to_bits(ipatoe->addr, ipatoe_bits,
127 (ipatoe->proto == QETH_PROT_IPV4) ?
128 4 : 16);
129 if (addr->proto == QETH_PROT_IPV4)
130 rc = !memcmp(addr_bits, ipatoe_bits,
131 min(32, ipatoe->mask_bits));
132 else
133 rc = !memcmp(addr_bits, ipatoe_bits,
134 min(128, ipatoe->mask_bits));
135 if (rc)
136 break;
137 }
138 /* invert? */
139 if ((addr->proto == QETH_PROT_IPV4) && card->ipato.invert4)
140 rc = !rc;
141 else if ((addr->proto == QETH_PROT_IPV6) && card->ipato.invert6)
142 rc = !rc;
143
144 return rc;
145 }
146
qeth_l3_delete_ip(struct qeth_card * card,struct qeth_ipaddr * tmp_addr)147 static int qeth_l3_delete_ip(struct qeth_card *card,
148 struct qeth_ipaddr *tmp_addr)
149 {
150 int rc = 0;
151 struct qeth_ipaddr *addr;
152
153 if (tmp_addr->type == QETH_IP_TYPE_RXIP)
154 QETH_CARD_TEXT(card, 2, "delrxip");
155 else if (tmp_addr->type == QETH_IP_TYPE_VIPA)
156 QETH_CARD_TEXT(card, 2, "delvipa");
157 else
158 QETH_CARD_TEXT(card, 2, "delip");
159
160 if (tmp_addr->proto == QETH_PROT_IPV4)
161 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
162 else {
163 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
164 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
165 }
166
167 addr = qeth_l3_find_addr_by_ip(card, tmp_addr);
168 if (!addr || !qeth_l3_addr_match_all(addr, tmp_addr))
169 return -ENOENT;
170
171 addr->ref_counter--;
172 if (addr->type == QETH_IP_TYPE_NORMAL && addr->ref_counter > 0)
173 return rc;
174 if (addr->in_progress)
175 return -EINPROGRESS;
176
177 if (qeth_card_hw_is_reachable(card))
178 rc = qeth_l3_deregister_addr_entry(card, addr);
179
180 hash_del(&addr->hnode);
181 kfree(addr);
182
183 return rc;
184 }
185
qeth_l3_add_ip(struct qeth_card * card,struct qeth_ipaddr * tmp_addr)186 static int qeth_l3_add_ip(struct qeth_card *card, struct qeth_ipaddr *tmp_addr)
187 {
188 int rc = 0;
189 struct qeth_ipaddr *addr;
190 char buf[40];
191
192 if (tmp_addr->type == QETH_IP_TYPE_RXIP)
193 QETH_CARD_TEXT(card, 2, "addrxip");
194 else if (tmp_addr->type == QETH_IP_TYPE_VIPA)
195 QETH_CARD_TEXT(card, 2, "addvipa");
196 else
197 QETH_CARD_TEXT(card, 2, "addip");
198
199 if (tmp_addr->proto == QETH_PROT_IPV4)
200 QETH_CARD_HEX(card, 4, &tmp_addr->u.a4.addr, 4);
201 else {
202 QETH_CARD_HEX(card, 4, &tmp_addr->u.a6.addr, 8);
203 QETH_CARD_HEX(card, 4, ((char *)&tmp_addr->u.a6.addr) + 8, 8);
204 }
205
206 addr = qeth_l3_find_addr_by_ip(card, tmp_addr);
207 if (addr) {
208 if (tmp_addr->type != QETH_IP_TYPE_NORMAL)
209 return -EADDRINUSE;
210 if (qeth_l3_addr_match_all(addr, tmp_addr)) {
211 addr->ref_counter++;
212 return 0;
213 }
214 qeth_l3_ipaddr_to_string(tmp_addr->proto, (u8 *)&tmp_addr->u,
215 buf);
216 dev_warn(&card->gdev->dev,
217 "Registering IP address %s failed\n", buf);
218 return -EADDRINUSE;
219 } else {
220 addr = qeth_l3_get_addr_buffer(tmp_addr->proto);
221 if (!addr)
222 return -ENOMEM;
223
224 memcpy(addr, tmp_addr, sizeof(struct qeth_ipaddr));
225 addr->ref_counter = 1;
226
227 if (qeth_l3_is_addr_covered_by_ipato(card, addr)) {
228 QETH_CARD_TEXT(card, 2, "tkovaddr");
229 addr->ipato = 1;
230 }
231 hash_add(card->ip_htable, &addr->hnode,
232 qeth_l3_ipaddr_hash(addr));
233
234 if (!qeth_card_hw_is_reachable(card)) {
235 addr->disp_flag = QETH_DISP_ADDR_ADD;
236 return 0;
237 }
238
239 /* qeth_l3_register_addr_entry can go to sleep
240 * if we add a IPV4 addr. It is caused by the reason
241 * that SETIP ipa cmd starts ARP staff for IPV4 addr.
242 * Thus we should unlock spinlock, and make a protection
243 * using in_progress variable to indicate that there is
244 * an hardware operation with this IPV4 address
245 */
246 if (addr->proto == QETH_PROT_IPV4) {
247 addr->in_progress = 1;
248 mutex_unlock(&card->ip_lock);
249 rc = qeth_l3_register_addr_entry(card, addr);
250 mutex_lock(&card->ip_lock);
251 addr->in_progress = 0;
252 } else
253 rc = qeth_l3_register_addr_entry(card, addr);
254
255 if (!rc || rc == -EADDRINUSE || rc == -ENETDOWN) {
256 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
257 if (addr->ref_counter < 1) {
258 qeth_l3_deregister_addr_entry(card, addr);
259 hash_del(&addr->hnode);
260 kfree(addr);
261 }
262 } else {
263 hash_del(&addr->hnode);
264 kfree(addr);
265 }
266 }
267 return rc;
268 }
269
qeth_l3_modify_ip(struct qeth_card * card,struct qeth_ipaddr * addr,bool add)270 static int qeth_l3_modify_ip(struct qeth_card *card, struct qeth_ipaddr *addr,
271 bool add)
272 {
273 int rc;
274
275 mutex_lock(&card->ip_lock);
276 rc = add ? qeth_l3_add_ip(card, addr) : qeth_l3_delete_ip(card, addr);
277 mutex_unlock(&card->ip_lock);
278
279 return rc;
280 }
281
qeth_l3_drain_rx_mode_cache(struct qeth_card * card)282 static void qeth_l3_drain_rx_mode_cache(struct qeth_card *card)
283 {
284 struct qeth_ipaddr *addr;
285 struct hlist_node *tmp;
286 int i;
287
288 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
289 hash_del(&addr->hnode);
290 kfree(addr);
291 }
292 }
293
qeth_l3_clear_ip_htable(struct qeth_card * card,int recover)294 static void qeth_l3_clear_ip_htable(struct qeth_card *card, int recover)
295 {
296 struct qeth_ipaddr *addr;
297 struct hlist_node *tmp;
298 int i;
299
300 QETH_CARD_TEXT(card, 4, "clearip");
301
302 mutex_lock(&card->ip_lock);
303
304 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
305 if (!recover) {
306 hash_del(&addr->hnode);
307 kfree(addr);
308 } else {
309 /* prepare for recovery */
310 addr->disp_flag = QETH_DISP_ADDR_ADD;
311 }
312 }
313
314 mutex_unlock(&card->ip_lock);
315 }
316
qeth_l3_recover_ip(struct qeth_card * card)317 static void qeth_l3_recover_ip(struct qeth_card *card)
318 {
319 struct qeth_ipaddr *addr;
320 struct hlist_node *tmp;
321 int i;
322 int rc;
323
324 QETH_CARD_TEXT(card, 4, "recovrip");
325
326 mutex_lock(&card->ip_lock);
327
328 hash_for_each_safe(card->ip_htable, i, tmp, addr, hnode) {
329 if (addr->disp_flag == QETH_DISP_ADDR_ADD) {
330 if (addr->proto == QETH_PROT_IPV4) {
331 addr->in_progress = 1;
332 mutex_unlock(&card->ip_lock);
333 rc = qeth_l3_register_addr_entry(card, addr);
334 mutex_lock(&card->ip_lock);
335 addr->in_progress = 0;
336 } else
337 rc = qeth_l3_register_addr_entry(card, addr);
338
339 if (!rc || rc == -EADDRINUSE || rc == -ENETDOWN) {
340 /* keep it in the records */
341 addr->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
342 if (addr->ref_counter < 1)
343 qeth_l3_delete_ip(card, addr);
344 } else {
345 /* bad address */
346 hash_del(&addr->hnode);
347 kfree(addr);
348 }
349 }
350 }
351
352 mutex_unlock(&card->ip_lock);
353 }
354
qeth_l3_setdelip_cb(struct qeth_card * card,struct qeth_reply * reply,unsigned long data)355 static int qeth_l3_setdelip_cb(struct qeth_card *card, struct qeth_reply *reply,
356 unsigned long data)
357 {
358 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
359
360 switch (cmd->hdr.return_code) {
361 case IPA_RC_SUCCESS:
362 return 0;
363 case IPA_RC_DUPLICATE_IP_ADDRESS:
364 return -EADDRINUSE;
365 case IPA_RC_MC_ADDR_NOT_FOUND:
366 return -ENOENT;
367 case IPA_RC_LAN_OFFLINE:
368 return -ENETDOWN;
369 default:
370 return -EIO;
371 }
372 }
373
qeth_l3_send_setdelmc(struct qeth_card * card,struct qeth_ipaddr * addr,int ipacmd)374 static int qeth_l3_send_setdelmc(struct qeth_card *card,
375 struct qeth_ipaddr *addr, int ipacmd)
376 {
377 struct qeth_cmd_buffer *iob;
378 struct qeth_ipa_cmd *cmd;
379
380 QETH_CARD_TEXT(card, 4, "setdelmc");
381
382 iob = qeth_ipa_alloc_cmd(card, ipacmd, addr->proto,
383 IPA_DATA_SIZEOF(setdelipm));
384 if (!iob)
385 return -ENOMEM;
386 cmd = __ipa_cmd(iob);
387 ether_addr_copy(cmd->data.setdelipm.mac, addr->mac);
388 if (addr->proto == QETH_PROT_IPV6)
389 memcpy(cmd->data.setdelipm.ip6, &addr->u.a6.addr,
390 sizeof(struct in6_addr));
391 else
392 memcpy(&cmd->data.setdelipm.ip4, &addr->u.a4.addr, 4);
393
394 return qeth_send_ipa_cmd(card, iob, qeth_l3_setdelip_cb, NULL);
395 }
396
qeth_l3_fill_netmask(u8 * netmask,unsigned int len)397 static void qeth_l3_fill_netmask(u8 *netmask, unsigned int len)
398 {
399 int i, j;
400 for (i = 0; i < 16; i++) {
401 j = (len) - (i * 8);
402 if (j >= 8)
403 netmask[i] = 0xff;
404 else if (j > 0)
405 netmask[i] = (u8)(0xFF00 >> j);
406 else
407 netmask[i] = 0;
408 }
409 }
410
qeth_l3_get_setdelip_flags(struct qeth_ipaddr * addr,bool set)411 static u32 qeth_l3_get_setdelip_flags(struct qeth_ipaddr *addr, bool set)
412 {
413 switch (addr->type) {
414 case QETH_IP_TYPE_RXIP:
415 return (set) ? QETH_IPA_SETIP_TAKEOVER_FLAG : 0;
416 case QETH_IP_TYPE_VIPA:
417 return (set) ? QETH_IPA_SETIP_VIPA_FLAG :
418 QETH_IPA_DELIP_VIPA_FLAG;
419 default:
420 return (set && addr->ipato) ? QETH_IPA_SETIP_TAKEOVER_FLAG : 0;
421 }
422 }
423
qeth_l3_send_setdelip(struct qeth_card * card,struct qeth_ipaddr * addr,enum qeth_ipa_cmds ipacmd)424 static int qeth_l3_send_setdelip(struct qeth_card *card,
425 struct qeth_ipaddr *addr,
426 enum qeth_ipa_cmds ipacmd)
427 {
428 struct qeth_cmd_buffer *iob;
429 struct qeth_ipa_cmd *cmd;
430 __u8 netmask[16];
431 u32 flags;
432
433 QETH_CARD_TEXT(card, 4, "setdelip");
434
435 iob = qeth_ipa_alloc_cmd(card, ipacmd, addr->proto,
436 IPA_DATA_SIZEOF(setdelip6));
437 if (!iob)
438 return -ENOMEM;
439 cmd = __ipa_cmd(iob);
440
441 flags = qeth_l3_get_setdelip_flags(addr, ipacmd == IPA_CMD_SETIP);
442 QETH_CARD_TEXT_(card, 4, "flags%02X", flags);
443
444 if (addr->proto == QETH_PROT_IPV6) {
445 memcpy(cmd->data.setdelip6.ip_addr, &addr->u.a6.addr,
446 sizeof(struct in6_addr));
447 qeth_l3_fill_netmask(netmask, addr->u.a6.pfxlen);
448 memcpy(cmd->data.setdelip6.mask, netmask,
449 sizeof(struct in6_addr));
450 cmd->data.setdelip6.flags = flags;
451 } else {
452 memcpy(cmd->data.setdelip4.ip_addr, &addr->u.a4.addr, 4);
453 memcpy(cmd->data.setdelip4.mask, &addr->u.a4.mask, 4);
454 cmd->data.setdelip4.flags = flags;
455 }
456
457 return qeth_send_ipa_cmd(card, iob, qeth_l3_setdelip_cb, NULL);
458 }
459
qeth_l3_send_setrouting(struct qeth_card * card,enum qeth_routing_types type,enum qeth_prot_versions prot)460 static int qeth_l3_send_setrouting(struct qeth_card *card,
461 enum qeth_routing_types type, enum qeth_prot_versions prot)
462 {
463 int rc;
464 struct qeth_ipa_cmd *cmd;
465 struct qeth_cmd_buffer *iob;
466
467 QETH_CARD_TEXT(card, 4, "setroutg");
468 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_SETRTG, prot,
469 IPA_DATA_SIZEOF(setrtg));
470 if (!iob)
471 return -ENOMEM;
472 cmd = __ipa_cmd(iob);
473 cmd->data.setrtg.type = (type);
474 rc = qeth_send_ipa_cmd(card, iob, NULL, NULL);
475
476 return rc;
477 }
478
qeth_l3_correct_routing_type(struct qeth_card * card,enum qeth_routing_types * type,enum qeth_prot_versions prot)479 static int qeth_l3_correct_routing_type(struct qeth_card *card,
480 enum qeth_routing_types *type, enum qeth_prot_versions prot)
481 {
482 if (IS_IQD(card)) {
483 switch (*type) {
484 case NO_ROUTER:
485 case PRIMARY_CONNECTOR:
486 case SECONDARY_CONNECTOR:
487 case MULTICAST_ROUTER:
488 return 0;
489 default:
490 goto out_inval;
491 }
492 } else {
493 switch (*type) {
494 case NO_ROUTER:
495 case PRIMARY_ROUTER:
496 case SECONDARY_ROUTER:
497 return 0;
498 case MULTICAST_ROUTER:
499 if (qeth_is_ipafunc_supported(card, prot,
500 IPA_OSA_MC_ROUTER))
501 return 0;
502 default:
503 goto out_inval;
504 }
505 }
506 out_inval:
507 *type = NO_ROUTER;
508 return -EINVAL;
509 }
510
qeth_l3_setrouting_v4(struct qeth_card * card)511 int qeth_l3_setrouting_v4(struct qeth_card *card)
512 {
513 int rc;
514
515 QETH_CARD_TEXT(card, 3, "setrtg4");
516
517 rc = qeth_l3_correct_routing_type(card, &card->options.route4.type,
518 QETH_PROT_IPV4);
519 if (rc)
520 return rc;
521
522 rc = qeth_l3_send_setrouting(card, card->options.route4.type,
523 QETH_PROT_IPV4);
524 if (rc) {
525 card->options.route4.type = NO_ROUTER;
526 QETH_DBF_MESSAGE(2, "Error (%#06x) while setting routing type on device %x. Type set to 'no router'.\n",
527 rc, CARD_DEVID(card));
528 }
529 return rc;
530 }
531
qeth_l3_setrouting_v6(struct qeth_card * card)532 int qeth_l3_setrouting_v6(struct qeth_card *card)
533 {
534 int rc = 0;
535
536 QETH_CARD_TEXT(card, 3, "setrtg6");
537
538 if (!qeth_is_supported(card, IPA_IPV6))
539 return 0;
540 rc = qeth_l3_correct_routing_type(card, &card->options.route6.type,
541 QETH_PROT_IPV6);
542 if (rc)
543 return rc;
544
545 rc = qeth_l3_send_setrouting(card, card->options.route6.type,
546 QETH_PROT_IPV6);
547 if (rc) {
548 card->options.route6.type = NO_ROUTER;
549 QETH_DBF_MESSAGE(2, "Error (%#06x) while setting routing type on device %x. Type set to 'no router'.\n",
550 rc, CARD_DEVID(card));
551 }
552 return rc;
553 }
554
555 /*
556 * IP address takeover related functions
557 */
558
559 /**
560 * qeth_l3_update_ipato() - Update 'takeover' property, for all NORMAL IPs.
561 *
562 * Caller must hold ip_lock.
563 */
qeth_l3_update_ipato(struct qeth_card * card)564 void qeth_l3_update_ipato(struct qeth_card *card)
565 {
566 struct qeth_ipaddr *addr;
567 unsigned int i;
568
569 hash_for_each(card->ip_htable, i, addr, hnode) {
570 if (addr->type != QETH_IP_TYPE_NORMAL)
571 continue;
572 addr->ipato = qeth_l3_is_addr_covered_by_ipato(card, addr);
573 }
574 }
575
qeth_l3_clear_ipato_list(struct qeth_card * card)576 static void qeth_l3_clear_ipato_list(struct qeth_card *card)
577 {
578 struct qeth_ipato_entry *ipatoe, *tmp;
579
580 mutex_lock(&card->ip_lock);
581
582 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
583 list_del(&ipatoe->entry);
584 kfree(ipatoe);
585 }
586
587 qeth_l3_update_ipato(card);
588 mutex_unlock(&card->ip_lock);
589 }
590
qeth_l3_add_ipato_entry(struct qeth_card * card,struct qeth_ipato_entry * new)591 int qeth_l3_add_ipato_entry(struct qeth_card *card,
592 struct qeth_ipato_entry *new)
593 {
594 struct qeth_ipato_entry *ipatoe;
595 int rc = 0;
596
597 QETH_CARD_TEXT(card, 2, "addipato");
598
599 mutex_lock(&card->ip_lock);
600
601 list_for_each_entry(ipatoe, &card->ipato.entries, entry) {
602 if (ipatoe->proto != new->proto)
603 continue;
604 if (!memcmp(ipatoe->addr, new->addr,
605 (ipatoe->proto == QETH_PROT_IPV4)? 4:16) &&
606 (ipatoe->mask_bits == new->mask_bits)) {
607 rc = -EEXIST;
608 break;
609 }
610 }
611
612 if (!rc) {
613 list_add_tail(&new->entry, &card->ipato.entries);
614 qeth_l3_update_ipato(card);
615 }
616
617 mutex_unlock(&card->ip_lock);
618
619 return rc;
620 }
621
qeth_l3_del_ipato_entry(struct qeth_card * card,enum qeth_prot_versions proto,u8 * addr,int mask_bits)622 int qeth_l3_del_ipato_entry(struct qeth_card *card,
623 enum qeth_prot_versions proto, u8 *addr,
624 int mask_bits)
625 {
626 struct qeth_ipato_entry *ipatoe, *tmp;
627 int rc = -ENOENT;
628
629 QETH_CARD_TEXT(card, 2, "delipato");
630
631 mutex_lock(&card->ip_lock);
632
633 list_for_each_entry_safe(ipatoe, tmp, &card->ipato.entries, entry) {
634 if (ipatoe->proto != proto)
635 continue;
636 if (!memcmp(ipatoe->addr, addr,
637 (proto == QETH_PROT_IPV4)? 4:16) &&
638 (ipatoe->mask_bits == mask_bits)) {
639 list_del(&ipatoe->entry);
640 qeth_l3_update_ipato(card);
641 kfree(ipatoe);
642 rc = 0;
643 }
644 }
645
646 mutex_unlock(&card->ip_lock);
647 return rc;
648 }
649
qeth_l3_modify_rxip_vipa(struct qeth_card * card,bool add,const u8 * ip,enum qeth_ip_types type,enum qeth_prot_versions proto)650 int qeth_l3_modify_rxip_vipa(struct qeth_card *card, bool add, const u8 *ip,
651 enum qeth_ip_types type,
652 enum qeth_prot_versions proto)
653 {
654 struct qeth_ipaddr addr;
655
656 qeth_l3_init_ipaddr(&addr, type, proto);
657 if (proto == QETH_PROT_IPV4)
658 memcpy(&addr.u.a4.addr, ip, 4);
659 else
660 memcpy(&addr.u.a6.addr, ip, 16);
661
662 return qeth_l3_modify_ip(card, &addr, add);
663 }
664
qeth_l3_modify_hsuid(struct qeth_card * card,bool add)665 int qeth_l3_modify_hsuid(struct qeth_card *card, bool add)
666 {
667 struct qeth_ipaddr addr;
668 unsigned int i;
669
670 qeth_l3_init_ipaddr(&addr, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV6);
671 addr.u.a6.addr.s6_addr[0] = 0xfe;
672 addr.u.a6.addr.s6_addr[1] = 0x80;
673 for (i = 0; i < 8; i++)
674 addr.u.a6.addr.s6_addr[8+i] = card->options.hsuid[i];
675
676 return qeth_l3_modify_ip(card, &addr, add);
677 }
678
qeth_l3_register_addr_entry(struct qeth_card * card,struct qeth_ipaddr * addr)679 static int qeth_l3_register_addr_entry(struct qeth_card *card,
680 struct qeth_ipaddr *addr)
681 {
682 char buf[50];
683 int rc = 0;
684 int cnt = 3;
685
686 if (card->options.sniffer)
687 return 0;
688
689 if (addr->proto == QETH_PROT_IPV4) {
690 QETH_CARD_TEXT(card, 2, "setaddr4");
691 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
692 } else if (addr->proto == QETH_PROT_IPV6) {
693 QETH_CARD_TEXT(card, 2, "setaddr6");
694 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
695 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
696 } else {
697 QETH_CARD_TEXT(card, 2, "setaddr?");
698 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
699 }
700 do {
701 if (addr->is_multicast)
702 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_SETIPM);
703 else
704 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_SETIP);
705 if (rc)
706 QETH_CARD_TEXT(card, 2, "failed");
707 } while ((--cnt > 0) && rc);
708 if (rc) {
709 QETH_CARD_TEXT(card, 2, "FAILED");
710 qeth_l3_ipaddr_to_string(addr->proto, (u8 *)&addr->u, buf);
711 dev_warn(&card->gdev->dev,
712 "Registering IP address %s failed\n", buf);
713 }
714 return rc;
715 }
716
qeth_l3_deregister_addr_entry(struct qeth_card * card,struct qeth_ipaddr * addr)717 static int qeth_l3_deregister_addr_entry(struct qeth_card *card,
718 struct qeth_ipaddr *addr)
719 {
720 int rc = 0;
721
722 if (card->options.sniffer)
723 return 0;
724
725 if (addr->proto == QETH_PROT_IPV4) {
726 QETH_CARD_TEXT(card, 2, "deladdr4");
727 QETH_CARD_HEX(card, 3, &addr->u.a4.addr, sizeof(int));
728 } else if (addr->proto == QETH_PROT_IPV6) {
729 QETH_CARD_TEXT(card, 2, "deladdr6");
730 QETH_CARD_HEX(card, 3, &addr->u.a6.addr, 8);
731 QETH_CARD_HEX(card, 3, ((char *)&addr->u.a6.addr) + 8, 8);
732 } else {
733 QETH_CARD_TEXT(card, 2, "deladdr?");
734 QETH_CARD_HEX(card, 3, addr, sizeof(struct qeth_ipaddr));
735 }
736 if (addr->is_multicast)
737 rc = qeth_l3_send_setdelmc(card, addr, IPA_CMD_DELIPM);
738 else
739 rc = qeth_l3_send_setdelip(card, addr, IPA_CMD_DELIP);
740 if (rc)
741 QETH_CARD_TEXT(card, 2, "failed");
742
743 return rc;
744 }
745
qeth_l3_setadapter_parms(struct qeth_card * card)746 static int qeth_l3_setadapter_parms(struct qeth_card *card)
747 {
748 int rc = 0;
749
750 QETH_CARD_TEXT(card, 2, "setadprm");
751
752 if (qeth_adp_supported(card, IPA_SETADP_ALTER_MAC_ADDRESS)) {
753 rc = qeth_setadpparms_change_macaddr(card);
754 if (rc)
755 dev_warn(&card->gdev->dev, "Reading the adapter MAC"
756 " address failed\n");
757 }
758
759 return rc;
760 }
761
qeth_l3_start_ipa_arp_processing(struct qeth_card * card)762 static int qeth_l3_start_ipa_arp_processing(struct qeth_card *card)
763 {
764 int rc;
765
766 QETH_CARD_TEXT(card, 3, "ipaarp");
767
768 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
769 dev_info(&card->gdev->dev,
770 "ARP processing not supported on %s!\n",
771 QETH_CARD_IFNAME(card));
772 return 0;
773 }
774 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING,
775 IPA_CMD_ASS_START, NULL);
776 if (rc) {
777 dev_warn(&card->gdev->dev,
778 "Starting ARP processing support for %s failed\n",
779 QETH_CARD_IFNAME(card));
780 }
781 return rc;
782 }
783
qeth_l3_start_ipa_source_mac(struct qeth_card * card)784 static int qeth_l3_start_ipa_source_mac(struct qeth_card *card)
785 {
786 int rc;
787
788 QETH_CARD_TEXT(card, 3, "stsrcmac");
789
790 if (!qeth_is_supported(card, IPA_SOURCE_MAC)) {
791 dev_info(&card->gdev->dev,
792 "Inbound source MAC-address not supported on %s\n",
793 QETH_CARD_IFNAME(card));
794 return -EOPNOTSUPP;
795 }
796
797 rc = qeth_send_simple_setassparms(card, IPA_SOURCE_MAC,
798 IPA_CMD_ASS_START, NULL);
799 if (rc)
800 dev_warn(&card->gdev->dev,
801 "Starting source MAC-address support for %s failed\n",
802 QETH_CARD_IFNAME(card));
803 return rc;
804 }
805
qeth_l3_start_ipa_vlan(struct qeth_card * card)806 static int qeth_l3_start_ipa_vlan(struct qeth_card *card)
807 {
808 int rc = 0;
809
810 QETH_CARD_TEXT(card, 3, "strtvlan");
811
812 if (!qeth_is_supported(card, IPA_FULL_VLAN)) {
813 dev_info(&card->gdev->dev,
814 "VLAN not supported on %s\n", QETH_CARD_IFNAME(card));
815 return -EOPNOTSUPP;
816 }
817
818 rc = qeth_send_simple_setassparms(card, IPA_VLAN_PRIO,
819 IPA_CMD_ASS_START, NULL);
820 if (rc) {
821 dev_warn(&card->gdev->dev,
822 "Starting VLAN support for %s failed\n",
823 QETH_CARD_IFNAME(card));
824 } else {
825 dev_info(&card->gdev->dev, "VLAN enabled\n");
826 }
827 return rc;
828 }
829
qeth_l3_start_ipa_multicast(struct qeth_card * card)830 static int qeth_l3_start_ipa_multicast(struct qeth_card *card)
831 {
832 int rc;
833
834 QETH_CARD_TEXT(card, 3, "stmcast");
835
836 if (!qeth_is_supported(card, IPA_MULTICASTING)) {
837 dev_info(&card->gdev->dev,
838 "Multicast not supported on %s\n",
839 QETH_CARD_IFNAME(card));
840 return -EOPNOTSUPP;
841 }
842
843 rc = qeth_send_simple_setassparms(card, IPA_MULTICASTING,
844 IPA_CMD_ASS_START, NULL);
845 if (rc) {
846 dev_warn(&card->gdev->dev,
847 "Starting multicast support for %s failed\n",
848 QETH_CARD_IFNAME(card));
849 } else {
850 dev_info(&card->gdev->dev, "Multicast enabled\n");
851 card->dev->flags |= IFF_MULTICAST;
852 }
853 return rc;
854 }
855
qeth_l3_softsetup_ipv6(struct qeth_card * card)856 static int qeth_l3_softsetup_ipv6(struct qeth_card *card)
857 {
858 u32 ipv6_data = 3;
859 int rc;
860
861 QETH_CARD_TEXT(card, 3, "softipv6");
862
863 if (IS_IQD(card))
864 goto out;
865
866 rc = qeth_send_simple_setassparms(card, IPA_IPV6, IPA_CMD_ASS_START,
867 &ipv6_data);
868 if (rc) {
869 dev_err(&card->gdev->dev,
870 "Activating IPv6 support for %s failed\n",
871 QETH_CARD_IFNAME(card));
872 return rc;
873 }
874 rc = qeth_send_simple_setassparms_v6(card, IPA_IPV6, IPA_CMD_ASS_START,
875 NULL);
876 if (rc) {
877 dev_err(&card->gdev->dev,
878 "Activating IPv6 support for %s failed\n",
879 QETH_CARD_IFNAME(card));
880 return rc;
881 }
882 rc = qeth_send_simple_setassparms_v6(card, IPA_PASSTHRU,
883 IPA_CMD_ASS_START, NULL);
884 if (rc) {
885 dev_warn(&card->gdev->dev,
886 "Enabling the passthrough mode for %s failed\n",
887 QETH_CARD_IFNAME(card));
888 return rc;
889 }
890 out:
891 dev_info(&card->gdev->dev, "IPV6 enabled\n");
892 return 0;
893 }
894
qeth_l3_start_ipa_ipv6(struct qeth_card * card)895 static int qeth_l3_start_ipa_ipv6(struct qeth_card *card)
896 {
897 QETH_CARD_TEXT(card, 3, "strtipv6");
898
899 if (!qeth_is_supported(card, IPA_IPV6)) {
900 dev_info(&card->gdev->dev,
901 "IPv6 not supported on %s\n", QETH_CARD_IFNAME(card));
902 return 0;
903 }
904 return qeth_l3_softsetup_ipv6(card);
905 }
906
qeth_l3_start_ipa_broadcast(struct qeth_card * card)907 static int qeth_l3_start_ipa_broadcast(struct qeth_card *card)
908 {
909 u32 filter_data = 1;
910 int rc;
911
912 QETH_CARD_TEXT(card, 3, "stbrdcst");
913 card->info.broadcast_capable = 0;
914 if (!qeth_is_supported(card, IPA_FILTERING)) {
915 dev_info(&card->gdev->dev,
916 "Broadcast not supported on %s\n",
917 QETH_CARD_IFNAME(card));
918 rc = -EOPNOTSUPP;
919 goto out;
920 }
921 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
922 IPA_CMD_ASS_START, NULL);
923 if (rc) {
924 dev_warn(&card->gdev->dev, "Enabling broadcast filtering for "
925 "%s failed\n", QETH_CARD_IFNAME(card));
926 goto out;
927 }
928
929 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
930 IPA_CMD_ASS_CONFIGURE, &filter_data);
931 if (rc) {
932 dev_warn(&card->gdev->dev,
933 "Setting up broadcast filtering for %s failed\n",
934 QETH_CARD_IFNAME(card));
935 goto out;
936 }
937 card->info.broadcast_capable = QETH_BROADCAST_WITH_ECHO;
938 dev_info(&card->gdev->dev, "Broadcast enabled\n");
939 rc = qeth_send_simple_setassparms(card, IPA_FILTERING,
940 IPA_CMD_ASS_ENABLE, &filter_data);
941 if (rc) {
942 dev_warn(&card->gdev->dev, "Setting up broadcast echo "
943 "filtering for %s failed\n", QETH_CARD_IFNAME(card));
944 goto out;
945 }
946 card->info.broadcast_capable = QETH_BROADCAST_WITHOUT_ECHO;
947 out:
948 if (card->info.broadcast_capable)
949 card->dev->flags |= IFF_BROADCAST;
950 else
951 card->dev->flags &= ~IFF_BROADCAST;
952 return rc;
953 }
954
qeth_l3_start_ipassists(struct qeth_card * card)955 static int qeth_l3_start_ipassists(struct qeth_card *card)
956 {
957 QETH_CARD_TEXT(card, 3, "strtipas");
958
959 if (qeth_set_access_ctrl_online(card, 0))
960 return -EIO;
961 qeth_l3_start_ipa_arp_processing(card); /* go on*/
962 qeth_l3_start_ipa_source_mac(card); /* go on*/
963 qeth_l3_start_ipa_vlan(card); /* go on*/
964 qeth_l3_start_ipa_multicast(card); /* go on*/
965 qeth_l3_start_ipa_ipv6(card); /* go on*/
966 qeth_l3_start_ipa_broadcast(card); /* go on*/
967 return 0;
968 }
969
qeth_l3_iqd_read_initial_mac_cb(struct qeth_card * card,struct qeth_reply * reply,unsigned long data)970 static int qeth_l3_iqd_read_initial_mac_cb(struct qeth_card *card,
971 struct qeth_reply *reply, unsigned long data)
972 {
973 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
974
975 if (cmd->hdr.return_code)
976 return -EIO;
977
978 ether_addr_copy(card->dev->dev_addr,
979 cmd->data.create_destroy_addr.unique_id);
980 return 0;
981 }
982
qeth_l3_iqd_read_initial_mac(struct qeth_card * card)983 static int qeth_l3_iqd_read_initial_mac(struct qeth_card *card)
984 {
985 int rc = 0;
986 struct qeth_cmd_buffer *iob;
987 struct qeth_ipa_cmd *cmd;
988
989 QETH_CARD_TEXT(card, 2, "hsrmac");
990
991 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_CREATE_ADDR, QETH_PROT_IPV6,
992 IPA_DATA_SIZEOF(create_destroy_addr));
993 if (!iob)
994 return -ENOMEM;
995 cmd = __ipa_cmd(iob);
996 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
997 card->info.unique_id;
998
999 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_iqd_read_initial_mac_cb,
1000 NULL);
1001 return rc;
1002 }
1003
qeth_l3_get_unique_id_cb(struct qeth_card * card,struct qeth_reply * reply,unsigned long data)1004 static int qeth_l3_get_unique_id_cb(struct qeth_card *card,
1005 struct qeth_reply *reply, unsigned long data)
1006 {
1007 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1008
1009 if (cmd->hdr.return_code == 0) {
1010 card->info.unique_id = *((__u16 *)
1011 &cmd->data.create_destroy_addr.unique_id[6]);
1012 return 0;
1013 }
1014
1015 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1016 UNIQUE_ID_NOT_BY_CARD;
1017 dev_warn(&card->gdev->dev, "The network adapter failed to generate a unique ID\n");
1018 return -EIO;
1019 }
1020
qeth_l3_get_unique_id(struct qeth_card * card)1021 static int qeth_l3_get_unique_id(struct qeth_card *card)
1022 {
1023 int rc = 0;
1024 struct qeth_cmd_buffer *iob;
1025 struct qeth_ipa_cmd *cmd;
1026
1027 QETH_CARD_TEXT(card, 2, "guniqeid");
1028
1029 if (!qeth_is_supported(card, IPA_IPV6)) {
1030 card->info.unique_id = UNIQUE_ID_IF_CREATE_ADDR_FAILED |
1031 UNIQUE_ID_NOT_BY_CARD;
1032 return 0;
1033 }
1034
1035 iob = qeth_ipa_alloc_cmd(card, IPA_CMD_CREATE_ADDR, QETH_PROT_IPV6,
1036 IPA_DATA_SIZEOF(create_destroy_addr));
1037 if (!iob)
1038 return -ENOMEM;
1039 cmd = __ipa_cmd(iob);
1040 *((__u16 *) &cmd->data.create_destroy_addr.unique_id[6]) =
1041 card->info.unique_id;
1042
1043 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_get_unique_id_cb, NULL);
1044 return rc;
1045 }
1046
1047 static int
qeth_diags_trace_cb(struct qeth_card * card,struct qeth_reply * reply,unsigned long data)1048 qeth_diags_trace_cb(struct qeth_card *card, struct qeth_reply *reply,
1049 unsigned long data)
1050 {
1051 struct qeth_ipa_cmd *cmd;
1052 __u16 rc;
1053
1054 QETH_CARD_TEXT(card, 2, "diastrcb");
1055
1056 cmd = (struct qeth_ipa_cmd *)data;
1057 rc = cmd->hdr.return_code;
1058 if (rc)
1059 QETH_CARD_TEXT_(card, 2, "dxter%x", rc);
1060 switch (cmd->data.diagass.action) {
1061 case QETH_DIAGS_CMD_TRACE_QUERY:
1062 break;
1063 case QETH_DIAGS_CMD_TRACE_DISABLE:
1064 switch (rc) {
1065 case 0:
1066 case IPA_RC_INVALID_SUBCMD:
1067 card->info.promisc_mode = SET_PROMISC_MODE_OFF;
1068 dev_info(&card->gdev->dev, "The HiperSockets network "
1069 "traffic analyzer is deactivated\n");
1070 break;
1071 default:
1072 break;
1073 }
1074 break;
1075 case QETH_DIAGS_CMD_TRACE_ENABLE:
1076 switch (rc) {
1077 case 0:
1078 card->info.promisc_mode = SET_PROMISC_MODE_ON;
1079 dev_info(&card->gdev->dev, "The HiperSockets network "
1080 "traffic analyzer is activated\n");
1081 break;
1082 case IPA_RC_HARDWARE_AUTH_ERROR:
1083 dev_warn(&card->gdev->dev, "The device is not "
1084 "authorized to run as a HiperSockets network "
1085 "traffic analyzer\n");
1086 break;
1087 case IPA_RC_TRACE_ALREADY_ACTIVE:
1088 dev_warn(&card->gdev->dev, "A HiperSockets "
1089 "network traffic analyzer is already "
1090 "active in the HiperSockets LAN\n");
1091 break;
1092 default:
1093 break;
1094 }
1095 break;
1096 default:
1097 QETH_DBF_MESSAGE(2, "Unknown sniffer action (%#06x) on device %x\n",
1098 cmd->data.diagass.action, CARD_DEVID(card));
1099 }
1100
1101 return rc ? -EIO : 0;
1102 }
1103
1104 static int
qeth_diags_trace(struct qeth_card * card,enum qeth_diags_trace_cmds diags_cmd)1105 qeth_diags_trace(struct qeth_card *card, enum qeth_diags_trace_cmds diags_cmd)
1106 {
1107 struct qeth_cmd_buffer *iob;
1108 struct qeth_ipa_cmd *cmd;
1109
1110 QETH_CARD_TEXT(card, 2, "diagtrac");
1111
1112 iob = qeth_get_diag_cmd(card, QETH_DIAGS_CMD_TRACE, 0);
1113 if (!iob)
1114 return -ENOMEM;
1115 cmd = __ipa_cmd(iob);
1116 cmd->data.diagass.type = QETH_DIAGS_TYPE_HIPERSOCKET;
1117 cmd->data.diagass.action = diags_cmd;
1118 return qeth_send_ipa_cmd(card, iob, qeth_diags_trace_cb, NULL);
1119 }
1120
1121 static void
qeth_l3_add_mc_to_hash(struct qeth_card * card,struct in_device * in4_dev)1122 qeth_l3_add_mc_to_hash(struct qeth_card *card, struct in_device *in4_dev)
1123 {
1124 struct ip_mc_list *im4;
1125 struct qeth_ipaddr *tmp, *ipm;
1126
1127 QETH_CARD_TEXT(card, 4, "addmc");
1128
1129 tmp = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1130 if (!tmp)
1131 return;
1132
1133 for (im4 = rcu_dereference(in4_dev->mc_list); im4 != NULL;
1134 im4 = rcu_dereference(im4->next_rcu)) {
1135 ip_eth_mc_map(im4->multiaddr, tmp->mac);
1136 tmp->u.a4.addr = be32_to_cpu(im4->multiaddr);
1137 tmp->is_multicast = 1;
1138
1139 ipm = qeth_l3_find_addr_by_ip(card, tmp);
1140 if (ipm) {
1141 /* for mcast, by-IP match means full match */
1142 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1143 } else {
1144 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV4);
1145 if (!ipm)
1146 continue;
1147 ether_addr_copy(ipm->mac, tmp->mac);
1148 ipm->u.a4.addr = be32_to_cpu(im4->multiaddr);
1149 ipm->is_multicast = 1;
1150 ipm->disp_flag = QETH_DISP_ADDR_ADD;
1151 hash_add(card->ip_mc_htable,
1152 &ipm->hnode, qeth_l3_ipaddr_hash(ipm));
1153 }
1154 }
1155
1156 kfree(tmp);
1157 }
1158
1159 /* called with rcu_read_lock */
qeth_l3_add_vlan_mc(struct qeth_card * card)1160 static void qeth_l3_add_vlan_mc(struct qeth_card *card)
1161 {
1162 struct in_device *in_dev;
1163 u16 vid;
1164
1165 QETH_CARD_TEXT(card, 4, "addmcvl");
1166
1167 if (!qeth_is_supported(card, IPA_FULL_VLAN))
1168 return;
1169
1170 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1171 struct net_device *netdev;
1172
1173 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1174 vid);
1175 if (netdev == NULL ||
1176 !(netdev->flags & IFF_UP))
1177 continue;
1178 in_dev = __in_dev_get_rcu(netdev);
1179 if (!in_dev)
1180 continue;
1181 qeth_l3_add_mc_to_hash(card, in_dev);
1182 }
1183 }
1184
qeth_l3_add_multicast_ipv4(struct qeth_card * card)1185 static void qeth_l3_add_multicast_ipv4(struct qeth_card *card)
1186 {
1187 struct in_device *in4_dev;
1188
1189 QETH_CARD_TEXT(card, 4, "chkmcv4");
1190
1191 rcu_read_lock();
1192 in4_dev = __in_dev_get_rcu(card->dev);
1193 if (in4_dev == NULL)
1194 goto unlock;
1195 qeth_l3_add_mc_to_hash(card, in4_dev);
1196 qeth_l3_add_vlan_mc(card);
1197 unlock:
1198 rcu_read_unlock();
1199 }
1200
qeth_l3_add_mc6_to_hash(struct qeth_card * card,struct inet6_dev * in6_dev)1201 static void qeth_l3_add_mc6_to_hash(struct qeth_card *card,
1202 struct inet6_dev *in6_dev)
1203 {
1204 struct qeth_ipaddr *ipm;
1205 struct ifmcaddr6 *im6;
1206 struct qeth_ipaddr *tmp;
1207
1208 QETH_CARD_TEXT(card, 4, "addmc6");
1209
1210 tmp = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1211 if (!tmp)
1212 return;
1213
1214 for (im6 = in6_dev->mc_list; im6 != NULL; im6 = im6->next) {
1215 ipv6_eth_mc_map(&im6->mca_addr, tmp->mac);
1216 memcpy(&tmp->u.a6.addr, &im6->mca_addr.s6_addr,
1217 sizeof(struct in6_addr));
1218 tmp->is_multicast = 1;
1219
1220 ipm = qeth_l3_find_addr_by_ip(card, tmp);
1221 if (ipm) {
1222 /* for mcast, by-IP match means full match */
1223 ipm->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
1224 continue;
1225 }
1226
1227 ipm = qeth_l3_get_addr_buffer(QETH_PROT_IPV6);
1228 if (!ipm)
1229 continue;
1230
1231 ether_addr_copy(ipm->mac, tmp->mac);
1232 memcpy(&ipm->u.a6.addr, &im6->mca_addr.s6_addr,
1233 sizeof(struct in6_addr));
1234 ipm->is_multicast = 1;
1235 ipm->disp_flag = QETH_DISP_ADDR_ADD;
1236 hash_add(card->ip_mc_htable,
1237 &ipm->hnode, qeth_l3_ipaddr_hash(ipm));
1238
1239 }
1240 kfree(tmp);
1241 }
1242
1243 /* called with rcu_read_lock */
qeth_l3_add_vlan_mc6(struct qeth_card * card)1244 static void qeth_l3_add_vlan_mc6(struct qeth_card *card)
1245 {
1246 struct inet6_dev *in_dev;
1247 u16 vid;
1248
1249 QETH_CARD_TEXT(card, 4, "admc6vl");
1250
1251 if (!qeth_is_supported(card, IPA_FULL_VLAN))
1252 return;
1253
1254 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) {
1255 struct net_device *netdev;
1256
1257 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q),
1258 vid);
1259 if (netdev == NULL ||
1260 !(netdev->flags & IFF_UP))
1261 continue;
1262 in_dev = in6_dev_get(netdev);
1263 if (!in_dev)
1264 continue;
1265 read_lock_bh(&in_dev->lock);
1266 qeth_l3_add_mc6_to_hash(card, in_dev);
1267 read_unlock_bh(&in_dev->lock);
1268 in6_dev_put(in_dev);
1269 }
1270 }
1271
qeth_l3_add_multicast_ipv6(struct qeth_card * card)1272 static void qeth_l3_add_multicast_ipv6(struct qeth_card *card)
1273 {
1274 struct inet6_dev *in6_dev;
1275
1276 QETH_CARD_TEXT(card, 4, "chkmcv6");
1277
1278 if (!qeth_is_supported(card, IPA_IPV6))
1279 return ;
1280 in6_dev = in6_dev_get(card->dev);
1281 if (!in6_dev)
1282 return;
1283
1284 rcu_read_lock();
1285 read_lock_bh(&in6_dev->lock);
1286 qeth_l3_add_mc6_to_hash(card, in6_dev);
1287 qeth_l3_add_vlan_mc6(card);
1288 read_unlock_bh(&in6_dev->lock);
1289 rcu_read_unlock();
1290 in6_dev_put(in6_dev);
1291 }
1292
qeth_l3_vlan_rx_add_vid(struct net_device * dev,__be16 proto,u16 vid)1293 static int qeth_l3_vlan_rx_add_vid(struct net_device *dev,
1294 __be16 proto, u16 vid)
1295 {
1296 struct qeth_card *card = dev->ml_priv;
1297
1298 set_bit(vid, card->active_vlans);
1299 return 0;
1300 }
1301
qeth_l3_vlan_rx_kill_vid(struct net_device * dev,__be16 proto,u16 vid)1302 static int qeth_l3_vlan_rx_kill_vid(struct net_device *dev,
1303 __be16 proto, u16 vid)
1304 {
1305 struct qeth_card *card = dev->ml_priv;
1306
1307 QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
1308
1309 clear_bit(vid, card->active_vlans);
1310 qeth_l3_set_rx_mode(dev);
1311 return 0;
1312 }
1313
qeth_l3_rebuild_skb(struct qeth_card * card,struct sk_buff * skb,struct qeth_hdr * hdr)1314 static void qeth_l3_rebuild_skb(struct qeth_card *card, struct sk_buff *skb,
1315 struct qeth_hdr *hdr)
1316 {
1317 struct af_iucv_trans_hdr *iucv = (struct af_iucv_trans_hdr *) skb->data;
1318 struct net_device *dev = skb->dev;
1319
1320 if (IS_IQD(card) && iucv->magic == ETH_P_AF_IUCV) {
1321 dev_hard_header(skb, dev, ETH_P_AF_IUCV, dev->dev_addr,
1322 "FAKELL", skb->len);
1323 return;
1324 }
1325
1326 if (!(hdr->hdr.l3.flags & QETH_HDR_PASSTHRU)) {
1327 u16 prot = (hdr->hdr.l3.flags & QETH_HDR_IPV6) ? ETH_P_IPV6 :
1328 ETH_P_IP;
1329 unsigned char tg_addr[ETH_ALEN];
1330
1331 skb_reset_network_header(skb);
1332 switch (hdr->hdr.l3.flags & QETH_HDR_CAST_MASK) {
1333 case QETH_CAST_MULTICAST:
1334 if (prot == ETH_P_IP)
1335 ip_eth_mc_map(ip_hdr(skb)->daddr, tg_addr);
1336 else
1337 ipv6_eth_mc_map(&ipv6_hdr(skb)->daddr, tg_addr);
1338 QETH_CARD_STAT_INC(card, rx_multicast);
1339 break;
1340 case QETH_CAST_BROADCAST:
1341 ether_addr_copy(tg_addr, card->dev->broadcast);
1342 QETH_CARD_STAT_INC(card, rx_multicast);
1343 break;
1344 default:
1345 if (card->options.sniffer)
1346 skb->pkt_type = PACKET_OTHERHOST;
1347 ether_addr_copy(tg_addr, card->dev->dev_addr);
1348 }
1349
1350 if (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_SRC_MAC_ADDR)
1351 card->dev->header_ops->create(skb, card->dev, prot,
1352 tg_addr, &hdr->hdr.l3.next_hop.rx.src_mac,
1353 skb->len);
1354 else
1355 card->dev->header_ops->create(skb, card->dev, prot,
1356 tg_addr, "FAKELL", skb->len);
1357 }
1358
1359 /* copy VLAN tag from hdr into skb */
1360 if (!card->options.sniffer &&
1361 (hdr->hdr.l3.ext_flags & (QETH_HDR_EXT_VLAN_FRAME |
1362 QETH_HDR_EXT_INCLUDE_VLAN_TAG))) {
1363 u16 tag = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME) ?
1364 hdr->hdr.l3.vlan_id :
1365 hdr->hdr.l3.next_hop.rx.vlan_id;
1366 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), tag);
1367 }
1368
1369 qeth_rx_csum(card, skb, hdr->hdr.l3.ext_flags);
1370 }
1371
qeth_l3_process_inbound_buffer(struct qeth_card * card,int budget,int * done)1372 static int qeth_l3_process_inbound_buffer(struct qeth_card *card,
1373 int budget, int *done)
1374 {
1375 int work_done = 0;
1376 struct sk_buff *skb;
1377 struct qeth_hdr *hdr;
1378 unsigned int len;
1379
1380 *done = 0;
1381 WARN_ON_ONCE(!budget);
1382 while (budget) {
1383 skb = qeth_core_get_next_skb(card,
1384 &card->qdio.in_q->bufs[card->rx.b_index],
1385 &card->rx.b_element, &card->rx.e_offset, &hdr);
1386 if (!skb) {
1387 *done = 1;
1388 break;
1389 }
1390 switch (hdr->hdr.l3.id) {
1391 case QETH_HEADER_TYPE_LAYER3:
1392 qeth_l3_rebuild_skb(card, skb, hdr);
1393 /* fall through */
1394 case QETH_HEADER_TYPE_LAYER2: /* for HiperSockets sniffer */
1395 skb->protocol = eth_type_trans(skb, skb->dev);
1396 len = skb->len;
1397 napi_gro_receive(&card->napi, skb);
1398 break;
1399 default:
1400 dev_kfree_skb_any(skb);
1401 QETH_CARD_TEXT(card, 3, "inbunkno");
1402 QETH_DBF_HEX(CTRL, 3, hdr, sizeof(*hdr));
1403 continue;
1404 }
1405 work_done++;
1406 budget--;
1407 QETH_CARD_STAT_INC(card, rx_packets);
1408 QETH_CARD_STAT_ADD(card, rx_bytes, len);
1409 }
1410 return work_done;
1411 }
1412
qeth_l3_stop_card(struct qeth_card * card)1413 static void qeth_l3_stop_card(struct qeth_card *card)
1414 {
1415 QETH_CARD_TEXT(card, 2, "stopcard");
1416
1417 qeth_set_allowed_threads(card, 0, 1);
1418
1419 cancel_work_sync(&card->rx_mode_work);
1420 qeth_l3_drain_rx_mode_cache(card);
1421
1422 if (card->options.sniffer &&
1423 (card->info.promisc_mode == SET_PROMISC_MODE_ON))
1424 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1425
1426 if (card->state == CARD_STATE_SOFTSETUP) {
1427 qeth_l3_clear_ip_htable(card, 1);
1428 qeth_clear_ipacmd_list(card);
1429 card->state = CARD_STATE_HARDSETUP;
1430 }
1431 if (card->state == CARD_STATE_HARDSETUP) {
1432 qeth_drain_output_queues(card);
1433 qeth_clear_working_pool_list(card);
1434 card->state = CARD_STATE_DOWN;
1435 }
1436
1437 qeth_qdio_clear_card(card, 0);
1438 flush_workqueue(card->event_wq);
1439 card->info.promisc_mode = 0;
1440 }
1441
qeth_l3_set_promisc_mode(struct qeth_card * card)1442 static void qeth_l3_set_promisc_mode(struct qeth_card *card)
1443 {
1444 bool enable = card->dev->flags & IFF_PROMISC;
1445
1446 if (card->info.promisc_mode == enable)
1447 return;
1448
1449 if (IS_VM_NIC(card)) { /* Guestlan trace */
1450 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
1451 qeth_setadp_promisc_mode(card, enable);
1452 } else if (card->options.sniffer && /* HiperSockets trace */
1453 qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) {
1454 if (enable) {
1455 QETH_CARD_TEXT(card, 3, "+promisc");
1456 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE);
1457 } else {
1458 QETH_CARD_TEXT(card, 3, "-promisc");
1459 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE);
1460 }
1461 }
1462 }
1463
qeth_l3_rx_mode_work(struct work_struct * work)1464 static void qeth_l3_rx_mode_work(struct work_struct *work)
1465 {
1466 struct qeth_card *card = container_of(work, struct qeth_card,
1467 rx_mode_work);
1468 struct qeth_ipaddr *addr;
1469 struct hlist_node *tmp;
1470 int i, rc;
1471
1472 QETH_CARD_TEXT(card, 3, "setmulti");
1473
1474 if (!card->options.sniffer) {
1475 qeth_l3_add_multicast_ipv4(card);
1476 qeth_l3_add_multicast_ipv6(card);
1477
1478 hash_for_each_safe(card->ip_mc_htable, i, tmp, addr, hnode) {
1479 switch (addr->disp_flag) {
1480 case QETH_DISP_ADDR_DELETE:
1481 rc = qeth_l3_deregister_addr_entry(card, addr);
1482 if (!rc || rc == -ENOENT) {
1483 hash_del(&addr->hnode);
1484 kfree(addr);
1485 }
1486 break;
1487 case QETH_DISP_ADDR_ADD:
1488 rc = qeth_l3_register_addr_entry(card, addr);
1489 if (rc && rc != -ENETDOWN) {
1490 hash_del(&addr->hnode);
1491 kfree(addr);
1492 break;
1493 }
1494 addr->ref_counter = 1;
1495 /* fall through */
1496 default:
1497 /* for next call to set_rx_mode(): */
1498 addr->disp_flag = QETH_DISP_ADDR_DELETE;
1499 }
1500 }
1501 }
1502
1503 qeth_l3_set_promisc_mode(card);
1504 }
1505
qeth_l3_arp_makerc(u16 rc)1506 static int qeth_l3_arp_makerc(u16 rc)
1507 {
1508 switch (rc) {
1509 case IPA_RC_SUCCESS:
1510 return 0;
1511 case QETH_IPA_ARP_RC_NOTSUPP:
1512 case QETH_IPA_ARP_RC_Q_NOTSUPP:
1513 return -EOPNOTSUPP;
1514 case QETH_IPA_ARP_RC_OUT_OF_RANGE:
1515 return -EINVAL;
1516 case QETH_IPA_ARP_RC_Q_NO_DATA:
1517 return -ENOENT;
1518 default:
1519 return -EIO;
1520 }
1521 }
1522
qeth_l3_arp_cmd_cb(struct qeth_card * card,struct qeth_reply * reply,unsigned long data)1523 static int qeth_l3_arp_cmd_cb(struct qeth_card *card, struct qeth_reply *reply,
1524 unsigned long data)
1525 {
1526 struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1527
1528 qeth_setassparms_cb(card, reply, data);
1529 return qeth_l3_arp_makerc(cmd->hdr.return_code);
1530 }
1531
qeth_l3_arp_set_no_entries(struct qeth_card * card,int no_entries)1532 static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries)
1533 {
1534 struct qeth_cmd_buffer *iob;
1535 int rc;
1536
1537 QETH_CARD_TEXT(card, 3, "arpstnoe");
1538
1539 /*
1540 * currently GuestLAN only supports the ARP assist function
1541 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES;
1542 * thus we say EOPNOTSUPP for this ARP function
1543 */
1544 if (IS_VM_NIC(card))
1545 return -EOPNOTSUPP;
1546 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1547 return -EOPNOTSUPP;
1548 }
1549
1550 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
1551 IPA_CMD_ASS_ARP_SET_NO_ENTRIES,
1552 SETASS_DATA_SIZEOF(flags_32bit),
1553 QETH_PROT_IPV4);
1554 if (!iob)
1555 return -ENOMEM;
1556
1557 __ipa_cmd(iob)->data.setassparms.data.flags_32bit = (u32) no_entries;
1558 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL);
1559 if (rc)
1560 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on device %x: %#x\n",
1561 CARD_DEVID(card), rc);
1562 return rc;
1563 }
1564
get_arp_entry_size(struct qeth_card * card,struct qeth_arp_query_data * qdata,struct qeth_arp_entrytype * type,__u8 strip_entries)1565 static __u32 get_arp_entry_size(struct qeth_card *card,
1566 struct qeth_arp_query_data *qdata,
1567 struct qeth_arp_entrytype *type, __u8 strip_entries)
1568 {
1569 __u32 rc;
1570 __u8 is_hsi;
1571
1572 is_hsi = qdata->reply_bits == 5;
1573 if (type->ip == QETHARP_IP_ADDR_V4) {
1574 QETH_CARD_TEXT(card, 4, "arpev4");
1575 if (strip_entries) {
1576 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5_short) :
1577 sizeof(struct qeth_arp_qi_entry7_short);
1578 } else {
1579 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5) :
1580 sizeof(struct qeth_arp_qi_entry7);
1581 }
1582 } else if (type->ip == QETHARP_IP_ADDR_V6) {
1583 QETH_CARD_TEXT(card, 4, "arpev6");
1584 if (strip_entries) {
1585 rc = is_hsi ?
1586 sizeof(struct qeth_arp_qi_entry5_short_ipv6) :
1587 sizeof(struct qeth_arp_qi_entry7_short_ipv6);
1588 } else {
1589 rc = is_hsi ?
1590 sizeof(struct qeth_arp_qi_entry5_ipv6) :
1591 sizeof(struct qeth_arp_qi_entry7_ipv6);
1592 }
1593 } else {
1594 QETH_CARD_TEXT(card, 4, "arpinv");
1595 rc = 0;
1596 }
1597
1598 return rc;
1599 }
1600
arpentry_matches_prot(struct qeth_arp_entrytype * type,__u16 prot)1601 static int arpentry_matches_prot(struct qeth_arp_entrytype *type, __u16 prot)
1602 {
1603 return (type->ip == QETHARP_IP_ADDR_V4 && prot == QETH_PROT_IPV4) ||
1604 (type->ip == QETHARP_IP_ADDR_V6 && prot == QETH_PROT_IPV6);
1605 }
1606
qeth_l3_arp_query_cb(struct qeth_card * card,struct qeth_reply * reply,unsigned long data)1607 static int qeth_l3_arp_query_cb(struct qeth_card *card,
1608 struct qeth_reply *reply, unsigned long data)
1609 {
1610 struct qeth_ipa_cmd *cmd;
1611 struct qeth_arp_query_data *qdata;
1612 struct qeth_arp_query_info *qinfo;
1613 int e;
1614 int entrybytes_done;
1615 int stripped_bytes;
1616 __u8 do_strip_entries;
1617
1618 QETH_CARD_TEXT(card, 3, "arpquecb");
1619
1620 qinfo = (struct qeth_arp_query_info *) reply->param;
1621 cmd = (struct qeth_ipa_cmd *) data;
1622 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.prot_version);
1623 if (cmd->hdr.return_code) {
1624 QETH_CARD_TEXT(card, 4, "arpcberr");
1625 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
1626 return qeth_l3_arp_makerc(cmd->hdr.return_code);
1627 }
1628 if (cmd->data.setassparms.hdr.return_code) {
1629 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code;
1630 QETH_CARD_TEXT(card, 4, "setaperr");
1631 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code);
1632 return qeth_l3_arp_makerc(cmd->hdr.return_code);
1633 }
1634 qdata = &cmd->data.setassparms.data.query_arp;
1635 QETH_CARD_TEXT_(card, 4, "anoen%i", qdata->no_entries);
1636
1637 do_strip_entries = (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) > 0;
1638 stripped_bytes = do_strip_entries ? QETH_QARP_MEDIASPECIFIC_BYTES : 0;
1639 entrybytes_done = 0;
1640 for (e = 0; e < qdata->no_entries; ++e) {
1641 char *cur_entry;
1642 __u32 esize;
1643 struct qeth_arp_entrytype *etype;
1644
1645 cur_entry = &qdata->data + entrybytes_done;
1646 etype = &((struct qeth_arp_qi_entry5 *) cur_entry)->type;
1647 if (!arpentry_matches_prot(etype, cmd->hdr.prot_version)) {
1648 QETH_CARD_TEXT(card, 4, "pmis");
1649 QETH_CARD_TEXT_(card, 4, "%i", etype->ip);
1650 break;
1651 }
1652 esize = get_arp_entry_size(card, qdata, etype,
1653 do_strip_entries);
1654 QETH_CARD_TEXT_(card, 5, "esz%i", esize);
1655 if (!esize)
1656 break;
1657
1658 if ((qinfo->udata_len - qinfo->udata_offset) < esize) {
1659 QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOSPC);
1660 memset(qinfo->udata, 0, 4);
1661 return -ENOSPC;
1662 }
1663
1664 memcpy(qinfo->udata + qinfo->udata_offset,
1665 &qdata->data + entrybytes_done + stripped_bytes,
1666 esize);
1667 entrybytes_done += esize + stripped_bytes;
1668 qinfo->udata_offset += esize;
1669 ++qinfo->no_entries;
1670 }
1671 /* check if all replies received ... */
1672 if (cmd->data.setassparms.hdr.seq_no <
1673 cmd->data.setassparms.hdr.number_of_replies)
1674 return 1;
1675 QETH_CARD_TEXT_(card, 4, "nove%i", qinfo->no_entries);
1676 memcpy(qinfo->udata, &qinfo->no_entries, 4);
1677 /* keep STRIP_ENTRIES flag so the user program can distinguish
1678 * stripped entries from normal ones */
1679 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES)
1680 qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES;
1681 memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2);
1682 QETH_CARD_TEXT_(card, 4, "rc%i", 0);
1683 return 0;
1684 }
1685
qeth_l3_query_arp_cache_info(struct qeth_card * card,enum qeth_prot_versions prot,struct qeth_arp_query_info * qinfo)1686 static int qeth_l3_query_arp_cache_info(struct qeth_card *card,
1687 enum qeth_prot_versions prot,
1688 struct qeth_arp_query_info *qinfo)
1689 {
1690 struct qeth_cmd_buffer *iob;
1691 struct qeth_ipa_cmd *cmd;
1692 int rc;
1693
1694 QETH_CARD_TEXT_(card, 3, "qarpipv%i", prot);
1695
1696 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
1697 IPA_CMD_ASS_ARP_QUERY_INFO,
1698 SETASS_DATA_SIZEOF(query_arp), prot);
1699 if (!iob)
1700 return -ENOMEM;
1701 cmd = __ipa_cmd(iob);
1702 cmd->data.setassparms.data.query_arp.request_bits = 0x000F;
1703 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_query_cb, qinfo);
1704 if (rc)
1705 QETH_DBF_MESSAGE(2, "Error while querying ARP cache on device %x: %#x\n",
1706 CARD_DEVID(card), rc);
1707 return rc;
1708 }
1709
qeth_l3_arp_query(struct qeth_card * card,char __user * udata)1710 static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata)
1711 {
1712 struct qeth_arp_query_info qinfo = {0, };
1713 int rc;
1714
1715 QETH_CARD_TEXT(card, 3, "arpquery");
1716
1717 if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/
1718 IPA_ARP_PROCESSING)) {
1719 QETH_CARD_TEXT(card, 3, "arpqnsup");
1720 rc = -EOPNOTSUPP;
1721 goto out;
1722 }
1723 /* get size of userspace buffer and mask_bits -> 6 bytes */
1724 if (copy_from_user(&qinfo, udata, 6)) {
1725 rc = -EFAULT;
1726 goto out;
1727 }
1728 qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL);
1729 if (!qinfo.udata) {
1730 rc = -ENOMEM;
1731 goto out;
1732 }
1733 qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET;
1734 rc = qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV4, &qinfo);
1735 if (rc) {
1736 if (copy_to_user(udata, qinfo.udata, 4))
1737 rc = -EFAULT;
1738 goto free_and_out;
1739 }
1740 if (qinfo.mask_bits & QETH_QARP_WITH_IPV6) {
1741 /* fails in case of GuestLAN QDIO mode */
1742 qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV6, &qinfo);
1743 }
1744 if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) {
1745 QETH_CARD_TEXT(card, 4, "qactf");
1746 rc = -EFAULT;
1747 goto free_and_out;
1748 }
1749 QETH_CARD_TEXT(card, 4, "qacts");
1750
1751 free_and_out:
1752 kfree(qinfo.udata);
1753 out:
1754 return rc;
1755 }
1756
qeth_l3_arp_modify_entry(struct qeth_card * card,struct qeth_arp_cache_entry * entry,enum qeth_arp_process_subcmds arp_cmd)1757 static int qeth_l3_arp_modify_entry(struct qeth_card *card,
1758 struct qeth_arp_cache_entry *entry,
1759 enum qeth_arp_process_subcmds arp_cmd)
1760 {
1761 struct qeth_arp_cache_entry *cmd_entry;
1762 struct qeth_cmd_buffer *iob;
1763 int rc;
1764
1765 if (arp_cmd == IPA_CMD_ASS_ARP_ADD_ENTRY)
1766 QETH_CARD_TEXT(card, 3, "arpadd");
1767 else
1768 QETH_CARD_TEXT(card, 3, "arpdel");
1769
1770 /*
1771 * currently GuestLAN only supports the ARP assist function
1772 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY;
1773 * thus we say EOPNOTSUPP for this ARP function
1774 */
1775 if (IS_VM_NIC(card))
1776 return -EOPNOTSUPP;
1777 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1778 return -EOPNOTSUPP;
1779 }
1780
1781 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING, arp_cmd,
1782 SETASS_DATA_SIZEOF(arp_entry),
1783 QETH_PROT_IPV4);
1784 if (!iob)
1785 return -ENOMEM;
1786
1787 cmd_entry = &__ipa_cmd(iob)->data.setassparms.data.arp_entry;
1788 ether_addr_copy(cmd_entry->macaddr, entry->macaddr);
1789 memcpy(cmd_entry->ipaddr, entry->ipaddr, 4);
1790 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL);
1791 if (rc)
1792 QETH_DBF_MESSAGE(2, "Could not modify (cmd: %#x) ARP entry on device %x: %#x\n",
1793 arp_cmd, CARD_DEVID(card), rc);
1794 return rc;
1795 }
1796
qeth_l3_arp_flush_cache(struct qeth_card * card)1797 static int qeth_l3_arp_flush_cache(struct qeth_card *card)
1798 {
1799 struct qeth_cmd_buffer *iob;
1800 int rc;
1801
1802 QETH_CARD_TEXT(card, 3, "arpflush");
1803
1804 /*
1805 * currently GuestLAN only supports the ARP assist function
1806 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE;
1807 * thus we say EOPNOTSUPP for this ARP function
1808 */
1809 if (IS_VM_NIC(card) || IS_IQD(card))
1810 return -EOPNOTSUPP;
1811 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) {
1812 return -EOPNOTSUPP;
1813 }
1814
1815 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING,
1816 IPA_CMD_ASS_ARP_FLUSH_CACHE, 0,
1817 QETH_PROT_IPV4);
1818 if (!iob)
1819 return -ENOMEM;
1820
1821 rc = qeth_send_ipa_cmd(card, iob, qeth_l3_arp_cmd_cb, NULL);
1822 if (rc)
1823 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on device %x: %#x\n",
1824 CARD_DEVID(card), rc);
1825 return rc;
1826 }
1827
qeth_l3_do_ioctl(struct net_device * dev,struct ifreq * rq,int cmd)1828 static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1829 {
1830 struct qeth_card *card = dev->ml_priv;
1831 struct qeth_arp_cache_entry arp_entry;
1832 enum qeth_arp_process_subcmds arp_cmd;
1833 int rc = 0;
1834
1835 switch (cmd) {
1836 case SIOC_QETH_ARP_SET_NO_ENTRIES:
1837 if (!capable(CAP_NET_ADMIN)) {
1838 rc = -EPERM;
1839 break;
1840 }
1841 rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue);
1842 break;
1843 case SIOC_QETH_ARP_QUERY_INFO:
1844 if (!capable(CAP_NET_ADMIN)) {
1845 rc = -EPERM;
1846 break;
1847 }
1848 rc = qeth_l3_arp_query(card, rq->ifr_ifru.ifru_data);
1849 break;
1850 case SIOC_QETH_ARP_ADD_ENTRY:
1851 case SIOC_QETH_ARP_REMOVE_ENTRY:
1852 if (!capable(CAP_NET_ADMIN))
1853 return -EPERM;
1854 if (copy_from_user(&arp_entry, rq->ifr_data, sizeof(arp_entry)))
1855 return -EFAULT;
1856
1857 arp_cmd = (cmd == SIOC_QETH_ARP_ADD_ENTRY) ?
1858 IPA_CMD_ASS_ARP_ADD_ENTRY :
1859 IPA_CMD_ASS_ARP_REMOVE_ENTRY;
1860 return qeth_l3_arp_modify_entry(card, &arp_entry, arp_cmd);
1861 case SIOC_QETH_ARP_FLUSH_CACHE:
1862 if (!capable(CAP_NET_ADMIN)) {
1863 rc = -EPERM;
1864 break;
1865 }
1866 rc = qeth_l3_arp_flush_cache(card);
1867 break;
1868 default:
1869 rc = -EOPNOTSUPP;
1870 }
1871 return rc;
1872 }
1873
qeth_l3_get_cast_type_rcu(struct sk_buff * skb,struct dst_entry * dst,int ipv)1874 static int qeth_l3_get_cast_type_rcu(struct sk_buff *skb, struct dst_entry *dst,
1875 int ipv)
1876 {
1877 struct neighbour *n = NULL;
1878
1879 if (dst)
1880 n = dst_neigh_lookup_skb(dst, skb);
1881
1882 if (n) {
1883 int cast_type = n->type;
1884
1885 neigh_release(n);
1886 if ((cast_type == RTN_BROADCAST) ||
1887 (cast_type == RTN_MULTICAST) ||
1888 (cast_type == RTN_ANYCAST))
1889 return cast_type;
1890 return RTN_UNICAST;
1891 }
1892
1893 /* no neighbour (eg AF_PACKET), fall back to target's IP address ... */
1894 switch (ipv) {
1895 case 4:
1896 if (ipv4_is_lbcast(ip_hdr(skb)->daddr))
1897 return RTN_BROADCAST;
1898 return ipv4_is_multicast(ip_hdr(skb)->daddr) ?
1899 RTN_MULTICAST : RTN_UNICAST;
1900 case 6:
1901 return ipv6_addr_is_multicast(&ipv6_hdr(skb)->daddr) ?
1902 RTN_MULTICAST : RTN_UNICAST;
1903 default:
1904 /* ... and MAC address */
1905 return qeth_get_ether_cast_type(skb);
1906 }
1907 }
1908
qeth_l3_get_cast_type(struct sk_buff * skb)1909 static int qeth_l3_get_cast_type(struct sk_buff *skb)
1910 {
1911 int ipv = qeth_get_ip_version(skb);
1912 struct dst_entry *dst;
1913 int cast_type;
1914
1915 rcu_read_lock();
1916 dst = qeth_dst_check_rcu(skb, ipv);
1917 cast_type = qeth_l3_get_cast_type_rcu(skb, dst, ipv);
1918 rcu_read_unlock();
1919
1920 return cast_type;
1921 }
1922
qeth_l3_cast_type_to_flag(int cast_type)1923 static u8 qeth_l3_cast_type_to_flag(int cast_type)
1924 {
1925 if (cast_type == RTN_MULTICAST)
1926 return QETH_CAST_MULTICAST;
1927 if (cast_type == RTN_ANYCAST)
1928 return QETH_CAST_ANYCAST;
1929 if (cast_type == RTN_BROADCAST)
1930 return QETH_CAST_BROADCAST;
1931 return QETH_CAST_UNICAST;
1932 }
1933
qeth_l3_fill_header(struct qeth_qdio_out_q * queue,struct qeth_hdr * hdr,struct sk_buff * skb,int ipv,unsigned int data_len)1934 static void qeth_l3_fill_header(struct qeth_qdio_out_q *queue,
1935 struct qeth_hdr *hdr, struct sk_buff *skb,
1936 int ipv, unsigned int data_len)
1937 {
1938 struct qeth_hdr_layer3 *l3_hdr = &hdr->hdr.l3;
1939 struct vlan_ethhdr *veth = vlan_eth_hdr(skb);
1940 struct qeth_card *card = queue->card;
1941 struct dst_entry *dst;
1942 int cast_type;
1943
1944 hdr->hdr.l3.length = data_len;
1945
1946 if (skb_is_gso(skb)) {
1947 hdr->hdr.l3.id = QETH_HEADER_TYPE_L3_TSO;
1948 } else {
1949 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3;
1950
1951 if (skb->protocol == htons(ETH_P_AF_IUCV)) {
1952 l3_hdr->flags = QETH_HDR_IPV6 | QETH_CAST_UNICAST;
1953 l3_hdr->next_hop.ipv6_addr.s6_addr16[0] = htons(0xfe80);
1954 memcpy(&l3_hdr->next_hop.ipv6_addr.s6_addr32[2],
1955 iucv_trans_hdr(skb)->destUserID, 8);
1956 return;
1957 }
1958
1959 if (skb->ip_summed == CHECKSUM_PARTIAL) {
1960 qeth_tx_csum(skb, &hdr->hdr.l3.ext_flags, ipv);
1961 /* some HW requires combined L3+L4 csum offload: */
1962 if (ipv == 4)
1963 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_CSUM_HDR_REQ;
1964 }
1965 }
1966
1967 if (ipv == 4 || IS_IQD(card)) {
1968 /* NETIF_F_HW_VLAN_CTAG_TX */
1969 if (skb_vlan_tag_present(skb)) {
1970 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_VLAN_FRAME;
1971 hdr->hdr.l3.vlan_id = skb_vlan_tag_get(skb);
1972 }
1973 } else if (veth->h_vlan_proto == htons(ETH_P_8021Q)) {
1974 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_INCLUDE_VLAN_TAG;
1975 hdr->hdr.l3.vlan_id = ntohs(veth->h_vlan_TCI);
1976 }
1977
1978 rcu_read_lock();
1979 dst = qeth_dst_check_rcu(skb, ipv);
1980
1981 if (IS_IQD(card) && skb_get_queue_mapping(skb) != QETH_IQD_MCAST_TXQ)
1982 cast_type = RTN_UNICAST;
1983 else
1984 cast_type = qeth_l3_get_cast_type_rcu(skb, dst, ipv);
1985 l3_hdr->flags |= qeth_l3_cast_type_to_flag(cast_type);
1986
1987 if (ipv == 4) {
1988 struct rtable *rt = (struct rtable *) dst;
1989
1990 *((__be32 *) &hdr->hdr.l3.next_hop.ipv4.addr) = (rt) ?
1991 rt_nexthop(rt, ip_hdr(skb)->daddr) :
1992 ip_hdr(skb)->daddr;
1993 } else if (ipv == 6) {
1994 struct rt6_info *rt = (struct rt6_info *) dst;
1995
1996 if (rt && !ipv6_addr_any(&rt->rt6i_gateway))
1997 l3_hdr->next_hop.ipv6_addr = rt->rt6i_gateway;
1998 else
1999 l3_hdr->next_hop.ipv6_addr = ipv6_hdr(skb)->daddr;
2000
2001 hdr->hdr.l3.flags |= QETH_HDR_IPV6;
2002 if (!IS_IQD(card))
2003 hdr->hdr.l3.flags |= QETH_HDR_PASSTHRU;
2004 } else {
2005 /* OSA only: */
2006 l3_hdr->flags |= QETH_HDR_PASSTHRU;
2007 }
2008 rcu_read_unlock();
2009 }
2010
qeth_l3_fixup_headers(struct sk_buff * skb)2011 static void qeth_l3_fixup_headers(struct sk_buff *skb)
2012 {
2013 struct iphdr *iph = ip_hdr(skb);
2014
2015 /* this is safe, IPv6 traffic takes a different path */
2016 if (skb->ip_summed == CHECKSUM_PARTIAL)
2017 iph->check = 0;
2018 if (skb_is_gso(skb)) {
2019 iph->tot_len = 0;
2020 tcp_hdr(skb)->check = ~tcp_v4_check(0, iph->saddr,
2021 iph->daddr, 0);
2022 }
2023 }
2024
qeth_l3_xmit(struct qeth_card * card,struct sk_buff * skb,struct qeth_qdio_out_q * queue,int ipv)2025 static int qeth_l3_xmit(struct qeth_card *card, struct sk_buff *skb,
2026 struct qeth_qdio_out_q *queue, int ipv)
2027 {
2028 unsigned int hw_hdr_len;
2029 int rc;
2030
2031 /* re-use the L2 header area for the HW header: */
2032 hw_hdr_len = skb_is_gso(skb) ? sizeof(struct qeth_hdr_tso) :
2033 sizeof(struct qeth_hdr);
2034 rc = skb_cow_head(skb, hw_hdr_len - ETH_HLEN);
2035 if (rc)
2036 return rc;
2037 skb_pull(skb, ETH_HLEN);
2038
2039 qeth_l3_fixup_headers(skb);
2040 return qeth_xmit(card, skb, queue, ipv, qeth_l3_fill_header);
2041 }
2042
qeth_l3_hard_start_xmit(struct sk_buff * skb,struct net_device * dev)2043 static netdev_tx_t qeth_l3_hard_start_xmit(struct sk_buff *skb,
2044 struct net_device *dev)
2045 {
2046 struct qeth_card *card = dev->ml_priv;
2047 u16 txq = skb_get_queue_mapping(skb);
2048 int ipv = qeth_get_ip_version(skb);
2049 struct qeth_qdio_out_q *queue;
2050 int rc;
2051
2052 if (!skb_is_gso(skb))
2053 qdisc_skb_cb(skb)->pkt_len = skb->len;
2054 if (IS_IQD(card)) {
2055 queue = card->qdio.out_qs[qeth_iqd_translate_txq(dev, txq)];
2056
2057 if (card->options.sniffer)
2058 goto tx_drop;
2059 if ((card->options.cq != QETH_CQ_ENABLED && !ipv) ||
2060 (card->options.cq == QETH_CQ_ENABLED &&
2061 skb->protocol != htons(ETH_P_AF_IUCV)))
2062 goto tx_drop;
2063 } else {
2064 queue = card->qdio.out_qs[txq];
2065 }
2066
2067 if (!(dev->flags & IFF_BROADCAST) &&
2068 qeth_l3_get_cast_type(skb) == RTN_BROADCAST)
2069 goto tx_drop;
2070
2071 if (ipv == 4 || IS_IQD(card))
2072 rc = qeth_l3_xmit(card, skb, queue, ipv);
2073 else
2074 rc = qeth_xmit(card, skb, queue, ipv, qeth_l3_fill_header);
2075
2076 if (!rc)
2077 return NETDEV_TX_OK;
2078
2079 tx_drop:
2080 QETH_TXQ_STAT_INC(queue, tx_dropped);
2081 kfree_skb(skb);
2082 return NETDEV_TX_OK;
2083 }
2084
qeth_l3_set_rx_mode(struct net_device * dev)2085 static void qeth_l3_set_rx_mode(struct net_device *dev)
2086 {
2087 struct qeth_card *card = dev->ml_priv;
2088
2089 schedule_work(&card->rx_mode_work);
2090 }
2091
2092 /*
2093 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting
2094 * NOARP on the netdevice is no option because it also turns off neighbor
2095 * solicitation. For IPv4 we install a neighbor_setup function. We don't want
2096 * arp resolution but we want the hard header (packet socket will work
2097 * e.g. tcpdump)
2098 */
qeth_l3_neigh_setup_noarp(struct neighbour * n)2099 static int qeth_l3_neigh_setup_noarp(struct neighbour *n)
2100 {
2101 n->nud_state = NUD_NOARP;
2102 memcpy(n->ha, "FAKELL", 6);
2103 n->output = n->ops->connected_output;
2104 return 0;
2105 }
2106
2107 static int
qeth_l3_neigh_setup(struct net_device * dev,struct neigh_parms * np)2108 qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np)
2109 {
2110 if (np->tbl->family == AF_INET)
2111 np->neigh_setup = qeth_l3_neigh_setup_noarp;
2112
2113 return 0;
2114 }
2115
qeth_l3_osa_features_check(struct sk_buff * skb,struct net_device * dev,netdev_features_t features)2116 static netdev_features_t qeth_l3_osa_features_check(struct sk_buff *skb,
2117 struct net_device *dev,
2118 netdev_features_t features)
2119 {
2120 if (vlan_get_protocol(skb) != htons(ETH_P_IP))
2121 features &= ~NETIF_F_HW_VLAN_CTAG_TX;
2122 return qeth_features_check(skb, dev, features);
2123 }
2124
qeth_l3_iqd_select_queue(struct net_device * dev,struct sk_buff * skb,struct net_device * sb_dev)2125 static u16 qeth_l3_iqd_select_queue(struct net_device *dev, struct sk_buff *skb,
2126 struct net_device *sb_dev)
2127 {
2128 return qeth_iqd_select_queue(dev, skb, qeth_l3_get_cast_type(skb),
2129 sb_dev);
2130 }
2131
qeth_l3_osa_select_queue(struct net_device * dev,struct sk_buff * skb,struct net_device * sb_dev)2132 static u16 qeth_l3_osa_select_queue(struct net_device *dev, struct sk_buff *skb,
2133 struct net_device *sb_dev)
2134 {
2135 struct qeth_card *card = dev->ml_priv;
2136
2137 return qeth_get_priority_queue(card, skb);
2138 }
2139
2140 static const struct net_device_ops qeth_l3_netdev_ops = {
2141 .ndo_open = qeth_open,
2142 .ndo_stop = qeth_stop,
2143 .ndo_get_stats64 = qeth_get_stats64,
2144 .ndo_start_xmit = qeth_l3_hard_start_xmit,
2145 .ndo_select_queue = qeth_l3_iqd_select_queue,
2146 .ndo_validate_addr = eth_validate_addr,
2147 .ndo_set_rx_mode = qeth_l3_set_rx_mode,
2148 .ndo_do_ioctl = qeth_do_ioctl,
2149 .ndo_fix_features = qeth_fix_features,
2150 .ndo_set_features = qeth_set_features,
2151 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid,
2152 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid,
2153 .ndo_tx_timeout = qeth_tx_timeout,
2154 };
2155
2156 static const struct net_device_ops qeth_l3_osa_netdev_ops = {
2157 .ndo_open = qeth_open,
2158 .ndo_stop = qeth_stop,
2159 .ndo_get_stats64 = qeth_get_stats64,
2160 .ndo_start_xmit = qeth_l3_hard_start_xmit,
2161 .ndo_features_check = qeth_l3_osa_features_check,
2162 .ndo_select_queue = qeth_l3_osa_select_queue,
2163 .ndo_validate_addr = eth_validate_addr,
2164 .ndo_set_rx_mode = qeth_l3_set_rx_mode,
2165 .ndo_do_ioctl = qeth_do_ioctl,
2166 .ndo_fix_features = qeth_fix_features,
2167 .ndo_set_features = qeth_set_features,
2168 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid,
2169 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid,
2170 .ndo_tx_timeout = qeth_tx_timeout,
2171 .ndo_neigh_setup = qeth_l3_neigh_setup,
2172 };
2173
qeth_l3_setup_netdev(struct qeth_card * card,bool carrier_ok)2174 static int qeth_l3_setup_netdev(struct qeth_card *card, bool carrier_ok)
2175 {
2176 unsigned int headroom;
2177 int rc;
2178
2179 if (IS_OSD(card) || IS_OSX(card)) {
2180 if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) ||
2181 (card->info.link_type == QETH_LINK_TYPE_HSTR)) {
2182 pr_info("qeth_l3: ignoring TR device\n");
2183 return -ENODEV;
2184 }
2185
2186 card->dev->netdev_ops = &qeth_l3_osa_netdev_ops;
2187
2188 /*IPv6 address autoconfiguration stuff*/
2189 qeth_l3_get_unique_id(card);
2190 if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD))
2191 card->dev->dev_id = card->info.unique_id & 0xffff;
2192
2193 if (!IS_VM_NIC(card)) {
2194 card->dev->features |= NETIF_F_SG;
2195 card->dev->hw_features |= NETIF_F_TSO |
2196 NETIF_F_RXCSUM | NETIF_F_IP_CSUM;
2197 card->dev->vlan_features |= NETIF_F_TSO |
2198 NETIF_F_RXCSUM | NETIF_F_IP_CSUM;
2199 }
2200
2201 if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) {
2202 card->dev->hw_features |= NETIF_F_IPV6_CSUM;
2203 card->dev->vlan_features |= NETIF_F_IPV6_CSUM;
2204 }
2205 if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) {
2206 card->dev->hw_features |= NETIF_F_TSO6;
2207 card->dev->vlan_features |= NETIF_F_TSO6;
2208 }
2209
2210 /* allow for de-acceleration of NETIF_F_HW_VLAN_CTAG_TX: */
2211 if (card->dev->hw_features & NETIF_F_TSO6)
2212 headroom = sizeof(struct qeth_hdr_tso) + VLAN_HLEN;
2213 else if (card->dev->hw_features & NETIF_F_TSO)
2214 headroom = sizeof(struct qeth_hdr_tso);
2215 else
2216 headroom = sizeof(struct qeth_hdr) + VLAN_HLEN;
2217 } else if (IS_IQD(card)) {
2218 card->dev->flags |= IFF_NOARP;
2219 card->dev->netdev_ops = &qeth_l3_netdev_ops;
2220 headroom = sizeof(struct qeth_hdr) - ETH_HLEN;
2221
2222 rc = qeth_l3_iqd_read_initial_mac(card);
2223 if (rc)
2224 goto out;
2225 } else
2226 return -ENODEV;
2227
2228 card->dev->needed_headroom = headroom;
2229 card->dev->features |= NETIF_F_HW_VLAN_CTAG_TX |
2230 NETIF_F_HW_VLAN_CTAG_RX |
2231 NETIF_F_HW_VLAN_CTAG_FILTER;
2232
2233 netif_keep_dst(card->dev);
2234 if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6))
2235 netif_set_gso_max_size(card->dev,
2236 PAGE_SIZE * (QETH_MAX_BUFFER_ELEMENTS(card) - 1));
2237
2238 netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
2239 rc = register_netdev(card->dev);
2240 if (!rc && carrier_ok)
2241 netif_carrier_on(card->dev);
2242
2243 out:
2244 if (rc)
2245 card->dev->netdev_ops = NULL;
2246 return rc;
2247 }
2248
2249 static const struct device_type qeth_l3_devtype = {
2250 .name = "qeth_layer3",
2251 .groups = qeth_l3_attr_groups,
2252 };
2253
qeth_l3_probe_device(struct ccwgroup_device * gdev)2254 static int qeth_l3_probe_device(struct ccwgroup_device *gdev)
2255 {
2256 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2257 int rc;
2258
2259 hash_init(card->ip_htable);
2260 mutex_init(&card->ip_lock);
2261 card->cmd_wq = alloc_ordered_workqueue("%s_cmd", 0,
2262 dev_name(&gdev->dev));
2263 if (!card->cmd_wq)
2264 return -ENOMEM;
2265
2266 if (gdev->dev.type == &qeth_generic_devtype) {
2267 rc = qeth_l3_create_device_attributes(&gdev->dev);
2268 if (rc) {
2269 destroy_workqueue(card->cmd_wq);
2270 return rc;
2271 }
2272 }
2273
2274 hash_init(card->ip_mc_htable);
2275 INIT_WORK(&card->rx_mode_work, qeth_l3_rx_mode_work);
2276 return 0;
2277 }
2278
qeth_l3_remove_device(struct ccwgroup_device * cgdev)2279 static void qeth_l3_remove_device(struct ccwgroup_device *cgdev)
2280 {
2281 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
2282
2283 if (cgdev->dev.type == &qeth_generic_devtype)
2284 qeth_l3_remove_device_attributes(&cgdev->dev);
2285
2286 qeth_set_allowed_threads(card, 0, 1);
2287 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
2288
2289 if (cgdev->state == CCWGROUP_ONLINE)
2290 qeth_l3_set_offline(cgdev);
2291
2292 cancel_work_sync(&card->close_dev_work);
2293 if (qeth_netdev_is_registered(card->dev))
2294 unregister_netdev(card->dev);
2295
2296 flush_workqueue(card->cmd_wq);
2297 destroy_workqueue(card->cmd_wq);
2298 qeth_l3_clear_ip_htable(card, 0);
2299 qeth_l3_clear_ipato_list(card);
2300 }
2301
qeth_l3_set_online(struct ccwgroup_device * gdev)2302 static int qeth_l3_set_online(struct ccwgroup_device *gdev)
2303 {
2304 struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2305 struct net_device *dev = card->dev;
2306 int rc = 0;
2307 bool carrier_ok;
2308
2309 mutex_lock(&card->discipline_mutex);
2310 mutex_lock(&card->conf_mutex);
2311 QETH_CARD_TEXT(card, 2, "setonlin");
2312
2313 rc = qeth_core_hardsetup_card(card, &carrier_ok);
2314 if (rc) {
2315 QETH_CARD_TEXT_(card, 2, "2err%04x", rc);
2316 rc = -ENODEV;
2317 goto out_remove;
2318 }
2319
2320 if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) {
2321 if (card->info.hwtrap &&
2322 qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM))
2323 card->info.hwtrap = 0;
2324 } else
2325 card->info.hwtrap = 0;
2326
2327 card->state = CARD_STATE_HARDSETUP;
2328 qeth_print_status_message(card);
2329
2330 /* softsetup */
2331 QETH_CARD_TEXT(card, 2, "softsetp");
2332
2333 rc = qeth_l3_setadapter_parms(card);
2334 if (rc)
2335 QETH_CARD_TEXT_(card, 2, "2err%04x", rc);
2336 if (!card->options.sniffer) {
2337 rc = qeth_l3_start_ipassists(card);
2338 if (rc) {
2339 QETH_CARD_TEXT_(card, 2, "3err%d", rc);
2340 goto out_remove;
2341 }
2342 rc = qeth_l3_setrouting_v4(card);
2343 if (rc)
2344 QETH_CARD_TEXT_(card, 2, "4err%04x", rc);
2345 rc = qeth_l3_setrouting_v6(card);
2346 if (rc)
2347 QETH_CARD_TEXT_(card, 2, "5err%04x", rc);
2348 }
2349
2350 rc = qeth_init_qdio_queues(card);
2351 if (rc) {
2352 QETH_CARD_TEXT_(card, 2, "6err%d", rc);
2353 rc = -ENODEV;
2354 goto out_remove;
2355 }
2356 card->state = CARD_STATE_SOFTSETUP;
2357
2358 qeth_set_allowed_threads(card, 0xffffffff, 0);
2359 qeth_l3_recover_ip(card);
2360
2361 if (!qeth_netdev_is_registered(dev)) {
2362 rc = qeth_l3_setup_netdev(card, carrier_ok);
2363 if (rc)
2364 goto out_remove;
2365 } else {
2366 rtnl_lock();
2367 if (carrier_ok)
2368 netif_carrier_on(dev);
2369 else
2370 netif_carrier_off(dev);
2371
2372 netif_device_attach(dev);
2373 qeth_enable_hw_features(dev);
2374
2375 if (card->info.open_when_online) {
2376 card->info.open_when_online = 0;
2377 dev_open(dev, NULL);
2378 }
2379 rtnl_unlock();
2380 }
2381 qeth_trace_features(card);
2382 /* let user_space know that device is online */
2383 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
2384 mutex_unlock(&card->conf_mutex);
2385 mutex_unlock(&card->discipline_mutex);
2386 return 0;
2387 out_remove:
2388 qeth_l3_stop_card(card);
2389 qeth_stop_channel(&card->data);
2390 qeth_stop_channel(&card->write);
2391 qeth_stop_channel(&card->read);
2392 qdio_free(CARD_DDEV(card));
2393
2394 mutex_unlock(&card->conf_mutex);
2395 mutex_unlock(&card->discipline_mutex);
2396 return rc;
2397 }
2398
__qeth_l3_set_offline(struct ccwgroup_device * cgdev,int recovery_mode)2399 static int __qeth_l3_set_offline(struct ccwgroup_device *cgdev,
2400 int recovery_mode)
2401 {
2402 struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
2403 int rc = 0, rc2 = 0, rc3 = 0;
2404
2405 mutex_lock(&card->discipline_mutex);
2406 mutex_lock(&card->conf_mutex);
2407 QETH_CARD_TEXT(card, 3, "setoffl");
2408
2409 if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
2410 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
2411 card->info.hwtrap = 1;
2412 }
2413
2414 rtnl_lock();
2415 card->info.open_when_online = card->dev->flags & IFF_UP;
2416 dev_close(card->dev);
2417 netif_device_detach(card->dev);
2418 netif_carrier_off(card->dev);
2419 rtnl_unlock();
2420
2421 qeth_l3_stop_card(card);
2422 if (card->options.cq == QETH_CQ_ENABLED) {
2423 rtnl_lock();
2424 call_netdevice_notifiers(NETDEV_REBOOT, card->dev);
2425 rtnl_unlock();
2426 }
2427
2428 rc = qeth_stop_channel(&card->data);
2429 rc2 = qeth_stop_channel(&card->write);
2430 rc3 = qeth_stop_channel(&card->read);
2431 if (!rc)
2432 rc = (rc2) ? rc2 : rc3;
2433 if (rc)
2434 QETH_CARD_TEXT_(card, 2, "1err%d", rc);
2435 qdio_free(CARD_DDEV(card));
2436
2437 /* let user_space know that device is offline */
2438 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
2439 mutex_unlock(&card->conf_mutex);
2440 mutex_unlock(&card->discipline_mutex);
2441 return 0;
2442 }
2443
qeth_l3_set_offline(struct ccwgroup_device * cgdev)2444 static int qeth_l3_set_offline(struct ccwgroup_device *cgdev)
2445 {
2446 return __qeth_l3_set_offline(cgdev, 0);
2447 }
2448
qeth_l3_recover(void * ptr)2449 static int qeth_l3_recover(void *ptr)
2450 {
2451 struct qeth_card *card;
2452 int rc = 0;
2453
2454 card = (struct qeth_card *) ptr;
2455 QETH_CARD_TEXT(card, 2, "recover1");
2456 QETH_CARD_HEX(card, 2, &card, sizeof(void *));
2457 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
2458 return 0;
2459 QETH_CARD_TEXT(card, 2, "recover2");
2460 dev_warn(&card->gdev->dev,
2461 "A recovery process has been started for the device\n");
2462 __qeth_l3_set_offline(card->gdev, 1);
2463 rc = qeth_l3_set_online(card->gdev);
2464 if (!rc)
2465 dev_info(&card->gdev->dev,
2466 "Device successfully recovered!\n");
2467 else {
2468 ccwgroup_set_offline(card->gdev);
2469 dev_warn(&card->gdev->dev, "The qeth device driver "
2470 "failed to recover an error on the device\n");
2471 }
2472 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
2473 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
2474 return 0;
2475 }
2476
2477 /* Returns zero if the command is successfully "consumed" */
qeth_l3_control_event(struct qeth_card * card,struct qeth_ipa_cmd * cmd)2478 static int qeth_l3_control_event(struct qeth_card *card,
2479 struct qeth_ipa_cmd *cmd)
2480 {
2481 return 1;
2482 }
2483
2484 struct qeth_discipline qeth_l3_discipline = {
2485 .devtype = &qeth_l3_devtype,
2486 .process_rx_buffer = qeth_l3_process_inbound_buffer,
2487 .recover = qeth_l3_recover,
2488 .setup = qeth_l3_probe_device,
2489 .remove = qeth_l3_remove_device,
2490 .set_online = qeth_l3_set_online,
2491 .set_offline = qeth_l3_set_offline,
2492 .do_ioctl = qeth_l3_do_ioctl,
2493 .control_event_handler = qeth_l3_control_event,
2494 };
2495 EXPORT_SYMBOL_GPL(qeth_l3_discipline);
2496
qeth_l3_handle_ip_event(struct qeth_card * card,struct qeth_ipaddr * addr,unsigned long event)2497 static int qeth_l3_handle_ip_event(struct qeth_card *card,
2498 struct qeth_ipaddr *addr,
2499 unsigned long event)
2500 {
2501 switch (event) {
2502 case NETDEV_UP:
2503 qeth_l3_modify_ip(card, addr, true);
2504 return NOTIFY_OK;
2505 case NETDEV_DOWN:
2506 qeth_l3_modify_ip(card, addr, false);
2507 return NOTIFY_OK;
2508 default:
2509 return NOTIFY_DONE;
2510 }
2511 }
2512
2513 struct qeth_l3_ip_event_work {
2514 struct work_struct work;
2515 struct qeth_card *card;
2516 struct qeth_ipaddr addr;
2517 };
2518
2519 #define to_ip_work(w) container_of((w), struct qeth_l3_ip_event_work, work)
2520
qeth_l3_add_ip_worker(struct work_struct * work)2521 static void qeth_l3_add_ip_worker(struct work_struct *work)
2522 {
2523 struct qeth_l3_ip_event_work *ip_work = to_ip_work(work);
2524
2525 qeth_l3_modify_ip(ip_work->card, &ip_work->addr, true);
2526 kfree(work);
2527 }
2528
qeth_l3_delete_ip_worker(struct work_struct * work)2529 static void qeth_l3_delete_ip_worker(struct work_struct *work)
2530 {
2531 struct qeth_l3_ip_event_work *ip_work = to_ip_work(work);
2532
2533 qeth_l3_modify_ip(ip_work->card, &ip_work->addr, false);
2534 kfree(work);
2535 }
2536
qeth_l3_get_card_from_dev(struct net_device * dev)2537 static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev)
2538 {
2539 if (is_vlan_dev(dev))
2540 dev = vlan_dev_real_dev(dev);
2541 if (dev->netdev_ops == &qeth_l3_osa_netdev_ops ||
2542 dev->netdev_ops == &qeth_l3_netdev_ops)
2543 return (struct qeth_card *) dev->ml_priv;
2544 return NULL;
2545 }
2546
qeth_l3_ip_event(struct notifier_block * this,unsigned long event,void * ptr)2547 static int qeth_l3_ip_event(struct notifier_block *this,
2548 unsigned long event, void *ptr)
2549 {
2550
2551 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
2552 struct net_device *dev = ifa->ifa_dev->dev;
2553 struct qeth_ipaddr addr;
2554 struct qeth_card *card;
2555
2556 if (dev_net(dev) != &init_net)
2557 return NOTIFY_DONE;
2558
2559 card = qeth_l3_get_card_from_dev(dev);
2560 if (!card)
2561 return NOTIFY_DONE;
2562 QETH_CARD_TEXT(card, 3, "ipevent");
2563
2564 qeth_l3_init_ipaddr(&addr, QETH_IP_TYPE_NORMAL, QETH_PROT_IPV4);
2565 addr.u.a4.addr = be32_to_cpu(ifa->ifa_address);
2566 addr.u.a4.mask = be32_to_cpu(ifa->ifa_mask);
2567
2568 return qeth_l3_handle_ip_event(card, &addr, event);
2569 }
2570
2571 static struct notifier_block qeth_l3_ip_notifier = {
2572 qeth_l3_ip_event,
2573 NULL,
2574 };
2575
qeth_l3_ip6_event(struct notifier_block * this,unsigned long event,void * ptr)2576 static int qeth_l3_ip6_event(struct notifier_block *this,
2577 unsigned long event, void *ptr)
2578 {
2579 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr;
2580 struct net_device *dev = ifa->idev->dev;
2581 struct qeth_l3_ip_event_work *ip_work;
2582 struct qeth_card *card;
2583
2584 if (event != NETDEV_UP && event != NETDEV_DOWN)
2585 return NOTIFY_DONE;
2586
2587 card = qeth_l3_get_card_from_dev(dev);
2588 if (!card)
2589 return NOTIFY_DONE;
2590 QETH_CARD_TEXT(card, 3, "ip6event");
2591 if (!qeth_is_supported(card, IPA_IPV6))
2592 return NOTIFY_DONE;
2593
2594 ip_work = kmalloc(sizeof(*ip_work), GFP_ATOMIC);
2595 if (!ip_work)
2596 return NOTIFY_DONE;
2597
2598 if (event == NETDEV_UP)
2599 INIT_WORK(&ip_work->work, qeth_l3_add_ip_worker);
2600 else
2601 INIT_WORK(&ip_work->work, qeth_l3_delete_ip_worker);
2602
2603 ip_work->card = card;
2604 qeth_l3_init_ipaddr(&ip_work->addr, QETH_IP_TYPE_NORMAL,
2605 QETH_PROT_IPV6);
2606 ip_work->addr.u.a6.addr = ifa->addr;
2607 ip_work->addr.u.a6.pfxlen = ifa->prefix_len;
2608
2609 queue_work(card->cmd_wq, &ip_work->work);
2610 return NOTIFY_OK;
2611 }
2612
2613 static struct notifier_block qeth_l3_ip6_notifier = {
2614 qeth_l3_ip6_event,
2615 NULL,
2616 };
2617
qeth_l3_register_notifiers(void)2618 static int qeth_l3_register_notifiers(void)
2619 {
2620 int rc;
2621
2622 QETH_DBF_TEXT(SETUP, 5, "regnotif");
2623 rc = register_inetaddr_notifier(&qeth_l3_ip_notifier);
2624 if (rc)
2625 return rc;
2626 rc = register_inet6addr_notifier(&qeth_l3_ip6_notifier);
2627 if (rc) {
2628 unregister_inetaddr_notifier(&qeth_l3_ip_notifier);
2629 return rc;
2630 }
2631 return 0;
2632 }
2633
qeth_l3_unregister_notifiers(void)2634 static void qeth_l3_unregister_notifiers(void)
2635 {
2636 QETH_DBF_TEXT(SETUP, 5, "unregnot");
2637 WARN_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier));
2638 WARN_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier));
2639 }
2640
qeth_l3_init(void)2641 static int __init qeth_l3_init(void)
2642 {
2643 pr_info("register layer 3 discipline\n");
2644 return qeth_l3_register_notifiers();
2645 }
2646
qeth_l3_exit(void)2647 static void __exit qeth_l3_exit(void)
2648 {
2649 qeth_l3_unregister_notifiers();
2650 pr_info("unregister layer 3 discipline\n");
2651 }
2652
2653 module_init(qeth_l3_init);
2654 module_exit(qeth_l3_exit);
2655 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
2656 MODULE_DESCRIPTION("qeth layer 3 discipline");
2657 MODULE_LICENSE("GPL");
2658