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