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