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