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 <[email protected]>,
   5  *               Frank Pavlic <[email protected]>,
   6  *               Thomas Spatzier <[email protected]>,
   7  *               Frank Blaschka <[email protected]>
   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/chsc.h>
  24 #include <asm/setup.h>
  25 #include "qeth_core.h"
  26 #include "qeth_l2.h"
  27
  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_addr_change_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 = -EADDRINUSE;
  57                 break;
  58         case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP:
  59         case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
  60                 rc = -EADDRNOTAVAIL;
  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 -EADDRINUSE:
 110                         dev_warn(&card->gdev->dev,
 111                                 "MAC address %pM already exists\n", mac);
 112                         break;
 113                 case -EADDRNOTAVAIL:
 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 == -EADDRINUSE)
 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                 qeth_drain_output_queues(card);
 288                 cancel_delayed_work_sync(&card->buffer_reclaim_work);
 289                 card->state = CARD_STATE_DOWN;
 290         }
 291
 292         qeth_qdio_clear_card(card, 0);
 293         qeth_clear_working_pool_list(card);
 294         flush_workqueue(card->event_wq);
 295         qeth_flush_local_addrs(card);
 296         card->info.promisc_mode = 0;
 297 }
 298
 299 static int qeth_l2_request_initial_mac(struct qeth_card *card)
 300 {
 301         int rc = 0;
 302
 303         QETH_CARD_TEXT(card, 2, "l2reqmac");
 304
 305         if (MACHINE_IS_VM) {
 306                 rc = qeth_vm_request_mac(card);
 307                 if (!rc)
 308                         goto out;
 309                 QETH_DBF_MESSAGE(2, "z/VM MAC Service failed on device %x: %#x\n",
 310                                  CARD_DEVID(card), rc);
 311                 QETH_CARD_TEXT_(card, 2, "err%04x", rc);
 312                 /* fall back to alternative mechanism: */
 313         }
 314
 315         if (!IS_OSN(card)) {
 316                 rc = qeth_setadpparms_change_macaddr(card);
 317                 if (!rc)
 318                         goto out;
 319                 QETH_DBF_MESSAGE(2, "READ_MAC Assist failed on device %x: %#x\n",
 320                                  CARD_DEVID(card), rc);
 321                 QETH_CARD_TEXT_(card, 2, "1err%04x", rc);
 322                 /* fall back once more: */
 323         }
 324
 325         /* some devices don't support a custom MAC address: */
 326         if (IS_OSM(card) || IS_OSX(card))
 327                 return (rc) ? rc : -EADDRNOTAVAIL;
 328         eth_hw_addr_random(card->dev);
 329
 330 out:
 331         QETH_CARD_HEX(card, 2, card->dev->dev_addr, card->dev->addr_len);
 332         return 0;
 333 }
 334
 335 static void qeth_l2_register_dev_addr(struct qeth_card *card)
 336 {
 337         if (!is_valid_ether_addr(card->dev->dev_addr))
 338                 qeth_l2_request_initial_mac(card);
 339
 340         if (!IS_OSN(card) && !qeth_l2_send_setmac(card, card->dev->dev_addr))
 341                 card->info.dev_addr_is_registered = 1;
 342         else
 343                 card->info.dev_addr_is_registered = 0;
 344 }
 345
 346 static int qeth_l2_validate_addr(struct net_device *dev)
 347 {
 348         struct qeth_card *card = dev->ml_priv;
 349
 350         if (card->info.dev_addr_is_registered)
 351                 return eth_validate_addr(dev);
 352
 353         QETH_CARD_TEXT(card, 4, "nomacadr");
 354         return -EPERM;
 355 }
 356
 357 static int qeth_l2_set_mac_address(struct net_device *dev, void *p)
 358 {
 359         struct sockaddr *addr = p;
 360         struct qeth_card *card = dev->ml_priv;
 361         u8 old_addr[ETH_ALEN];
 362         int rc = 0;
 363
 364         QETH_CARD_TEXT(card, 3, "setmac");
 365
 366         if (IS_OSM(card) || IS_OSX(card)) {
 367                 QETH_CARD_TEXT(card, 3, "setmcTYP");
 368                 return -EOPNOTSUPP;
 369         }
 370         QETH_CARD_HEX(card, 3, addr->sa_data, ETH_ALEN);
 371         if (!is_valid_ether_addr(addr->sa_data))
 372                 return -EADDRNOTAVAIL;
 373
 374         /* don't register the same address twice */
 375         if (ether_addr_equal_64bits(dev->dev_addr, addr->sa_data) &&
 376             card->info.dev_addr_is_registered)
 377                 return 0;
 378
 379         /* add the new address, switch over, drop the old */
 380         rc = qeth_l2_send_setmac(card, addr->sa_data);
 381         if (rc)
 382                 return rc;
 383         ether_addr_copy(old_addr, dev->dev_addr);
 384         ether_addr_copy(dev->dev_addr, addr->sa_data);
 385
 386         if (card->info.dev_addr_is_registered)
 387                 qeth_l2_remove_mac(card, old_addr);
 388         card->info.dev_addr_is_registered = 1;
 389         return 0;
 390 }
 391
 392 static void qeth_l2_promisc_to_bridge(struct qeth_card *card, bool enable)
 393 {
 394         int role;
 395         int rc;
 396
 397         QETH_CARD_TEXT(card, 3, "pmisc2br");
 398
 399         if (enable) {
 400                 if (card->options.sbp.reflect_promisc_primary)
 401                         role = QETH_SBP_ROLE_PRIMARY;
 402                 else
 403                         role = QETH_SBP_ROLE_SECONDARY;
 404         } else
 405                 role = QETH_SBP_ROLE_NONE;
 406
 407         rc = qeth_bridgeport_setrole(card, role);
 408         QETH_CARD_TEXT_(card, 2, "bpm%c%04x", enable ? '+' : '-', rc);
 409         if (!rc) {
 410                 card->options.sbp.role = role;
 411                 card->info.promisc_mode = enable;
 412         }
 413 }
 414
 415 static void qeth_l2_set_promisc_mode(struct qeth_card *card)
 416 {
 417         bool enable = card->dev->flags & IFF_PROMISC;
 418
 419         if (card->info.promisc_mode == enable)
 420                 return;
 421
 422         if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE)) {
 423                 qeth_setadp_promisc_mode(card, enable);
 424         } else {
 425                 mutex_lock(&card->sbp_lock);
 426                 if (card->options.sbp.reflect_promisc)
 427                         qeth_l2_promisc_to_bridge(card, enable);
 428                 mutex_unlock(&card->sbp_lock);
 429         }
 430 }
 431
 432 /* New MAC address is added to the hash table and marked to be written on card
 433  * only if there is not in the hash table storage already
 434  *
 435 */
 436 static void qeth_l2_add_mac(struct qeth_card *card, struct netdev_hw_addr *ha)
 437 {
 438         u32 mac_hash = get_unaligned((u32 *)(&ha->addr[2]));
 439         struct qeth_mac *mac;
 440
 441         hash_for_each_possible(card->mac_htable, mac, hnode, mac_hash) {
 442                 if (ether_addr_equal_64bits(ha->addr, mac->mac_addr)) {
 443                         mac->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
 444                         return;
 445                 }
 446         }
 447
 448         mac = kzalloc(sizeof(struct qeth_mac), GFP_ATOMIC);
 449         if (!mac)
 450                 return;
 451
 452         ether_addr_copy(mac->mac_addr, ha->addr);
 453         mac->disp_flag = QETH_DISP_ADDR_ADD;
 454
 455         hash_add(card->mac_htable, &mac->hnode, mac_hash);
 456 }
 457
 458 static void qeth_l2_rx_mode_work(struct work_struct *work)
 459 {
 460         struct qeth_card *card = container_of(work, struct qeth_card,
 461                                               rx_mode_work);
 462         struct net_device *dev = card->dev;
 463         struct netdev_hw_addr *ha;
 464         struct qeth_mac *mac;
 465         struct hlist_node *tmp;
 466         int i;
 467         int rc;
 468
 469         QETH_CARD_TEXT(card, 3, "setmulti");
 470
 471         netif_addr_lock_bh(dev);
 472         netdev_for_each_mc_addr(ha, dev)
 473                 qeth_l2_add_mac(card, ha);
 474         netdev_for_each_uc_addr(ha, dev)
 475                 qeth_l2_add_mac(card, ha);
 476         netif_addr_unlock_bh(dev);
 477
 478         hash_for_each_safe(card->mac_htable, i, tmp, mac, hnode) {
 479                 switch (mac->disp_flag) {
 480                 case QETH_DISP_ADDR_DELETE:
 481                         qeth_l2_remove_mac(card, mac->mac_addr);
 482                         hash_del(&mac->hnode);
 483                         kfree(mac);
 484                         break;
 485                 case QETH_DISP_ADDR_ADD:
 486                         rc = qeth_l2_write_mac(card, mac->mac_addr);
 487                         if (rc) {
 488                                 hash_del(&mac->hnode);
 489                                 kfree(mac);
 490                                 break;
 491                         }
 492                         /* fall through */
 493                 default:
 494                         /* for next call to set_rx_mode(): */
 495                         mac->disp_flag = QETH_DISP_ADDR_DELETE;
 496                 }
 497         }
 498
 499         qeth_l2_set_promisc_mode(card);
 500 }
 501
 502 static int qeth_l2_xmit_osn(struct qeth_card *card, struct sk_buff *skb,
 503                             struct qeth_qdio_out_q *queue)
 504 {
 505         gfp_t gfp = GFP_ATOMIC | (skb_pfmemalloc(skb) ? __GFP_MEMALLOC : 0);
 506         struct qeth_hdr *hdr = (struct qeth_hdr *)skb->data;
 507         addr_t end = (addr_t)(skb->data + sizeof(*hdr));
 508         addr_t start = (addr_t)skb->data;
 509         unsigned int elements = 0;
 510         unsigned int hd_len = 0;
 511         int rc;
 512
 513         if (skb->protocol == htons(ETH_P_IPV6))
 514                 return -EPROTONOSUPPORT;
 515
 516         if (qeth_get_elements_for_range(start, end) > 1) {
 517                 /* Misaligned HW header, move it to its own buffer element. */
 518                 hdr = kmem_cache_alloc(qeth_core_header_cache, gfp);
 519                 if (!hdr)
 520                         return -ENOMEM;
 521                 hd_len = sizeof(*hdr);
 522                 skb_copy_from_linear_data(skb, (char *)hdr, hd_len);
 523                 elements++;
 524         }
 525
 526         elements += qeth_count_elements(skb, hd_len);
 527         if (elements > queue->max_elements) {
 528                 rc = -E2BIG;
 529                 goto out;
 530         }
 531
 532         rc = qeth_do_send_packet(card, queue, skb, hdr, hd_len, hd_len,
 533                                  elements);
 534 out:
 535         if (rc && hd_len)
 536                 kmem_cache_free(qeth_core_header_cache, hdr);
 537         return rc;
 538 }
 539
 540 static netdev_tx_t qeth_l2_hard_start_xmit(struct sk_buff *skb,
 541                                            struct net_device *dev)
 542 {
 543         struct qeth_card *card = dev->ml_priv;
 544         u16 txq = skb_get_queue_mapping(skb);
 545         struct qeth_qdio_out_q *queue;
 546         int rc;
 547
 548         if (!skb_is_gso(skb))
 549                 qdisc_skb_cb(skb)->pkt_len = skb->len;
 550         if (IS_IQD(card))
 551                 txq = qeth_iqd_translate_txq(dev, txq);
 552         queue = card->qdio.out_qs[txq];
 553
 554         if (IS_OSN(card))
 555                 rc = qeth_l2_xmit_osn(card, skb, queue);
 556         else
 557                 rc = qeth_xmit(card, skb, queue, qeth_get_ip_version(skb),
 558                                qeth_l2_fill_header);
 559
 560         if (!rc)
 561                 return NETDEV_TX_OK;
 562
 563         QETH_TXQ_STAT_INC(queue, tx_dropped);
 564         kfree_skb(skb);
 565         return NETDEV_TX_OK;
 566 }
 567
 568 static u16 qeth_l2_select_queue(struct net_device *dev, struct sk_buff *skb,
 569                                 struct net_device *sb_dev)
 570 {
 571         struct qeth_card *card = dev->ml_priv;
 572
 573         if (IS_IQD(card))
 574                 return qeth_iqd_select_queue(dev, skb,
 575                                              qeth_get_ether_cast_type(skb),
 576                                              sb_dev);
 577
 578         return IS_VM_NIC(card) ? netdev_pick_tx(dev, skb, sb_dev) :
 579                                  qeth_get_priority_queue(card, skb);
 580 }
 581
 582 static const struct device_type qeth_l2_devtype = {
 583         .name = "qeth_layer2",
 584         .groups = qeth_l2_attr_groups,
 585 };
 586
 587 static int qeth_l2_probe_device(struct ccwgroup_device *gdev)
 588 {
 589         struct qeth_card *card = dev_get_drvdata(&gdev->dev);
 590         int rc;
 591
 592         if (IS_OSN(card))
 593                 dev_notice(&gdev->dev, "OSN support will be dropped in 2021\n");
 594
 595         qeth_l2_vnicc_set_defaults(card);
 596         mutex_init(&card->sbp_lock);
 597
 598         if (gdev->dev.type == &qeth_generic_devtype) {
 599                 rc = qeth_l2_create_device_attributes(&gdev->dev);
 600                 if (rc)
 601                         return rc;
 602         }
 603
 604         hash_init(card->mac_htable);
 605         INIT_WORK(&card->rx_mode_work, qeth_l2_rx_mode_work);
 606         return 0;
 607 }
 608
 609 static void qeth_l2_remove_device(struct ccwgroup_device *cgdev)
 610 {
 611         struct qeth_card *card = dev_get_drvdata(&cgdev->dev);
 612
 613         if (cgdev->dev.type == &qeth_generic_devtype)
 614                 qeth_l2_remove_device_attributes(&cgdev->dev);
 615         qeth_set_allowed_threads(card, 0, 1);
 616         wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
 617
 618         if (cgdev->state == CCWGROUP_ONLINE)
 619                 qeth_set_offline(card, false);
 620
 621         cancel_work_sync(&card->close_dev_work);
 622         if (card->dev->reg_state == NETREG_REGISTERED)
 623                 unregister_netdev(card->dev);
 624 }
 625
 626 static void qeth_l2_set_rx_mode(struct net_device *dev)
 627 {
 628         struct qeth_card *card = dev->ml_priv;
 629
 630         schedule_work(&card->rx_mode_work);
 631 }
 632
 633 /**
 634  *      qeth_l2_pnso() - perform network subchannel operation
 635  *      @card: qeth_card structure pointer
 636  *      @cnc: Boolean Change-Notification Control
 637  *      @cb: Callback function will be executed for each element
 638  *              of the address list
 639  *      @priv: Pointer to pass to the callback function.
 640  *
 641  *      Collects network information in a network address list and calls the
 642  *      callback function for every entry in the list. If "change-notification-
 643  *      control" is set, further changes in the address list will be reported
 644  *      via the IPA command.
 645  */
 646 static int qeth_l2_pnso(struct qeth_card *card, int cnc,
 647                         void (*cb)(void *priv, struct chsc_pnso_naid_l2 *entry),
 648                         void *priv)
 649 {
 650         struct ccw_device *ddev = CARD_DDEV(card);
 651         struct chsc_pnso_area *rr;
 652         u32 prev_instance = 0;
 653         int isfirstblock = 1;
 654         int i, size, elems;
 655         int rc;
 656
 657         QETH_CARD_TEXT(card, 2, "PNSO");
 658         rr = (struct chsc_pnso_area *)get_zeroed_page(GFP_KERNEL);
 659         if (rr == NULL)
 660                 return -ENOMEM;
 661         do {
 662                 /* on the first iteration, naihdr.resume_token will be zero */
 663                 rc = ccw_device_pnso(ddev, rr, rr->naihdr.resume_token, cnc);
 664                 if (rc)
 665                         continue;
 666                 if (cb == NULL)
 667                         continue;
 668
 669                 size = rr->naihdr.naids;
 670                 if (size != sizeof(struct chsc_pnso_naid_l2)) {
 671                         WARN_ON_ONCE(1);
 672                         continue;
 673                 }
 674
 675                 elems = (rr->response.length - sizeof(struct chsc_header) -
 676                          sizeof(struct chsc_pnso_naihdr)) / size;
 677
 678                 if (!isfirstblock && (rr->naihdr.instance != prev_instance)) {
 679                         /* Inform the caller that they need to scrap */
 680                         /* the data that was already reported via cb */
 681                         rc = -EAGAIN;
 682                         break;
 683                 }
 684                 isfirstblock = 0;
 685                 prev_instance = rr->naihdr.instance;
 686                 for (i = 0; i < elems; i++)
 687                         (*cb)(priv, &rr->entries[i]);
 688         } while ((rc == -EBUSY) || (!rc && /* list stored */
 689                    /* resume token is non-zero => list incomplete */
 690                    (rr->naihdr.resume_token.t1 || rr->naihdr.resume_token.t2)));
 691
 692         if (rc)
 693                 QETH_CARD_TEXT_(card, 2, "PNrp%04x", rr->response.code);
 694
 695         free_page((unsigned long)rr);
 696         return rc;
 697 }
 698
 699 static const struct net_device_ops qeth_l2_netdev_ops = {
 700         .ndo_open               = qeth_open,
 701         .ndo_stop               = qeth_stop,
 702         .ndo_get_stats64        = qeth_get_stats64,
 703         .ndo_start_xmit         = qeth_l2_hard_start_xmit,
 704         .ndo_features_check     = qeth_features_check,
 705         .ndo_select_queue       = qeth_l2_select_queue,
 706         .ndo_validate_addr      = qeth_l2_validate_addr,
 707         .ndo_set_rx_mode        = qeth_l2_set_rx_mode,
 708         .ndo_do_ioctl           = qeth_do_ioctl,
 709         .ndo_set_mac_address    = qeth_l2_set_mac_address,
 710         .ndo_vlan_rx_add_vid    = qeth_l2_vlan_rx_add_vid,
 711         .ndo_vlan_rx_kill_vid   = qeth_l2_vlan_rx_kill_vid,
 712         .ndo_tx_timeout         = qeth_tx_timeout,
 713         .ndo_fix_features       = qeth_fix_features,
 714         .ndo_set_features       = qeth_set_features
 715 };
 716
 717 static const struct net_device_ops qeth_osn_netdev_ops = {
 718         .ndo_open               = qeth_open,
 719         .ndo_stop               = qeth_stop,
 720         .ndo_get_stats64        = qeth_get_stats64,
 721         .ndo_start_xmit         = qeth_l2_hard_start_xmit,
 722         .ndo_validate_addr      = eth_validate_addr,
 723         .ndo_tx_timeout         = qeth_tx_timeout,
 724 };
 725
 726 static int qeth_l2_setup_netdev(struct qeth_card *card)
 727 {
 728         int rc;
 729
 730         if (IS_OSN(card)) {
 731                 card->dev->netdev_ops = &qeth_osn_netdev_ops;
 732                 card->dev->flags |= IFF_NOARP;
 733                 goto add_napi;
 734         }
 735
 736         rc = qeth_setup_netdev(card);
 737         if (rc)
 738                 return rc;
 739
 740         card->dev->needed_headroom = sizeof(struct qeth_hdr);
 741         card->dev->netdev_ops = &qeth_l2_netdev_ops;
 742         card->dev->priv_flags |= IFF_UNICAST_FLT;
 743
 744         if (IS_OSM(card)) {
 745                 card->dev->features |= NETIF_F_VLAN_CHALLENGED;
 746         } else {
 747                 if (!IS_VM_NIC(card))
 748                         card->dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
 749                 card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
 750         }
 751
 752         if (IS_OSD(card) && !IS_VM_NIC(card)) {
 753                 card->dev->features |= NETIF_F_SG;
 754                 /* OSA 3S and earlier has no RX/TX support */
 755                 if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) {
 756                         card->dev->hw_features |= NETIF_F_IP_CSUM;
 757                         card->dev->vlan_features |= NETIF_F_IP_CSUM;
 758                 }
 759         }
 760         if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) {
 761                 card->dev->hw_features |= NETIF_F_IPV6_CSUM;
 762                 card->dev->vlan_features |= NETIF_F_IPV6_CSUM;
 763         }
 764         if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM) ||
 765             qeth_is_supported6(card, IPA_INBOUND_CHECKSUM_V6)) {
 766                 card->dev->hw_features |= NETIF_F_RXCSUM;
 767                 card->dev->vlan_features |= NETIF_F_RXCSUM;
 768         }
 769         if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
 770                 card->dev->hw_features |= NETIF_F_TSO;
 771                 card->dev->vlan_features |= NETIF_F_TSO;
 772         }
 773         if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) {
 774                 card->dev->hw_features |= NETIF_F_TSO6;
 775                 card->dev->vlan_features |= NETIF_F_TSO6;
 776         }
 777
 778         if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6)) {
 779                 card->dev->needed_headroom = sizeof(struct qeth_hdr_tso);
 780                 netif_keep_dst(card->dev);
 781                 netif_set_gso_max_size(card->dev,
 782                                        PAGE_SIZE * (QDIO_MAX_ELEMENTS_PER_BUFFER - 1));
 783         }
 784
 785 add_napi:
 786         netif_napi_add(card->dev, &card->napi, qeth_poll, QETH_NAPI_WEIGHT);
 787         return register_netdev(card->dev);
 788 }
 789
 790 static void qeth_l2_trace_features(struct qeth_card *card)
 791 {
 792         /* Set BridgePort features */
 793         QETH_CARD_TEXT(card, 2, "featuSBP");
 794         QETH_CARD_HEX(card, 2, &card->options.sbp.supported_funcs,
 795                       sizeof(card->options.sbp.supported_funcs));
 796         /* VNIC Characteristics features */
 797         QETH_CARD_TEXT(card, 2, "feaVNICC");
 798         QETH_CARD_HEX(card, 2, &card->options.vnicc.sup_chars,
 799                       sizeof(card->options.vnicc.sup_chars));
 800 }
 801
 802 static void qeth_l2_setup_bridgeport_attrs(struct qeth_card *card)
 803 {
 804         if (!card->options.sbp.reflect_promisc &&
 805             card->options.sbp.role != QETH_SBP_ROLE_NONE) {
 806                 /* Conditional to avoid spurious error messages */
 807                 qeth_bridgeport_setrole(card, card->options.sbp.role);
 808                 /* Let the callback function refresh the stored role value. */
 809                 qeth_bridgeport_query_ports(card, &card->options.sbp.role,
 810                                             NULL);
 811         }
 812         if (card->options.sbp.hostnotification) {
 813                 if (qeth_bridgeport_an_set(card, 1))
 814                         card->options.sbp.hostnotification = 0;
 815         } else {
 816                 qeth_bridgeport_an_set(card, 0);
 817         }
 818 }
 819
 820 static int qeth_l2_set_online(struct qeth_card *card)
 821 {
 822         struct ccwgroup_device *gdev = card->gdev;
 823         struct net_device *dev = card->dev;
 824         int rc = 0;
 825         bool carrier_ok;
 826
 827         rc = qeth_core_hardsetup_card(card, &carrier_ok);
 828         if (rc) {
 829                 QETH_CARD_TEXT_(card, 2, "2err%04x", rc);
 830                 rc = -ENODEV;
 831                 goto out_remove;
 832         }
 833
 834         mutex_lock(&card->sbp_lock);
 835         qeth_bridgeport_query_support(card);
 836         if (card->options.sbp.supported_funcs) {
 837                 qeth_l2_setup_bridgeport_attrs(card);
 838                 dev_info(&card->gdev->dev,
 839                          "The device represents a Bridge Capable Port\n");
 840         }
 841         mutex_unlock(&card->sbp_lock);
 842
 843         qeth_l2_register_dev_addr(card);
 844
 845         /* for the rx_bcast characteristic, init VNICC after setmac */
 846         qeth_l2_vnicc_init(card);
 847
 848         qeth_trace_features(card);
 849         qeth_l2_trace_features(card);
 850
 851         qeth_print_status_message(card);
 852
 853         /* softsetup */
 854         QETH_CARD_TEXT(card, 2, "softsetp");
 855
 856         card->state = CARD_STATE_SOFTSETUP;
 857
 858         qeth_set_allowed_threads(card, 0xffffffff, 0);
 859
 860         if (dev->reg_state != NETREG_REGISTERED) {
 861                 rc = qeth_l2_setup_netdev(card);
 862                 if (rc)
 863                         goto out_remove;
 864
 865                 if (carrier_ok)
 866                         netif_carrier_on(dev);
 867         } else {
 868                 rtnl_lock();
 869                 if (carrier_ok)
 870                         netif_carrier_on(dev);
 871                 else
 872                         netif_carrier_off(dev);
 873
 874                 netif_device_attach(dev);
 875                 qeth_enable_hw_features(dev);
 876
 877                 if (card->info.open_when_online) {
 878                         card->info.open_when_online = 0;
 879                         dev_open(dev, NULL);
 880                 }
 881                 rtnl_unlock();
 882         }
 883         /* let user_space know that device is online */
 884         kobject_uevent(&gdev->dev.kobj, KOBJ_CHANGE);
 885         return 0;
 886
 887 out_remove:
 888         qeth_l2_stop_card(card);
 889         qeth_stop_channel(&card->data);
 890         qeth_stop_channel(&card->write);
 891         qeth_stop_channel(&card->read);
 892         qdio_free(CARD_DDEV(card));
 893         return rc;
 894 }
 895
 896 static void qeth_l2_set_offline(struct qeth_card *card)
 897 {
 898         qeth_l2_stop_card(card);
 899 }
 900
 901 static int __init qeth_l2_init(void)
 902 {
 903         pr_info("register layer 2 discipline\n");
 904         return 0;
 905 }
 906
 907 static void __exit qeth_l2_exit(void)
 908 {
 909         pr_info("unregister layer 2 discipline\n");
 910 }
 911
 912 /* Returns zero if the command is successfully "consumed" */
 913 static int qeth_l2_control_event(struct qeth_card *card,
 914                                         struct qeth_ipa_cmd *cmd)
 915 {
 916         switch (cmd->hdr.command) {
 917         case IPA_CMD_SETBRIDGEPORT_OSA:
 918         case IPA_CMD_SETBRIDGEPORT_IQD:
 919                 if (cmd->data.sbp.hdr.command_code ==
 920                                 IPA_SBP_BRIDGE_PORT_STATE_CHANGE) {
 921                         qeth_bridge_state_change(card, cmd);
 922                         return 0;
 923                 } else
 924                         return 1;
 925         case IPA_CMD_ADDRESS_CHANGE_NOTIF:
 926                 qeth_addr_change_event(card, cmd);
 927                 return 0;
 928         default:
 929                 return 1;
 930         }
 931 }
 932
 933 struct qeth_discipline qeth_l2_discipline = {
 934         .devtype = &qeth_l2_devtype,
 935         .setup = qeth_l2_probe_device,
 936         .remove = qeth_l2_remove_device,
 937         .set_online = qeth_l2_set_online,
 938         .set_offline = qeth_l2_set_offline,
 939         .do_ioctl = NULL,
 940         .control_event_handler = qeth_l2_control_event,
 941 };
 942 EXPORT_SYMBOL_GPL(qeth_l2_discipline);
 943
 944 #ifdef CONFIG_QETH_OSN
 945 static void qeth_osn_assist_cb(struct qeth_card *card,
 946                                struct qeth_cmd_buffer *iob,
 947                                unsigned int data_length)
 948 {
 949         qeth_notify_cmd(iob, 0);
 950         qeth_put_cmd(iob);
 951 }
 952
 953 int qeth_osn_assist(struct net_device *dev, void *data, int data_len)
 954 {
 955         struct qeth_cmd_buffer *iob;
 956         struct qeth_card *card;
 957
 958         if (data_len < 0)
 959                 return -EINVAL;
 960         if (!dev)
 961                 return -ENODEV;
 962         card = dev->ml_priv;
 963         if (!card)
 964                 return -ENODEV;
 965         QETH_CARD_TEXT(card, 2, "osnsdmc");
 966         if (!qeth_card_hw_is_reachable(card))
 967                 return -ENODEV;
 968
 969         iob = qeth_alloc_cmd(&card->write, IPA_PDU_HEADER_SIZE + data_len, 1,
 970                              QETH_IPA_TIMEOUT);
 971         if (!iob)
 972                 return -ENOMEM;
 973
 974         qeth_prepare_ipa_cmd(card, iob, (u16) data_len, NULL);
 975
 976         memcpy(__ipa_cmd(iob), data, data_len);
 977         iob->callback = qeth_osn_assist_cb;
 978         return qeth_send_ipa_cmd(card, iob, NULL, NULL);
 979 }
 980 EXPORT_SYMBOL(qeth_osn_assist);
 981
 982 int qeth_osn_register(unsigned char *read_dev_no, struct net_device **dev,
 983                   int (*assist_cb)(struct net_device *, void *),
 984                   int (*data_cb)(struct sk_buff *))
 985 {
 986         struct qeth_card *card;
 987         char bus_id[16];
 988         u16 devno;
 989
 990         memcpy(&devno, read_dev_no, 2);
 991         sprintf(bus_id, "0.0.%04x", devno);
 992         card = qeth_get_card_by_busid(bus_id);
 993         if (!card || !IS_OSN(card))
 994                 return -ENODEV;
 995         *dev = card->dev;
 996
 997         QETH_CARD_TEXT(card, 2, "osnreg");
 998         if ((assist_cb == NULL) || (data_cb == NULL))
 999                 return -EINVAL;
1000         card->osn_info.assist_cb = assist_cb;
1001         card->osn_info.data_cb = data_cb;
1002         return 0;
1003 }
1004 EXPORT_SYMBOL(qeth_osn_register);
1005
1006 void qeth_osn_deregister(struct net_device *dev)
1007 {
1008         struct qeth_card *card;
1009
1010         if (!dev)
1011                 return;
1012         card = dev->ml_priv;
1013         if (!card)
1014                 return;
1015         QETH_CARD_TEXT(card, 2, "osndereg");
1016         card->osn_info.assist_cb = NULL;
1017         card->osn_info.data_cb = NULL;
1018         return;
1019 }
1020 EXPORT_SYMBOL(qeth_osn_deregister);
1021 #endif
1022
1023 /* SETBRIDGEPORT support, async notifications */
1024
1025 enum qeth_an_event_type {anev_reg_unreg, anev_abort, anev_reset};
1026
1027 /**
1028  * qeth_bridge_emit_host_event() - bridgeport address change notification
1029  * @card:  qeth_card structure pointer, for udev events.
1030  * @evtype:  "normal" register/unregister, or abort, or reset. For abort
1031  *            and reset token and addr_lnid are unused and may be NULL.
1032  * @code:  event bitmask: high order bit 0x80 value 1 means removal of an
1033  *                        object, 0 - addition of an object.
1034  *                        0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC.
1035  * @token: "network token" structure identifying physical address of the port.
1036  * @addr_lnid: pointer to structure with MAC address and VLAN ID.
1037  *
1038  * This function is called when registrations and deregistrations are
1039  * reported by the hardware, and also when notifications are enabled -
1040  * for all currently registered addresses.
1041  */
1042 static void qeth_bridge_emit_host_event(struct qeth_card *card,
1043                                         enum qeth_an_event_type evtype,
1044                                         u8 code,
1045                                         struct net_if_token *token,
1046                                         struct mac_addr_lnid *addr_lnid)
1047 {
1048         char str[7][32];
1049         char *env[8];
1050         int i = 0;
1051
1052         switch (evtype) {
1053         case anev_reg_unreg:
1054                 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=%s",
1055                                 (code & IPA_ADDR_CHANGE_CODE_REMOVAL)
1056                                 ? "deregister" : "register");
1057                 env[i] = str[i]; i++;
1058                 if (code & IPA_ADDR_CHANGE_CODE_VLANID) {
1059                         snprintf(str[i], sizeof(str[i]), "VLAN=%d",
1060                                 addr_lnid->lnid);
1061                         env[i] = str[i]; i++;
1062                 }
1063                 if (code & IPA_ADDR_CHANGE_CODE_MACADDR) {
1064                         snprintf(str[i], sizeof(str[i]), "MAC=%pM",
1065                                 addr_lnid->mac);
1066                         env[i] = str[i]; i++;
1067                 }
1068                 snprintf(str[i], sizeof(str[i]), "NTOK_BUSID=%x.%x.%04x",
1069                         token->cssid, token->ssid, token->devnum);
1070                 env[i] = str[i]; i++;
1071                 snprintf(str[i], sizeof(str[i]), "NTOK_IID=%02x", token->iid);
1072                 env[i] = str[i]; i++;
1073                 snprintf(str[i], sizeof(str[i]), "NTOK_CHPID=%02x",
1074                                 token->chpid);
1075                 env[i] = str[i]; i++;
1076                 snprintf(str[i], sizeof(str[i]), "NTOK_CHID=%04x", token->chid);
1077                 env[i] = str[i]; i++;
1078                 break;
1079         case anev_abort:
1080                 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=abort");
1081                 env[i] = str[i]; i++;
1082                 break;
1083         case anev_reset:
1084                 snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=reset");
1085                 env[i] = str[i]; i++;
1086                 break;
1087         }
1088         env[i] = NULL;
1089         kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env);
1090 }
1091
1092 struct qeth_bridge_state_data {
1093         struct work_struct worker;
1094         struct qeth_card *card;
1095         struct qeth_sbp_state_change qports;
1096 };
1097
1098 static void qeth_bridge_state_change_worker(struct work_struct *work)
1099 {
1100         struct qeth_bridge_state_data *data =
1101                 container_of(work, struct qeth_bridge_state_data, worker);
1102         /* We are only interested in the first entry - local port */
1103         struct qeth_sbp_port_entry *entry = &data->qports.entry[0];
1104         char env_locrem[32];
1105         char env_role[32];
1106         char env_state[32];
1107         char *env[] = {
1108                 env_locrem,
1109                 env_role,
1110                 env_state,
1111                 NULL
1112         };
1113
1114         /* Role should not change by itself, but if it did, */
1115         /* information from the hardware is authoritative.  */
1116         mutex_lock(&data->card->sbp_lock);
1117         data->card->options.sbp.role = entry->role;
1118         mutex_unlock(&data->card->sbp_lock);
1119
1120         snprintf(env_locrem, sizeof(env_locrem), "BRIDGEPORT=statechange");
1121         snprintf(env_role, sizeof(env_role), "ROLE=%s",
1122                 (entry->role == QETH_SBP_ROLE_NONE) ? "none" :
1123                 (entry->role == QETH_SBP_ROLE_PRIMARY) ? "primary" :
1124                 (entry->role == QETH_SBP_ROLE_SECONDARY) ? "secondary" :
1125                 "<INVALID>");
1126         snprintf(env_state, sizeof(env_state), "STATE=%s",
1127                 (entry->state == QETH_SBP_STATE_INACTIVE) ? "inactive" :
1128                 (entry->state == QETH_SBP_STATE_STANDBY) ? "standby" :
1129                 (entry->state == QETH_SBP_STATE_ACTIVE) ? "active" :
1130                 "<INVALID>");
1131         kobject_uevent_env(&data->card->gdev->dev.kobj,
1132                                 KOBJ_CHANGE, env);
1133         kfree(data);
1134 }
1135
1136 static void qeth_bridge_state_change(struct qeth_card *card,
1137                                         struct qeth_ipa_cmd *cmd)
1138 {
1139         struct qeth_sbp_state_change *qports =
1140                  &cmd->data.sbp.data.state_change;
1141         struct qeth_bridge_state_data *data;
1142         int extrasize;
1143
1144         QETH_CARD_TEXT(card, 2, "brstchng");
1145         if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
1146                 QETH_CARD_TEXT_(card, 2, "BPsz%04x", qports->entry_length);
1147                 return;
1148         }
1149         extrasize = sizeof(struct qeth_sbp_port_entry) * qports->num_entries;
1150         data = kzalloc(sizeof(struct qeth_bridge_state_data) + extrasize,
1151                 GFP_ATOMIC);
1152         if (!data) {
1153                 QETH_CARD_TEXT(card, 2, "BPSalloc");
1154                 return;
1155         }
1156         INIT_WORK(&data->worker, qeth_bridge_state_change_worker);
1157         data->card = card;
1158         memcpy(&data->qports, qports,
1159                         sizeof(struct qeth_sbp_state_change) + extrasize);
1160         queue_work(card->event_wq, &data->worker);
1161 }
1162
1163 struct qeth_addr_change_data {
1164         struct work_struct worker;
1165         struct qeth_card *card;
1166         struct qeth_ipacmd_addr_change ac_event;
1167 };
1168
1169 static void qeth_addr_change_event_worker(struct work_struct *work)
1170 {
1171         struct qeth_addr_change_data *data =
1172                 container_of(work, struct qeth_addr_change_data, worker);
1173         int i;
1174
1175         QETH_CARD_TEXT(data->card, 4, "adrchgew");
1176         if (data->ac_event.lost_event_mask) {
1177                 dev_info(&data->card->gdev->dev,
1178                          "Address change notification stopped on %s (%s)\n",
1179                          data->card->dev->name,
1180                         (data->ac_event.lost_event_mask == 0x01)
1181                         ? "Overflow"
1182                         : (data->ac_event.lost_event_mask == 0x02)
1183                         ? "Bridge port state change"
1184                         : "Unknown reason");
1185                 mutex_lock(&data->card->sbp_lock);
1186                 data->card->options.sbp.hostnotification = 0;
1187                 mutex_unlock(&data->card->sbp_lock);
1188                 qeth_bridge_emit_host_event(data->card, anev_abort,
1189                                             0, NULL, NULL);
1190         } else
1191                 for (i = 0; i < data->ac_event.num_entries; i++) {
1192                         struct qeth_ipacmd_addr_change_entry *entry =
1193                                         &data->ac_event.entry[i];
1194                         qeth_bridge_emit_host_event(data->card,
1195                                                     anev_reg_unreg,
1196                                                     entry->change_code,
1197                                                     &entry->token,
1198                                                     &entry->addr_lnid);
1199                 }
1200         kfree(data);
1201 }
1202
1203 static void qeth_addr_change_event(struct qeth_card *card,
1204                                    struct qeth_ipa_cmd *cmd)
1205 {
1206         struct qeth_ipacmd_addr_change *hostevs =
1207                  &cmd->data.addrchange;
1208         struct qeth_addr_change_data *data;
1209         int extrasize;
1210
1211         QETH_CARD_TEXT(card, 4, "adrchgev");
1212         if (cmd->hdr.return_code != 0x0000) {
1213                 if (cmd->hdr.return_code == 0x0010) {
1214                         if (hostevs->lost_event_mask == 0x00)
1215                                 hostevs->lost_event_mask = 0xff;
1216                 } else {
1217                         QETH_CARD_TEXT_(card, 2, "ACHN%04x",
1218                                 cmd->hdr.return_code);
1219                         return;
1220                 }
1221         }
1222         extrasize = sizeof(struct qeth_ipacmd_addr_change_entry) *
1223                                                 hostevs->num_entries;
1224         data = kzalloc(sizeof(struct qeth_addr_change_data) + extrasize,
1225                        GFP_ATOMIC);
1226         if (!data) {
1227                 QETH_CARD_TEXT(card, 2, "ACNalloc");
1228                 return;
1229         }
1230         INIT_WORK(&data->worker, qeth_addr_change_event_worker);
1231         data->card = card;
1232         memcpy(&data->ac_event, hostevs,
1233                         sizeof(struct qeth_ipacmd_addr_change) + extrasize);
1234         queue_work(card->event_wq, &data->worker);
1235 }
1236
1237 /* SETBRIDGEPORT support; sending commands */
1238
1239 struct _qeth_sbp_cbctl {
1240         union {
1241                 u32 supported;
1242                 struct {
1243                         enum qeth_sbp_roles *role;
1244                         enum qeth_sbp_states *state;
1245                 } qports;
1246         } data;
1247 };
1248
1249 static int qeth_bridgeport_makerc(struct qeth_card *card,
1250                                   struct qeth_ipa_cmd *cmd)
1251 {
1252         struct qeth_ipacmd_setbridgeport *sbp = &cmd->data.sbp;
1253         enum qeth_ipa_sbp_cmd setcmd = sbp->hdr.command_code;
1254         u16 ipa_rc = cmd->hdr.return_code;
1255         u16 sbp_rc = sbp->hdr.return_code;
1256         int rc;
1257
1258         if (ipa_rc == IPA_RC_SUCCESS && sbp_rc == IPA_RC_SUCCESS)
1259                 return 0;
1260
1261         if ((IS_IQD(card) && ipa_rc == IPA_RC_SUCCESS) ||
1262             (!IS_IQD(card) && ipa_rc == sbp_rc)) {
1263                 switch (sbp_rc) {
1264                 case IPA_RC_SUCCESS:
1265                         rc = 0;
1266                         break;
1267                 case IPA_RC_L2_UNSUPPORTED_CMD:
1268                 case IPA_RC_UNSUPPORTED_COMMAND:
1269                         rc = -EOPNOTSUPP;
1270                         break;
1271                 case IPA_RC_SBP_OSA_NOT_CONFIGURED:
1272                 case IPA_RC_SBP_IQD_NOT_CONFIGURED:
1273                         rc = -ENODEV; /* maybe not the best code here? */
1274                         dev_err(&card->gdev->dev,
1275         "The device is not configured as a Bridge Port\n");
1276                         break;
1277                 case IPA_RC_SBP_OSA_OS_MISMATCH:
1278                 case IPA_RC_SBP_IQD_OS_MISMATCH:
1279                         rc = -EPERM;
1280                         dev_err(&card->gdev->dev,
1281         "A Bridge Port is already configured by a different operating system\n");
1282                         break;
1283                 case IPA_RC_SBP_OSA_ANO_DEV_PRIMARY:
1284                 case IPA_RC_SBP_IQD_ANO_DEV_PRIMARY:
1285                         switch (setcmd) {
1286                         case IPA_SBP_SET_PRIMARY_BRIDGE_PORT:
1287                                 rc = -EEXIST;
1288                                 dev_err(&card->gdev->dev,
1289         "The LAN already has a primary Bridge Port\n");
1290                                 break;
1291                         case IPA_SBP_SET_SECONDARY_BRIDGE_PORT:
1292                                 rc = -EBUSY;
1293                                 dev_err(&card->gdev->dev,
1294         "The device is already a primary Bridge Port\n");
1295                                 break;
1296                         default:
1297                                 rc = -EIO;
1298                         }
1299                         break;
1300                 case IPA_RC_SBP_OSA_CURRENT_SECOND:
1301                 case IPA_RC_SBP_IQD_CURRENT_SECOND:
1302                         rc = -EBUSY;
1303                         dev_err(&card->gdev->dev,
1304         "The device is already a secondary Bridge Port\n");
1305                         break;
1306                 case IPA_RC_SBP_OSA_LIMIT_SECOND:
1307                 case IPA_RC_SBP_IQD_LIMIT_SECOND:
1308                         rc = -EEXIST;
1309                         dev_err(&card->gdev->dev,
1310         "The LAN cannot have more secondary Bridge Ports\n");
1311                         break;
1312                 case IPA_RC_SBP_OSA_CURRENT_PRIMARY:
1313                 case IPA_RC_SBP_IQD_CURRENT_PRIMARY:
1314                         rc = -EBUSY;
1315                         dev_err(&card->gdev->dev,
1316         "The device is already a primary Bridge Port\n");
1317                         break;
1318                 case IPA_RC_SBP_OSA_NOT_AUTHD_BY_ZMAN:
1319                 case IPA_RC_SBP_IQD_NOT_AUTHD_BY_ZMAN:
1320                         rc = -EACCES;
1321                         dev_err(&card->gdev->dev,
1322         "The device is not authorized to be a Bridge Port\n");
1323                         break;
1324                 default:
1325                         rc = -EIO;
1326                 }
1327         } else {
1328                 switch (ipa_rc) {
1329                 case IPA_RC_NOTSUPP:
1330                         rc = -EOPNOTSUPP;
1331                         break;
1332                 case IPA_RC_UNSUPPORTED_COMMAND:
1333                         rc = -EOPNOTSUPP;
1334                         break;
1335                 default:
1336                         rc = -EIO;
1337                 }
1338         }
1339
1340         if (rc) {
1341                 QETH_CARD_TEXT_(card, 2, "SBPi%04x", ipa_rc);
1342                 QETH_CARD_TEXT_(card, 2, "SBPc%04x", sbp_rc);
1343         }
1344         return rc;
1345 }
1346
1347 static struct qeth_cmd_buffer *qeth_sbp_build_cmd(struct qeth_card *card,
1348                                                   enum qeth_ipa_sbp_cmd sbp_cmd,
1349                                                   unsigned int data_length)
1350 {
1351         enum qeth_ipa_cmds ipa_cmd = IS_IQD(card) ? IPA_CMD_SETBRIDGEPORT_IQD :
1352                                                     IPA_CMD_SETBRIDGEPORT_OSA;
1353         struct qeth_ipacmd_sbp_hdr *hdr;
1354         struct qeth_cmd_buffer *iob;
1355
1356         iob = qeth_ipa_alloc_cmd(card, ipa_cmd, QETH_PROT_NONE,
1357                                  data_length +
1358                                  offsetof(struct qeth_ipacmd_setbridgeport,
1359                                           data));
1360         if (!iob)
1361                 return iob;
1362
1363         hdr = &__ipa_cmd(iob)->data.sbp.hdr;
1364         hdr->cmdlength = sizeof(*hdr) + data_length;
1365         hdr->command_code = sbp_cmd;
1366         hdr->used_total = 1;
1367         hdr->seq_no = 1;
1368         return iob;
1369 }
1370
1371 static int qeth_bridgeport_query_support_cb(struct qeth_card *card,
1372         struct qeth_reply *reply, unsigned long data)
1373 {
1374         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1375         struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1376         int rc;
1377
1378         QETH_CARD_TEXT(card, 2, "brqsupcb");
1379         rc = qeth_bridgeport_makerc(card, cmd);
1380         if (rc)
1381                 return rc;
1382
1383         cbctl->data.supported =
1384                 cmd->data.sbp.data.query_cmds_supp.supported_cmds;
1385         return 0;
1386 }
1387
1388 /**
1389  * qeth_bridgeport_query_support() - store bitmask of supported subfunctions.
1390  * @card:                            qeth_card structure pointer.
1391  *
1392  * Sets bitmask of supported setbridgeport subfunctions in the qeth_card
1393  * strucutre: card->options.sbp.supported_funcs.
1394  */
1395 static void qeth_bridgeport_query_support(struct qeth_card *card)
1396 {
1397         struct qeth_cmd_buffer *iob;
1398         struct _qeth_sbp_cbctl cbctl;
1399
1400         QETH_CARD_TEXT(card, 2, "brqsuppo");
1401         iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_COMMANDS_SUPPORTED,
1402                                  SBP_DATA_SIZEOF(query_cmds_supp));
1403         if (!iob)
1404                 return;
1405
1406         if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb,
1407                               &cbctl)) {
1408                 card->options.sbp.role = QETH_SBP_ROLE_NONE;
1409                 card->options.sbp.supported_funcs = 0;
1410                 return;
1411         }
1412         card->options.sbp.supported_funcs = cbctl.data.supported;
1413 }
1414
1415 static int qeth_bridgeport_query_ports_cb(struct qeth_card *card,
1416         struct qeth_reply *reply, unsigned long data)
1417 {
1418         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1419         struct qeth_sbp_query_ports *qports = &cmd->data.sbp.data.query_ports;
1420         struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1421         int rc;
1422
1423         QETH_CARD_TEXT(card, 2, "brqprtcb");
1424         rc = qeth_bridgeport_makerc(card, cmd);
1425         if (rc)
1426                 return rc;
1427
1428         if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
1429                 QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length);
1430                 return -EINVAL;
1431         }
1432         /* first entry contains the state of the local port */
1433         if (qports->num_entries > 0) {
1434                 if (cbctl->data.qports.role)
1435                         *cbctl->data.qports.role = qports->entry[0].role;
1436                 if (cbctl->data.qports.state)
1437                         *cbctl->data.qports.state = qports->entry[0].state;
1438         }
1439         return 0;
1440 }
1441
1442 /**
1443  * qeth_bridgeport_query_ports() - query local bridgeport status.
1444  * @card:                          qeth_card structure pointer.
1445  * @role:   Role of the port: 0-none, 1-primary, 2-secondary.
1446  * @state:  State of the port: 0-inactive, 1-standby, 2-active.
1447  *
1448  * Returns negative errno-compatible error indication or 0 on success.
1449  *
1450  * 'role' and 'state' are not updated in case of hardware operation failure.
1451  */
1452 int qeth_bridgeport_query_ports(struct qeth_card *card,
1453         enum qeth_sbp_roles *role, enum qeth_sbp_states *state)
1454 {
1455         struct qeth_cmd_buffer *iob;
1456         struct _qeth_sbp_cbctl cbctl = {
1457                 .data = {
1458                         .qports = {
1459                                 .role = role,
1460                                 .state = state,
1461                         },
1462                 },
1463         };
1464
1465         QETH_CARD_TEXT(card, 2, "brqports");
1466         if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS))
1467                 return -EOPNOTSUPP;
1468         iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_BRIDGE_PORTS, 0);
1469         if (!iob)
1470                 return -ENOMEM;
1471
1472         return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb,
1473                                  &cbctl);
1474 }
1475
1476 static int qeth_bridgeport_set_cb(struct qeth_card *card,
1477         struct qeth_reply *reply, unsigned long data)
1478 {
1479         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data;
1480
1481         QETH_CARD_TEXT(card, 2, "brsetrcb");
1482         return qeth_bridgeport_makerc(card, cmd);
1483 }
1484
1485 /**
1486  * qeth_bridgeport_setrole() - Assign primary role to the port.
1487  * @card:                      qeth_card structure pointer.
1488  * @role:                      Role to assign.
1489  *
1490  * Returns negative errno-compatible error indication or 0 on success.
1491  */
1492 int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role)
1493 {
1494         struct qeth_cmd_buffer *iob;
1495         enum qeth_ipa_sbp_cmd setcmd;
1496         unsigned int cmdlength = 0;
1497
1498         QETH_CARD_TEXT(card, 2, "brsetrol");
1499         switch (role) {
1500         case QETH_SBP_ROLE_NONE:
1501                 setcmd = IPA_SBP_RESET_BRIDGE_PORT_ROLE;
1502                 break;
1503         case QETH_SBP_ROLE_PRIMARY:
1504                 setcmd = IPA_SBP_SET_PRIMARY_BRIDGE_PORT;
1505                 cmdlength = SBP_DATA_SIZEOF(set_primary);
1506                 break;
1507         case QETH_SBP_ROLE_SECONDARY:
1508                 setcmd = IPA_SBP_SET_SECONDARY_BRIDGE_PORT;
1509                 break;
1510         default:
1511                 return -EINVAL;
1512         }
1513         if (!(card->options.sbp.supported_funcs & setcmd))
1514                 return -EOPNOTSUPP;
1515         iob = qeth_sbp_build_cmd(card, setcmd, cmdlength);
1516         if (!iob)
1517                 return -ENOMEM;
1518
1519         return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb, NULL);
1520 }
1521
1522 static void qeth_bridgeport_an_set_cb(void *priv,
1523                                       struct chsc_pnso_naid_l2 *entry)
1524 {
1525         struct qeth_card *card = (struct qeth_card *)priv;
1526         u8 code;
1527
1528         code = IPA_ADDR_CHANGE_CODE_MACADDR;
1529         if (entry->addr_lnid.lnid < VLAN_N_VID)
1530                 code |= IPA_ADDR_CHANGE_CODE_VLANID;
1531         qeth_bridge_emit_host_event(card, anev_reg_unreg, code,
1532                                     (struct net_if_token *)&entry->nit,
1533                                     (struct mac_addr_lnid *)&entry->addr_lnid);
1534 }
1535
1536 /**
1537  * qeth_bridgeport_an_set() - Enable or disable bridgeport address notification
1538  * @card:                     qeth_card structure pointer.
1539  * @enable:                   0 - disable, non-zero - enable notifications
1540  *
1541  * Returns negative errno-compatible error indication or 0 on success.
1542  *
1543  * On enable, emits a series of address notifications udev events for all
1544  * currently registered hosts.
1545  */
1546 int qeth_bridgeport_an_set(struct qeth_card *card, int enable)
1547 {
1548         int rc;
1549
1550         if (!card->options.sbp.supported_funcs)
1551                 return -EOPNOTSUPP;
1552
1553         if (enable) {
1554                 qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL);
1555                 rc = qeth_l2_pnso(card, 1, qeth_bridgeport_an_set_cb, card);
1556         } else
1557                 rc = qeth_l2_pnso(card, 0, NULL, NULL);
1558         return rc;
1559 }
1560
1561 static bool qeth_bridgeport_is_in_use(struct qeth_card *card)
1562 {
1563         return (card->options.sbp.role || card->options.sbp.reflect_promisc ||
1564                 card->options.sbp.hostnotification);
1565 }
1566
1567 /* VNIC Characteristics support */
1568
1569 /* handle VNICC IPA command return codes; convert to error codes */
1570 static int qeth_l2_vnicc_makerc(struct qeth_card *card, u16 ipa_rc)
1571 {
1572         int rc;
1573
1574         switch (ipa_rc) {
1575         case IPA_RC_SUCCESS:
1576                 return ipa_rc;
1577         case IPA_RC_L2_UNSUPPORTED_CMD:
1578         case IPA_RC_NOTSUPP:
1579                 rc = -EOPNOTSUPP;
1580                 break;
1581         case IPA_RC_VNICC_OOSEQ:
1582                 rc = -EALREADY;
1583                 break;
1584         case IPA_RC_VNICC_VNICBP:
1585                 rc = -EBUSY;
1586                 break;
1587         case IPA_RC_L2_ADDR_TABLE_FULL:
1588                 rc = -ENOSPC;
1589                 break;
1590         case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
1591                 rc = -EACCES;
1592                 break;
1593         default:
1594                 rc = -EIO;
1595         }
1596
1597         QETH_CARD_TEXT_(card, 2, "err%04x", ipa_rc);
1598         return rc;
1599 }
1600
1601 /* generic VNICC request call back */
1602 static int qeth_l2_vnicc_request_cb(struct qeth_card *card,
1603                                     struct qeth_reply *reply,
1604                                     unsigned long data)
1605 {
1606         struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1607         struct qeth_ipacmd_vnicc *rep = &cmd->data.vnicc;
1608         u32 sub_cmd = cmd->data.vnicc.hdr.sub_command;
1609
1610         QETH_CARD_TEXT(card, 2, "vniccrcb");
1611         if (cmd->hdr.return_code)
1612                 return qeth_l2_vnicc_makerc(card, cmd->hdr.return_code);
1613         /* return results to caller */
1614         card->options.vnicc.sup_chars = rep->vnicc_cmds.supported;
1615         card->options.vnicc.cur_chars = rep->vnicc_cmds.enabled;
1616
1617         if (sub_cmd == IPA_VNICC_QUERY_CMDS)
1618                 *(u32 *)reply->param = rep->data.query_cmds.sup_cmds;
1619         else if (sub_cmd == IPA_VNICC_GET_TIMEOUT)
1620                 *(u32 *)reply->param = rep->data.getset_timeout.timeout;
1621
1622         return 0;
1623 }
1624
1625 static struct qeth_cmd_buffer *qeth_l2_vnicc_build_cmd(struct qeth_card *card,
1626                                                        u32 vnicc_cmd,
1627                                                        unsigned int data_length)
1628 {
1629         struct qeth_ipacmd_vnicc_hdr *hdr;
1630         struct qeth_cmd_buffer *iob;
1631
1632         iob = qeth_ipa_alloc_cmd(card, IPA_CMD_VNICC, QETH_PROT_NONE,
1633                                  data_length +
1634                                  offsetof(struct qeth_ipacmd_vnicc, data));
1635         if (!iob)
1636                 return NULL;
1637
1638         hdr = &__ipa_cmd(iob)->data.vnicc.hdr;
1639         hdr->data_length = sizeof(*hdr) + data_length;
1640         hdr->sub_command = vnicc_cmd;
1641         return iob;
1642 }
1643
1644 /* VNICC query VNIC characteristics request */
1645 static int qeth_l2_vnicc_query_chars(struct qeth_card *card)
1646 {
1647         struct qeth_cmd_buffer *iob;
1648
1649         QETH_CARD_TEXT(card, 2, "vniccqch");
1650         iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CHARS, 0);
1651         if (!iob)
1652                 return -ENOMEM;
1653
1654         return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL);
1655 }
1656
1657 /* VNICC query sub commands request */
1658 static int qeth_l2_vnicc_query_cmds(struct qeth_card *card, u32 vnic_char,
1659                                     u32 *sup_cmds)
1660 {
1661         struct qeth_cmd_buffer *iob;
1662
1663         QETH_CARD_TEXT(card, 2, "vniccqcm");
1664         iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CMDS,
1665                                       VNICC_DATA_SIZEOF(query_cmds));
1666         if (!iob)
1667                 return -ENOMEM;
1668
1669         __ipa_cmd(iob)->data.vnicc.data.query_cmds.vnic_char = vnic_char;
1670
1671         return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, sup_cmds);
1672 }
1673
1674 /* VNICC enable/disable characteristic request */
1675 static int qeth_l2_vnicc_set_char(struct qeth_card *card, u32 vnic_char,
1676                                       u32 cmd)
1677 {
1678         struct qeth_cmd_buffer *iob;
1679
1680         QETH_CARD_TEXT(card, 2, "vniccedc");
1681         iob = qeth_l2_vnicc_build_cmd(card, cmd, VNICC_DATA_SIZEOF(set_char));
1682         if (!iob)
1683                 return -ENOMEM;
1684
1685         __ipa_cmd(iob)->data.vnicc.data.set_char.vnic_char = vnic_char;
1686
1687         return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL);
1688 }
1689
1690 /* VNICC get/set timeout for characteristic request */
1691 static int qeth_l2_vnicc_getset_timeout(struct qeth_card *card, u32 vnicc,
1692                                         u32 cmd, u32 *timeout)
1693 {
1694         struct qeth_vnicc_getset_timeout *getset_timeout;
1695         struct qeth_cmd_buffer *iob;
1696
1697         QETH_CARD_TEXT(card, 2, "vniccgst");
1698         iob = qeth_l2_vnicc_build_cmd(card, cmd,
1699                                       VNICC_DATA_SIZEOF(getset_timeout));
1700         if (!iob)
1701                 return -ENOMEM;
1702
1703         getset_timeout = &__ipa_cmd(iob)->data.vnicc.data.getset_timeout;
1704         getset_timeout->vnic_char = vnicc;
1705
1706         if (cmd == IPA_VNICC_SET_TIMEOUT)
1707                 getset_timeout->timeout = *timeout;
1708
1709         return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, timeout);
1710 }
1711
1712 /* set current VNICC flag state; called from sysfs store function */
1713 int qeth_l2_vnicc_set_state(struct qeth_card *card, u32 vnicc, bool state)
1714 {
1715         int rc = 0;
1716         u32 cmd;
1717
1718         QETH_CARD_TEXT(card, 2, "vniccsch");
1719
1720         /* check if characteristic and enable/disable are supported */
1721         if (!(card->options.vnicc.sup_chars & vnicc) ||
1722             !(card->options.vnicc.set_char_sup & vnicc))
1723                 return -EOPNOTSUPP;
1724
1725         if (qeth_bridgeport_is_in_use(card))
1726                 return -EBUSY;
1727
1728         /* set enable/disable command and store wanted characteristic */
1729         if (state) {
1730                 cmd = IPA_VNICC_ENABLE;
1731                 card->options.vnicc.wanted_chars |= vnicc;
1732         } else {
1733                 cmd = IPA_VNICC_DISABLE;
1734                 card->options.vnicc.wanted_chars &= ~vnicc;
1735         }
1736
1737         /* do we need to do anything? */
1738         if (card->options.vnicc.cur_chars == card->options.vnicc.wanted_chars)
1739                 return rc;
1740
1741         /* if card is not ready, simply stop here */
1742         if (!qeth_card_hw_is_reachable(card)) {
1743                 if (state)
1744                         card->options.vnicc.cur_chars |= vnicc;
1745                 else
1746                         card->options.vnicc.cur_chars &= ~vnicc;
1747                 return rc;
1748         }
1749
1750         rc = qeth_l2_vnicc_set_char(card, vnicc, cmd);
1751         if (rc)
1752                 card->options.vnicc.wanted_chars =
1753                         card->options.vnicc.cur_chars;
1754         else {
1755                 /* successful online VNICC change; handle special cases */
1756                 if (state && vnicc == QETH_VNICC_RX_BCAST)
1757                         card->options.vnicc.rx_bcast_enabled = true;
1758                 if (!state && vnicc == QETH_VNICC_LEARNING)
1759                         qeth_l2_vnicc_recover_timeout(card, vnicc,
1760                                         &card->options.vnicc.learning_timeout);
1761         }
1762
1763         return rc;
1764 }
1765
1766 /* get current VNICC flag state; called from sysfs show function */
1767 int qeth_l2_vnicc_get_state(struct qeth_card *card, u32 vnicc, bool *state)
1768 {
1769         int rc = 0;
1770
1771         QETH_CARD_TEXT(card, 2, "vniccgch");
1772
1773         /* check if characteristic is supported */
1774         if (!(card->options.vnicc.sup_chars & vnicc))
1775                 return -EOPNOTSUPP;
1776
1777         if (qeth_bridgeport_is_in_use(card))
1778                 return -EBUSY;
1779
1780         /* if card is ready, query current VNICC state */
1781         if (qeth_card_hw_is_reachable(card))
1782                 rc = qeth_l2_vnicc_query_chars(card);
1783
1784         *state = (card->options.vnicc.cur_chars & vnicc) ? true : false;
1785         return rc;
1786 }
1787
1788 /* set VNICC timeout; called from sysfs store function. Currently, only learning
1789  * supports timeout
1790  */
1791 int qeth_l2_vnicc_set_timeout(struct qeth_card *card, u32 timeout)
1792 {
1793         int rc = 0;
1794
1795         QETH_CARD_TEXT(card, 2, "vniccsto");
1796
1797         /* check if characteristic and set_timeout are supported */
1798         if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
1799             !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
1800                 return -EOPNOTSUPP;
1801
1802         if (qeth_bridgeport_is_in_use(card))
1803                 return -EBUSY;
1804
1805         /* do we need to do anything? */
1806         if (card->options.vnicc.learning_timeout == timeout)
1807                 return rc;
1808
1809         /* if card is not ready, simply store the value internally and return */
1810         if (!qeth_card_hw_is_reachable(card)) {
1811                 card->options.vnicc.learning_timeout = timeout;
1812                 return rc;
1813         }
1814
1815         /* send timeout value to card; if successful, store value internally */
1816         rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
1817                                           IPA_VNICC_SET_TIMEOUT, &timeout);
1818         if (!rc)
1819                 card->options.vnicc.learning_timeout = timeout;
1820
1821         return rc;
1822 }
1823
1824 /* get current VNICC timeout; called from sysfs show function. Currently, only
1825  * learning supports timeout
1826  */
1827 int qeth_l2_vnicc_get_timeout(struct qeth_card *card, u32 *timeout)
1828 {
1829         int rc = 0;
1830
1831         QETH_CARD_TEXT(card, 2, "vniccgto");
1832
1833         /* check if characteristic and get_timeout are supported */
1834         if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
1835             !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
1836                 return -EOPNOTSUPP;
1837
1838         if (qeth_bridgeport_is_in_use(card))
1839                 return -EBUSY;
1840
1841         /* if card is ready, get timeout. Otherwise, just return stored value */
1842         *timeout = card->options.vnicc.learning_timeout;
1843         if (qeth_card_hw_is_reachable(card))
1844                 rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
1845                                                   IPA_VNICC_GET_TIMEOUT,
1846                                                   timeout);
1847
1848         return rc;
1849 }
1850
1851 /* check if VNICC is currently enabled */
1852 bool qeth_l2_vnicc_is_in_use(struct qeth_card *card)
1853 {
1854         if (!card->options.vnicc.sup_chars)
1855                 return false;
1856         /* default values are only OK if rx_bcast was not enabled by user
1857          * or the card is offline.
1858          */
1859         if (card->options.vnicc.cur_chars == QETH_VNICC_DEFAULT) {
1860                 if (!card->options.vnicc.rx_bcast_enabled ||
1861                     !qeth_card_hw_is_reachable(card))
1862                         return false;
1863         }
1864         return true;
1865 }
1866
1867 /* recover user timeout setting */
1868 static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
1869                                           u32 *timeout)
1870 {
1871         if (card->options.vnicc.sup_chars & vnicc &&
1872             card->options.vnicc.getset_timeout_sup & vnicc &&
1873             !qeth_l2_vnicc_getset_timeout(card, vnicc, IPA_VNICC_SET_TIMEOUT,
1874                                           timeout))
1875                 return false;
1876         *timeout = QETH_VNICC_DEFAULT_TIMEOUT;
1877         return true;
1878 }
1879
1880 /* recover user characteristic setting */
1881 static bool qeth_l2_vnicc_recover_char(struct qeth_card *card, u32 vnicc,
1882                                        bool enable)
1883 {
1884         u32 cmd = enable ? IPA_VNICC_ENABLE : IPA_VNICC_DISABLE;
1885
1886         if (card->options.vnicc.sup_chars & vnicc &&
1887             card->options.vnicc.set_char_sup & vnicc &&
1888             !qeth_l2_vnicc_set_char(card, vnicc, cmd))
1889                 return false;
1890         card->options.vnicc.wanted_chars &= ~vnicc;
1891         card->options.vnicc.wanted_chars |= QETH_VNICC_DEFAULT & vnicc;
1892         return true;
1893 }
1894
1895 /* (re-)initialize VNICC */
1896 static void qeth_l2_vnicc_init(struct qeth_card *card)
1897 {
1898         u32 *timeout = &card->options.vnicc.learning_timeout;
1899         bool enable, error = false;
1900         unsigned int chars_len, i;
1901         unsigned long chars_tmp;
1902         u32 sup_cmds, vnicc;
1903
1904         QETH_CARD_TEXT(card, 2, "vniccini");
1905         /* reset rx_bcast */
1906         card->options.vnicc.rx_bcast_enabled = 0;
1907         /* initial query and storage of VNIC characteristics */
1908         if (qeth_l2_vnicc_query_chars(card)) {
1909                 if (card->options.vnicc.wanted_chars != QETH_VNICC_DEFAULT ||
1910                     *timeout != QETH_VNICC_DEFAULT_TIMEOUT)
1911                         dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
1912                 /* fail quietly if user didn't change the default config */
1913                 card->options.vnicc.sup_chars = 0;
1914                 card->options.vnicc.cur_chars = 0;
1915                 card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
1916                 return;
1917         }
1918         /* get supported commands for each supported characteristic */
1919         chars_tmp = card->options.vnicc.sup_chars;
1920         chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE;
1921         for_each_set_bit(i, &chars_tmp, chars_len) {
1922                 vnicc = BIT(i);
1923                 if (qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds)) {
1924                         sup_cmds = 0;
1925                         error = true;
1926                 }
1927                 if ((sup_cmds & IPA_VNICC_SET_TIMEOUT) &&
1928                     (sup_cmds & IPA_VNICC_GET_TIMEOUT))
1929                         card->options.vnicc.getset_timeout_sup |= vnicc;
1930                 else
1931                         card->options.vnicc.getset_timeout_sup &= ~vnicc;
1932                 if ((sup_cmds & IPA_VNICC_ENABLE) &&
1933                     (sup_cmds & IPA_VNICC_DISABLE))
1934                         card->options.vnicc.set_char_sup |= vnicc;
1935                 else
1936                         card->options.vnicc.set_char_sup &= ~vnicc;
1937         }
1938         /* enforce assumed default values and recover settings, if changed  */
1939         error |= qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING,
1940                                                timeout);
1941         /* Change chars, if necessary  */
1942         chars_tmp = card->options.vnicc.wanted_chars ^
1943                     card->options.vnicc.cur_chars;
1944         chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE;
1945         for_each_set_bit(i, &chars_tmp, chars_len) {
1946                 vnicc = BIT(i);
1947                 enable = card->options.vnicc.wanted_chars & vnicc;
1948                 error |= qeth_l2_vnicc_recover_char(card, vnicc, enable);
1949         }
1950         if (error)
1951                 dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
1952 }
1953
1954 /* configure default values of VNIC characteristics */
1955 static void qeth_l2_vnicc_set_defaults(struct qeth_card *card)
1956 {
1957         /* characteristics values */
1958         card->options.vnicc.sup_chars = QETH_VNICC_ALL;
1959         card->options.vnicc.cur_chars = QETH_VNICC_DEFAULT;
1960         card->options.vnicc.learning_timeout = QETH_VNICC_DEFAULT_TIMEOUT;
1961         /* supported commands */
1962         card->options.vnicc.set_char_sup = QETH_VNICC_ALL;
1963         card->options.vnicc.getset_timeout_sup = QETH_VNICC_LEARNING;
1964         /* settings wanted by users */
1965         card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
1966 }
1967
1968 module_init(qeth_l2_init);
1969 module_exit(qeth_l2_exit);
1970 MODULE_AUTHOR("Frank Blaschka <[email protected]>");
1971 MODULE_DESCRIPTION("qeth layer 2 discipline");
1972 MODULE_LICENSE("GPL");