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