drivers/s390/net/qeth_l3_main.c

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