drivers/s390/net/qeth_l2_main.c

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