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