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