drivers/s390/net/qeth_l3_main.c

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