git.rot13.org Git - linux/blob - drivers/s390/net/qeth_l2_main.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *    Copyright IBM Corp. 2007, 2009
   4  *    Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
   5  *               Frank Pavlic <fpavlic@de.ibm.com>,
   6  *               Thomas Spatzier <tspat@de.ibm.com>,
   7  *               Frank Blaschka <frank.blaschka@de.ibm.com>
   8  */
   9
  10 #define KMSG_COMPONENT "qeth"
  11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  12
  13 #include <linux/module.h>
  14 #include <linux/moduleparam.h>
  15 #include <linux/string.h>
  16 #include <linux/errno.h>
  17 #include <linux/kernel.h>
  18 #include <linux/slab.h>
  19 #include <linux/etherdevice.h>
  20 #include <linux/list.h>
  21 #include <linux/hash.h>
  22 #include <linux/hashtable.h>
  23 #include <asm/setup.h>
  24 #include "qeth_core.h"
  25 #include "qeth_l2.h"
  26
  27 static int qeth_l2_set_offline(struct ccwgroup_device *);
  28 static void qeth_bridgeport_query_support(struct qeth_card *card);
  29 static void qeth_bridge_state_change(struct qeth_card *card,
  30                                         struct qeth_ipa_cmd *cmd);
  31 static void qeth_bridge_host_event(struct qeth_card *card,
  32                                         struct qeth_ipa_cmd *cmd);
  33 static void qeth_l2_vnicc_set_defaults(struct qeth_card *card);
  34 static void qeth_l2_vnicc_init(struct qeth_card *card);
  35 static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
  36                                           u32 *timeout);
  37
  38 static int qeth_setdelmac_makerc(struct qeth_card *card, int retcode)
  39 {
  40         int rc;
  41
  42         if (retcode)
  43                 QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
  44         switch (retcode) {
  45         case IPA_RC_SUCCESS:
  46                 rc = 0;
  47                 break;
  48         case IPA_RC_L2_UNSUPPORTED_CMD:
  49                 rc = -EOPNOTSUPP;
  50                 break;
  51         case IPA_RC_L2_ADDR_TABLE_FULL:
  52                 rc = -ENOSPC;
  53                 break;
  54         case IPA_RC_L2_DUP_MAC:
  55         case IPA_RC_L2_DUP_LAYER3_MAC:
  56                 rc = -EEXIST;
  57                 break;
  58         case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP:
  59         case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
  60                 rc = -EPERM;
  61                 break;
  62         case IPA_RC_L2_MAC_NOT_FOUND:
  63                 rc = -ENOENT;
  64                 break;
  65         case -ENOMEM:
  66                 rc = -ENOMEM;
  67                 break;
  68         default:
  69                 rc = -EIO;
  70                 break;
  71         }
  72         return rc;
  73 }
  74
  75 static int qeth_l2_send_setdelmac(struct qeth_card *card, __u8 *mac,
  76                            enum qeth_ipa_cmds ipacmd)
  77 {
  78         struct qeth_ipa_cmd *cmd;
  79         struct qeth_cmd_buffer *iob;
  80
  81         QETH_CARD_TEXT(card, 2, "L2sdmac");
  82         iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4);
  83         if (!iob)
  84                 return -ENOMEM;
  85         cmd = __ipa_cmd(iob);
  86         cmd->data.setdelmac.mac_length = ETH_ALEN;
  87         ether_addr_copy(cmd->data.setdelmac.mac, mac);
  88         return qeth_setdelmac_makerc(card, qeth_send_ipa_cmd(card, iob,
  89                                            NULL, NULL));
  90 }
  91
  92 static int qeth_l2_send_setmac(struct qeth_card *card, __u8 *mac)
  93 {
  94         int rc;
  95
  96         QETH_CARD_TEXT(card, 2, "L2Setmac");
  97         rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC);
  98         if (rc == 0) {
  99                 dev_info(&card->gdev->dev,
 100                          "MAC address %pM successfully registered\n", mac);
 101         } else {
 102                 switch (rc) {
 103                 case -EEXIST:
 104                         dev_warn(&card->gdev->dev,
 105                                 "MAC address %pM already exists\n", mac);
 106                         break;
 107                 case -EPERM:
 108                         dev_warn(&card->gdev->dev,
 109                                 "MAC address %pM is not authorized\n", mac);
 110                         break;
 111                 }
 112         }
 113         return rc;
 114 }
 115
 116 static int qeth_l2_write_mac(struct qeth_card *card, u8 *mac)
 117 {
 118         enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ?
 119                                         IPA_CMD_SETGMAC : IPA_CMD_SETVMAC;
 120         int rc;
 121
 122         QETH_CARD_TEXT(card, 2, "L2Wmac");
 123         rc = qeth_l2_send_setdelmac(card, mac, cmd);
 124         if (rc == -EEXIST)
 125                 QETH_DBF_MESSAGE(2, "MAC already registered on device %x\n",
 126                                  CARD_DEVID(card));
 127         else if (rc)
 128                 QETH_DBF_MESSAGE(2, "Failed to register MAC on device %x: %d\n",
 129                                  CARD_DEVID(card), rc);
 130         return rc;
 131 }
 132
 133 static int qeth_l2_remove_mac(struct qeth_card *card, u8 *mac)
 134 {
 135         enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ?
 136                                         IPA_CMD_DELGMAC : IPA_CMD_DELVMAC;
 137         int rc;
 138
 139         QETH_CARD_TEXT(card, 2, "L2Rmac");
 140         rc = qeth_l2_send_setdelmac(card, mac, cmd);
 141         if (rc)
 142                 QETH_DBF_MESSAGE(2, "Failed to delete MAC on device %u: %d\n",
 143                                  CARD_DEVID(card), rc);
 144         return rc;
 145 }
 146
 147 static void qeth_l2_del_all_macs(struct qeth_card *card)
 148 {
 149         struct qeth_mac *mac;
 150         struct hlist_node *tmp;
 151         int i;
 152
 153         spin_lock_bh(&card->mclock);
 154         hash_for_each_safe(card->mac_htable, i, tmp, mac, hnode) {
 155                 hash_del(&mac->hnode);
 156                 kfree(mac);
 157         }
 158         spin_unlock_bh(&card->mclock);
 159 }
 160
 161 static int qeth_l2_get_cast_type(struct qeth_card *card, struct sk_buff *skb)
 162 {
 163         if (card->info.type == QETH_CARD_TYPE_OSN)
 164                 return RTN_UNICAST;
 165         if (is_broadcast_ether_addr(skb->data))
 166                 return RTN_BROADCAST;
 167         if (is_multicast_ether_addr(skb->data))
 168                 return RTN_MULTICAST;
 169         return RTN_UNICAST;
 170 }
 171
 172 static void qeth_l2_fill_header(struct qeth_card *card, struct qeth_hdr *hdr,
 173                                 struct sk_buff *skb, int ipv, int cast_type,
 174                                 unsigned int data_len)
 175 {
 176         struct vlan_ethhdr *veth = vlan_eth_hdr(skb);
 177
 178         hdr->hdr.l2.pkt_length = data_len;
 179
 180         if (skb_is_gso(skb)) {
 181                 hdr->hdr.l2.id = QETH_HEADER_TYPE_L2_TSO;
 182         } else {
 183                 hdr->hdr.l2.id = QETH_HEADER_TYPE_LAYER2;
 184                 if (skb->ip_summed == CHECKSUM_PARTIAL) {
 185                         qeth_tx_csum(skb, &hdr->hdr.l2.flags[1], ipv);
 186                         if (card->options.performance_stats)
 187                                 card->perf_stats.tx_csum++;
 188                 }
 189         }
 190
 191         /* set byte byte 3 to casting flags */
 192         if (cast_type == RTN_MULTICAST)
 193                 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST;
 194         else if (cast_type == RTN_BROADCAST)
 195                 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_BROADCAST;
 196         else
 197                 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_UNICAST;
 198
 199         /* VSWITCH relies on the VLAN
 200          * information to be present in
 201          * the QDIO header */
 202         if (veth->h_vlan_proto == __constant_htons(ETH_P_8021Q)) {
 203                 hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_VLAN;
 204                 hdr->hdr.l2.vlan_id = ntohs(veth->h_vlan_TCI);
 205         }
 206 }
 207
 208 static int qeth_setdelvlan_makerc(struct qeth_card *card, int retcode)
 209 {
 210         if (retcode)
 211                 QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
 212
 213         switch (retcode) {
 214         case IPA_RC_SUCCESS:
 215                 return 0;
 216         case IPA_RC_L2_INVALID_VLAN_ID:
 217                 return -EINVAL;
 218         case IPA_RC_L2_DUP_VLAN_ID:
 219                 return -EEXIST;
 220         case IPA_RC_L2_VLAN_ID_NOT_FOUND:
 221                 return -ENOENT;
 222         case IPA_RC_L2_VLAN_ID_NOT_ALLOWED:
 223                 return -EPERM;
 224         case -ENOMEM:
 225                 return -ENOMEM;
 226         default:
 227                 return -EIO;
 228         }
 229 }
 230
 231 static int qeth_l2_send_setdelvlan_cb(struct qeth_card *card,
 232                                       struct qeth_reply *reply,
 233                                       unsigned long data)
 234 {
 235         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
 236
 237         QETH_CARD_TEXT(card, 2, "L2sdvcb");
 238         if (cmd->hdr.return_code) {
 239                 QETH_DBF_MESSAGE(2, "Error in processing VLAN %u on device %x: %#x.\n",
 240                                  cmd->data.setdelvlan.vlan_id,
 241                                  CARD_DEVID(card), cmd->hdr.return_code);
 242                 QETH_CARD_TEXT_(card, 2, "L2VL%4x", cmd->hdr.command);
 243                 QETH_CARD_TEXT_(card, 2, "err%d", cmd->hdr.return_code);
 244         }
 245         return 0;
 246 }
 247
 248 static int qeth_l2_send_setdelvlan(struct qeth_card *card, __u16 i,
 249                                    enum qeth_ipa_cmds ipacmd)
 250 {
 251         struct qeth_ipa_cmd *cmd;
 252         struct qeth_cmd_buffer *iob;
 253
 254         QETH_CARD_TEXT_(card, 4, "L2sdv%x", ipacmd);
 255         iob = qeth_get_ipacmd_buffer(card, ipacmd, QETH_PROT_IPV4);
 256         if (!iob)
 257                 return -ENOMEM;
 258         cmd = __ipa_cmd(iob);
 259         cmd->data.setdelvlan.vlan_id = i;
 260         return qeth_setdelvlan_makerc(card, qeth_send_ipa_cmd(card, iob,
 261                                             qeth_l2_send_setdelvlan_cb, NULL));
 262 }
 263
 264 static int qeth_l2_vlan_rx_add_vid(struct net_device *dev,
 265                                    __be16 proto, u16 vid)
 266 {
 267         struct qeth_card *card = dev->ml_priv;
 268
 269         QETH_CARD_TEXT_(card, 4, "aid:%d", vid);
 270         if (!vid)
 271                 return 0;
 272
 273         return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_SETVLAN);
 274 }
 275
 276 static int qeth_l2_vlan_rx_kill_vid(struct net_device *dev,
 277                                     __be16 proto, u16 vid)
 278 {
 279         struct qeth_card *card = dev->ml_priv;
 280
 281         QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
 282         if (!vid)
 283                 return 0;
 284
 285         return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN);
 286 }
 287
 288 static void qeth_l2_stop_card(struct qeth_card *card, int recovery_mode)
 289 {
 290         QETH_DBF_TEXT(SETUP , 2, "stopcard");
 291         QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
 292
 293         qeth_set_allowed_threads(card, 0, 1);
 294         if (card->read.state == CH_STATE_UP &&
 295             card->write.state == CH_STATE_UP &&
 296             (card->state == CARD_STATE_UP)) {
 297                 if (recovery_mode && !IS_OSN(card)) {
 298                         qeth_stop(card->dev);
 299                 } else {
 300                         rtnl_lock();
 301                         dev_close(card->dev);
 302                         rtnl_unlock();
 303                 }
 304                 card->info.mac_bits &= ~QETH_LAYER2_MAC_REGISTERED;
 305                 card->state = CARD_STATE_SOFTSETUP;
 306         }
 307         if (card->state == CARD_STATE_SOFTSETUP) {
 308                 qeth_l2_del_all_macs(card);
 309                 qeth_clear_ipacmd_list(card);
 310                 card->state = CARD_STATE_HARDSETUP;
 311         }
 312         if (card->state == CARD_STATE_HARDSETUP) {
 313                 qeth_qdio_clear_card(card, 0);
 314                 qeth_clear_qdio_buffers(card);
 315                 qeth_clear_working_pool_list(card);
 316                 card->state = CARD_STATE_DOWN;
 317         }
 318         if (card->state == CARD_STATE_DOWN) {
 319                 qeth_clear_cmd_buffers(&card->read);
 320                 qeth_clear_cmd_buffers(&card->write);
 321         }
 322
 323         flush_workqueue(card->event_wq);
 324 }
 325
 326 static int qeth_l2_process_inbound_buffer(struct qeth_card *card,
 327                                 int budget, int *done)
 328 {
 329         int work_done = 0;
 330         struct sk_buff *skb;
 331         struct qeth_hdr *hdr;
 332         unsigned int len;
 333
 334         *done = 0;
 335         WARN_ON_ONCE(!budget);
 336         while (budget) {
 337                 skb = qeth_core_get_next_skb(card,
 338                         &card->qdio.in_q->bufs[card->rx.b_index],
 339                         &card->rx.b_element, &card->rx.e_offset, &hdr);
 340                 if (!skb) {
 341                         *done = 1;
 342                         break;
 343                 }
 344                 switch (hdr->hdr.l2.id) {
 345                 case QETH_HEADER_TYPE_LAYER2:
 346                         skb->protocol = eth_type_trans(skb, skb->dev);
 347                         qeth_rx_csum(card, skb, hdr->hdr.l2.flags[1]);
 348                         if (skb->protocol == htons(ETH_P_802_2))
 349                                 *((__u32 *)skb->cb) = ++card->seqno.pkt_seqno;
 350                         len = skb->len;
 351                         napi_gro_receive(&card->napi, skb);
 352                         break;
 353                 case QETH_HEADER_TYPE_OSN:
 354                         if (card->info.type == QETH_CARD_TYPE_OSN) {
 355                                 skb_push(skb, sizeof(struct qeth_hdr));
 356                                 skb_copy_to_linear_data(skb, hdr,
 357                                                 sizeof(struct qeth_hdr));
 358                                 len = skb->len;
 359                                 card->osn_info.data_cb(skb);
 360                                 break;
 361                         }
 362                         /* else unknown */
 363                 default:
 364                         dev_kfree_skb_any(skb);
 365                         QETH_CARD_TEXT(card, 3, "inbunkno");
 366                         QETH_DBF_HEX(CTRL, 3, hdr, sizeof(*hdr));
 367                         continue;
 368                 }
 369                 work_done++;
 370                 budget--;
 371                 card->stats.rx_packets++;
 372                 card->stats.rx_bytes += len;
 373         }
 374         return work_done;
 375 }
 376
 377 static int qeth_l2_request_initial_mac(struct qeth_card *card)
 378 {
 379         int rc = 0;
 380
 381         QETH_DBF_TEXT(SETUP, 2, "l2reqmac");
 382         QETH_DBF_TEXT_(SETUP, 2, "doL2%s", CARD_BUS_ID(card));
 383
 384         if (MACHINE_IS_VM) {
 385                 rc = qeth_vm_request_mac(card);
 386                 if (!rc)
 387                         goto out;
 388                 QETH_DBF_MESSAGE(2, "z/VM MAC Service failed on device %x: %#x\n",
 389                                  CARD_DEVID(card), rc);
 390                 QETH_DBF_TEXT_(SETUP, 2, "err%04x", rc);
 391                 /* fall back to alternative mechanism: */
 392         }
 393
 394         if (!IS_OSN(card)) {
 395                 rc = qeth_setadpparms_change_macaddr(card);
 396                 if (!rc && is_valid_ether_addr(card->dev->dev_addr))
 397                         goto out;
 398                 QETH_DBF_MESSAGE(2, "READ_MAC Assist failed on device %x: %#x\n",
 399                                  CARD_DEVID(card), rc);
 400                 QETH_DBF_TEXT_(SETUP, 2, "1err%04x", rc);
 401                 /* fall back once more: */
 402         }
 403
 404         /* some devices don't support a custom MAC address: */
 405         if (card->info.type == QETH_CARD_TYPE_OSM ||
 406             card->info.type == QETH_CARD_TYPE_OSX)
 407                 return (rc) ? rc : -EADDRNOTAVAIL;
 408         eth_hw_addr_random(card->dev);
 409
 410 out:
 411         QETH_DBF_HEX(SETUP, 2, card->dev->dev_addr, card->dev->addr_len);
 412         return 0;
 413 }
 414
 415 static void qeth_l2_register_dev_addr(struct qeth_card *card)
 416 {
 417         if (!is_valid_ether_addr(card->dev->dev_addr))
 418                 qeth_l2_request_initial_mac(card);
 419
 420         if (!IS_OSN(card) && !qeth_l2_send_setmac(card, card->dev->dev_addr))
 421                 card->info.mac_bits |= QETH_LAYER2_MAC_REGISTERED;
 422 }
 423
 424 static int qeth_l2_validate_addr(struct net_device *dev)
 425 {
 426         struct qeth_card *card = dev->ml_priv;
 427
 428         if (IS_OSN(card) || (card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))
 429                 return eth_validate_addr(dev);
 430
 431         QETH_CARD_TEXT(card, 4, "nomacadr");
 432         return -EPERM;
 433 }
 434
 435 static int qeth_l2_set_mac_address(struct net_device *dev, void *p)
 436 {
 437         struct sockaddr *addr = p;
 438         struct qeth_card *card = dev->ml_priv;
 439         u8 old_addr[ETH_ALEN];
 440         int rc = 0;
 441
 442         QETH_CARD_TEXT(card, 3, "setmac");
 443
 444         if (card->info.type == QETH_CARD_TYPE_OSN ||
 445             card->info.type == QETH_CARD_TYPE_OSM ||
 446             card->info.type == QETH_CARD_TYPE_OSX) {
 447                 QETH_CARD_TEXT(card, 3, "setmcTYP");
 448                 return -EOPNOTSUPP;
 449         }
 450         QETH_CARD_HEX(card, 3, addr->sa_data, ETH_ALEN);
 451         if (!is_valid_ether_addr(addr->sa_data))
 452                 return -EADDRNOTAVAIL;
 453
 454         /* don't register the same address twice */
 455         if (ether_addr_equal_64bits(dev->dev_addr, addr->sa_data) &&
 456             (card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED))
 457                 return 0;
 458
 459         /* add the new address, switch over, drop the old */
 460         rc = qeth_l2_send_setmac(card, addr->sa_data);
 461         if (rc)
 462                 return rc;
 463         ether_addr_copy(old_addr, dev->dev_addr);
 464         ether_addr_copy(dev->dev_addr, addr->sa_data);
 465
 466         if (card->info.mac_bits & QETH_LAYER2_MAC_REGISTERED)
 467                 qeth_l2_remove_mac(card, old_addr);
 468         card->info.mac_bits |= QETH_LAYER2_MAC_REGISTERED;
 469         return 0;
 470 }
 471
 472 static void qeth_promisc_to_bridge(struct qeth_card *card)
 473 {
 474         struct net_device *dev = card->dev;
 475         enum qeth_ipa_promisc_modes promisc_mode;
 476         int role;
 477         int rc;
 478
 479         QETH_CARD_TEXT(card, 3, "pmisc2br");
 480
 481         if (!card->options.sbp.reflect_promisc)
 482                 return;
 483         promisc_mode = (dev->flags & IFF_PROMISC) ? SET_PROMISC_MODE_ON
 484                                                 : SET_PROMISC_MODE_OFF;
 485         if (promisc_mode == card->info.promisc_mode)
 486                 return;
 487
 488         if (promisc_mode == SET_PROMISC_MODE_ON) {
 489                 if (card->options.sbp.reflect_promisc_primary)
 490                         role = QETH_SBP_ROLE_PRIMARY;
 491                 else
 492                         role = QETH_SBP_ROLE_SECONDARY;
 493         } else
 494                 role = QETH_SBP_ROLE_NONE;
 495
 496         rc = qeth_bridgeport_setrole(card, role);
 497         QETH_DBF_TEXT_(SETUP, 2, "bpm%c%04x",
 498                         (promisc_mode == SET_PROMISC_MODE_ON) ? '+' : '-', rc);
 499         if (!rc) {
 500                 card->options.sbp.role = role;
 501                 card->info.promisc_mode = promisc_mode;
 502         }
 503
 504 }
 505 /* New MAC address is added to the hash table and marked to be written on card
 506  * only if there is not in the hash table storage already
 507  *
 508 */
 509 static void qeth_l2_add_mac(struct qeth_card *card, struct netdev_hw_addr *ha)
 510 {
 511         u32 mac_hash = get_unaligned((u32 *)(&ha->addr[2]));
 512         struct qeth_mac *mac;
 513
 514         hash_for_each_possible(card->mac_htable, mac, hnode, mac_hash) {
 515                 if (ether_addr_equal_64bits(ha->addr, mac->mac_addr)) {
 516                         mac->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
 517                         return;
 518                 }
 519         }
 520
 521         mac = kzalloc(sizeof(struct qeth_mac), GFP_ATOMIC);
 522         if (!mac)
 523                 return;
 524
 525         ether_addr_copy(mac->mac_addr, ha->addr);
 526         mac->disp_flag = QETH_DISP_ADDR_ADD;
 527
 528         hash_add(card->mac_htable, &mac->hnode, mac_hash);
 529 }
 530
 531 static void qeth_l2_set_rx_mode(struct net_device *dev)
 532 {
 533         struct qeth_card *card = dev->ml_priv;
 534         struct netdev_hw_addr *ha;
 535         struct qeth_mac *mac;
 536         struct hlist_node *tmp;
 537         int i;
 538         int rc;
 539
 540         if (card->info.type == QETH_CARD_TYPE_OSN)
 541                 return;
 542
 543         QETH_CARD_TEXT(card, 3, "setmulti");
 544
 545         spin_lock_bh(&card->mclock);
 546
 547         netdev_for_each_mc_addr(ha, dev)
 548                 qeth_l2_add_mac(card, ha);
 549         netdev_for_each_uc_addr(ha, dev)
 550                 qeth_l2_add_mac(card, ha);
 551
 552         hash_for_each_safe(card->mac_htable, i, tmp, mac, hnode) {
 553                 switch (mac->disp_flag) {
 554                 case QETH_DISP_ADDR_DELETE:
 555                         qeth_l2_remove_mac(card, mac->mac_addr);
 556                         hash_del(&mac->hnode);
 557                         kfree(mac);
 558                         break;
 559                 case QETH_DISP_ADDR_ADD:
 560                         rc = qeth_l2_write_mac(card, mac->mac_addr);
 561                         if (rc) {
 562                                 hash_del(&mac->hnode);
 563                                 kfree(mac);
 564                                 break;
 565                         }
 566                         /* fall through */
 567                 default:
 568                         /* for next call to set_rx_mode(): */
 569                         mac->disp_flag = QETH_DISP_ADDR_DELETE;
 570                 }
 571         }
 572
 573         spin_unlock_bh(&card->mclock);
 574
 575         if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE))
 576                 qeth_setadp_promisc_mode(card);
 577         else
 578                 qeth_promisc_to_bridge(card);
 579 }
 580
 581 static int qeth_l2_xmit_osn(struct qeth_card *card, struct sk_buff *skb,
 582                             struct qeth_qdio_out_q *queue)
 583 {
 584         struct qeth_hdr *hdr = (struct qeth_hdr *)skb->data;
 585         addr_t end = (addr_t)(skb->data + sizeof(*hdr));
 586         addr_t start = (addr_t)skb->data;
 587         unsigned int elements = 0;
 588         unsigned int hd_len = 0;
 589         int rc;
 590
 591         if (skb->protocol == htons(ETH_P_IPV6))
 592                 return -EPROTONOSUPPORT;
 593
 594         if (qeth_get_elements_for_range(start, end) > 1) {
 595                 /* Misaligned HW header, move it to its own buffer element. */
 596                 hdr = kmem_cache_alloc(qeth_core_header_cache, GFP_ATOMIC);
 597                 if (!hdr)
 598                         return -ENOMEM;
 599                 hd_len = sizeof(*hdr);
 600                 skb_copy_from_linear_data(skb, (char *)hdr, hd_len);
 601                 elements++;
 602         }
 603
 604         elements += qeth_count_elements(skb, hd_len);
 605         if (elements > QETH_MAX_BUFFER_ELEMENTS(card)) {
 606                 rc = -E2BIG;
 607                 goto out;
 608         }
 609
 610         rc = qeth_do_send_packet(card, queue, skb, hdr, hd_len, hd_len,
 611                                  elements);
 612 out:
 613         if (rc && hd_len)
 614                 kmem_cache_free(qeth_core_header_cache, hdr);
 615         return rc;
 616 }
 617
 618 static netdev_tx_t qeth_l2_hard_start_xmit(struct sk_buff *skb,
 619                                            struct net_device *dev)
 620 {
 621         struct qeth_card *card = dev->ml_priv;
 622         int cast_type = qeth_l2_get_cast_type(card, skb);
 623         int ipv = qeth_get_ip_version(skb);
 624         struct qeth_qdio_out_q *queue;
 625         int tx_bytes = skb->len;
 626         int rc;
 627
 628         if (card->state != CARD_STATE_UP) {
 629                 card->stats.tx_carrier_errors++;
 630                 goto tx_drop;
 631         }
 632
 633         queue = qeth_get_tx_queue(card, skb, ipv, cast_type);
 634
 635         if (card->options.performance_stats) {
 636                 card->perf_stats.outbound_cnt++;
 637                 card->perf_stats.outbound_start_time = qeth_get_micros();
 638         }
 639         netif_stop_queue(dev);
 640
 641         if (IS_OSN(card))
 642                 rc = qeth_l2_xmit_osn(card, skb, queue);
 643         else
 644                 rc = qeth_xmit(card, skb, queue, ipv, cast_type,
 645                                qeth_l2_fill_header);
 646
 647         if (!rc) {
 648                 card->stats.tx_packets++;
 649                 card->stats.tx_bytes += tx_bytes;
 650                 if (card->options.performance_stats)
 651                         card->perf_stats.outbound_time += qeth_get_micros() -
 652                                 card->perf_stats.outbound_start_time;
 653                 netif_wake_queue(dev);
 654                 return NETDEV_TX_OK;
 655         } else if (rc == -EBUSY) {
 656                 return NETDEV_TX_BUSY;
 657         } /* else fall through */
 658
 659 tx_drop:
 660         card->stats.tx_dropped++;
 661         card->stats.tx_errors++;
 662         dev_kfree_skb_any(skb);
 663         netif_wake_queue(dev);
 664         return NETDEV_TX_OK;
 665 }
 666
 667 static const struct device_type qeth_l2_devtype = {
 668         .name = "qeth_layer2",
 669         .groups = qeth_l2_attr_groups,
 670 };
 671
 672 static int qeth_l2_probe_device(struct ccwgroup_device *gdev)
 673 {
 674         struct qeth_card *card = dev_get_drvdata(&gdev->dev);
 675         int rc;
 676
 677         if (gdev->dev.type == &qeth_generic_devtype) {
 678                 rc = qeth_l2_create_device_attributes(&gdev->dev);
 679                 if (rc)
 680                         return rc;
 681         }
 682
 683         hash_init(card->mac_htable);
 684         card->info.hwtrap = 0;
 685         qeth_l2_vnicc_set_defaults(card);
 686         return 0;
 687 }
 688
 689 static void qeth_l2_remove_device(struct ccwgroup_device *cgdev)
 690 {
 691         struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
 692
 693         if (cgdev->dev.type == &qeth_generic_devtype)
 694                 qeth_l2_remove_device_attributes(&cgdev->dev);
 695         qeth_set_allowed_threads(card, 0, 1);
 696         wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
 697
 698         if (cgdev->state == CCWGROUP_ONLINE)
 699                 qeth_l2_set_offline(cgdev);
 700
 701         cancel_work_sync(&card->close_dev_work);
 702         if (qeth_netdev_is_registered(card->dev))
 703                 unregister_netdev(card->dev);
 704 }
 705
 706 static const struct ethtool_ops qeth_l2_ethtool_ops = {
 707         .get_link = ethtool_op_get_link,
 708         .get_strings = qeth_core_get_strings,
 709         .get_ethtool_stats = qeth_core_get_ethtool_stats,
 710         .get_sset_count = qeth_core_get_sset_count,
 711         .get_drvinfo = qeth_core_get_drvinfo,
 712         .get_link_ksettings = qeth_core_ethtool_get_link_ksettings,
 713 };
 714
 715 static const struct ethtool_ops qeth_l2_osn_ops = {
 716         .get_strings = qeth_core_get_strings,
 717         .get_ethtool_stats = qeth_core_get_ethtool_stats,
 718         .get_sset_count = qeth_core_get_sset_count,
 719         .get_drvinfo = qeth_core_get_drvinfo,
 720 };
 721
 722 static const struct net_device_ops qeth_l2_netdev_ops = {
 723         .ndo_open               = qeth_open,
 724         .ndo_stop               = qeth_stop,
 725         .ndo_get_stats          = qeth_get_stats,
 726         .ndo_start_xmit         = qeth_l2_hard_start_xmit,
 727         .ndo_features_check     = qeth_features_check,
 728         .ndo_validate_addr      = qeth_l2_validate_addr,
 729         .ndo_set_rx_mode        = qeth_l2_set_rx_mode,
 730         .ndo_do_ioctl           = qeth_do_ioctl,
 731         .ndo_set_mac_address    = qeth_l2_set_mac_address,
 732         .ndo_vlan_rx_add_vid    = qeth_l2_vlan_rx_add_vid,
 733         .ndo_vlan_rx_kill_vid   = qeth_l2_vlan_rx_kill_vid,
 734         .ndo_tx_timeout         = qeth_tx_timeout,
 735         .ndo_fix_features       = qeth_fix_features,
 736         .ndo_set_features       = qeth_set_features
 737 };
 738
 739 static int qeth_l2_setup_netdev(struct qeth_card *card, bool carrier_ok)
 740 {
 741         int rc;
 742
 743         card->dev->priv_flags |= IFF_UNICAST_FLT;
 744         card->dev->netdev_ops = &qeth_l2_netdev_ops;
 745         if (card->info.type == QETH_CARD_TYPE_OSN) {
 746                 card->dev->ethtool_ops = &qeth_l2_osn_ops;
 747                 card->dev->flags |= IFF_NOARP;
 748         } else {
 749                 card->dev->ethtool_ops = &qeth_l2_ethtool_ops;
 750                 card->dev->needed_headroom = sizeof(struct qeth_hdr);
 751         }
 752
 753         if (IS_OSM(card)) {
 754                 card->dev->features |= NETIF_F_VLAN_CHALLENGED;
 755         } else {
 756                 if (!IS_VM_NIC(card))
 757                         card->dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
 758                 card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
 759         }
 760
 761         if (card->info.type == QETH_CARD_TYPE_OSD && !card->info.guestlan) {
 762                 card->dev->features |= NETIF_F_SG;
 763                 /* OSA 3S and earlier has no RX/TX support */
 764                 if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) {
 765                         card->dev->hw_features |= NETIF_F_IP_CSUM;
 766                         card->dev->vlan_features |= NETIF_F_IP_CSUM;
 767                 }
 768         }
 769         if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) {
 770                 card->dev->hw_features |= NETIF_F_IPV6_CSUM;
 771                 card->dev->vlan_features |= NETIF_F_IPV6_CSUM;
 772         }
 773         if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM) ||
 774             qeth_is_supported6(card, IPA_INBOUND_CHECKSUM_V6)) {
 775                 card->dev->hw_features |= NETIF_F_RXCSUM;
 776                 card->dev->vlan_features |= NETIF_F_RXCSUM;
 777         }
 778         if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
 779                 card->dev->hw_features |= NETIF_F_TSO;
 780                 card->dev->vlan_features |= NETIF_F_TSO;
 781         }
 782         if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) {
 783                 card->dev->hw_features |= NETIF_F_TSO6;
 784                 card->dev->vlan_features |= NETIF_F_TSO6;
 785         }
 786
 787         if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6)) {
 788                 card->dev->needed_headroom = sizeof(struct qeth_hdr_tso);
 789                 netif_set_gso_max_size(card->dev,
 790                                        PAGE_SIZE * (QDIO_MAX_ELEMENTS_PER_BUFFER - 1));
 791         }
 792
 793         netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
 794         rc = register_netdev(card->dev);
 795         if (!rc && carrier_ok)
 796                 netif_carrier_on(card->dev);
 797
 798         if (rc)
 799                 card->dev->netdev_ops = NULL;
 800         return rc;
 801 }
 802
 803 static int qeth_l2_start_ipassists(struct qeth_card *card)
 804 {
 805         /* configure isolation level */
 806         if (qeth_set_access_ctrl_online(card, 0))
 807                 return -ENODEV;
 808         return 0;
 809 }
 810
 811 static void qeth_l2_trace_features(struct qeth_card *card)
 812 {
 813         /* Set BridgePort features */
 814         QETH_CARD_TEXT(card, 2, "featuSBP");
 815         QETH_CARD_HEX(card, 2, &card->options.sbp.supported_funcs,
 816                       sizeof(card->options.sbp.supported_funcs));
 817         /* VNIC Characteristics features */
 818         QETH_CARD_TEXT(card, 2, "feaVNICC");
 819         QETH_CARD_HEX(card, 2, &card->options.vnicc.sup_chars,
 820                       sizeof(card->options.vnicc.sup_chars));
 821 }
 822
 823 static int __qeth_l2_set_online(struct ccwgroup_device *gdev, int recovery_mode)
 824 {
 825         struct qeth_card *card = dev_get_drvdata(&gdev->dev);
 826         struct net_device *dev = card->dev;
 827         int rc = 0;
 828         enum qeth_card_states recover_flag;
 829         bool carrier_ok;
 830
 831         mutex_lock(&card->discipline_mutex);
 832         mutex_lock(&card->conf_mutex);
 833         QETH_DBF_TEXT(SETUP, 2, "setonlin");
 834         QETH_DBF_HEX(SETUP, 2, &card, sizeof(void *));
 835
 836         recover_flag = card->state;
 837         rc = qeth_core_hardsetup_card(card, &carrier_ok);
 838         if (rc) {
 839                 QETH_DBF_TEXT_(SETUP, 2, "2err%04x", rc);
 840                 rc = -ENODEV;
 841                 goto out_remove;
 842         }
 843         qeth_bridgeport_query_support(card);
 844         if (card->options.sbp.supported_funcs)
 845                 dev_info(&card->gdev->dev,
 846                 "The device represents a Bridge Capable Port\n");
 847
 848         qeth_l2_register_dev_addr(card);
 849
 850         if (qeth_is_diagass_supported(card, QETH_DIAGS_CMD_TRAP)) {
 851                 if (card->info.hwtrap &&
 852                     qeth_hw_trap(card, QETH_DIAGS_TRAP_ARM))
 853                         card->info.hwtrap = 0;
 854         } else
 855                 card->info.hwtrap = 0;
 856
 857         /* for the rx_bcast characteristic, init VNICC after setmac */
 858         qeth_l2_vnicc_init(card);
 859
 860         qeth_trace_features(card);
 861         qeth_l2_trace_features(card);
 862
 863         qeth_l2_setup_bridgeport_attrs(card);
 864
 865         card->state = CARD_STATE_HARDSETUP;
 866         qeth_print_status_message(card);
 867
 868         /* softsetup */
 869         QETH_DBF_TEXT(SETUP, 2, "softsetp");
 870
 871         if ((card->info.type == QETH_CARD_TYPE_OSD) ||
 872             (card->info.type == QETH_CARD_TYPE_OSX)) {
 873                 rc = qeth_l2_start_ipassists(card);
 874                 if (rc)
 875                         goto out_remove;
 876         }
 877
 878         rc = qeth_init_qdio_queues(card);
 879         if (rc) {
 880                 QETH_DBF_TEXT_(SETUP, 2, "6err%d", rc);
 881                 rc = -ENODEV;
 882                 goto out_remove;
 883         }
 884         card->state = CARD_STATE_SOFTSETUP;
 885
 886         qeth_set_allowed_threads(card, 0xffffffff, 0);
 887
 888         if (!qeth_netdev_is_registered(dev)) {
 889                 rc = qeth_l2_setup_netdev(card, carrier_ok);
 890                 if (rc)
 891                         goto out_remove;
 892         } else {
 893                 rtnl_lock();
 894                 if (carrier_ok)
 895                         netif_carrier_on(dev);
 896                 else
 897                         netif_carrier_off(dev);
 898
 899                 netif_device_attach(dev);
 900                 qeth_enable_hw_features(dev);
 901
 902                 if (recover_flag == CARD_STATE_RECOVER) {
 903                         if (recovery_mode && !IS_OSN(card)) {
 904                                 if (!qeth_l2_validate_addr(dev)) {
 905                                         qeth_open(dev);
 906                                         qeth_l2_set_rx_mode(dev);
 907                                 }
 908                         } else {
 909                                 dev_open(dev, NULL);
 910                         }
 911                 }
 912                 rtnl_unlock();
 913         }
 914         /* let user_space know that device is online */
 915         kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
 916         mutex_unlock(&card->conf_mutex);
 917         mutex_unlock(&card->discipline_mutex);
 918         return 0;
 919
 920 out_remove:
 921         qeth_l2_stop_card(card, 0);
 922         ccw_device_set_offline(CARD_DDEV(card));
 923         ccw_device_set_offline(CARD_WDEV(card));
 924         ccw_device_set_offline(CARD_RDEV(card));
 925         qdio_free(CARD_DDEV(card));
 926         if (recover_flag == CARD_STATE_RECOVER)
 927                 card->state = CARD_STATE_RECOVER;
 928         else
 929                 card->state = CARD_STATE_DOWN;
 930         mutex_unlock(&card->conf_mutex);
 931         mutex_unlock(&card->discipline_mutex);
 932         return rc;
 933 }
 934
 935 static int qeth_l2_set_online(struct ccwgroup_device *gdev)
 936 {
 937         return __qeth_l2_set_online(gdev, 0);
 938 }
 939
 940 static int __qeth_l2_set_offline(struct ccwgroup_device *cgdev,
 941                                         int recovery_mode)
 942 {
 943         struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
 944         int rc = 0, rc2 = 0, rc3 = 0;
 945         enum qeth_card_states recover_flag;
 946
 947         mutex_lock(&card->discipline_mutex);
 948         mutex_lock(&card->conf_mutex);
 949         QETH_DBF_TEXT(SETUP, 3, "setoffl");
 950         QETH_DBF_HEX(SETUP, 3, &card, sizeof(void *));
 951
 952         rtnl_lock();
 953         netif_device_detach(card->dev);
 954         netif_carrier_off(card->dev);
 955         rtnl_unlock();
 956
 957         recover_flag = card->state;
 958         if ((!recovery_mode && card->info.hwtrap) || card->info.hwtrap == 2) {
 959                 qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
 960                 card->info.hwtrap = 1;
 961         }
 962         qeth_l2_stop_card(card, recovery_mode);
 963         rc  = ccw_device_set_offline(CARD_DDEV(card));
 964         rc2 = ccw_device_set_offline(CARD_WDEV(card));
 965         rc3 = ccw_device_set_offline(CARD_RDEV(card));
 966         if (!rc)
 967                 rc = (rc2) ? rc2 : rc3;
 968         if (rc)
 969                 QETH_DBF_TEXT_(SETUP, 2, "1err%d", rc);
 970         qdio_free(CARD_DDEV(card));
 971         if (recover_flag == CARD_STATE_UP)
 972                 card->state = CARD_STATE_RECOVER;
 973         /* let user_space know that device is offline */
 974         kobject_uevent(&cgdev->dev.kobj, KOBJ_CHANGE);
 975         mutex_unlock(&card->conf_mutex);
 976         mutex_unlock(&card->discipline_mutex);
 977         return 0;
 978 }
 979
 980 static int qeth_l2_set_offline(struct ccwgroup_device *cgdev)
 981 {
 982         return __qeth_l2_set_offline(cgdev, 0);
 983 }
 984
 985 static int qeth_l2_recover(void *ptr)
 986 {
 987         struct qeth_card *card;
 988         int rc = 0;
 989
 990         card = (struct qeth_card *) ptr;
 991         QETH_CARD_TEXT(card, 2, "recover1");
 992         if (!qeth_do_run_thread(card, QETH_RECOVER_THREAD))
 993                 return 0;
 994         QETH_CARD_TEXT(card, 2, "recover2");
 995         dev_warn(&card->gdev->dev,
 996                 "A recovery process has been started for the device\n");
 997         __qeth_l2_set_offline(card->gdev, 1);
 998         rc = __qeth_l2_set_online(card->gdev, 1);
 999         if (!rc)
1000                 dev_info(&card->gdev->dev,
1001                         "Device successfully recovered!\n");
1002         else {
1003                 qeth_close_dev(card);
1004                 dev_warn(&card->gdev->dev, "The qeth device driver "
1005                                 "failed to recover an error on the device\n");
1006         }
1007         qeth_clear_thread_start_bit(card, QETH_RECOVER_THREAD);
1008         qeth_clear_thread_running_bit(card, QETH_RECOVER_THREAD);
1009         return 0;
1010 }
1011
1012 static int __init qeth_l2_init(void)
1013 {
1014         pr_info("register layer 2 discipline\n");
1015         return 0;
1016 }
1017
1018 static void __exit qeth_l2_exit(void)
1019 {
1020         pr_info("unregister layer 2 discipline\n");
1021 }
1022
1023 static int qeth_l2_pm_suspend(struct ccwgroup_device *gdev)
1024 {
1025         struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1026
1027         qeth_set_allowed_threads(card, 0, 1);
1028         wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
1029         if (gdev->state == CCWGROUP_OFFLINE)
1030                 return 0;
1031         if (card->state == CARD_STATE_UP) {
1032                 if (card->info.hwtrap)
1033                         qeth_hw_trap(card, QETH_DIAGS_TRAP_DISARM);
1034                 __qeth_l2_set_offline(card->gdev, 1);
1035         } else
1036                 __qeth_l2_set_offline(card->gdev, 0);
1037         return 0;
1038 }
1039
1040 static int qeth_l2_pm_resume(struct ccwgroup_device *gdev)
1041 {
1042         struct qeth_card *card = dev_get_drvdata(&gdev->dev);
1043         int rc = 0;
1044
1045         if (card->state == CARD_STATE_RECOVER) {
1046                 rc = __qeth_l2_set_online(card->gdev, 1);
1047                 if (rc) {
1048                         rtnl_lock();
1049                         dev_close(card->dev);
1050                         rtnl_unlock();
1051                 }
1052         } else
1053                 rc = __qeth_l2_set_online(card->gdev, 0);
1054
1055         qeth_set_allowed_threads(card, 0xffffffff, 0);
1056         if (rc)
1057                 dev_warn(&card->gdev->dev, "The qeth device driver "
1058                         "failed to recover an error on the device\n");
1059         return rc;
1060 }
1061
1062 /* Returns zero if the command is successfully "consumed" */
1063 static int qeth_l2_control_event(struct qeth_card *card,
1064                                         struct qeth_ipa_cmd *cmd)
1065 {
1066         switch (cmd->hdr.command) {
1067         case IPA_CMD_SETBRIDGEPORT_OSA:
1068         case IPA_CMD_SETBRIDGEPORT_IQD:
1069                 if (cmd->data.sbp.hdr.command_code ==
1070                                 IPA_SBP_BRIDGE_PORT_STATE_CHANGE) {
1071                         qeth_bridge_state_change(card, cmd);
1072                         return 0;
1073                 } else
1074                         return 1;
1075         case IPA_CMD_ADDRESS_CHANGE_NOTIF:
1076                 qeth_bridge_host_event(card, cmd);
1077                 return 0;
1078         default:
1079                 return 1;
1080         }
1081 }
1082
1083 struct qeth_discipline qeth_l2_discipline = {
1084         .devtype = &qeth_l2_devtype,
1085         .process_rx_buffer = qeth_l2_process_inbound_buffer,
1086         .recover = qeth_l2_recover,
1087         .setup = qeth_l2_probe_device,
1088         .remove = qeth_l2_remove_device,
1089         .set_online = qeth_l2_set_online,
1090         .set_offline = qeth_l2_set_offline,
1091         .freeze = qeth_l2_pm_suspend,
1092         .thaw = qeth_l2_pm_resume,
1093         .restore = qeth_l2_pm_resume,
1094         .do_ioctl = NULL,
1095         .control_event_handler = qeth_l2_control_event,
1096 };
1097 EXPORT_SYMBOL_GPL(qeth_l2_discipline);
1098
1099 static int qeth_osn_send_control_data(struct qeth_card *card, int len,
1100                            struct qeth_cmd_buffer *iob)
1101 {
1102         struct qeth_channel *channel = iob->channel;
1103         int rc = 0;
1104
1105         QETH_CARD_TEXT(card, 5, "osndctrd");
1106
1107         wait_event(card->wait_q,
1108                    atomic_cmpxchg(&channel->irq_pending, 0, 1) == 0);
1109         qeth_prepare_control_data(card, len, iob);
1110         QETH_CARD_TEXT(card, 6, "osnoirqp");
1111         spin_lock_irq(get_ccwdev_lock(channel->ccwdev));
1112         rc = ccw_device_start_timeout(channel->ccwdev, channel->ccw,
1113                                       (addr_t) iob, 0, 0, QETH_IPA_TIMEOUT);
1114         spin_unlock_irq(get_ccwdev_lock(channel->ccwdev));
1115         if (rc) {
1116                 QETH_DBF_MESSAGE(2, "qeth_osn_send_control_data: "
1117                            "ccw_device_start rc = %i\n", rc);
1118                 QETH_CARD_TEXT_(card, 2, " err%d", rc);
1119                 qeth_release_buffer(channel, iob);
1120                 atomic_set(&channel->irq_pending, 0);
1121                 wake_up(&card->wait_q);
1122         }
1123         return rc;
1124 }
1125
1126 static int qeth_osn_send_ipa_cmd(struct qeth_card *card,
1127                         struct qeth_cmd_buffer *iob, int data_len)
1128 {
1129         u16 s1, s2;
1130
1131         QETH_CARD_TEXT(card, 4, "osndipa");
1132
1133         qeth_prepare_ipa_cmd(card, iob);
1134         s1 = (u16)(IPA_PDU_HEADER_SIZE + data_len);
1135         s2 = (u16)data_len;
1136         memcpy(QETH_IPA_PDU_LEN_TOTAL(iob->data), &s1, 2);
1137         memcpy(QETH_IPA_PDU_LEN_PDU1(iob->data), &s2, 2);
1138         memcpy(QETH_IPA_PDU_LEN_PDU2(iob->data), &s2, 2);
1139         memcpy(QETH_IPA_PDU_LEN_PDU3(iob->data), &s2, 2);
1140         return qeth_osn_send_control_data(card, s1, iob);
1141 }
1142
1143 int qeth_osn_assist(struct net_device *dev, void *data, int data_len)
1144 {
1145         struct qeth_cmd_buffer *iob;
1146         struct qeth_card *card;
1147
1148         if (!dev)
1149                 return -ENODEV;
1150         card = dev->ml_priv;
1151         if (!card)
1152                 return -ENODEV;
1153         QETH_CARD_TEXT(card, 2, "osnsdmc");
1154         if (!qeth_card_hw_is_reachable(card))
1155                 return -ENODEV;
1156         iob = qeth_wait_for_buffer(&card->write);
1157         memcpy(__ipa_cmd(iob), data, data_len);
1158         return qeth_osn_send_ipa_cmd(card, iob, data_len);
1159 }
1160 EXPORT_SYMBOL(qeth_osn_assist);
1161
1162 int qeth_osn_register(unsigned char *read_dev_no, struct net_device **dev,
1163                   int (*assist_cb)(struct net_device *, void *),
1164                   int (*data_cb)(struct sk_buff *))
1165 {
1166         struct qeth_card *card;
1167         char bus_id[16];
1168         u16 devno;
1169
1170         memcpy(&devno, read_dev_no, 2);
1171         sprintf(bus_id, "0.0.%04x", devno);
1172         card = qeth_get_card_by_busid(bus_id);
1173         if (!card || !IS_OSN(card))
1174                 return -ENODEV;
1175         *dev = card->dev;
1176
1177         QETH_CARD_TEXT(card, 2, "osnreg");
1178         if ((assist_cb == NULL) || (data_cb == NULL))
1179                 return -EINVAL;
1180         card->osn_info.assist_cb = assist_cb;
1181         card->osn_info.data_cb = data_cb;
1182         return 0;
1183 }
1184 EXPORT_SYMBOL(qeth_osn_register);
1185
1186 void qeth_osn_deregister(struct net_device *dev)
1187 {
1188         struct qeth_card *card;
1189
1190         if (!dev)
1191                 return;
1192         card = dev->ml_priv;
1193         if (!card)
1194                 return;
1195         QETH_CARD_TEXT(card, 2, "osndereg");
1196         card->osn_info.assist_cb = NULL;
1197         card->osn_info.data_cb = NULL;
1198         return;
1199 }
1200 EXPORT_SYMBOL(qeth_osn_deregister);
1201
1202 /* SETBRIDGEPORT support, async notifications */
1203
1204 enum qeth_an_event_type {anev_reg_unreg, anev_abort, anev_reset};
1205
1206 /**
1207  * qeth_bridge_emit_host_event() - bridgeport address change notification
1208  * @card:  qeth_card structure pointer, for udev events.
1209  * @evtype:  "normal" register/unregister, or abort, or reset. For abort
1210  *            and reset token and addr_lnid are unused and may be NULL.
1211  * @code:  event bitmask: high order bit 0x80 value 1 means removal of an
1212  *                        object, 0 - addition of an object.
1213  *                        0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC.
1214  * @token: "network token" structure identifying physical address of the port.
1215  * @addr_lnid: pointer to structure with MAC address and VLAN ID.
1216  *
1217  * This function is called when registrations and deregistrations are
1218  * reported by the hardware, and also when notifications are enabled -
1219  * for all currently registered addresses.
1220  */
1221 static void qeth_bridge_emit_host_event(struct qeth_card *card,
1222         enum qeth_an_event_type evtype,
1223         u8 code, struct net_if_token *token, struct mac_addr_lnid *addr_lnid)
1224 {
1225         char str[7][32];
1226         char *env[8];
1227         int i = 0;
1228
1229         switch (evtype) {
1230         case anev_reg_unreg:
1231                 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=%s",
1232                                 (code & IPA_ADDR_CHANGE_CODE_REMOVAL)
1233                                 ? "deregister" : "register");
1234                 env[i] = str[i]; i++;
1235                 if (code & IPA_ADDR_CHANGE_CODE_VLANID) {
1236                         snprintf(str[i], sizeof(str[i]), "VLAN=%d",
1237                                 addr_lnid->lnid);
1238                         env[i] = str[i]; i++;
1239                 }
1240                 if (code & IPA_ADDR_CHANGE_CODE_MACADDR) {
1241                         snprintf(str[i], sizeof(str[i]), "MAC=%pM",
1242                                 addr_lnid->mac);
1243                         env[i] = str[i]; i++;
1244                 }
1245                 snprintf(str[i], sizeof(str[i]), "NTOK_BUSID=%x.%x.%04x",
1246                         token->cssid, token->ssid, token->devnum);
1247                 env[i] = str[i]; i++;
1248                 snprintf(str[i], sizeof(str[i]), "NTOK_IID=%02x", token->iid);
1249                 env[i] = str[i]; i++;
1250                 snprintf(str[i], sizeof(str[i]), "NTOK_CHPID=%02x",
1251                                 token->chpid);
1252                 env[i] = str[i]; i++;
1253                 snprintf(str[i], sizeof(str[i]), "NTOK_CHID=%04x", token->chid);
1254                 env[i] = str[i]; i++;
1255                 break;
1256         case anev_abort:
1257                 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=abort");
1258                 env[i] = str[i]; i++;
1259                 break;
1260         case anev_reset:
1261                 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=reset");
1262                 env[i] = str[i]; i++;
1263                 break;
1264         }
1265         env[i] = NULL;
1266         kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env);
1267 }
1268
1269 struct qeth_bridge_state_data {
1270         struct work_struct worker;
1271         struct qeth_card *card;
1272         struct qeth_sbp_state_change qports;
1273 };
1274
1275 static void qeth_bridge_state_change_worker(struct work_struct *work)
1276 {
1277         struct qeth_bridge_state_data *data =
1278                 container_of(work, struct qeth_bridge_state_data, worker);
1279         /* We are only interested in the first entry - local port */
1280         struct qeth_sbp_port_entry *entry = &data->qports.entry[0];
1281         char env_locrem[32];
1282         char env_role[32];
1283         char env_state[32];
1284         char *env[] = {
1285                 env_locrem,
1286                 env_role,
1287                 env_state,
1288                 NULL
1289         };
1290
1291         /* Role should not change by itself, but if it did, */
1292         /* information from the hardware is authoritative.  */
1293         mutex_lock(&data->card->conf_mutex);
1294         data->card->options.sbp.role = entry->role;
1295         mutex_unlock(&data->card->conf_mutex);
1296
1297         snprintf(env_locrem, sizeof(env_locrem), "BRIDGEPORT=statechange");
1298         snprintf(env_role, sizeof(env_role), "ROLE=%s",
1299                 (entry->role == QETH_SBP_ROLE_NONE) ? "none" :
1300                 (entry->role == QETH_SBP_ROLE_PRIMARY) ? "primary" :
1301                 (entry->role == QETH_SBP_ROLE_SECONDARY) ? "secondary" :
1302                 "<INVALID>");
1303         snprintf(env_state, sizeof(env_state), "STATE=%s",
1304                 (entry->state == QETH_SBP_STATE_INACTIVE) ? "inactive" :
1305                 (entry->state == QETH_SBP_STATE_STANDBY) ? "standby" :
1306                 (entry->state == QETH_SBP_STATE_ACTIVE) ? "active" :
1307                 "<INVALID>");
1308         kobject_uevent_env(&data->card->gdev->dev.kobj,
1309                                 KOBJ_CHANGE, env);
1310         kfree(data);
1311 }
1312
1313 static void qeth_bridge_state_change(struct qeth_card *card,
1314                                         struct qeth_ipa_cmd *cmd)
1315 {
1316         struct qeth_sbp_state_change *qports =
1317                  &cmd->data.sbp.data.state_change;
1318         struct qeth_bridge_state_data *data;
1319         int extrasize;
1320
1321         QETH_CARD_TEXT(card, 2, "brstchng");
1322         if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
1323                 QETH_CARD_TEXT_(card, 2, "BPsz%04x", qports->entry_length);
1324                 return;
1325         }
1326         extrasize = sizeof(struct qeth_sbp_port_entry) * qports->num_entries;
1327         data = kzalloc(sizeof(struct qeth_bridge_state_data) + extrasize,
1328                 GFP_ATOMIC);
1329         if (!data) {
1330                 QETH_CARD_TEXT(card, 2, "BPSalloc");
1331                 return;
1332         }
1333         INIT_WORK(&data->worker, qeth_bridge_state_change_worker);
1334         data->card = card;
1335         memcpy(&data->qports, qports,
1336                         sizeof(struct qeth_sbp_state_change) + extrasize);
1337         queue_work(card->event_wq, &data->worker);
1338 }
1339
1340 struct qeth_bridge_host_data {
1341         struct work_struct worker;
1342         struct qeth_card *card;
1343         struct qeth_ipacmd_addr_change hostevs;
1344 };
1345
1346 static void qeth_bridge_host_event_worker(struct work_struct *work)
1347 {
1348         struct qeth_bridge_host_data *data =
1349                 container_of(work, struct qeth_bridge_host_data, worker);
1350         int i;
1351
1352         if (data->hostevs.lost_event_mask) {
1353                 dev_info(&data->card->gdev->dev,
1354 "Address notification from the Bridge Port stopped %s (%s)\n",
1355                         data->card->dev->name,
1356                         (data->hostevs.lost_event_mask == 0x01)
1357                         ? "Overflow"
1358                         : (data->hostevs.lost_event_mask == 0x02)
1359                         ? "Bridge port state change"
1360                         : "Unknown reason");
1361                 mutex_lock(&data->card->conf_mutex);
1362                 data->card->options.sbp.hostnotification = 0;
1363                 mutex_unlock(&data->card->conf_mutex);
1364                 qeth_bridge_emit_host_event(data->card, anev_abort,
1365                         0, NULL, NULL);
1366         } else
1367                 for (i = 0; i < data->hostevs.num_entries; i++) {
1368                         struct qeth_ipacmd_addr_change_entry *entry =
1369                                         &data->hostevs.entry[i];
1370                         qeth_bridge_emit_host_event(data->card,
1371                                         anev_reg_unreg,
1372                                         entry->change_code,
1373                                         &entry->token, &entry->addr_lnid);
1374                 }
1375         kfree(data);
1376 }
1377
1378 static void qeth_bridge_host_event(struct qeth_card *card,
1379                                         struct qeth_ipa_cmd *cmd)
1380 {
1381         struct qeth_ipacmd_addr_change *hostevs =
1382                  &cmd->data.addrchange;
1383         struct qeth_bridge_host_data *data;
1384         int extrasize;
1385
1386         QETH_CARD_TEXT(card, 2, "brhostev");
1387         if (cmd->hdr.return_code != 0x0000) {
1388                 if (cmd->hdr.return_code == 0x0010) {
1389                         if (hostevs->lost_event_mask == 0x00)
1390                                 hostevs->lost_event_mask = 0xff;
1391                 } else {
1392                         QETH_CARD_TEXT_(card, 2, "BPHe%04x",
1393                                 cmd->hdr.return_code);
1394                         return;
1395                 }
1396         }
1397         extrasize = sizeof(struct qeth_ipacmd_addr_change_entry) *
1398                                                 hostevs->num_entries;
1399         data = kzalloc(sizeof(struct qeth_bridge_host_data) + extrasize,
1400                 GFP_ATOMIC);
1401         if (!data) {
1402                 QETH_CARD_TEXT(card, 2, "BPHalloc");
1403                 return;
1404         }
1405         INIT_WORK(&data->worker, qeth_bridge_host_event_worker);
1406         data->card = card;
1407         memcpy(&data->hostevs, hostevs,
1408                         sizeof(struct qeth_ipacmd_addr_change) + extrasize);
1409         queue_work(card->event_wq, &data->worker);
1410 }
1411
1412 /* SETBRIDGEPORT support; sending commands */
1413
1414 struct _qeth_sbp_cbctl {
1415         u16 ipa_rc;
1416         u16 cmd_rc;
1417         union {
1418                 u32 supported;
1419                 struct {
1420                         enum qeth_sbp_roles *role;
1421                         enum qeth_sbp_states *state;
1422                 } qports;
1423         } data;
1424 };
1425
1426 /**
1427  * qeth_bridgeport_makerc() - derive "traditional" error from hardware codes.
1428  * @card:                     qeth_card structure pointer, for debug messages.
1429  * @cbctl:                    state structure with hardware return codes.
1430  * @setcmd:                   IPA command code
1431  *
1432  * Returns negative errno-compatible error indication or 0 on success.
1433  */
1434 static int qeth_bridgeport_makerc(struct qeth_card *card,
1435         struct _qeth_sbp_cbctl *cbctl, enum qeth_ipa_sbp_cmd setcmd)
1436 {
1437         int rc;
1438         int is_iqd = (card->info.type == QETH_CARD_TYPE_IQD);
1439
1440         if ((is_iqd && (cbctl->ipa_rc == IPA_RC_SUCCESS)) ||
1441             (!is_iqd && (cbctl->ipa_rc == cbctl->cmd_rc)))
1442                 switch (cbctl->cmd_rc) {
1443                 case IPA_RC_SUCCESS:
1444                         rc = 0;
1445                         break;
1446                 case IPA_RC_L2_UNSUPPORTED_CMD:
1447                 case IPA_RC_UNSUPPORTED_COMMAND:
1448                         rc = -EOPNOTSUPP;
1449                         break;
1450                 case IPA_RC_SBP_OSA_NOT_CONFIGURED:
1451                 case IPA_RC_SBP_IQD_NOT_CONFIGURED:
1452                         rc = -ENODEV; /* maybe not the best code here? */
1453                         dev_err(&card->gdev->dev,
1454         "The device is not configured as a Bridge Port\n");
1455                         break;
1456                 case IPA_RC_SBP_OSA_OS_MISMATCH:
1457                 case IPA_RC_SBP_IQD_OS_MISMATCH:
1458                         rc = -EPERM;
1459                         dev_err(&card->gdev->dev,
1460         "A Bridge Port is already configured by a different operating system\n");
1461                         break;
1462                 case IPA_RC_SBP_OSA_ANO_DEV_PRIMARY:
1463                 case IPA_RC_SBP_IQD_ANO_DEV_PRIMARY:
1464                         switch (setcmd) {
1465                         case IPA_SBP_SET_PRIMARY_BRIDGE_PORT:
1466                                 rc = -EEXIST;
1467                                 dev_err(&card->gdev->dev,
1468         "The LAN already has a primary Bridge Port\n");
1469                                 break;
1470                         case IPA_SBP_SET_SECONDARY_BRIDGE_PORT:
1471                                 rc = -EBUSY;
1472                                 dev_err(&card->gdev->dev,
1473         "The device is already a primary Bridge Port\n");
1474                                 break;
1475                         default:
1476                                 rc = -EIO;
1477                         }
1478                         break;
1479                 case IPA_RC_SBP_OSA_CURRENT_SECOND:
1480                 case IPA_RC_SBP_IQD_CURRENT_SECOND:
1481                         rc = -EBUSY;
1482                         dev_err(&card->gdev->dev,
1483         "The device is already a secondary Bridge Port\n");
1484                         break;
1485                 case IPA_RC_SBP_OSA_LIMIT_SECOND:
1486                 case IPA_RC_SBP_IQD_LIMIT_SECOND:
1487                         rc = -EEXIST;
1488                         dev_err(&card->gdev->dev,
1489         "The LAN cannot have more secondary Bridge Ports\n");
1490                         break;
1491                 case IPA_RC_SBP_OSA_CURRENT_PRIMARY:
1492                 case IPA_RC_SBP_IQD_CURRENT_PRIMARY:
1493                         rc = -EBUSY;
1494                         dev_err(&card->gdev->dev,
1495         "The device is already a primary Bridge Port\n");
1496                         break;
1497                 case IPA_RC_SBP_OSA_NOT_AUTHD_BY_ZMAN:
1498                 case IPA_RC_SBP_IQD_NOT_AUTHD_BY_ZMAN:
1499                         rc = -EACCES;
1500                         dev_err(&card->gdev->dev,
1501         "The device is not authorized to be a Bridge Port\n");
1502                         break;
1503                 default:
1504                         rc = -EIO;
1505                 }
1506         else
1507                 switch (cbctl->ipa_rc) {
1508                 case IPA_RC_NOTSUPP:
1509                         rc = -EOPNOTSUPP;
1510                         break;
1511                 case IPA_RC_UNSUPPORTED_COMMAND:
1512                         rc = -EOPNOTSUPP;
1513                         break;
1514                 default:
1515                         rc = -EIO;
1516                 }
1517
1518         if (rc) {
1519                 QETH_CARD_TEXT_(card, 2, "SBPi%04x", cbctl->ipa_rc);
1520                 QETH_CARD_TEXT_(card, 2, "SBPc%04x", cbctl->cmd_rc);
1521         }
1522         return rc;
1523 }
1524
1525 static struct qeth_cmd_buffer *qeth_sbp_build_cmd(struct qeth_card *card,
1526                                                   enum qeth_ipa_sbp_cmd sbp_cmd,
1527                                                   unsigned int cmd_length)
1528 {
1529         enum qeth_ipa_cmds ipa_cmd = (card->info.type == QETH_CARD_TYPE_IQD) ?
1530                                         IPA_CMD_SETBRIDGEPORT_IQD :
1531                                         IPA_CMD_SETBRIDGEPORT_OSA;
1532         struct qeth_cmd_buffer *iob;
1533         struct qeth_ipa_cmd *cmd;
1534
1535         iob = qeth_get_ipacmd_buffer(card, ipa_cmd, 0);
1536         if (!iob)
1537                 return iob;
1538         cmd = __ipa_cmd(iob);
1539         cmd->data.sbp.hdr.cmdlength = sizeof(struct qeth_ipacmd_sbp_hdr) +
1540                                       cmd_length;
1541         cmd->data.sbp.hdr.command_code = sbp_cmd;
1542         cmd->data.sbp.hdr.used_total = 1;
1543         cmd->data.sbp.hdr.seq_no = 1;
1544         return iob;
1545 }
1546
1547 static int qeth_bridgeport_query_support_cb(struct qeth_card *card,
1548         struct qeth_reply *reply, unsigned long data)
1549 {
1550         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1551         struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1552         QETH_CARD_TEXT(card, 2, "brqsupcb");
1553         cbctl->ipa_rc = cmd->hdr.return_code;
1554         cbctl->cmd_rc = cmd->data.sbp.hdr.return_code;
1555         if ((cbctl->ipa_rc == 0) && (cbctl->cmd_rc == 0)) {
1556                 cbctl->data.supported =
1557                         cmd->data.sbp.data.query_cmds_supp.supported_cmds;
1558         } else {
1559                 cbctl->data.supported = 0;
1560         }
1561         return 0;
1562 }
1563
1564 /**
1565  * qeth_bridgeport_query_support() - store bitmask of supported subfunctions.
1566  * @card:                            qeth_card structure pointer.
1567  *
1568  * Sets bitmask of supported setbridgeport subfunctions in the qeth_card
1569  * strucutre: card->options.sbp.supported_funcs.
1570  */
1571 static void qeth_bridgeport_query_support(struct qeth_card *card)
1572 {
1573         struct qeth_cmd_buffer *iob;
1574         struct _qeth_sbp_cbctl cbctl;
1575
1576         QETH_CARD_TEXT(card, 2, "brqsuppo");
1577         iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_COMMANDS_SUPPORTED,
1578                                  sizeof(struct qeth_sbp_query_cmds_supp));
1579         if (!iob)
1580                 return;
1581         if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb,
1582                                                         (void *)&cbctl) ||
1583             qeth_bridgeport_makerc(card, &cbctl,
1584                                         IPA_SBP_QUERY_COMMANDS_SUPPORTED)) {
1585                 /* non-zero makerc signifies failure, and produce messages */
1586                 card->options.sbp.role = QETH_SBP_ROLE_NONE;
1587                 return;
1588         }
1589         card->options.sbp.supported_funcs = cbctl.data.supported;
1590 }
1591
1592 static int qeth_bridgeport_query_ports_cb(struct qeth_card *card,
1593         struct qeth_reply *reply, unsigned long data)
1594 {
1595         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1596         struct qeth_sbp_query_ports *qports = &cmd->data.sbp.data.query_ports;
1597         struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1598
1599         QETH_CARD_TEXT(card, 2, "brqprtcb");
1600         cbctl->ipa_rc = cmd->hdr.return_code;
1601         cbctl->cmd_rc = cmd->data.sbp.hdr.return_code;
1602         if ((cbctl->ipa_rc != 0) || (cbctl->cmd_rc != 0))
1603                 return 0;
1604         if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
1605                 cbctl->cmd_rc = 0xffff;
1606                 QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length);
1607                 return 0;
1608         }
1609         /* first entry contains the state of the local port */
1610         if (qports->num_entries > 0) {
1611                 if (cbctl->data.qports.role)
1612                         *cbctl->data.qports.role = qports->entry[0].role;
1613                 if (cbctl->data.qports.state)
1614                         *cbctl->data.qports.state = qports->entry[0].state;
1615         }
1616         return 0;
1617 }
1618
1619 /**
1620  * qeth_bridgeport_query_ports() - query local bridgeport status.
1621  * @card:                          qeth_card structure pointer.
1622  * @role:   Role of the port: 0-none, 1-primary, 2-secondary.
1623  * @state:  State of the port: 0-inactive, 1-standby, 2-active.
1624  *
1625  * Returns negative errno-compatible error indication or 0 on success.
1626  *
1627  * 'role' and 'state' are not updated in case of hardware operation failure.
1628  */
1629 int qeth_bridgeport_query_ports(struct qeth_card *card,
1630         enum qeth_sbp_roles *role, enum qeth_sbp_states *state)
1631 {
1632         int rc = 0;
1633         struct qeth_cmd_buffer *iob;
1634         struct _qeth_sbp_cbctl cbctl = {
1635                 .data = {
1636                         .qports = {
1637                                 .role = role,
1638                                 .state = state,
1639                         },
1640                 },
1641         };
1642
1643         QETH_CARD_TEXT(card, 2, "brqports");
1644         if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS))
1645                 return -EOPNOTSUPP;
1646         iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_BRIDGE_PORTS, 0);
1647         if (!iob)
1648                 return -ENOMEM;
1649         rc = qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb,
1650                                 (void *)&cbctl);
1651         if (rc < 0)
1652                 return rc;
1653         return qeth_bridgeport_makerc(card, &cbctl, IPA_SBP_QUERY_BRIDGE_PORTS);
1654 }
1655
1656 static int qeth_bridgeport_set_cb(struct qeth_card *card,
1657         struct qeth_reply *reply, unsigned long data)
1658 {
1659         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data;
1660         struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1661         QETH_CARD_TEXT(card, 2, "brsetrcb");
1662         cbctl->ipa_rc = cmd->hdr.return_code;
1663         cbctl->cmd_rc = cmd->data.sbp.hdr.return_code;
1664         return 0;
1665 }
1666
1667 /**
1668  * qeth_bridgeport_setrole() - Assign primary role to the port.
1669  * @card:                      qeth_card structure pointer.
1670  * @role:                      Role to assign.
1671  *
1672  * Returns negative errno-compatible error indication or 0 on success.
1673  */
1674 int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role)
1675 {
1676         int rc = 0;
1677         int cmdlength;
1678         struct qeth_cmd_buffer *iob;
1679         struct _qeth_sbp_cbctl cbctl;
1680         enum qeth_ipa_sbp_cmd setcmd;
1681
1682         QETH_CARD_TEXT(card, 2, "brsetrol");
1683         switch (role) {
1684         case QETH_SBP_ROLE_NONE:
1685                 setcmd = IPA_SBP_RESET_BRIDGE_PORT_ROLE;
1686                 cmdlength = sizeof(struct qeth_sbp_reset_role);
1687                 break;
1688         case QETH_SBP_ROLE_PRIMARY:
1689                 setcmd = IPA_SBP_SET_PRIMARY_BRIDGE_PORT;
1690                 cmdlength = sizeof(struct qeth_sbp_set_primary);
1691                 break;
1692         case QETH_SBP_ROLE_SECONDARY:
1693                 setcmd = IPA_SBP_SET_SECONDARY_BRIDGE_PORT;
1694                 cmdlength = sizeof(struct qeth_sbp_set_secondary);
1695                 break;
1696         default:
1697                 return -EINVAL;
1698         }
1699         if (!(card->options.sbp.supported_funcs & setcmd))
1700                 return -EOPNOTSUPP;
1701         iob = qeth_sbp_build_cmd(card, setcmd, cmdlength);
1702         if (!iob)
1703                 return -ENOMEM;
1704         rc = qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb,
1705                                 (void *)&cbctl);
1706         if (rc < 0)
1707                 return rc;
1708         return qeth_bridgeport_makerc(card, &cbctl, setcmd);
1709 }
1710
1711 /**
1712  * qeth_anset_makerc() - derive "traditional" error from hardware codes.
1713  * @card:                     qeth_card structure pointer, for debug messages.
1714  *
1715  * Returns negative errno-compatible error indication or 0 on success.
1716  */
1717 static int qeth_anset_makerc(struct qeth_card *card, int pnso_rc, u16 response)
1718 {
1719         int rc;
1720
1721         if (pnso_rc == 0)
1722                 switch (response) {
1723                 case 0x0001:
1724                         rc = 0;
1725                         break;
1726                 case 0x0004:
1727                 case 0x0100:
1728                 case 0x0106:
1729                         rc = -EOPNOTSUPP;
1730                         dev_err(&card->gdev->dev,
1731                                 "Setting address notification failed\n");
1732                         break;
1733                 case 0x0107:
1734                         rc = -EAGAIN;
1735                         break;
1736                 default:
1737                         rc = -EIO;
1738                 }
1739         else
1740                 rc = -EIO;
1741
1742         if (rc) {
1743                 QETH_CARD_TEXT_(card, 2, "SBPp%04x", pnso_rc);
1744                 QETH_CARD_TEXT_(card, 2, "SBPr%04x", response);
1745         }
1746         return rc;
1747 }
1748
1749 static void qeth_bridgeport_an_set_cb(void *priv,
1750                 enum qdio_brinfo_entry_type type, void *entry)
1751 {
1752         struct qeth_card *card = (struct qeth_card *)priv;
1753         struct qdio_brinfo_entry_l2 *l2entry;
1754         u8 code;
1755
1756         if (type != l2_addr_lnid) {
1757                 WARN_ON_ONCE(1);
1758                 return;
1759         }
1760
1761         l2entry = (struct qdio_brinfo_entry_l2 *)entry;
1762         code = IPA_ADDR_CHANGE_CODE_MACADDR;
1763         if (l2entry->addr_lnid.lnid)
1764                 code |= IPA_ADDR_CHANGE_CODE_VLANID;
1765         qeth_bridge_emit_host_event(card, anev_reg_unreg, code,
1766                 (struct net_if_token *)&l2entry->nit,
1767                 (struct mac_addr_lnid *)&l2entry->addr_lnid);
1768 }
1769
1770 /**
1771  * qeth_bridgeport_an_set() - Enable or disable bridgeport address notification
1772  * @card:                     qeth_card structure pointer.
1773  * @enable:                   0 - disable, non-zero - enable notifications
1774  *
1775  * Returns negative errno-compatible error indication or 0 on success.
1776  *
1777  * On enable, emits a series of address notifications udev events for all
1778  * currently registered hosts.
1779  */
1780 int qeth_bridgeport_an_set(struct qeth_card *card, int enable)
1781 {
1782         int rc;
1783         u16 response;
1784         struct ccw_device *ddev;
1785         struct subchannel_id schid;
1786
1787         if (!card)
1788                 return -EINVAL;
1789         if (!card->options.sbp.supported_funcs)
1790                 return -EOPNOTSUPP;
1791         ddev = CARD_DDEV(card);
1792         ccw_device_get_schid(ddev, &schid);
1793
1794         if (enable) {
1795                 qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL);
1796                 rc = qdio_pnso_brinfo(schid, 1, &response,
1797                         qeth_bridgeport_an_set_cb, card);
1798         } else
1799                 rc = qdio_pnso_brinfo(schid, 0, &response, NULL, NULL);
1800         return qeth_anset_makerc(card, rc, response);
1801 }
1802
1803 static bool qeth_bridgeport_is_in_use(struct qeth_card *card)
1804 {
1805         return (card->options.sbp.role || card->options.sbp.reflect_promisc ||
1806                 card->options.sbp.hostnotification);
1807 }
1808
1809 /* VNIC Characteristics support */
1810
1811 /* handle VNICC IPA command return codes; convert to error codes */
1812 static int qeth_l2_vnicc_makerc(struct qeth_card *card, int ipa_rc)
1813 {
1814         int rc;
1815
1816         switch (ipa_rc) {
1817         case IPA_RC_SUCCESS:
1818                 return ipa_rc;
1819         case IPA_RC_L2_UNSUPPORTED_CMD:
1820         case IPA_RC_NOTSUPP:
1821                 rc = -EOPNOTSUPP;
1822                 break;
1823         case IPA_RC_VNICC_OOSEQ:
1824                 rc = -EALREADY;
1825                 break;
1826         case IPA_RC_VNICC_VNICBP:
1827                 rc = -EBUSY;
1828                 break;
1829         case IPA_RC_L2_ADDR_TABLE_FULL:
1830                 rc = -ENOSPC;
1831                 break;
1832         case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
1833                 rc = -EACCES;
1834                 break;
1835         default:
1836                 rc = -EIO;
1837         }
1838
1839         QETH_CARD_TEXT_(card, 2, "err%04x", ipa_rc);
1840         return rc;
1841 }
1842
1843 /* generic VNICC request call back control */
1844 struct _qeth_l2_vnicc_request_cbctl {
1845         u32 sub_cmd;
1846         struct {
1847                 u32 vnic_char;
1848                 u32 timeout;
1849         } param;
1850         struct {
1851                 union{
1852                         u32 *sup_cmds;
1853                         u32 *timeout;
1854                 };
1855         } result;
1856 };
1857
1858 /* generic VNICC request call back */
1859 static int qeth_l2_vnicc_request_cb(struct qeth_card *card,
1860                                     struct qeth_reply *reply,
1861                                     unsigned long data)
1862 {
1863         struct _qeth_l2_vnicc_request_cbctl *cbctl =
1864                 (struct _qeth_l2_vnicc_request_cbctl *) reply->param;
1865         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1866         struct qeth_ipacmd_vnicc *rep = &cmd->data.vnicc;
1867
1868         QETH_CARD_TEXT(card, 2, "vniccrcb");
1869         if (cmd->hdr.return_code)
1870                 return 0;
1871         /* return results to caller */
1872         card->options.vnicc.sup_chars = rep->hdr.sup;
1873         card->options.vnicc.cur_chars = rep->hdr.cur;
1874
1875         if (cbctl->sub_cmd == IPA_VNICC_QUERY_CMDS)
1876                 *cbctl->result.sup_cmds = rep->query_cmds.sup_cmds;
1877
1878         if (cbctl->sub_cmd == IPA_VNICC_GET_TIMEOUT)
1879                 *cbctl->result.timeout = rep->getset_timeout.timeout;
1880
1881         return 0;
1882 }
1883
1884 /* generic VNICC request */
1885 static int qeth_l2_vnicc_request(struct qeth_card *card,
1886                                  struct _qeth_l2_vnicc_request_cbctl *cbctl)
1887 {
1888         struct qeth_ipacmd_vnicc *req;
1889         struct qeth_cmd_buffer *iob;
1890         struct qeth_ipa_cmd *cmd;
1891         int rc;
1892
1893         QETH_CARD_TEXT(card, 2, "vniccreq");
1894
1895         /* get new buffer for request */
1896         iob = qeth_get_ipacmd_buffer(card, IPA_CMD_VNICC, 0);
1897         if (!iob)
1898                 return -ENOMEM;
1899
1900         /* create header for request */
1901         cmd = __ipa_cmd(iob);
1902         req = &cmd->data.vnicc;
1903
1904         /* create sub command header for request */
1905         req->sub_hdr.data_length = sizeof(req->sub_hdr);
1906         req->sub_hdr.sub_command = cbctl->sub_cmd;
1907
1908         /* create sub command specific request fields */
1909         switch (cbctl->sub_cmd) {
1910         case IPA_VNICC_QUERY_CHARS:
1911                 break;
1912         case IPA_VNICC_QUERY_CMDS:
1913                 req->sub_hdr.data_length += sizeof(req->query_cmds);
1914                 req->query_cmds.vnic_char = cbctl->param.vnic_char;
1915                 break;
1916         case IPA_VNICC_ENABLE:
1917         case IPA_VNICC_DISABLE:
1918                 req->sub_hdr.data_length += sizeof(req->set_char);
1919                 req->set_char.vnic_char = cbctl->param.vnic_char;
1920                 break;
1921         case IPA_VNICC_SET_TIMEOUT:
1922                 req->getset_timeout.timeout = cbctl->param.timeout;
1923                 /* fallthrough */
1924         case IPA_VNICC_GET_TIMEOUT:
1925                 req->sub_hdr.data_length += sizeof(req->getset_timeout);
1926                 req->getset_timeout.vnic_char = cbctl->param.vnic_char;
1927                 break;
1928         default:
1929                 qeth_release_buffer(iob->channel, iob);
1930                 return -EOPNOTSUPP;
1931         }
1932
1933         /* send request */
1934         rc = qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb,
1935                                (void *) cbctl);
1936
1937         return qeth_l2_vnicc_makerc(card, rc);
1938 }
1939
1940 /* VNICC query VNIC characteristics request */
1941 static int qeth_l2_vnicc_query_chars(struct qeth_card *card)
1942 {
1943         struct _qeth_l2_vnicc_request_cbctl cbctl;
1944
1945         /* prepare callback control */
1946         cbctl.sub_cmd = IPA_VNICC_QUERY_CHARS;
1947
1948         QETH_CARD_TEXT(card, 2, "vniccqch");
1949         return qeth_l2_vnicc_request(card, &cbctl);
1950 }
1951
1952 /* VNICC query sub commands request */
1953 static int qeth_l2_vnicc_query_cmds(struct qeth_card *card, u32 vnic_char,
1954                                     u32 *sup_cmds)
1955 {
1956         struct _qeth_l2_vnicc_request_cbctl cbctl;
1957
1958         /* prepare callback control */
1959         cbctl.sub_cmd = IPA_VNICC_QUERY_CMDS;
1960         cbctl.param.vnic_char = vnic_char;
1961         cbctl.result.sup_cmds = sup_cmds;
1962
1963         QETH_CARD_TEXT(card, 2, "vniccqcm");
1964         return qeth_l2_vnicc_request(card, &cbctl);
1965 }
1966
1967 /* VNICC enable/disable characteristic request */
1968 static int qeth_l2_vnicc_set_char(struct qeth_card *card, u32 vnic_char,
1969                                       u32 cmd)
1970 {
1971         struct _qeth_l2_vnicc_request_cbctl cbctl;
1972
1973         /* prepare callback control */
1974         cbctl.sub_cmd = cmd;
1975         cbctl.param.vnic_char = vnic_char;
1976
1977         QETH_CARD_TEXT(card, 2, "vniccedc");
1978         return qeth_l2_vnicc_request(card, &cbctl);
1979 }
1980
1981 /* VNICC get/set timeout for characteristic request */
1982 static int qeth_l2_vnicc_getset_timeout(struct qeth_card *card, u32 vnicc,
1983                                         u32 cmd, u32 *timeout)
1984 {
1985         struct _qeth_l2_vnicc_request_cbctl cbctl;
1986
1987         /* prepare callback control */
1988         cbctl.sub_cmd = cmd;
1989         cbctl.param.vnic_char = vnicc;
1990         if (cmd == IPA_VNICC_SET_TIMEOUT)
1991                 cbctl.param.timeout = *timeout;
1992         if (cmd == IPA_VNICC_GET_TIMEOUT)
1993                 cbctl.result.timeout = timeout;
1994
1995         QETH_CARD_TEXT(card, 2, "vniccgst");
1996         return qeth_l2_vnicc_request(card, &cbctl);
1997 }
1998
1999 /* set current VNICC flag state; called from sysfs store function */
2000 int qeth_l2_vnicc_set_state(struct qeth_card *card, u32 vnicc, bool state)
2001 {
2002         int rc = 0;
2003         u32 cmd;
2004
2005         QETH_CARD_TEXT(card, 2, "vniccsch");
2006
2007         /* do not change anything if BridgePort is enabled */
2008         if (qeth_bridgeport_is_in_use(card))
2009                 return -EBUSY;
2010
2011         /* check if characteristic and enable/disable are supported */
2012         if (!(card->options.vnicc.sup_chars & vnicc) ||
2013             !(card->options.vnicc.set_char_sup & vnicc))
2014                 return -EOPNOTSUPP;
2015
2016         /* set enable/disable command and store wanted characteristic */
2017         if (state) {
2018                 cmd = IPA_VNICC_ENABLE;
2019                 card->options.vnicc.wanted_chars |= vnicc;
2020         } else {
2021                 cmd = IPA_VNICC_DISABLE;
2022                 card->options.vnicc.wanted_chars &= ~vnicc;
2023         }
2024
2025         /* do we need to do anything? */
2026         if (card->options.vnicc.cur_chars == card->options.vnicc.wanted_chars)
2027                 return rc;
2028
2029         /* if card is not ready, simply stop here */
2030         if (!qeth_card_hw_is_reachable(card)) {
2031                 if (state)
2032                         card->options.vnicc.cur_chars |= vnicc;
2033                 else
2034                         card->options.vnicc.cur_chars &= ~vnicc;
2035                 return rc;
2036         }
2037
2038         rc = qeth_l2_vnicc_set_char(card, vnicc, cmd);
2039         if (rc)
2040                 card->options.vnicc.wanted_chars =
2041                         card->options.vnicc.cur_chars;
2042         else {
2043                 /* successful online VNICC change; handle special cases */
2044                 if (state && vnicc == QETH_VNICC_RX_BCAST)
2045                         card->options.vnicc.rx_bcast_enabled = true;
2046                 if (!state && vnicc == QETH_VNICC_LEARNING)
2047                         qeth_l2_vnicc_recover_timeout(card, vnicc,
2048                                         &card->options.vnicc.learning_timeout);
2049         }
2050
2051         return rc;
2052 }
2053
2054 /* get current VNICC flag state; called from sysfs show function */
2055 int qeth_l2_vnicc_get_state(struct qeth_card *card, u32 vnicc, bool *state)
2056 {
2057         int rc = 0;
2058
2059         QETH_CARD_TEXT(card, 2, "vniccgch");
2060
2061         /* do not get anything if BridgePort is enabled */
2062         if (qeth_bridgeport_is_in_use(card))
2063                 return -EBUSY;
2064
2065         /* check if characteristic is supported */
2066         if (!(card->options.vnicc.sup_chars & vnicc))
2067                 return -EOPNOTSUPP;
2068
2069         /* if card is ready, query current VNICC state */
2070         if (qeth_card_hw_is_reachable(card))
2071                 rc = qeth_l2_vnicc_query_chars(card);
2072
2073         *state = (card->options.vnicc.cur_chars & vnicc) ? true : false;
2074         return rc;
2075 }
2076
2077 /* set VNICC timeout; called from sysfs store function. Currently, only learning
2078  * supports timeout
2079  */
2080 int qeth_l2_vnicc_set_timeout(struct qeth_card *card, u32 timeout)
2081 {
2082         int rc = 0;
2083
2084         QETH_CARD_TEXT(card, 2, "vniccsto");
2085
2086         /* do not change anything if BridgePort is enabled */
2087         if (qeth_bridgeport_is_in_use(card))
2088                 return -EBUSY;
2089
2090         /* check if characteristic and set_timeout are supported */
2091         if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
2092             !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
2093                 return -EOPNOTSUPP;
2094
2095         /* do we need to do anything? */
2096         if (card->options.vnicc.learning_timeout == timeout)
2097                 return rc;
2098
2099         /* if card is not ready, simply store the value internally and return */
2100         if (!qeth_card_hw_is_reachable(card)) {
2101                 card->options.vnicc.learning_timeout = timeout;
2102                 return rc;
2103         }
2104
2105         /* send timeout value to card; if successful, store value internally */
2106         rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
2107                                           IPA_VNICC_SET_TIMEOUT, &timeout);
2108         if (!rc)
2109                 card->options.vnicc.learning_timeout = timeout;
2110
2111         return rc;
2112 }
2113
2114 /* get current VNICC timeout; called from sysfs show function. Currently, only
2115  * learning supports timeout
2116  */
2117 int qeth_l2_vnicc_get_timeout(struct qeth_card *card, u32 *timeout)
2118 {
2119         int rc = 0;
2120
2121         QETH_CARD_TEXT(card, 2, "vniccgto");
2122
2123         /* do not get anything if BridgePort is enabled */
2124         if (qeth_bridgeport_is_in_use(card))
2125                 return -EBUSY;
2126
2127         /* check if characteristic and get_timeout are supported */
2128         if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
2129             !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
2130                 return -EOPNOTSUPP;
2131         /* if card is ready, get timeout. Otherwise, just return stored value */
2132         *timeout = card->options.vnicc.learning_timeout;
2133         if (qeth_card_hw_is_reachable(card))
2134                 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
2135                                                   IPA_VNICC_GET_TIMEOUT,
2136                                                   timeout);
2137
2138         return rc;
2139 }
2140
2141 /* check if VNICC is currently enabled */
2142 bool qeth_l2_vnicc_is_in_use(struct qeth_card *card)
2143 {
2144         /* if everything is turned off, VNICC is not active */
2145         if (!card->options.vnicc.cur_chars)
2146                 return false;
2147         /* default values are only OK if rx_bcast was not enabled by user
2148          * or the card is offline.
2149          */
2150         if (card->options.vnicc.cur_chars == QETH_VNICC_DEFAULT) {
2151                 if (!card->options.vnicc.rx_bcast_enabled ||
2152                     !qeth_card_hw_is_reachable(card))
2153                         return false;
2154         }
2155         return true;
2156 }
2157
2158 /* recover user timeout setting */
2159 static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
2160                                           u32 *timeout)
2161 {
2162         if (card->options.vnicc.sup_chars & vnicc &&
2163             card->options.vnicc.getset_timeout_sup & vnicc &&
2164             !qeth_l2_vnicc_getset_timeout(card, vnicc, IPA_VNICC_SET_TIMEOUT,
2165                                           timeout))
2166                 return false;
2167         *timeout = QETH_VNICC_DEFAULT_TIMEOUT;
2168         return true;
2169 }
2170
2171 /* recover user characteristic setting */
2172 static bool qeth_l2_vnicc_recover_char(struct qeth_card *card, u32 vnicc,
2173                                        bool enable)
2174 {
2175         u32 cmd = enable ? IPA_VNICC_ENABLE : IPA_VNICC_DISABLE;
2176
2177         if (card->options.vnicc.sup_chars & vnicc &&
2178             card->options.vnicc.set_char_sup & vnicc &&
2179             !qeth_l2_vnicc_set_char(card, vnicc, cmd))
2180                 return false;
2181         card->options.vnicc.wanted_chars &= ~vnicc;
2182         card->options.vnicc.wanted_chars |= QETH_VNICC_DEFAULT & vnicc;
2183         return true;
2184 }
2185
2186 /* (re-)initialize VNICC */
2187 static void qeth_l2_vnicc_init(struct qeth_card *card)
2188 {
2189         u32 *timeout = &card->options.vnicc.learning_timeout;
2190         unsigned int chars_len, i;
2191         unsigned long chars_tmp;
2192         u32 sup_cmds, vnicc;
2193         bool enable, error;
2194
2195         QETH_CARD_TEXT(card, 2, "vniccini");
2196         /* reset rx_bcast */
2197         card->options.vnicc.rx_bcast_enabled = 0;
2198         /* initial query and storage of VNIC characteristics */
2199         if (qeth_l2_vnicc_query_chars(card)) {
2200                 if (card->options.vnicc.wanted_chars != QETH_VNICC_DEFAULT ||
2201                     *timeout != QETH_VNICC_DEFAULT_TIMEOUT)
2202                         dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
2203                 /* fail quietly if user didn't change the default config */
2204                 card->options.vnicc.sup_chars = 0;
2205                 card->options.vnicc.cur_chars = 0;
2206                 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
2207                 return;
2208         }
2209         /* get supported commands for each supported characteristic */
2210         chars_tmp = card->options.vnicc.sup_chars;
2211         chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE;
2212         for_each_set_bit(i, &chars_tmp, chars_len) {
2213                 vnicc = BIT(i);
2214                 qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds);
2215                 if (!(sup_cmds & IPA_VNICC_SET_TIMEOUT) ||
2216                     !(sup_cmds & IPA_VNICC_GET_TIMEOUT))
2217                         card->options.vnicc.getset_timeout_sup &= ~vnicc;
2218                 if (!(sup_cmds & IPA_VNICC_ENABLE) ||
2219                     !(sup_cmds & IPA_VNICC_DISABLE))
2220                         card->options.vnicc.set_char_sup &= ~vnicc;
2221         }
2222         /* enforce assumed default values and recover settings, if changed  */
2223         error = qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING,
2224                                               timeout);
2225         chars_tmp = card->options.vnicc.wanted_chars ^ QETH_VNICC_DEFAULT;
2226         chars_tmp |= QETH_VNICC_BRIDGE_INVISIBLE;
2227         chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE;
2228         for_each_set_bit(i, &chars_tmp, chars_len) {
2229                 vnicc = BIT(i);
2230                 enable = card->options.vnicc.wanted_chars & vnicc;
2231                 error |= qeth_l2_vnicc_recover_char(card, vnicc, enable);
2232         }
2233         if (error)
2234                 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
2235 }
2236
2237 /* configure default values of VNIC characteristics */
2238 static void qeth_l2_vnicc_set_defaults(struct qeth_card *card)
2239 {
2240         /* characteristics values */
2241         card->options.vnicc.sup_chars = QETH_VNICC_ALL;
2242         card->options.vnicc.cur_chars = QETH_VNICC_DEFAULT;
2243         card->options.vnicc.learning_timeout = QETH_VNICC_DEFAULT_TIMEOUT;
2244         /* supported commands */
2245         card->options.vnicc.set_char_sup = QETH_VNICC_ALL;
2246         card->options.vnicc.getset_timeout_sup = QETH_VNICC_LEARNING;
2247         /* settings wanted by users */
2248         card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
2249 }
2250
2251 module_init(qeth_l2_init);
2252 module_exit(qeth_l2_exit);
2253 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
2254 MODULE_DESCRIPTION("qeth layer 2 discipline");
2255 MODULE_LICENSE("GPL");