drivers/s390/net/qeth_l3_main.c

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