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