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