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