drivers/s390/net/qeth_l3_main.c

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