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