drivers/s390/net/qeth_l3_main.c

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