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