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