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