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