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