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 goto out; 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 out: 1571 in_dev_put(in_dev); 1572 } 1573 1574 static void qeth_l3_free_vlan_addresses6(struct qeth_card *card, 1575 unsigned short vid) 1576 { 1577 #ifdef CONFIG_QETH_IPV6 1578 struct inet6_dev *in6_dev; 1579 struct inet6_ifaddr *ifa; 1580 struct qeth_ipaddr *addr; 1581 struct net_device *netdev; 1582 1583 QETH_CARD_TEXT(card, 4, "frvaddr6"); 1584 1585 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q), vid); 1586 if (!netdev) 1587 return; 1588 1589 in6_dev = in6_dev_get(netdev); 1590 if (!in6_dev) 1591 return; 1592 1593 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6); 1594 if (!addr) 1595 goto out; 1596 1597 spin_lock_bh(&card->ip_lock); 1598 1599 list_for_each_entry(ifa, &in6_dev->addr_list, if_list) { 1600 memcpy(&addr->u.a6.addr, &ifa->addr, 1601 sizeof(struct in6_addr)); 1602 addr->u.a6.pfxlen = ifa->prefix_len; 1603 addr->type = QETH_IP_TYPE_NORMAL; 1604 qeth_l3_delete_ip(card, addr); 1605 } 1606 1607 spin_unlock_bh(&card->ip_lock); 1608 1609 kfree(addr); 1610 out: 1611 in6_dev_put(in6_dev); 1612 #endif /* CONFIG_QETH_IPV6 */ 1613 } 1614 1615 static void qeth_l3_free_vlan_addresses(struct qeth_card *card, 1616 unsigned short vid) 1617 { 1618 rcu_read_lock(); 1619 qeth_l3_free_vlan_addresses4(card, vid); 1620 qeth_l3_free_vlan_addresses6(card, vid); 1621 rcu_read_unlock(); 1622 } 1623 1624 static int qeth_l3_vlan_rx_add_vid(struct net_device *dev, 1625 __be16 proto, u16 vid) 1626 { 1627 struct qeth_card *card = dev->ml_priv; 1628 1629 set_bit(vid, card->active_vlans); 1630 return 0; 1631 } 1632 1633 static int qeth_l3_vlan_rx_kill_vid(struct net_device *dev, 1634 __be16 proto, u16 vid) 1635 { 1636 struct qeth_card *card = dev->ml_priv; 1637 1638 QETH_CARD_TEXT_(card, 4, "kid:%d", vid); 1639 1640 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) { 1641 QETH_CARD_TEXT(card, 3, "kidREC"); 1642 return 0; 1643 } 1644 /* unregister IP addresses of vlan device */ 1645 qeth_l3_free_vlan_addresses(card, vid); 1646 clear_bit(vid, card->active_vlans); 1647 qeth_l3_set_multicast_list(card->dev); 1648 return 0; 1649 } 1650 1651 static void qeth_l3_rebuild_skb(struct qeth_card *card, struct sk_buff *skb, 1652 struct qeth_hdr *hdr) 1653 { 1654 __u16 prot; 1655 struct iphdr *ip_hdr; 1656 unsigned char tg_addr[MAX_ADDR_LEN]; 1657 1658 if (!(hdr->hdr.l3.flags & QETH_HDR_PASSTHRU)) { 1659 prot = (hdr->hdr.l3.flags & QETH_HDR_IPV6) ? ETH_P_IPV6 : 1660 ETH_P_IP; 1661 switch (hdr->hdr.l3.flags & QETH_HDR_CAST_MASK) { 1662 case QETH_CAST_MULTICAST: 1663 switch (prot) { 1664 #ifdef CONFIG_QETH_IPV6 1665 case ETH_P_IPV6: 1666 ndisc_mc_map((struct in6_addr *) 1667 skb->data + 24, 1668 tg_addr, card->dev, 0); 1669 break; 1670 #endif 1671 case ETH_P_IP: 1672 ip_hdr = (struct iphdr *)skb->data; 1673 ip_eth_mc_map(ip_hdr->daddr, tg_addr); 1674 break; 1675 default: 1676 memcpy(tg_addr, card->dev->broadcast, 1677 card->dev->addr_len); 1678 } 1679 card->stats.multicast++; 1680 skb->pkt_type = PACKET_MULTICAST; 1681 break; 1682 case QETH_CAST_BROADCAST: 1683 memcpy(tg_addr, card->dev->broadcast, 1684 card->dev->addr_len); 1685 card->stats.multicast++; 1686 skb->pkt_type = PACKET_BROADCAST; 1687 break; 1688 case QETH_CAST_UNICAST: 1689 case QETH_CAST_ANYCAST: 1690 case QETH_CAST_NOCAST: 1691 default: 1692 if (card->options.sniffer) 1693 skb->pkt_type = PACKET_OTHERHOST; 1694 else 1695 skb->pkt_type = PACKET_HOST; 1696 memcpy(tg_addr, card->dev->dev_addr, 1697 card->dev->addr_len); 1698 } 1699 if (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_SRC_MAC_ADDR) 1700 card->dev->header_ops->create(skb, card->dev, prot, 1701 tg_addr, &hdr->hdr.l3.dest_addr[2], 1702 card->dev->addr_len); 1703 else 1704 card->dev->header_ops->create(skb, card->dev, prot, 1705 tg_addr, "FAKELL", card->dev->addr_len); 1706 } 1707 1708 skb->protocol = eth_type_trans(skb, card->dev); 1709 1710 /* copy VLAN tag from hdr into skb */ 1711 if (!card->options.sniffer && 1712 (hdr->hdr.l3.ext_flags & (QETH_HDR_EXT_VLAN_FRAME | 1713 QETH_HDR_EXT_INCLUDE_VLAN_TAG))) { 1714 u16 tag = (hdr->hdr.l3.ext_flags & QETH_HDR_EXT_VLAN_FRAME) ? 1715 hdr->hdr.l3.vlan_id : 1716 *((u16 *)&hdr->hdr.l3.dest_addr[12]); 1717 __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), tag); 1718 } 1719 1720 if (card->dev->features & NETIF_F_RXCSUM) { 1721 if ((hdr->hdr.l3.ext_flags & 1722 (QETH_HDR_EXT_CSUM_HDR_REQ | 1723 QETH_HDR_EXT_CSUM_TRANSP_REQ)) == 1724 (QETH_HDR_EXT_CSUM_HDR_REQ | 1725 QETH_HDR_EXT_CSUM_TRANSP_REQ)) 1726 skb->ip_summed = CHECKSUM_UNNECESSARY; 1727 else 1728 skb->ip_summed = CHECKSUM_NONE; 1729 } else 1730 skb->ip_summed = CHECKSUM_NONE; 1731 } 1732 1733 static int qeth_l3_process_inbound_buffer(struct qeth_card *card, 1734 int budget, int *done) 1735 { 1736 int work_done = 0; 1737 struct sk_buff *skb; 1738 struct qeth_hdr *hdr; 1739 unsigned int len; 1740 __u16 magic; 1741 1742 *done = 0; 1743 WARN_ON_ONCE(!budget); 1744 while (budget) { 1745 skb = qeth_core_get_next_skb(card, 1746 &card->qdio.in_q->bufs[card->rx.b_index], 1747 &card->rx.b_element, &card->rx.e_offset, &hdr); 1748 if (!skb) { 1749 *done = 1; 1750 break; 1751 } 1752 skb->dev = card->dev; 1753 switch (hdr->hdr.l3.id) { 1754 case QETH_HEADER_TYPE_LAYER3: 1755 magic = *(__u16 *)skb->data; 1756 if ((card->info.type == QETH_CARD_TYPE_IQD) && 1757 (magic == ETH_P_AF_IUCV)) { 1758 skb->protocol = cpu_to_be16(ETH_P_AF_IUCV); 1759 skb->pkt_type = PACKET_HOST; 1760 skb->mac_header = NET_SKB_PAD; 1761 skb->dev = card->dev; 1762 len = skb->len; 1763 card->dev->header_ops->create(skb, card->dev, 0, 1764 card->dev->dev_addr, "FAKELL", 1765 card->dev->addr_len); 1766 netif_receive_skb(skb); 1767 } else { 1768 qeth_l3_rebuild_skb(card, skb, hdr); 1769 len = skb->len; 1770 napi_gro_receive(&card->napi, skb); 1771 } 1772 break; 1773 case QETH_HEADER_TYPE_LAYER2: /* for HiperSockets sniffer */ 1774 skb->pkt_type = PACKET_HOST; 1775 skb->protocol = eth_type_trans(skb, skb->dev); 1776 len = skb->len; 1777 netif_receive_skb(skb); 1778 break; 1779 default: 1780 dev_kfree_skb_any(skb); 1781 QETH_CARD_TEXT(card, 3, "inbunkno"); 1782 QETH_DBF_HEX(CTRL, 3, hdr, QETH_DBF_CTRL_LEN); 1783 continue; 1784 } 1785 work_done++; 1786 budget--; 1787 card->stats.rx_packets++; 1788 card->stats.rx_bytes += len; 1789 } 1790 return work_done; 1791 } 1792 1793 static int qeth_l3_verify_vlan_dev(struct net_device *dev, 1794 struct qeth_card *card) 1795 { 1796 int rc = 0; 1797 u16 vid; 1798 1799 for_each_set_bit(vid, card->active_vlans, VLAN_N_VID) { 1800 struct net_device *netdev; 1801 1802 rcu_read_lock(); 1803 netdev = __vlan_find_dev_deep_rcu(card->dev, htons(ETH_P_8021Q), 1804 vid); 1805 rcu_read_unlock(); 1806 if (netdev == dev) { 1807 rc = QETH_VLAN_CARD; 1808 break; 1809 } 1810 } 1811 1812 if (rc && !(vlan_dev_real_dev(dev)->ml_priv == (void *)card)) 1813 return 0; 1814 1815 return rc; 1816 } 1817 1818 static int qeth_l3_verify_dev(struct net_device *dev) 1819 { 1820 struct qeth_card *card; 1821 int rc = 0; 1822 unsigned long flags; 1823 1824 read_lock_irqsave(&qeth_core_card_list.rwlock, flags); 1825 list_for_each_entry(card, &qeth_core_card_list.list, list) { 1826 if (card->dev == dev) { 1827 rc = QETH_REAL_CARD; 1828 break; 1829 } 1830 rc = qeth_l3_verify_vlan_dev(dev, card); 1831 if (rc) 1832 break; 1833 } 1834 read_unlock_irqrestore(&qeth_core_card_list.rwlock, flags); 1835 1836 return rc; 1837 } 1838 1839 static struct qeth_card *qeth_l3_get_card_from_dev(struct net_device *dev) 1840 { 1841 struct qeth_card *card = NULL; 1842 int rc; 1843 1844 rc = qeth_l3_verify_dev(dev); 1845 if (rc == QETH_REAL_CARD) 1846 card = dev->ml_priv; 1847 else if (rc == QETH_VLAN_CARD) 1848 card = vlan_dev_real_dev(dev)->ml_priv; 1849 if (card && card->options.layer2) 1850 card = NULL; 1851 if (card) 1852 QETH_CARD_TEXT_(card, 4, "%d", rc); 1853 return card ; 1854 } 1855 1856 static void qeth_l3_stop_card(struct qeth_card *card, int recovery_mode) 1857 { 1858 QETH_DBF_TEXT(SETUP, 2, "stopcard"); 1859 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *)); 1860 1861 qeth_set_allowed_threads(card, 0, 1); 1862 if (card->options.sniffer && 1863 (card->info.promisc_mode == SET_PROMISC_MODE_ON)) 1864 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE); 1865 if (card->read.state == CH_STATE_UP && 1866 card->write.state == CH_STATE_UP && 1867 (card->state == CARD_STATE_UP)) { 1868 if (recovery_mode) 1869 qeth_l3_stop(card->dev); 1870 else { 1871 rtnl_lock(); 1872 dev_close(card->dev); 1873 rtnl_unlock(); 1874 } 1875 card->state = CARD_STATE_SOFTSETUP; 1876 } 1877 if (card->state == CARD_STATE_SOFTSETUP) { 1878 qeth_l3_clear_ip_htable(card, 1); 1879 qeth_clear_ipacmd_list(card); 1880 card->state = CARD_STATE_HARDSETUP; 1881 } 1882 if (card->state == CARD_STATE_HARDSETUP) { 1883 qeth_qdio_clear_card(card, 0); 1884 qeth_clear_qdio_buffers(card); 1885 qeth_clear_working_pool_list(card); 1886 card->state = CARD_STATE_DOWN; 1887 } 1888 if (card->state == CARD_STATE_DOWN) { 1889 qeth_clear_cmd_buffers(&card->read); 1890 qeth_clear_cmd_buffers(&card->write); 1891 } 1892 } 1893 1894 /* 1895 * test for and Switch promiscuous mode (on or off) 1896 * either for guestlan or HiperSocket Sniffer 1897 */ 1898 static void 1899 qeth_l3_handle_promisc_mode(struct qeth_card *card) 1900 { 1901 struct net_device *dev = card->dev; 1902 1903 if (((dev->flags & IFF_PROMISC) && 1904 (card->info.promisc_mode == SET_PROMISC_MODE_ON)) || 1905 (!(dev->flags & IFF_PROMISC) && 1906 (card->info.promisc_mode == SET_PROMISC_MODE_OFF))) 1907 return; 1908 1909 if (card->info.guestlan) { /* Guestlan trace */ 1910 if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE)) 1911 qeth_setadp_promisc_mode(card); 1912 } else if (card->options.sniffer && /* HiperSockets trace */ 1913 qeth_adp_supported(card, IPA_SETADP_SET_DIAG_ASSIST)) { 1914 if (dev->flags & IFF_PROMISC) { 1915 QETH_CARD_TEXT(card, 3, "+promisc"); 1916 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_ENABLE); 1917 } else { 1918 QETH_CARD_TEXT(card, 3, "-promisc"); 1919 qeth_diags_trace(card, QETH_DIAGS_CMD_TRACE_DISABLE); 1920 } 1921 } 1922 } 1923 1924 static void qeth_l3_set_multicast_list(struct net_device *dev) 1925 { 1926 struct qeth_card *card = dev->ml_priv; 1927 1928 QETH_CARD_TEXT(card, 3, "setmulti"); 1929 if (qeth_threads_running(card, QETH_RECOVER_THREAD) && 1930 (card->state != CARD_STATE_UP)) 1931 return; 1932 if (!card->options.sniffer) { 1933 1934 spin_lock_bh(&card->mclock); 1935 1936 qeth_l3_mark_all_mc_to_be_deleted(card); 1937 1938 qeth_l3_add_multicast_ipv4(card); 1939 #ifdef CONFIG_QETH_IPV6 1940 qeth_l3_add_multicast_ipv6(card); 1941 #endif 1942 qeth_l3_delete_nonused_mc(card); 1943 qeth_l3_add_all_new_mc(card); 1944 1945 spin_unlock_bh(&card->mclock); 1946 1947 if (!qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE)) 1948 return; 1949 } 1950 qeth_l3_handle_promisc_mode(card); 1951 } 1952 1953 static const char *qeth_l3_arp_get_error_cause(int *rc) 1954 { 1955 switch (*rc) { 1956 case QETH_IPA_ARP_RC_FAILED: 1957 *rc = -EIO; 1958 return "operation failed"; 1959 case QETH_IPA_ARP_RC_NOTSUPP: 1960 *rc = -EOPNOTSUPP; 1961 return "operation not supported"; 1962 case QETH_IPA_ARP_RC_OUT_OF_RANGE: 1963 *rc = -EINVAL; 1964 return "argument out of range"; 1965 case QETH_IPA_ARP_RC_Q_NOTSUPP: 1966 *rc = -EOPNOTSUPP; 1967 return "query operation not supported"; 1968 case QETH_IPA_ARP_RC_Q_NO_DATA: 1969 *rc = -ENOENT; 1970 return "no query data available"; 1971 default: 1972 return "unknown error"; 1973 } 1974 } 1975 1976 static int qeth_l3_arp_set_no_entries(struct qeth_card *card, int no_entries) 1977 { 1978 int tmp; 1979 int rc; 1980 1981 QETH_CARD_TEXT(card, 3, "arpstnoe"); 1982 1983 /* 1984 * currently GuestLAN only supports the ARP assist function 1985 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_SET_NO_ENTRIES; 1986 * thus we say EOPNOTSUPP for this ARP function 1987 */ 1988 if (card->info.guestlan) 1989 return -EOPNOTSUPP; 1990 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) { 1991 return -EOPNOTSUPP; 1992 } 1993 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING, 1994 IPA_CMD_ASS_ARP_SET_NO_ENTRIES, 1995 no_entries); 1996 if (rc) { 1997 tmp = rc; 1998 QETH_DBF_MESSAGE(2, "Could not set number of ARP entries on " 1999 "%s: %s (0x%x/%d)\n", QETH_CARD_IFNAME(card), 2000 qeth_l3_arp_get_error_cause(&rc), tmp, tmp); 2001 } 2002 return rc; 2003 } 2004 2005 static __u32 get_arp_entry_size(struct qeth_card *card, 2006 struct qeth_arp_query_data *qdata, 2007 struct qeth_arp_entrytype *type, __u8 strip_entries) 2008 { 2009 __u32 rc; 2010 __u8 is_hsi; 2011 2012 is_hsi = qdata->reply_bits == 5; 2013 if (type->ip == QETHARP_IP_ADDR_V4) { 2014 QETH_CARD_TEXT(card, 4, "arpev4"); 2015 if (strip_entries) { 2016 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5_short) : 2017 sizeof(struct qeth_arp_qi_entry7_short); 2018 } else { 2019 rc = is_hsi ? sizeof(struct qeth_arp_qi_entry5) : 2020 sizeof(struct qeth_arp_qi_entry7); 2021 } 2022 } else if (type->ip == QETHARP_IP_ADDR_V6) { 2023 QETH_CARD_TEXT(card, 4, "arpev6"); 2024 if (strip_entries) { 2025 rc = is_hsi ? 2026 sizeof(struct qeth_arp_qi_entry5_short_ipv6) : 2027 sizeof(struct qeth_arp_qi_entry7_short_ipv6); 2028 } else { 2029 rc = is_hsi ? 2030 sizeof(struct qeth_arp_qi_entry5_ipv6) : 2031 sizeof(struct qeth_arp_qi_entry7_ipv6); 2032 } 2033 } else { 2034 QETH_CARD_TEXT(card, 4, "arpinv"); 2035 rc = 0; 2036 } 2037 2038 return rc; 2039 } 2040 2041 static int arpentry_matches_prot(struct qeth_arp_entrytype *type, __u16 prot) 2042 { 2043 return (type->ip == QETHARP_IP_ADDR_V4 && prot == QETH_PROT_IPV4) || 2044 (type->ip == QETHARP_IP_ADDR_V6 && prot == QETH_PROT_IPV6); 2045 } 2046 2047 static int qeth_l3_arp_query_cb(struct qeth_card *card, 2048 struct qeth_reply *reply, unsigned long data) 2049 { 2050 struct qeth_ipa_cmd *cmd; 2051 struct qeth_arp_query_data *qdata; 2052 struct qeth_arp_query_info *qinfo; 2053 int i; 2054 int e; 2055 int entrybytes_done; 2056 int stripped_bytes; 2057 __u8 do_strip_entries; 2058 2059 QETH_CARD_TEXT(card, 3, "arpquecb"); 2060 2061 qinfo = (struct qeth_arp_query_info *) reply->param; 2062 cmd = (struct qeth_ipa_cmd *) data; 2063 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.prot_version); 2064 if (cmd->hdr.return_code) { 2065 QETH_CARD_TEXT(card, 4, "arpcberr"); 2066 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code); 2067 return 0; 2068 } 2069 if (cmd->data.setassparms.hdr.return_code) { 2070 cmd->hdr.return_code = cmd->data.setassparms.hdr.return_code; 2071 QETH_CARD_TEXT(card, 4, "setaperr"); 2072 QETH_CARD_TEXT_(card, 4, "%i", cmd->hdr.return_code); 2073 return 0; 2074 } 2075 qdata = &cmd->data.setassparms.data.query_arp; 2076 QETH_CARD_TEXT_(card, 4, "anoen%i", qdata->no_entries); 2077 2078 do_strip_entries = (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) > 0; 2079 stripped_bytes = do_strip_entries ? QETH_QARP_MEDIASPECIFIC_BYTES : 0; 2080 entrybytes_done = 0; 2081 for (e = 0; e < qdata->no_entries; ++e) { 2082 char *cur_entry; 2083 __u32 esize; 2084 struct qeth_arp_entrytype *etype; 2085 2086 cur_entry = &qdata->data + entrybytes_done; 2087 etype = &((struct qeth_arp_qi_entry5 *) cur_entry)->type; 2088 if (!arpentry_matches_prot(etype, cmd->hdr.prot_version)) { 2089 QETH_CARD_TEXT(card, 4, "pmis"); 2090 QETH_CARD_TEXT_(card, 4, "%i", etype->ip); 2091 break; 2092 } 2093 esize = get_arp_entry_size(card, qdata, etype, 2094 do_strip_entries); 2095 QETH_CARD_TEXT_(card, 5, "esz%i", esize); 2096 if (!esize) 2097 break; 2098 2099 if ((qinfo->udata_len - qinfo->udata_offset) < esize) { 2100 QETH_CARD_TEXT_(card, 4, "qaer3%i", -ENOMEM); 2101 cmd->hdr.return_code = IPA_RC_ENOMEM; 2102 goto out_error; 2103 } 2104 2105 memcpy(qinfo->udata + qinfo->udata_offset, 2106 &qdata->data + entrybytes_done + stripped_bytes, 2107 esize); 2108 entrybytes_done += esize + stripped_bytes; 2109 qinfo->udata_offset += esize; 2110 ++qinfo->no_entries; 2111 } 2112 /* check if all replies received ... */ 2113 if (cmd->data.setassparms.hdr.seq_no < 2114 cmd->data.setassparms.hdr.number_of_replies) 2115 return 1; 2116 QETH_CARD_TEXT_(card, 4, "nove%i", qinfo->no_entries); 2117 memcpy(qinfo->udata, &qinfo->no_entries, 4); 2118 /* keep STRIP_ENTRIES flag so the user program can distinguish 2119 * stripped entries from normal ones */ 2120 if (qinfo->mask_bits & QETH_QARP_STRIP_ENTRIES) 2121 qdata->reply_bits |= QETH_QARP_STRIP_ENTRIES; 2122 memcpy(qinfo->udata + QETH_QARP_MASK_OFFSET, &qdata->reply_bits, 2); 2123 QETH_CARD_TEXT_(card, 4, "rc%i", 0); 2124 return 0; 2125 out_error: 2126 i = 0; 2127 memcpy(qinfo->udata, &i, 4); 2128 return 0; 2129 } 2130 2131 static int qeth_l3_send_ipa_arp_cmd(struct qeth_card *card, 2132 struct qeth_cmd_buffer *iob, int len, 2133 int (*reply_cb)(struct qeth_card *, struct qeth_reply *, 2134 unsigned long), 2135 void *reply_param) 2136 { 2137 QETH_CARD_TEXT(card, 4, "sendarp"); 2138 2139 memcpy(iob->data, IPA_PDU_HEADER, IPA_PDU_HEADER_SIZE); 2140 memcpy(QETH_IPA_CMD_DEST_ADDR(iob->data), 2141 &card->token.ulp_connection_r, QETH_MPC_TOKEN_LENGTH); 2142 return qeth_send_control_data(card, IPA_PDU_HEADER_SIZE + len, iob, 2143 reply_cb, reply_param); 2144 } 2145 2146 static int qeth_l3_query_arp_cache_info(struct qeth_card *card, 2147 enum qeth_prot_versions prot, 2148 struct qeth_arp_query_info *qinfo) 2149 { 2150 struct qeth_cmd_buffer *iob; 2151 struct qeth_ipa_cmd *cmd; 2152 int tmp; 2153 int rc; 2154 2155 QETH_CARD_TEXT_(card, 3, "qarpipv%i", prot); 2156 2157 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING, 2158 IPA_CMD_ASS_ARP_QUERY_INFO, 2159 sizeof(struct qeth_arp_query_data) 2160 - sizeof(char), 2161 prot); 2162 if (!iob) 2163 return -ENOMEM; 2164 cmd = (struct qeth_ipa_cmd *)(iob->data+IPA_PDU_HEADER_SIZE); 2165 cmd->data.setassparms.data.query_arp.request_bits = 0x000F; 2166 cmd->data.setassparms.data.query_arp.reply_bits = 0; 2167 cmd->data.setassparms.data.query_arp.no_entries = 0; 2168 rc = qeth_l3_send_ipa_arp_cmd(card, iob, 2169 QETH_SETASS_BASE_LEN+QETH_ARP_CMD_LEN, 2170 qeth_l3_arp_query_cb, (void *)qinfo); 2171 if (rc) { 2172 tmp = rc; 2173 QETH_DBF_MESSAGE(2, 2174 "Error while querying ARP cache on %s: %s " 2175 "(0x%x/%d)\n", QETH_CARD_IFNAME(card), 2176 qeth_l3_arp_get_error_cause(&rc), tmp, tmp); 2177 } 2178 2179 return rc; 2180 } 2181 2182 static int qeth_l3_arp_query(struct qeth_card *card, char __user *udata) 2183 { 2184 struct qeth_arp_query_info qinfo = {0, }; 2185 int rc; 2186 2187 QETH_CARD_TEXT(card, 3, "arpquery"); 2188 2189 if (!qeth_is_supported(card,/*IPA_QUERY_ARP_ADDR_INFO*/ 2190 IPA_ARP_PROCESSING)) { 2191 QETH_CARD_TEXT(card, 3, "arpqnsup"); 2192 rc = -EOPNOTSUPP; 2193 goto out; 2194 } 2195 /* get size of userspace buffer and mask_bits -> 6 bytes */ 2196 if (copy_from_user(&qinfo, udata, 6)) { 2197 rc = -EFAULT; 2198 goto out; 2199 } 2200 qinfo.udata = kzalloc(qinfo.udata_len, GFP_KERNEL); 2201 if (!qinfo.udata) { 2202 rc = -ENOMEM; 2203 goto out; 2204 } 2205 qinfo.udata_offset = QETH_QARP_ENTRIES_OFFSET; 2206 rc = qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV4, &qinfo); 2207 if (rc) { 2208 if (copy_to_user(udata, qinfo.udata, 4)) 2209 rc = -EFAULT; 2210 goto free_and_out; 2211 } 2212 #ifdef CONFIG_QETH_IPV6 2213 if (qinfo.mask_bits & QETH_QARP_WITH_IPV6) { 2214 /* fails in case of GuestLAN QDIO mode */ 2215 qeth_l3_query_arp_cache_info(card, QETH_PROT_IPV6, &qinfo); 2216 } 2217 #endif 2218 if (copy_to_user(udata, qinfo.udata, qinfo.udata_len)) { 2219 QETH_CARD_TEXT(card, 4, "qactf"); 2220 rc = -EFAULT; 2221 goto free_and_out; 2222 } 2223 QETH_CARD_TEXT(card, 4, "qacts"); 2224 2225 free_and_out: 2226 kfree(qinfo.udata); 2227 out: 2228 return rc; 2229 } 2230 2231 static int qeth_l3_arp_add_entry(struct qeth_card *card, 2232 struct qeth_arp_cache_entry *entry) 2233 { 2234 struct qeth_cmd_buffer *iob; 2235 char buf[16]; 2236 int tmp; 2237 int rc; 2238 2239 QETH_CARD_TEXT(card, 3, "arpadent"); 2240 2241 /* 2242 * currently GuestLAN only supports the ARP assist function 2243 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_ADD_ENTRY; 2244 * thus we say EOPNOTSUPP for this ARP function 2245 */ 2246 if (card->info.guestlan) 2247 return -EOPNOTSUPP; 2248 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) { 2249 return -EOPNOTSUPP; 2250 } 2251 2252 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING, 2253 IPA_CMD_ASS_ARP_ADD_ENTRY, 2254 sizeof(struct qeth_arp_cache_entry), 2255 QETH_PROT_IPV4); 2256 if (!iob) 2257 return -ENOMEM; 2258 rc = qeth_send_setassparms(card, iob, 2259 sizeof(struct qeth_arp_cache_entry), 2260 (unsigned long) entry, 2261 qeth_setassparms_cb, NULL); 2262 if (rc) { 2263 tmp = rc; 2264 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf); 2265 QETH_DBF_MESSAGE(2, "Could not add ARP entry for address %s " 2266 "on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card), 2267 qeth_l3_arp_get_error_cause(&rc), tmp, tmp); 2268 } 2269 return rc; 2270 } 2271 2272 static int qeth_l3_arp_remove_entry(struct qeth_card *card, 2273 struct qeth_arp_cache_entry *entry) 2274 { 2275 struct qeth_cmd_buffer *iob; 2276 char buf[16] = {0, }; 2277 int tmp; 2278 int rc; 2279 2280 QETH_CARD_TEXT(card, 3, "arprment"); 2281 2282 /* 2283 * currently GuestLAN only supports the ARP assist function 2284 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_REMOVE_ENTRY; 2285 * thus we say EOPNOTSUPP for this ARP function 2286 */ 2287 if (card->info.guestlan) 2288 return -EOPNOTSUPP; 2289 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) { 2290 return -EOPNOTSUPP; 2291 } 2292 memcpy(buf, entry, 12); 2293 iob = qeth_get_setassparms_cmd(card, IPA_ARP_PROCESSING, 2294 IPA_CMD_ASS_ARP_REMOVE_ENTRY, 2295 12, 2296 QETH_PROT_IPV4); 2297 if (!iob) 2298 return -ENOMEM; 2299 rc = qeth_send_setassparms(card, iob, 2300 12, (unsigned long)buf, 2301 qeth_setassparms_cb, NULL); 2302 if (rc) { 2303 tmp = rc; 2304 memset(buf, 0, 16); 2305 qeth_l3_ipaddr4_to_string((u8 *)entry->ipaddr, buf); 2306 QETH_DBF_MESSAGE(2, "Could not delete ARP entry for address %s" 2307 " on %s: %s (0x%x/%d)\n", buf, QETH_CARD_IFNAME(card), 2308 qeth_l3_arp_get_error_cause(&rc), tmp, tmp); 2309 } 2310 return rc; 2311 } 2312 2313 static int qeth_l3_arp_flush_cache(struct qeth_card *card) 2314 { 2315 int rc; 2316 int tmp; 2317 2318 QETH_CARD_TEXT(card, 3, "arpflush"); 2319 2320 /* 2321 * currently GuestLAN only supports the ARP assist function 2322 * IPA_CMD_ASS_ARP_QUERY_INFO, but not IPA_CMD_ASS_ARP_FLUSH_CACHE; 2323 * thus we say EOPNOTSUPP for this ARP function 2324 */ 2325 if (card->info.guestlan || (card->info.type == QETH_CARD_TYPE_IQD)) 2326 return -EOPNOTSUPP; 2327 if (!qeth_is_supported(card, IPA_ARP_PROCESSING)) { 2328 return -EOPNOTSUPP; 2329 } 2330 rc = qeth_send_simple_setassparms(card, IPA_ARP_PROCESSING, 2331 IPA_CMD_ASS_ARP_FLUSH_CACHE, 0); 2332 if (rc) { 2333 tmp = rc; 2334 QETH_DBF_MESSAGE(2, "Could not flush ARP cache on %s: %s " 2335 "(0x%x/%d)\n", QETH_CARD_IFNAME(card), 2336 qeth_l3_arp_get_error_cause(&rc), tmp, tmp); 2337 } 2338 return rc; 2339 } 2340 2341 static int qeth_l3_do_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 2342 { 2343 struct qeth_card *card = dev->ml_priv; 2344 struct qeth_arp_cache_entry arp_entry; 2345 int rc = 0; 2346 2347 switch (cmd) { 2348 case SIOC_QETH_ARP_SET_NO_ENTRIES: 2349 if (!capable(CAP_NET_ADMIN)) { 2350 rc = -EPERM; 2351 break; 2352 } 2353 rc = qeth_l3_arp_set_no_entries(card, rq->ifr_ifru.ifru_ivalue); 2354 break; 2355 case SIOC_QETH_ARP_QUERY_INFO: 2356 if (!capable(CAP_NET_ADMIN)) { 2357 rc = -EPERM; 2358 break; 2359 } 2360 rc = qeth_l3_arp_query(card, rq->ifr_ifru.ifru_data); 2361 break; 2362 case SIOC_QETH_ARP_ADD_ENTRY: 2363 if (!capable(CAP_NET_ADMIN)) { 2364 rc = -EPERM; 2365 break; 2366 } 2367 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data, 2368 sizeof(struct qeth_arp_cache_entry))) 2369 rc = -EFAULT; 2370 else 2371 rc = qeth_l3_arp_add_entry(card, &arp_entry); 2372 break; 2373 case SIOC_QETH_ARP_REMOVE_ENTRY: 2374 if (!capable(CAP_NET_ADMIN)) { 2375 rc = -EPERM; 2376 break; 2377 } 2378 if (copy_from_user(&arp_entry, rq->ifr_ifru.ifru_data, 2379 sizeof(struct qeth_arp_cache_entry))) 2380 rc = -EFAULT; 2381 else 2382 rc = qeth_l3_arp_remove_entry(card, &arp_entry); 2383 break; 2384 case SIOC_QETH_ARP_FLUSH_CACHE: 2385 if (!capable(CAP_NET_ADMIN)) { 2386 rc = -EPERM; 2387 break; 2388 } 2389 rc = qeth_l3_arp_flush_cache(card); 2390 break; 2391 default: 2392 rc = -EOPNOTSUPP; 2393 } 2394 return rc; 2395 } 2396 2397 static int qeth_l3_get_cast_type(struct qeth_card *card, struct sk_buff *skb) 2398 { 2399 int cast_type = RTN_UNSPEC; 2400 struct neighbour *n = NULL; 2401 struct dst_entry *dst; 2402 2403 rcu_read_lock(); 2404 dst = skb_dst(skb); 2405 if (dst) 2406 n = dst_neigh_lookup_skb(dst, skb); 2407 if (n) { 2408 cast_type = n->type; 2409 rcu_read_unlock(); 2410 neigh_release(n); 2411 if ((cast_type == RTN_BROADCAST) || 2412 (cast_type == RTN_MULTICAST) || 2413 (cast_type == RTN_ANYCAST)) 2414 return cast_type; 2415 else 2416 return RTN_UNSPEC; 2417 } 2418 rcu_read_unlock(); 2419 2420 /* try something else */ 2421 if (be16_to_cpu(skb->protocol) == ETH_P_IPV6) 2422 return (skb_network_header(skb)[24] == 0xff) ? 2423 RTN_MULTICAST : 0; 2424 else if (be16_to_cpu(skb->protocol) == ETH_P_IP) 2425 return ((skb_network_header(skb)[16] & 0xf0) == 0xe0) ? 2426 RTN_MULTICAST : 0; 2427 /* ... */ 2428 if (!memcmp(skb->data, skb->dev->broadcast, 6)) 2429 return RTN_BROADCAST; 2430 else { 2431 u16 hdr_mac; 2432 2433 hdr_mac = *((u16 *)skb->data); 2434 /* tr multicast? */ 2435 switch (card->info.link_type) { 2436 case QETH_LINK_TYPE_HSTR: 2437 case QETH_LINK_TYPE_LANE_TR: 2438 if ((hdr_mac == QETH_TR_MAC_NC) || 2439 (hdr_mac == QETH_TR_MAC_C)) 2440 return RTN_MULTICAST; 2441 break; 2442 /* eth or so multicast? */ 2443 default: 2444 if ((hdr_mac == QETH_ETH_MAC_V4) || 2445 (hdr_mac == QETH_ETH_MAC_V6)) 2446 return RTN_MULTICAST; 2447 } 2448 } 2449 return cast_type; 2450 } 2451 2452 static void qeth_l3_fill_af_iucv_hdr(struct qeth_card *card, 2453 struct qeth_hdr *hdr, struct sk_buff *skb) 2454 { 2455 char daddr[16]; 2456 struct af_iucv_trans_hdr *iucv_hdr; 2457 2458 memset(hdr, 0, sizeof(struct qeth_hdr)); 2459 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3; 2460 hdr->hdr.l3.ext_flags = 0; 2461 hdr->hdr.l3.length = skb->len - ETH_HLEN; 2462 hdr->hdr.l3.flags = QETH_HDR_IPV6 | QETH_CAST_UNICAST; 2463 2464 iucv_hdr = (struct af_iucv_trans_hdr *) (skb->data + ETH_HLEN); 2465 memset(daddr, 0, sizeof(daddr)); 2466 daddr[0] = 0xfe; 2467 daddr[1] = 0x80; 2468 memcpy(&daddr[8], iucv_hdr->destUserID, 8); 2469 memcpy(hdr->hdr.l3.dest_addr, daddr, 16); 2470 } 2471 2472 static void qeth_l3_fill_header(struct qeth_card *card, struct qeth_hdr *hdr, 2473 struct sk_buff *skb, int ipv, int cast_type) 2474 { 2475 struct dst_entry *dst; 2476 2477 memset(hdr, 0, sizeof(struct qeth_hdr)); 2478 hdr->hdr.l3.id = QETH_HEADER_TYPE_LAYER3; 2479 hdr->hdr.l3.ext_flags = 0; 2480 2481 /* 2482 * before we're going to overwrite this location with next hop ip. 2483 * v6 uses passthrough, v4 sets the tag in the QDIO header. 2484 */ 2485 if (skb_vlan_tag_present(skb)) { 2486 if ((ipv == 4) || (card->info.type == QETH_CARD_TYPE_IQD)) 2487 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_VLAN_FRAME; 2488 else 2489 hdr->hdr.l3.ext_flags = QETH_HDR_EXT_INCLUDE_VLAN_TAG; 2490 hdr->hdr.l3.vlan_id = skb_vlan_tag_get(skb); 2491 } 2492 2493 hdr->hdr.l3.length = skb->len - sizeof(struct qeth_hdr); 2494 2495 rcu_read_lock(); 2496 dst = skb_dst(skb); 2497 if (ipv == 4) { 2498 struct rtable *rt = (struct rtable *) dst; 2499 __be32 *pkey = &ip_hdr(skb)->daddr; 2500 2501 if (rt && rt->rt_gateway) 2502 pkey = &rt->rt_gateway; 2503 2504 /* IPv4 */ 2505 hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags4(cast_type); 2506 memset(hdr->hdr.l3.dest_addr, 0, 12); 2507 *((__be32 *) (&hdr->hdr.l3.dest_addr[12])) = *pkey; 2508 } else if (ipv == 6) { 2509 struct rt6_info *rt = (struct rt6_info *) dst; 2510 struct in6_addr *pkey = &ipv6_hdr(skb)->daddr; 2511 2512 if (rt && !ipv6_addr_any(&rt->rt6i_gateway)) 2513 pkey = &rt->rt6i_gateway; 2514 2515 /* IPv6 */ 2516 hdr->hdr.l3.flags = qeth_l3_get_qeth_hdr_flags6(cast_type); 2517 if (card->info.type == QETH_CARD_TYPE_IQD) 2518 hdr->hdr.l3.flags &= ~QETH_HDR_PASSTHRU; 2519 memcpy(hdr->hdr.l3.dest_addr, pkey, 16); 2520 } else { 2521 if (!memcmp(skb->data + sizeof(struct qeth_hdr), 2522 skb->dev->broadcast, 6)) { 2523 /* broadcast? */ 2524 hdr->hdr.l3.flags = QETH_CAST_BROADCAST | 2525 QETH_HDR_PASSTHRU; 2526 } else { 2527 hdr->hdr.l3.flags = (cast_type == RTN_MULTICAST) ? 2528 QETH_CAST_MULTICAST | QETH_HDR_PASSTHRU : 2529 QETH_CAST_UNICAST | QETH_HDR_PASSTHRU; 2530 } 2531 } 2532 rcu_read_unlock(); 2533 } 2534 2535 static void qeth_l3_hdr_csum(struct qeth_card *card, struct qeth_hdr *hdr, 2536 struct sk_buff *skb) 2537 { 2538 struct iphdr *iph = ip_hdr(skb); 2539 2540 /* tcph->check contains already the pseudo hdr checksum 2541 * so just set the header flags 2542 */ 2543 if (iph->protocol == IPPROTO_UDP) 2544 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_UDP; 2545 hdr->hdr.l3.ext_flags |= QETH_HDR_EXT_CSUM_TRANSP_REQ | 2546 QETH_HDR_EXT_CSUM_HDR_REQ; 2547 iph->check = 0; 2548 if (card->options.performance_stats) 2549 card->perf_stats.tx_csum++; 2550 } 2551 2552 static void qeth_tso_fill_header(struct qeth_card *card, 2553 struct qeth_hdr *qhdr, struct sk_buff *skb) 2554 { 2555 struct qeth_hdr_tso *hdr = (struct qeth_hdr_tso *)qhdr; 2556 struct tcphdr *tcph = tcp_hdr(skb); 2557 struct iphdr *iph = ip_hdr(skb); 2558 struct ipv6hdr *ip6h = ipv6_hdr(skb); 2559 2560 /*fix header to TSO values ...*/ 2561 hdr->hdr.hdr.l3.id = QETH_HEADER_TYPE_TSO; 2562 hdr->hdr.hdr.l3.length = skb->len - sizeof(struct qeth_hdr_tso); 2563 /*set values which are fix for the first approach ...*/ 2564 hdr->ext.hdr_tot_len = (__u16) sizeof(struct qeth_hdr_ext_tso); 2565 hdr->ext.imb_hdr_no = 1; 2566 hdr->ext.hdr_type = 1; 2567 hdr->ext.hdr_version = 1; 2568 hdr->ext.hdr_len = 28; 2569 /*insert non-fix values */ 2570 hdr->ext.mss = skb_shinfo(skb)->gso_size; 2571 hdr->ext.dg_hdr_len = (__u16)(ip_hdrlen(skb) + tcp_hdrlen(skb)); 2572 hdr->ext.payload_len = (__u16)(skb->len - hdr->ext.dg_hdr_len - 2573 sizeof(struct qeth_hdr_tso)); 2574 tcph->check = 0; 2575 if (be16_to_cpu(skb->protocol) == ETH_P_IPV6) { 2576 ip6h->payload_len = 0; 2577 tcph->check = ~csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr, 2578 0, IPPROTO_TCP, 0); 2579 } else { 2580 /*OSA want us to set these values ...*/ 2581 tcph->check = ~csum_tcpudp_magic(iph->saddr, iph->daddr, 2582 0, IPPROTO_TCP, 0); 2583 iph->tot_len = 0; 2584 iph->check = 0; 2585 } 2586 } 2587 2588 /** 2589 * qeth_l3_get_elements_no_tso() - find number of SBALEs for skb data for tso 2590 * @card: qeth card structure, to check max. elems. 2591 * @skb: SKB address 2592 * @extra_elems: extra elems needed, to check against max. 2593 * 2594 * Returns the number of pages, and thus QDIO buffer elements, needed to cover 2595 * skb data, including linear part and fragments, but excluding TCP header. 2596 * (Exclusion of TCP header distinguishes it from qeth_get_elements_no().) 2597 * Checks if the result plus extra_elems fits under the limit for the card. 2598 * Returns 0 if it does not. 2599 * Note: extra_elems is not included in the returned result. 2600 */ 2601 static int qeth_l3_get_elements_no_tso(struct qeth_card *card, 2602 struct sk_buff *skb, int extra_elems) 2603 { 2604 addr_t tcpdptr = (addr_t)tcp_hdr(skb) + tcp_hdrlen(skb); 2605 int elements = qeth_get_elements_for_range( 2606 tcpdptr, 2607 (addr_t)skb->data + skb_headlen(skb)) + 2608 qeth_get_elements_for_frags(skb); 2609 2610 if ((elements + extra_elems) > QETH_MAX_BUFFER_ELEMENTS(card)) { 2611 QETH_DBF_MESSAGE(2, 2612 "Invalid size of TSO IP packet (Number=%d / Length=%d). Discarded.\n", 2613 elements + extra_elems, skb->len); 2614 return 0; 2615 } 2616 return elements; 2617 } 2618 2619 static netdev_tx_t qeth_l3_hard_start_xmit(struct sk_buff *skb, 2620 struct net_device *dev) 2621 { 2622 int rc; 2623 __be16 *tag; 2624 struct qeth_hdr *hdr = NULL; 2625 int hdr_elements = 0; 2626 int elements; 2627 struct qeth_card *card = dev->ml_priv; 2628 struct sk_buff *new_skb = NULL; 2629 int ipv = qeth_get_ip_version(skb); 2630 int cast_type = qeth_l3_get_cast_type(card, skb); 2631 struct qeth_qdio_out_q *queue = 2632 card->qdio.out_qs[card->qdio.do_prio_queueing 2633 || (cast_type && card->info.is_multicast_different) ? 2634 qeth_get_priority_queue(card, skb, ipv, cast_type) : 2635 card->qdio.default_out_queue]; 2636 int tx_bytes = skb->len; 2637 unsigned int hd_len = 0; 2638 bool use_tso; 2639 int data_offset = -1; 2640 unsigned int nr_frags; 2641 2642 if (((card->info.type == QETH_CARD_TYPE_IQD) && 2643 (((card->options.cq != QETH_CQ_ENABLED) && !ipv) || 2644 ((card->options.cq == QETH_CQ_ENABLED) && 2645 (be16_to_cpu(skb->protocol) != ETH_P_AF_IUCV)))) || 2646 card->options.sniffer) 2647 goto tx_drop; 2648 2649 if ((card->state != CARD_STATE_UP) || !card->lan_online) { 2650 card->stats.tx_carrier_errors++; 2651 goto tx_drop; 2652 } 2653 2654 if ((cast_type == RTN_BROADCAST) && 2655 (card->info.broadcast_capable == 0)) 2656 goto tx_drop; 2657 2658 if (card->options.performance_stats) { 2659 card->perf_stats.outbound_cnt++; 2660 card->perf_stats.outbound_start_time = qeth_get_micros(); 2661 } 2662 2663 /* Ignore segment size from skb_is_gso(), 1 page is always used. */ 2664 use_tso = skb_is_gso(skb) && 2665 (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4); 2666 2667 if (card->info.type == QETH_CARD_TYPE_IQD) { 2668 new_skb = skb; 2669 data_offset = ETH_HLEN; 2670 hd_len = sizeof(*hdr); 2671 hdr = kmem_cache_alloc(qeth_core_header_cache, GFP_ATOMIC); 2672 if (!hdr) 2673 goto tx_drop; 2674 hdr_elements++; 2675 } else { 2676 /* create a clone with writeable headroom */ 2677 new_skb = skb_realloc_headroom(skb, sizeof(struct qeth_hdr_tso) 2678 + VLAN_HLEN); 2679 if (!new_skb) 2680 goto tx_drop; 2681 2682 if (ipv == 4) { 2683 skb_pull(new_skb, ETH_HLEN); 2684 } 2685 2686 if (ipv != 4 && skb_vlan_tag_present(new_skb)) { 2687 skb_push(new_skb, VLAN_HLEN); 2688 skb_copy_to_linear_data(new_skb, new_skb->data + 4, 4); 2689 skb_copy_to_linear_data_offset(new_skb, 4, 2690 new_skb->data + 8, 4); 2691 skb_copy_to_linear_data_offset(new_skb, 8, 2692 new_skb->data + 12, 4); 2693 tag = (__be16 *)(new_skb->data + 12); 2694 *tag = cpu_to_be16(ETH_P_8021Q); 2695 *(tag + 1) = cpu_to_be16(skb_vlan_tag_get(new_skb)); 2696 } 2697 } 2698 2699 netif_stop_queue(dev); 2700 2701 /* fix hardware limitation: as long as we do not have sbal 2702 * chaining we can not send long frag lists 2703 */ 2704 if ((card->info.type != QETH_CARD_TYPE_IQD) && 2705 ((use_tso && !qeth_l3_get_elements_no_tso(card, new_skb, 1)) || 2706 (!use_tso && !qeth_get_elements_no(card, new_skb, 0, 0)))) { 2707 int lin_rc = skb_linearize(new_skb); 2708 2709 if (card->options.performance_stats) { 2710 if (lin_rc) 2711 card->perf_stats.tx_linfail++; 2712 else 2713 card->perf_stats.tx_lin++; 2714 } 2715 if (lin_rc) 2716 goto tx_drop; 2717 } 2718 nr_frags = skb_shinfo(new_skb)->nr_frags; 2719 2720 if (use_tso) { 2721 hdr = skb_push(new_skb, sizeof(struct qeth_hdr_tso)); 2722 memset(hdr, 0, sizeof(struct qeth_hdr_tso)); 2723 qeth_l3_fill_header(card, hdr, new_skb, ipv, cast_type); 2724 qeth_tso_fill_header(card, hdr, new_skb); 2725 hdr_elements++; 2726 } else { 2727 if (data_offset < 0) { 2728 hdr = skb_push(new_skb, sizeof(struct qeth_hdr)); 2729 qeth_l3_fill_header(card, hdr, new_skb, ipv, 2730 cast_type); 2731 } else { 2732 if (be16_to_cpu(new_skb->protocol) == ETH_P_AF_IUCV) 2733 qeth_l3_fill_af_iucv_hdr(card, hdr, new_skb); 2734 else { 2735 qeth_l3_fill_header(card, hdr, new_skb, ipv, 2736 cast_type); 2737 hdr->hdr.l3.length = new_skb->len - data_offset; 2738 } 2739 } 2740 2741 if (skb->ip_summed == CHECKSUM_PARTIAL) 2742 qeth_l3_hdr_csum(card, hdr, new_skb); 2743 } 2744 2745 elements = use_tso ? 2746 qeth_l3_get_elements_no_tso(card, new_skb, hdr_elements) : 2747 qeth_get_elements_no(card, new_skb, hdr_elements, 2748 (data_offset > 0) ? data_offset : 0); 2749 if (!elements) { 2750 if (data_offset >= 0) 2751 kmem_cache_free(qeth_core_header_cache, hdr); 2752 goto tx_drop; 2753 } 2754 elements += hdr_elements; 2755 2756 if (card->info.type != QETH_CARD_TYPE_IQD) { 2757 int len; 2758 if (use_tso) { 2759 hd_len = sizeof(struct qeth_hdr_tso) + 2760 ip_hdrlen(new_skb) + tcp_hdrlen(new_skb); 2761 len = hd_len; 2762 } else { 2763 len = sizeof(struct qeth_hdr_layer3); 2764 } 2765 2766 if (qeth_hdr_chk_and_bounce(new_skb, &hdr, len)) 2767 goto tx_drop; 2768 rc = qeth_do_send_packet(card, queue, new_skb, hdr, hd_len, 2769 hd_len, elements); 2770 } else 2771 rc = qeth_do_send_packet_fast(queue, new_skb, hdr, data_offset, 2772 hd_len); 2773 2774 if (!rc) { 2775 card->stats.tx_packets++; 2776 card->stats.tx_bytes += tx_bytes; 2777 if (new_skb != skb) 2778 dev_kfree_skb_any(skb); 2779 if (card->options.performance_stats) { 2780 if (use_tso) { 2781 card->perf_stats.large_send_bytes += tx_bytes; 2782 card->perf_stats.large_send_cnt++; 2783 } 2784 if (nr_frags) { 2785 card->perf_stats.sg_skbs_sent++; 2786 /* nr_frags + skb->data */ 2787 card->perf_stats.sg_frags_sent += nr_frags + 1; 2788 } 2789 } 2790 rc = NETDEV_TX_OK; 2791 } else { 2792 if (data_offset >= 0) 2793 kmem_cache_free(qeth_core_header_cache, hdr); 2794 2795 if (rc == -EBUSY) { 2796 if (new_skb != skb) 2797 dev_kfree_skb_any(new_skb); 2798 return NETDEV_TX_BUSY; 2799 } else 2800 goto tx_drop; 2801 } 2802 2803 netif_wake_queue(dev); 2804 if (card->options.performance_stats) 2805 card->perf_stats.outbound_time += qeth_get_micros() - 2806 card->perf_stats.outbound_start_time; 2807 return rc; 2808 2809 tx_drop: 2810 card->stats.tx_dropped++; 2811 card->stats.tx_errors++; 2812 if ((new_skb != skb) && new_skb) 2813 dev_kfree_skb_any(new_skb); 2814 dev_kfree_skb_any(skb); 2815 netif_wake_queue(dev); 2816 return NETDEV_TX_OK; 2817 } 2818 2819 static int __qeth_l3_open(struct net_device *dev) 2820 { 2821 struct qeth_card *card = dev->ml_priv; 2822 int rc = 0; 2823 2824 QETH_CARD_TEXT(card, 4, "qethopen"); 2825 if (card->state == CARD_STATE_UP) 2826 return rc; 2827 if (card->state != CARD_STATE_SOFTSETUP) 2828 return -ENODEV; 2829 card->data.state = CH_STATE_UP; 2830 card->state = CARD_STATE_UP; 2831 netif_start_queue(dev); 2832 2833 if (qdio_stop_irq(card->data.ccwdev, 0) >= 0) { 2834 napi_enable(&card->napi); 2835 napi_schedule(&card->napi); 2836 } else 2837 rc = -EIO; 2838 return rc; 2839 } 2840 2841 static int qeth_l3_open(struct net_device *dev) 2842 { 2843 struct qeth_card *card = dev->ml_priv; 2844 2845 QETH_CARD_TEXT(card, 5, "qethope_"); 2846 if (qeth_wait_for_threads(card, QETH_RECOVER_THREAD)) { 2847 QETH_CARD_TEXT(card, 3, "openREC"); 2848 return -ERESTARTSYS; 2849 } 2850 return __qeth_l3_open(dev); 2851 } 2852 2853 static int qeth_l3_stop(struct net_device *dev) 2854 { 2855 struct qeth_card *card = dev->ml_priv; 2856 2857 QETH_CARD_TEXT(card, 4, "qethstop"); 2858 netif_tx_disable(dev); 2859 if (card->state == CARD_STATE_UP) { 2860 card->state = CARD_STATE_SOFTSETUP; 2861 napi_disable(&card->napi); 2862 } 2863 return 0; 2864 } 2865 2866 static const struct ethtool_ops qeth_l3_ethtool_ops = { 2867 .get_link = ethtool_op_get_link, 2868 .get_strings = qeth_core_get_strings, 2869 .get_ethtool_stats = qeth_core_get_ethtool_stats, 2870 .get_sset_count = qeth_core_get_sset_count, 2871 .get_drvinfo = qeth_core_get_drvinfo, 2872 .get_link_ksettings = qeth_core_ethtool_get_link_ksettings, 2873 }; 2874 2875 /* 2876 * we need NOARP for IPv4 but we want neighbor solicitation for IPv6. Setting 2877 * NOARP on the netdevice is no option because it also turns off neighbor 2878 * solicitation. For IPv4 we install a neighbor_setup function. We don't want 2879 * arp resolution but we want the hard header (packet socket will work 2880 * e.g. tcpdump) 2881 */ 2882 static int qeth_l3_neigh_setup_noarp(struct neighbour *n) 2883 { 2884 n->nud_state = NUD_NOARP; 2885 memcpy(n->ha, "FAKELL", 6); 2886 n->output = n->ops->connected_output; 2887 return 0; 2888 } 2889 2890 static int 2891 qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np) 2892 { 2893 if (np->tbl->family == AF_INET) 2894 np->neigh_setup = qeth_l3_neigh_setup_noarp; 2895 2896 return 0; 2897 } 2898 2899 static const struct net_device_ops qeth_l3_netdev_ops = { 2900 .ndo_open = qeth_l3_open, 2901 .ndo_stop = qeth_l3_stop, 2902 .ndo_get_stats = qeth_get_stats, 2903 .ndo_start_xmit = qeth_l3_hard_start_xmit, 2904 .ndo_validate_addr = eth_validate_addr, 2905 .ndo_set_rx_mode = qeth_l3_set_multicast_list, 2906 .ndo_do_ioctl = qeth_do_ioctl, 2907 .ndo_change_mtu = qeth_change_mtu, 2908 .ndo_fix_features = qeth_fix_features, 2909 .ndo_set_features = qeth_set_features, 2910 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid, 2911 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid, 2912 .ndo_tx_timeout = qeth_tx_timeout, 2913 }; 2914 2915 static const struct net_device_ops qeth_l3_osa_netdev_ops = { 2916 .ndo_open = qeth_l3_open, 2917 .ndo_stop = qeth_l3_stop, 2918 .ndo_get_stats = qeth_get_stats, 2919 .ndo_start_xmit = qeth_l3_hard_start_xmit, 2920 .ndo_validate_addr = eth_validate_addr, 2921 .ndo_set_rx_mode = qeth_l3_set_multicast_list, 2922 .ndo_do_ioctl = qeth_do_ioctl, 2923 .ndo_change_mtu = qeth_change_mtu, 2924 .ndo_fix_features = qeth_fix_features, 2925 .ndo_set_features = qeth_set_features, 2926 .ndo_vlan_rx_add_vid = qeth_l3_vlan_rx_add_vid, 2927 .ndo_vlan_rx_kill_vid = qeth_l3_vlan_rx_kill_vid, 2928 .ndo_tx_timeout = qeth_tx_timeout, 2929 .ndo_neigh_setup = qeth_l3_neigh_setup, 2930 }; 2931 2932 static int qeth_l3_setup_netdev(struct qeth_card *card) 2933 { 2934 int rc; 2935 2936 if (card->info.type == QETH_CARD_TYPE_OSD || 2937 card->info.type == QETH_CARD_TYPE_OSX) { 2938 if ((card->info.link_type == QETH_LINK_TYPE_LANE_TR) || 2939 (card->info.link_type == QETH_LINK_TYPE_HSTR)) { 2940 pr_info("qeth_l3: ignoring TR device\n"); 2941 return -ENODEV; 2942 } else { 2943 card->dev = alloc_etherdev(0); 2944 if (!card->dev) 2945 return -ENODEV; 2946 card->dev->netdev_ops = &qeth_l3_osa_netdev_ops; 2947 2948 /*IPv6 address autoconfiguration stuff*/ 2949 qeth_l3_get_unique_id(card); 2950 if (!(card->info.unique_id & UNIQUE_ID_NOT_BY_CARD)) 2951 card->dev->dev_id = card->info.unique_id & 2952 0xffff; 2953 if (!card->info.guestlan) { 2954 card->dev->hw_features = NETIF_F_SG | 2955 NETIF_F_RXCSUM | NETIF_F_IP_CSUM | 2956 NETIF_F_TSO; 2957 card->dev->vlan_features = NETIF_F_SG | 2958 NETIF_F_RXCSUM | NETIF_F_IP_CSUM | 2959 NETIF_F_TSO; 2960 } 2961 } 2962 } else if (card->info.type == QETH_CARD_TYPE_IQD) { 2963 card->dev = alloc_netdev(0, "hsi%d", NET_NAME_UNKNOWN, 2964 ether_setup); 2965 if (!card->dev) 2966 return -ENODEV; 2967 card->dev->flags |= IFF_NOARP; 2968 card->dev->netdev_ops = &qeth_l3_netdev_ops; 2969 rc = qeth_l3_iqd_read_initial_mac(card); 2970 if (rc) 2971 return rc; 2972 if (card->options.hsuid[0]) 2973 memcpy(card->dev->perm_addr, card->options.hsuid, 9); 2974 } else 2975 return -ENODEV; 2976 2977 card->dev->ml_priv = card; 2978 card->dev->watchdog_timeo = QETH_TX_TIMEOUT; 2979 card->dev->mtu = card->info.initial_mtu; 2980 card->dev->min_mtu = 64; 2981 card->dev->max_mtu = ETH_MAX_MTU; 2982 card->dev->ethtool_ops = &qeth_l3_ethtool_ops; 2983 card->dev->features |= NETIF_F_HW_VLAN_CTAG_TX | 2984 NETIF_F_HW_VLAN_CTAG_RX | 2985 NETIF_F_HW_VLAN_CTAG_FILTER; 2986 netif_keep_dst(card->dev); 2987 card->dev->gso_max_size = (QETH_MAX_BUFFER_ELEMENTS(card) - 1) * 2988 PAGE_SIZE; 2989 2990 SET_NETDEV_DEV(card->dev, &card->gdev->dev); 2991 netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT); 2992 netif_carrier_off(card->dev); 2993 return register_netdev(card->dev); 2994 } 2995 2996 static const struct device_type qeth_l3_devtype = { 2997 .name = "qeth_layer3", 2998 .groups = qeth_l3_attr_groups, 2999 }; 3000 3001 static int qeth_l3_probe_device(struct ccwgroup_device *gdev) 3002 { 3003 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 3004 int rc; 3005 3006 if (gdev->dev.type == &qeth_generic_devtype) { 3007 rc = qeth_l3_create_device_attributes(&gdev->dev); 3008 if (rc) 3009 return rc; 3010 } 3011 hash_init(card->ip_htable); 3012 hash_init(card->ip_mc_htable); 3013 card->options.layer2 = 0; 3014 card->info.hwtrap = 0; 3015 return 0; 3016 } 3017 3018 static void qeth_l3_remove_device(struct ccwgroup_device *cgdev) 3019 { 3020 struct qeth_card *card = dev_get_drvdata(&cgdev->dev); 3021 3022 if (cgdev->dev.type == &qeth_generic_devtype) 3023 qeth_l3_remove_device_attributes(&cgdev->dev); 3024 3025 qeth_set_allowed_threads(card, 0, 1); 3026 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0); 3027 3028 if (cgdev->state == CCWGROUP_ONLINE) 3029 qeth_l3_set_offline(cgdev); 3030 3031 if (card->dev) { 3032 netif_napi_del(&card->napi); 3033 unregister_netdev(card->dev); 3034 card->dev = NULL; 3035 } 3036 3037 qeth_l3_clear_ip_htable(card, 0); 3038 qeth_l3_clear_ipato_list(card); 3039 return; 3040 } 3041 3042 static int __qeth_l3_set_online(struct ccwgroup_device *gdev, int recovery_mode) 3043 { 3044 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 3045 int rc = 0; 3046 enum qeth_card_states recover_flag; 3047 3048 mutex_lock(&card->discipline_mutex); 3049 mutex_lock(&card->conf_mutex); 3050 QETH_DBF_TEXT(SETUP, 2, "setonlin"); 3051 QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *)); 3052 3053 recover_flag = card->state; 3054 rc = qeth_core_hardsetup_card(card); 3055 if (rc) { 3056 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc); 3057 rc = -ENODEV; 3058 goto out_remove; 3059 } 3060 3061 if (!card->dev && qeth_l3_setup_netdev(card)) { 3062 rc = -ENODEV; 3063 goto out_remove; 3064 } 3065 3066 if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) { 3067 if (card->info.hwtrap && 3068 qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM)) 3069 card->info.hwtrap = 0; 3070 } else 3071 card->info.hwtrap = 0; 3072 3073 card->state = CARD_STATE_HARDSETUP; 3074 memset(&card->rx, 0, sizeof(struct qeth_rx)); 3075 qeth_print_status_message(card); 3076 3077 /* softsetup */ 3078 QETH_DBF_TEXT(SETUP, 2, "softsetp"); 3079 3080 rc = qeth_l3_setadapter_parms(card); 3081 if (rc) 3082 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc); 3083 if (!card->options.sniffer) { 3084 rc = qeth_l3_start_ipassists(card); 3085 if (rc) { 3086 QETH_DBF_TEXT_(SETUP, 2, "3err%d", rc); 3087 goto out_remove; 3088 } 3089 rc = qeth_l3_setrouting_v4(card); 3090 if (rc) 3091 QETH_DBF_TEXT_(SETUP, 2, "4err%04x", rc); 3092 rc = qeth_l3_setrouting_v6(card); 3093 if (rc) 3094 QETH_DBF_TEXT_(SETUP, 2, "5err%04x", rc); 3095 } 3096 netif_tx_disable(card->dev); 3097 3098 rc = qeth_init_qdio_queues(card); 3099 if (rc) { 3100 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc); 3101 rc = -ENODEV; 3102 goto out_remove; 3103 } 3104 card->state = CARD_STATE_SOFTSETUP; 3105 3106 qeth_set_allowed_threads(card, 0xffffffff, 0); 3107 qeth_l3_recover_ip(card); 3108 if (card->lan_online) 3109 netif_carrier_on(card->dev); 3110 else 3111 netif_carrier_off(card->dev); 3112 if (recover_flag == CARD_STATE_RECOVER) { 3113 rtnl_lock(); 3114 if (recovery_mode) 3115 __qeth_l3_open(card->dev); 3116 else 3117 dev_open(card->dev); 3118 qeth_l3_set_multicast_list(card->dev); 3119 qeth_recover_features(card->dev); 3120 rtnl_unlock(); 3121 } 3122 qeth_trace_features(card); 3123 /* let user_space know that device is online */ 3124 kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE); 3125 mutex_unlock(&card->conf_mutex); 3126 mutex_unlock(&card->discipline_mutex); 3127 return 0; 3128 out_remove: 3129 qeth_l3_stop_card(card, 0); 3130 ccw_device_set_offline(CARD_DDEV(card)); 3131 ccw_device_set_offline(CARD_WDEV(card)); 3132 ccw_device_set_offline(CARD_RDEV(card)); 3133 qdio_free(CARD_DDEV(card)); 3134 if (recover_flag == CARD_STATE_RECOVER) 3135 card->state = CARD_STATE_RECOVER; 3136 else 3137 card->state = CARD_STATE_DOWN; 3138 mutex_unlock(&card->conf_mutex); 3139 mutex_unlock(&card->discipline_mutex); 3140 return rc; 3141 } 3142 3143 static int qeth_l3_set_online(struct ccwgroup_device *gdev) 3144 { 3145 return __qeth_l3_set_online(gdev, 0); 3146 } 3147 3148 static int __qeth_l3_set_offline(struct ccwgroup_device *cgdev, 3149 int recovery_mode) 3150 { 3151 struct qeth_card *card = dev_get_drvdata(&cgdev->dev); 3152 int rc = 0, rc2 = 0, rc3 = 0; 3153 enum qeth_card_states recover_flag; 3154 3155 mutex_lock(&card->discipline_mutex); 3156 mutex_lock(&card->conf_mutex); 3157 QETH_DBF_TEXT(SETUP, 3, "setoffl"); 3158 QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *)); 3159 3160 if (card->dev && netif_carrier_ok(card->dev)) 3161 netif_carrier_off(card->dev); 3162 recover_flag = card->state; 3163 if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) { 3164 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM); 3165 card->info.hwtrap = 1; 3166 } 3167 qeth_l3_stop_card(card, recovery_mode); 3168 if ((card->options.cq == QETH_CQ_ENABLED) && card->dev) { 3169 rtnl_lock(); 3170 call_netdevice_notifiers(NETDEV_REBOOT, card->dev); 3171 rtnl_unlock(); 3172 } 3173 rc = ccw_device_set_offline(CARD_DDEV(card)); 3174 rc2 = ccw_device_set_offline(CARD_WDEV(card)); 3175 rc3 = ccw_device_set_offline(CARD_RDEV(card)); 3176 if (!rc) 3177 rc = (rc2) ? rc2 : rc3; 3178 if (rc) 3179 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc); 3180 qdio_free(CARD_DDEV(card)); 3181 if (recover_flag == CARD_STATE_UP) 3182 card->state = CARD_STATE_RECOVER; 3183 /* let user_space know that device is offline */ 3184 kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE); 3185 mutex_unlock(&card->conf_mutex); 3186 mutex_unlock(&card->discipline_mutex); 3187 return 0; 3188 } 3189 3190 static int qeth_l3_set_offline(struct ccwgroup_device *cgdev) 3191 { 3192 return __qeth_l3_set_offline(cgdev, 0); 3193 } 3194 3195 static int qeth_l3_recover(void *ptr) 3196 { 3197 struct qeth_card *card; 3198 int rc = 0; 3199 3200 card = (struct qeth_card *) ptr; 3201 QETH_CARD_TEXT(card, 2, "recover1"); 3202 QETH_CARD_HEX(card, 2, &card, sizeof(void *)); 3203 if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD)) 3204 return 0; 3205 QETH_CARD_TEXT(card, 2, "recover2"); 3206 dev_warn(&card->gdev->dev, 3207 "A recovery process has been started for the device\n"); 3208 qeth_set_recovery_task(card); 3209 __qeth_l3_set_offline(card->gdev, 1); 3210 rc = __qeth_l3_set_online(card->gdev, 1); 3211 if (!rc) 3212 dev_info(&card->gdev->dev, 3213 "Device successfully recovered!\n"); 3214 else { 3215 qeth_close_dev(card); 3216 dev_warn(&card->gdev->dev, "The qeth device driver " 3217 "failed to recover an error on the device\n"); 3218 } 3219 qeth_clear_recovery_task(card); 3220 qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD); 3221 qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD); 3222 return 0; 3223 } 3224 3225 static int qeth_l3_pm_suspend(struct ccwgroup_device *gdev) 3226 { 3227 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 3228 3229 if (card->dev) 3230 netif_device_detach(card->dev); 3231 qeth_set_allowed_threads(card, 0, 1); 3232 wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0); 3233 if (gdev->state == CCWGROUP_OFFLINE) 3234 return 0; 3235 if (card->state == CARD_STATE_UP) { 3236 if (card->info.hwtrap) 3237 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM); 3238 __qeth_l3_set_offline(card->gdev, 1); 3239 } else 3240 __qeth_l3_set_offline(card->gdev, 0); 3241 return 0; 3242 } 3243 3244 static int qeth_l3_pm_resume(struct ccwgroup_device *gdev) 3245 { 3246 struct qeth_card *card = dev_get_drvdata(&gdev->dev); 3247 int rc = 0; 3248 3249 if (gdev->state == CCWGROUP_OFFLINE) 3250 goto out; 3251 3252 if (card->state == CARD_STATE_RECOVER) { 3253 rc = __qeth_l3_set_online(card->gdev, 1); 3254 if (rc) { 3255 rtnl_lock(); 3256 dev_close(card->dev); 3257 rtnl_unlock(); 3258 } 3259 } else 3260 rc = __qeth_l3_set_online(card->gdev, 0); 3261 out: 3262 qeth_set_allowed_threads(card, 0xffffffff, 0); 3263 if (card->dev) 3264 netif_device_attach(card->dev); 3265 if (rc) 3266 dev_warn(&card->gdev->dev, "The qeth device driver " 3267 "failed to recover an error on the device\n"); 3268 return rc; 3269 } 3270 3271 /* Returns zero if the command is successfully "consumed" */ 3272 static int qeth_l3_control_event(struct qeth_card *card, 3273 struct qeth_ipa_cmd *cmd) 3274 { 3275 return 1; 3276 } 3277 3278 struct qeth_discipline qeth_l3_discipline = { 3279 .devtype = &qeth_l3_devtype, 3280 .start_poll = qeth_qdio_start_poll, 3281 .input_handler = (qdio_handler_t *) qeth_qdio_input_handler, 3282 .output_handler = (qdio_handler_t *) qeth_qdio_output_handler, 3283 .process_rx_buffer = qeth_l3_process_inbound_buffer, 3284 .recover = qeth_l3_recover, 3285 .setup = qeth_l3_probe_device, 3286 .remove = qeth_l3_remove_device, 3287 .set_online = qeth_l3_set_online, 3288 .set_offline = qeth_l3_set_offline, 3289 .freeze = qeth_l3_pm_suspend, 3290 .thaw = qeth_l3_pm_resume, 3291 .restore = qeth_l3_pm_resume, 3292 .do_ioctl = qeth_l3_do_ioctl, 3293 .control_event_handler = qeth_l3_control_event, 3294 }; 3295 EXPORT_SYMBOL_GPL(qeth_l3_discipline); 3296 3297 static int qeth_l3_ip_event(struct notifier_block *this, 3298 unsigned long event, void *ptr) 3299 { 3300 3301 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr; 3302 struct net_device *dev = (struct net_device *)ifa->ifa_dev->dev; 3303 struct qeth_ipaddr *addr; 3304 struct qeth_card *card; 3305 3306 if (dev_net(dev) != &init_net) 3307 return NOTIFY_DONE; 3308 3309 card = qeth_l3_get_card_from_dev(dev); 3310 if (!card) 3311 return NOTIFY_DONE; 3312 QETH_CARD_TEXT(card, 3, "ipevent"); 3313 3314 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV4); 3315 if (addr) { 3316 addr->u.a4.addr = be32_to_cpu(ifa->ifa_address); 3317 addr->u.a4.mask = be32_to_cpu(ifa->ifa_mask); 3318 addr->type = QETH_IP_TYPE_NORMAL; 3319 } else 3320 return NOTIFY_DONE; 3321 3322 switch (event) { 3323 case NETDEV_UP: 3324 spin_lock_bh(&card->ip_lock); 3325 qeth_l3_add_ip(card, addr); 3326 spin_unlock_bh(&card->ip_lock); 3327 break; 3328 case NETDEV_DOWN: 3329 spin_lock_bh(&card->ip_lock); 3330 qeth_l3_delete_ip(card, addr); 3331 spin_unlock_bh(&card->ip_lock); 3332 break; 3333 } 3334 3335 kfree(addr); 3336 return NOTIFY_DONE; 3337 } 3338 3339 static struct notifier_block qeth_l3_ip_notifier = { 3340 qeth_l3_ip_event, 3341 NULL, 3342 }; 3343 3344 #ifdef CONFIG_QETH_IPV6 3345 /** 3346 * IPv6 event handler 3347 */ 3348 static int qeth_l3_ip6_event(struct notifier_block *this, 3349 unsigned long event, void *ptr) 3350 { 3351 struct inet6_ifaddr *ifa = (struct inet6_ifaddr *)ptr; 3352 struct net_device *dev = (struct net_device *)ifa->idev->dev; 3353 struct qeth_ipaddr *addr; 3354 struct qeth_card *card; 3355 3356 card = qeth_l3_get_card_from_dev(dev); 3357 if (!card) 3358 return NOTIFY_DONE; 3359 QETH_CARD_TEXT(card, 3, "ip6event"); 3360 if (!qeth_is_supported(card, IPA_IPV6)) 3361 return NOTIFY_DONE; 3362 3363 addr = qeth_l3_get_addr_buffer(QETH_PROT_IPV6); 3364 if (addr) { 3365 memcpy(&addr->u.a6.addr, &ifa->addr, sizeof(struct in6_addr)); 3366 addr->u.a6.pfxlen = ifa->prefix_len; 3367 addr->type = QETH_IP_TYPE_NORMAL; 3368 } else 3369 return NOTIFY_DONE; 3370 3371 switch (event) { 3372 case NETDEV_UP: 3373 spin_lock_bh(&card->ip_lock); 3374 qeth_l3_add_ip(card, addr); 3375 spin_unlock_bh(&card->ip_lock); 3376 break; 3377 case NETDEV_DOWN: 3378 spin_lock_bh(&card->ip_lock); 3379 qeth_l3_delete_ip(card, addr); 3380 spin_unlock_bh(&card->ip_lock); 3381 break; 3382 } 3383 3384 kfree(addr); 3385 return NOTIFY_DONE; 3386 } 3387 3388 static struct notifier_block qeth_l3_ip6_notifier = { 3389 qeth_l3_ip6_event, 3390 NULL, 3391 }; 3392 #endif 3393 3394 static int qeth_l3_register_notifiers(void) 3395 { 3396 int rc; 3397 3398 QETH_DBF_TEXT(SETUP, 5, "regnotif"); 3399 rc = register_inetaddr_notifier(&qeth_l3_ip_notifier); 3400 if (rc) 3401 return rc; 3402 #ifdef CONFIG_QETH_IPV6 3403 rc = register_inet6addr_notifier(&qeth_l3_ip6_notifier); 3404 if (rc) { 3405 unregister_inetaddr_notifier(&qeth_l3_ip_notifier); 3406 return rc; 3407 } 3408 #else 3409 pr_warn("There is no IPv6 support for the layer 3 discipline\n"); 3410 #endif 3411 return 0; 3412 } 3413 3414 static void qeth_l3_unregister_notifiers(void) 3415 { 3416 3417 QETH_DBF_TEXT(SETUP, 5, "unregnot"); 3418 WARN_ON(unregister_inetaddr_notifier(&qeth_l3_ip_notifier)); 3419 #ifdef CONFIG_QETH_IPV6 3420 WARN_ON(unregister_inet6addr_notifier(&qeth_l3_ip6_notifier)); 3421 #endif /* QETH_IPV6 */ 3422 } 3423 3424 static int __init qeth_l3_init(void) 3425 { 3426 int rc = 0; 3427 3428 pr_info("register layer 3 discipline\n"); 3429 rc = qeth_l3_register_notifiers(); 3430 return rc; 3431 } 3432 3433 static void __exit qeth_l3_exit(void) 3434 { 3435 qeth_l3_unregister_notifiers(); 3436 pr_info("unregister layer 3 discipline\n"); 3437 } 3438 3439 module_init(qeth_l3_init); 3440 module_exit(qeth_l3_exit); 3441 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>"); 3442 MODULE_DESCRIPTION("qeth layer 3 discipline"); 3443 MODULE_LICENSE("GPL"); 3444