Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *    Copyright IBM Corp. 2007, 2009
0004  *    Author(s): Utz Bacher <utz.bacher@de.ibm.com>,
0005  *       Frank Pavlic <fpavlic@de.ibm.com>,
0006  *       Thomas Spatzier <tspat@de.ibm.com>,
0007  *       Frank Blaschka <frank.blaschka@de.ibm.com>
0008  */
0009 
0010 #define KMSG_COMPONENT "qeth"
0011 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
0012 
0013 #include <linux/module.h>
0014 #include <linux/moduleparam.h>
0015 #include <linux/string.h>
0016 #include <linux/errno.h>
0017 #include <linux/kernel.h>
0018 #include <linux/slab.h>
0019 #include <linux/etherdevice.h>
0020 #include <linux/if_bridge.h>
0021 #include <linux/list.h>
0022 #include <linux/hash.h>
0023 #include <linux/hashtable.h>
0024 #include <net/switchdev.h>
0025 #include <asm/chsc.h>
0026 #include <asm/css_chars.h>
0027 #include <asm/setup.h>
0028 #include "qeth_core.h"
0029 #include "qeth_l2.h"
0030 
0031 static int qeth_l2_setdelmac_makerc(struct qeth_card *card, u16 retcode)
0032 {
0033     int rc;
0034 
0035     if (retcode)
0036         QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
0037     switch (retcode) {
0038     case IPA_RC_SUCCESS:
0039         rc = 0;
0040         break;
0041     case IPA_RC_L2_UNSUPPORTED_CMD:
0042         rc = -EOPNOTSUPP;
0043         break;
0044     case IPA_RC_L2_ADDR_TABLE_FULL:
0045         rc = -ENOSPC;
0046         break;
0047     case IPA_RC_L2_DUP_MAC:
0048     case IPA_RC_L2_DUP_LAYER3_MAC:
0049         rc = -EADDRINUSE;
0050         break;
0051     case IPA_RC_L2_MAC_NOT_AUTH_BY_HYP:
0052     case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
0053         rc = -EADDRNOTAVAIL;
0054         break;
0055     case IPA_RC_L2_MAC_NOT_FOUND:
0056         rc = -ENOENT;
0057         break;
0058     default:
0059         rc = -EIO;
0060         break;
0061     }
0062     return rc;
0063 }
0064 
0065 static int qeth_l2_send_setdelmac_cb(struct qeth_card *card,
0066                      struct qeth_reply *reply,
0067                      unsigned long data)
0068 {
0069     struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
0070 
0071     return qeth_l2_setdelmac_makerc(card, cmd->hdr.return_code);
0072 }
0073 
0074 static int qeth_l2_send_setdelmac(struct qeth_card *card, const __u8 *mac,
0075                enum qeth_ipa_cmds ipacmd)
0076 {
0077     struct qeth_ipa_cmd *cmd;
0078     struct qeth_cmd_buffer *iob;
0079 
0080     QETH_CARD_TEXT(card, 2, "L2sdmac");
0081     iob = qeth_ipa_alloc_cmd(card, ipacmd, QETH_PROT_IPV4,
0082                  IPA_DATA_SIZEOF(setdelmac));
0083     if (!iob)
0084         return -ENOMEM;
0085     cmd = __ipa_cmd(iob);
0086     cmd->data.setdelmac.mac_length = ETH_ALEN;
0087     ether_addr_copy(cmd->data.setdelmac.mac, mac);
0088     return qeth_send_ipa_cmd(card, iob, qeth_l2_send_setdelmac_cb, NULL);
0089 }
0090 
0091 static int qeth_l2_send_setmac(struct qeth_card *card, const __u8 *mac)
0092 {
0093     int rc;
0094 
0095     QETH_CARD_TEXT(card, 2, "L2Setmac");
0096     rc = qeth_l2_send_setdelmac(card, mac, IPA_CMD_SETVMAC);
0097     if (rc == 0) {
0098         dev_info(&card->gdev->dev,
0099              "MAC address %pM successfully registered\n", mac);
0100     } else {
0101         switch (rc) {
0102         case -EADDRINUSE:
0103             dev_warn(&card->gdev->dev,
0104                 "MAC address %pM already exists\n", mac);
0105             break;
0106         case -EADDRNOTAVAIL:
0107             dev_warn(&card->gdev->dev,
0108                 "MAC address %pM is not authorized\n", mac);
0109             break;
0110         }
0111     }
0112     return rc;
0113 }
0114 
0115 static int qeth_l2_write_mac(struct qeth_card *card, u8 *mac)
0116 {
0117     enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ?
0118                     IPA_CMD_SETGMAC : IPA_CMD_SETVMAC;
0119     int rc;
0120 
0121     QETH_CARD_TEXT(card, 2, "L2Wmac");
0122     rc = qeth_l2_send_setdelmac(card, mac, cmd);
0123     if (rc == -EADDRINUSE)
0124         QETH_DBF_MESSAGE(2, "MAC address %012llx is already registered on device %x\n",
0125                  ether_addr_to_u64(mac), CARD_DEVID(card));
0126     else if (rc)
0127         QETH_DBF_MESSAGE(2, "Failed to register MAC address %012llx on device %x: %d\n",
0128                  ether_addr_to_u64(mac), CARD_DEVID(card), rc);
0129     return rc;
0130 }
0131 
0132 static int qeth_l2_remove_mac(struct qeth_card *card, u8 *mac)
0133 {
0134     enum qeth_ipa_cmds cmd = is_multicast_ether_addr(mac) ?
0135                     IPA_CMD_DELGMAC : IPA_CMD_DELVMAC;
0136     int rc;
0137 
0138     QETH_CARD_TEXT(card, 2, "L2Rmac");
0139     rc = qeth_l2_send_setdelmac(card, mac, cmd);
0140     if (rc)
0141         QETH_DBF_MESSAGE(2, "Failed to delete MAC address %012llx on device %x: %d\n",
0142                  ether_addr_to_u64(mac), CARD_DEVID(card), rc);
0143     return rc;
0144 }
0145 
0146 static void qeth_l2_drain_rx_mode_cache(struct qeth_card *card)
0147 {
0148     struct qeth_mac *mac;
0149     struct hlist_node *tmp;
0150     int i;
0151 
0152     hash_for_each_safe(card->rx_mode_addrs, i, tmp, mac, hnode) {
0153         hash_del(&mac->hnode);
0154         kfree(mac);
0155     }
0156 }
0157 
0158 static void qeth_l2_fill_header(struct qeth_qdio_out_q *queue,
0159                 struct qeth_hdr *hdr, struct sk_buff *skb,
0160                 __be16 proto, unsigned int data_len)
0161 {
0162     int cast_type = qeth_get_ether_cast_type(skb);
0163     struct vlan_ethhdr *veth = vlan_eth_hdr(skb);
0164 
0165     hdr->hdr.l2.pkt_length = data_len;
0166 
0167     if (skb_is_gso(skb)) {
0168         hdr->hdr.l2.id = QETH_HEADER_TYPE_L2_TSO;
0169     } else {
0170         hdr->hdr.l2.id = QETH_HEADER_TYPE_LAYER2;
0171         if (skb->ip_summed == CHECKSUM_PARTIAL)
0172             qeth_tx_csum(skb, &hdr->hdr.l2.flags[1], proto);
0173     }
0174 
0175     /* set byte byte 3 to casting flags */
0176     if (cast_type == RTN_MULTICAST)
0177         hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_MULTICAST;
0178     else if (cast_type == RTN_BROADCAST)
0179         hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_BROADCAST;
0180     else
0181         hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_UNICAST;
0182 
0183     /* VSWITCH relies on the VLAN
0184      * information to be present in
0185      * the QDIO header */
0186     if (veth->h_vlan_proto == htons(ETH_P_8021Q)) {
0187         hdr->hdr.l2.flags[2] |= QETH_LAYER2_FLAG_VLAN;
0188         hdr->hdr.l2.vlan_id = ntohs(veth->h_vlan_TCI);
0189     }
0190 }
0191 
0192 static int qeth_l2_setdelvlan_makerc(struct qeth_card *card, u16 retcode)
0193 {
0194     if (retcode)
0195         QETH_CARD_TEXT_(card, 2, "err%04x", retcode);
0196 
0197     switch (retcode) {
0198     case IPA_RC_SUCCESS:
0199         return 0;
0200     case IPA_RC_L2_INVALID_VLAN_ID:
0201         return -EINVAL;
0202     case IPA_RC_L2_DUP_VLAN_ID:
0203         return -EEXIST;
0204     case IPA_RC_L2_VLAN_ID_NOT_FOUND:
0205         return -ENOENT;
0206     case IPA_RC_L2_VLAN_ID_NOT_ALLOWED:
0207         return -EPERM;
0208     default:
0209         return -EIO;
0210     }
0211 }
0212 
0213 static int qeth_l2_send_setdelvlan_cb(struct qeth_card *card,
0214                       struct qeth_reply *reply,
0215                       unsigned long data)
0216 {
0217     struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
0218 
0219     QETH_CARD_TEXT(card, 2, "L2sdvcb");
0220     if (cmd->hdr.return_code) {
0221         QETH_DBF_MESSAGE(2, "Error in processing VLAN %u on device %x: %#x.\n",
0222                  cmd->data.setdelvlan.vlan_id,
0223                  CARD_DEVID(card), cmd->hdr.return_code);
0224         QETH_CARD_TEXT_(card, 2, "L2VL%4x", cmd->hdr.command);
0225     }
0226     return qeth_l2_setdelvlan_makerc(card, cmd->hdr.return_code);
0227 }
0228 
0229 static int qeth_l2_send_setdelvlan(struct qeth_card *card, __u16 i,
0230                    enum qeth_ipa_cmds ipacmd)
0231 {
0232     struct qeth_ipa_cmd *cmd;
0233     struct qeth_cmd_buffer *iob;
0234 
0235     QETH_CARD_TEXT_(card, 4, "L2sdv%x", ipacmd);
0236     iob = qeth_ipa_alloc_cmd(card, ipacmd, QETH_PROT_IPV4,
0237                  IPA_DATA_SIZEOF(setdelvlan));
0238     if (!iob)
0239         return -ENOMEM;
0240     cmd = __ipa_cmd(iob);
0241     cmd->data.setdelvlan.vlan_id = i;
0242     return qeth_send_ipa_cmd(card, iob, qeth_l2_send_setdelvlan_cb, NULL);
0243 }
0244 
0245 static int qeth_l2_vlan_rx_add_vid(struct net_device *dev,
0246                    __be16 proto, u16 vid)
0247 {
0248     struct qeth_card *card = dev->ml_priv;
0249 
0250     QETH_CARD_TEXT_(card, 4, "aid:%d", vid);
0251     if (!vid)
0252         return 0;
0253 
0254     return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_SETVLAN);
0255 }
0256 
0257 static int qeth_l2_vlan_rx_kill_vid(struct net_device *dev,
0258                     __be16 proto, u16 vid)
0259 {
0260     struct qeth_card *card = dev->ml_priv;
0261 
0262     QETH_CARD_TEXT_(card, 4, "kid:%d", vid);
0263     if (!vid)
0264         return 0;
0265 
0266     return qeth_l2_send_setdelvlan(card, vid, IPA_CMD_DELVLAN);
0267 }
0268 
0269 static void qeth_l2_set_pnso_mode(struct qeth_card *card,
0270                   enum qeth_pnso_mode mode)
0271 {
0272     spin_lock_irq(get_ccwdev_lock(CARD_RDEV(card)));
0273     WRITE_ONCE(card->info.pnso_mode, mode);
0274     spin_unlock_irq(get_ccwdev_lock(CARD_RDEV(card)));
0275 
0276     if (mode == QETH_PNSO_NONE)
0277         drain_workqueue(card->event_wq);
0278 }
0279 
0280 static void qeth_l2_dev2br_fdb_flush(struct qeth_card *card)
0281 {
0282     struct switchdev_notifier_fdb_info info = {};
0283 
0284     QETH_CARD_TEXT(card, 2, "fdbflush");
0285 
0286     info.addr = NULL;
0287     /* flush all VLANs: */
0288     info.vid = 0;
0289     info.added_by_user = false;
0290     info.offloaded = true;
0291 
0292     call_switchdev_notifiers(SWITCHDEV_FDB_FLUSH_TO_BRIDGE,
0293                  card->dev, &info.info, NULL);
0294 }
0295 
0296 static int qeth_l2_request_initial_mac(struct qeth_card *card)
0297 {
0298     int rc = 0;
0299 
0300     QETH_CARD_TEXT(card, 2, "l2reqmac");
0301 
0302     if (MACHINE_IS_VM) {
0303         rc = qeth_vm_request_mac(card);
0304         if (!rc)
0305             goto out;
0306         QETH_DBF_MESSAGE(2, "z/VM MAC Service failed on device %x: %#x\n",
0307                  CARD_DEVID(card), rc);
0308         QETH_CARD_TEXT_(card, 2, "err%04x", rc);
0309         /* fall back to alternative mechanism: */
0310     }
0311 
0312     rc = qeth_setadpparms_change_macaddr(card);
0313     if (!rc)
0314         goto out;
0315     QETH_DBF_MESSAGE(2, "READ_MAC Assist failed on device %x: %#x\n",
0316              CARD_DEVID(card), rc);
0317     QETH_CARD_TEXT_(card, 2, "1err%04x", rc);
0318 
0319     /* Fall back once more, but some devices don't support a custom MAC
0320      * address:
0321      */
0322     if (IS_OSM(card) || IS_OSX(card))
0323         return (rc) ? rc : -EADDRNOTAVAIL;
0324     eth_hw_addr_random(card->dev);
0325 
0326 out:
0327     QETH_CARD_HEX(card, 2, card->dev->dev_addr, card->dev->addr_len);
0328     return 0;
0329 }
0330 
0331 static void qeth_l2_register_dev_addr(struct qeth_card *card)
0332 {
0333     if (!is_valid_ether_addr(card->dev->dev_addr))
0334         qeth_l2_request_initial_mac(card);
0335 
0336     if (!qeth_l2_send_setmac(card, card->dev->dev_addr))
0337         card->info.dev_addr_is_registered = 1;
0338     else
0339         card->info.dev_addr_is_registered = 0;
0340 }
0341 
0342 static int qeth_l2_validate_addr(struct net_device *dev)
0343 {
0344     struct qeth_card *card = dev->ml_priv;
0345 
0346     if (card->info.dev_addr_is_registered)
0347         return eth_validate_addr(dev);
0348 
0349     QETH_CARD_TEXT(card, 4, "nomacadr");
0350     return -EPERM;
0351 }
0352 
0353 static int qeth_l2_set_mac_address(struct net_device *dev, void *p)
0354 {
0355     struct sockaddr *addr = p;
0356     struct qeth_card *card = dev->ml_priv;
0357     u8 old_addr[ETH_ALEN];
0358     int rc = 0;
0359 
0360     QETH_CARD_TEXT(card, 3, "setmac");
0361 
0362     if (IS_OSM(card) || IS_OSX(card)) {
0363         QETH_CARD_TEXT(card, 3, "setmcTYP");
0364         return -EOPNOTSUPP;
0365     }
0366     QETH_CARD_HEX(card, 3, addr->sa_data, ETH_ALEN);
0367     if (!is_valid_ether_addr(addr->sa_data))
0368         return -EADDRNOTAVAIL;
0369 
0370     /* don't register the same address twice */
0371     if (ether_addr_equal_64bits(dev->dev_addr, addr->sa_data) &&
0372         card->info.dev_addr_is_registered)
0373         return 0;
0374 
0375     /* add the new address, switch over, drop the old */
0376     rc = qeth_l2_send_setmac(card, addr->sa_data);
0377     if (rc)
0378         return rc;
0379     ether_addr_copy(old_addr, dev->dev_addr);
0380     eth_hw_addr_set(dev, addr->sa_data);
0381 
0382     if (card->info.dev_addr_is_registered)
0383         qeth_l2_remove_mac(card, old_addr);
0384     card->info.dev_addr_is_registered = 1;
0385     return 0;
0386 }
0387 
0388 static void qeth_l2_promisc_to_bridge(struct qeth_card *card, bool enable)
0389 {
0390     int role;
0391     int rc;
0392 
0393     QETH_CARD_TEXT(card, 3, "pmisc2br");
0394 
0395     if (enable) {
0396         if (card->options.sbp.reflect_promisc_primary)
0397             role = QETH_SBP_ROLE_PRIMARY;
0398         else
0399             role = QETH_SBP_ROLE_SECONDARY;
0400     } else
0401         role = QETH_SBP_ROLE_NONE;
0402 
0403     rc = qeth_bridgeport_setrole(card, role);
0404     QETH_CARD_TEXT_(card, 2, "bpm%c%04x", enable ? '+' : '-', rc);
0405     if (!rc) {
0406         card->options.sbp.role = role;
0407         card->info.promisc_mode = enable;
0408     }
0409 }
0410 
0411 static void qeth_l2_set_promisc_mode(struct qeth_card *card)
0412 {
0413     bool enable = card->dev->flags & IFF_PROMISC;
0414 
0415     if (card->info.promisc_mode == enable)
0416         return;
0417 
0418     if (qeth_adp_supported(card, IPA_SETADP_SET_PROMISC_MODE)) {
0419         qeth_setadp_promisc_mode(card, enable);
0420     } else {
0421         mutex_lock(&card->sbp_lock);
0422         if (card->options.sbp.reflect_promisc)
0423             qeth_l2_promisc_to_bridge(card, enable);
0424         mutex_unlock(&card->sbp_lock);
0425     }
0426 }
0427 
0428 /* New MAC address is added to the hash table and marked to be written on card
0429  * only if there is not in the hash table storage already
0430  *
0431 */
0432 static void qeth_l2_add_mac(struct qeth_card *card, struct netdev_hw_addr *ha)
0433 {
0434     u32 mac_hash = get_unaligned((u32 *)(&ha->addr[2]));
0435     struct qeth_mac *mac;
0436 
0437     hash_for_each_possible(card->rx_mode_addrs, mac, hnode, mac_hash) {
0438         if (ether_addr_equal_64bits(ha->addr, mac->mac_addr)) {
0439             mac->disp_flag = QETH_DISP_ADDR_DO_NOTHING;
0440             return;
0441         }
0442     }
0443 
0444     mac = kzalloc(sizeof(struct qeth_mac), GFP_ATOMIC);
0445     if (!mac)
0446         return;
0447 
0448     ether_addr_copy(mac->mac_addr, ha->addr);
0449     mac->disp_flag = QETH_DISP_ADDR_ADD;
0450 
0451     hash_add(card->rx_mode_addrs, &mac->hnode, mac_hash);
0452 }
0453 
0454 static void qeth_l2_rx_mode_work(struct work_struct *work)
0455 {
0456     struct qeth_card *card = container_of(work, struct qeth_card,
0457                           rx_mode_work);
0458     struct net_device *dev = card->dev;
0459     struct netdev_hw_addr *ha;
0460     struct qeth_mac *mac;
0461     struct hlist_node *tmp;
0462     int i;
0463     int rc;
0464 
0465     QETH_CARD_TEXT(card, 3, "setmulti");
0466 
0467     netif_addr_lock_bh(dev);
0468     netdev_for_each_mc_addr(ha, dev)
0469         qeth_l2_add_mac(card, ha);
0470     netdev_for_each_uc_addr(ha, dev)
0471         qeth_l2_add_mac(card, ha);
0472     netif_addr_unlock_bh(dev);
0473 
0474     hash_for_each_safe(card->rx_mode_addrs, i, tmp, mac, hnode) {
0475         switch (mac->disp_flag) {
0476         case QETH_DISP_ADDR_DELETE:
0477             qeth_l2_remove_mac(card, mac->mac_addr);
0478             hash_del(&mac->hnode);
0479             kfree(mac);
0480             break;
0481         case QETH_DISP_ADDR_ADD:
0482             rc = qeth_l2_write_mac(card, mac->mac_addr);
0483             if (rc) {
0484                 hash_del(&mac->hnode);
0485                 kfree(mac);
0486                 break;
0487             }
0488             fallthrough;
0489         default:
0490             /* for next call to set_rx_mode(): */
0491             mac->disp_flag = QETH_DISP_ADDR_DELETE;
0492         }
0493     }
0494 
0495     qeth_l2_set_promisc_mode(card);
0496 }
0497 
0498 static netdev_tx_t qeth_l2_hard_start_xmit(struct sk_buff *skb,
0499                        struct net_device *dev)
0500 {
0501     struct qeth_card *card = dev->ml_priv;
0502     u16 txq = skb_get_queue_mapping(skb);
0503     struct qeth_qdio_out_q *queue;
0504     int rc;
0505 
0506     if (!skb_is_gso(skb))
0507         qdisc_skb_cb(skb)->pkt_len = skb->len;
0508     if (IS_IQD(card))
0509         txq = qeth_iqd_translate_txq(dev, txq);
0510     queue = card->qdio.out_qs[txq];
0511 
0512     rc = qeth_xmit(card, skb, queue, vlan_get_protocol(skb),
0513                qeth_l2_fill_header);
0514     if (!rc)
0515         return NETDEV_TX_OK;
0516 
0517     QETH_TXQ_STAT_INC(queue, tx_dropped);
0518     kfree_skb(skb);
0519     return NETDEV_TX_OK;
0520 }
0521 
0522 static u16 qeth_l2_iqd_select_queue(struct net_device *dev, struct sk_buff *skb,
0523                     struct net_device *sb_dev)
0524 {
0525     return qeth_iqd_select_queue(dev, skb, qeth_get_ether_cast_type(skb),
0526                      sb_dev);
0527 }
0528 
0529 static void qeth_l2_set_rx_mode(struct net_device *dev)
0530 {
0531     struct qeth_card *card = dev->ml_priv;
0532 
0533     schedule_work(&card->rx_mode_work);
0534 }
0535 
0536 /**
0537  *  qeth_l2_pnso() - perform network subchannel operation
0538  *  @card: qeth_card structure pointer
0539  *  @oc: Operation Code
0540  *  @cnc: Boolean Change-Notification Control
0541  *  @cb: Callback function will be executed for each element
0542  *      of the address list
0543  *  @priv: Pointer to pass to the callback function.
0544  *
0545  *  Collects network information in a network address list and calls the
0546  *  callback function for every entry in the list. If "change-notification-
0547  *  control" is set, further changes in the address list will be reported
0548  *  via the IPA command.
0549  */
0550 static int qeth_l2_pnso(struct qeth_card *card, u8 oc, int cnc,
0551             void (*cb)(void *priv, struct chsc_pnso_naid_l2 *entry),
0552             void *priv)
0553 {
0554     struct ccw_device *ddev = CARD_DDEV(card);
0555     struct chsc_pnso_area *rr;
0556     u32 prev_instance = 0;
0557     int isfirstblock = 1;
0558     int i, size, elems;
0559     int rc;
0560 
0561     rr = (struct chsc_pnso_area *)get_zeroed_page(GFP_KERNEL);
0562     if (rr == NULL)
0563         return -ENOMEM;
0564     do {
0565         QETH_CARD_TEXT(card, 2, "PNSO");
0566         /* on the first iteration, naihdr.resume_token will be zero */
0567         rc = ccw_device_pnso(ddev, rr, oc, rr->naihdr.resume_token,
0568                      cnc);
0569         if (rc)
0570             continue;
0571         if (cb == NULL)
0572             continue;
0573 
0574         size = rr->naihdr.naids;
0575         if (size != sizeof(struct chsc_pnso_naid_l2)) {
0576             WARN_ON_ONCE(1);
0577             continue;
0578         }
0579 
0580         elems = (rr->response.length - sizeof(struct chsc_header) -
0581              sizeof(struct chsc_pnso_naihdr)) / size;
0582 
0583         if (!isfirstblock && (rr->naihdr.instance != prev_instance)) {
0584             /* Inform the caller that they need to scrap */
0585             /* the data that was already reported via cb */
0586             rc = -EAGAIN;
0587             break;
0588         }
0589         isfirstblock = 0;
0590         prev_instance = rr->naihdr.instance;
0591         for (i = 0; i < elems; i++)
0592             (*cb)(priv, &rr->entries[i]);
0593     } while ((rc == -EBUSY) || (!rc && /* list stored */
0594            /* resume token is non-zero => list incomplete */
0595            (rr->naihdr.resume_token.t1 || rr->naihdr.resume_token.t2)));
0596 
0597     if (rc)
0598         QETH_CARD_TEXT_(card, 2, "PNrp%04x", rr->response.code);
0599 
0600     free_page((unsigned long)rr);
0601     return rc;
0602 }
0603 
0604 static bool qeth_is_my_net_if_token(struct qeth_card *card,
0605                     struct net_if_token *token)
0606 {
0607     return ((card->info.ddev_devno == token->devnum) &&
0608         (card->info.cssid == token->cssid) &&
0609         (card->info.iid == token->iid) &&
0610         (card->info.ssid == token->ssid) &&
0611         (card->info.chpid == token->chpid) &&
0612         (card->info.chid == token->chid));
0613 }
0614 
0615 /**
0616  *  qeth_l2_dev2br_fdb_notify() - update fdb of master bridge
0617  *  @card:  qeth_card structure pointer
0618  *  @code:  event bitmask: high order bit 0x80 set to
0619  *              1 - removal of an object
0620  *              0 - addition of an object
0621  *                 Object type(s):
0622  *              0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC
0623  *  @token: "network token" structure identifying 'physical' location
0624  *      of the target
0625  *  @addr_lnid: structure with MAC address and VLAN ID of the target
0626  */
0627 static void qeth_l2_dev2br_fdb_notify(struct qeth_card *card, u8 code,
0628                       struct net_if_token *token,
0629                       struct mac_addr_lnid *addr_lnid)
0630 {
0631     struct switchdev_notifier_fdb_info info = {};
0632     u8 ntfy_mac[ETH_ALEN];
0633 
0634     ether_addr_copy(ntfy_mac, addr_lnid->mac);
0635     /* Ignore VLAN only changes */
0636     if (!(code & IPA_ADDR_CHANGE_CODE_MACADDR))
0637         return;
0638     /* Ignore mcast entries */
0639     if (is_multicast_ether_addr(ntfy_mac))
0640         return;
0641     /* Ignore my own addresses */
0642     if (qeth_is_my_net_if_token(card, token))
0643         return;
0644 
0645     info.addr = ntfy_mac;
0646     /* don't report VLAN IDs */
0647     info.vid = 0;
0648     info.added_by_user = false;
0649     info.offloaded = true;
0650 
0651     if (code & IPA_ADDR_CHANGE_CODE_REMOVAL) {
0652         call_switchdev_notifiers(SWITCHDEV_FDB_DEL_TO_BRIDGE,
0653                      card->dev, &info.info, NULL);
0654         QETH_CARD_TEXT(card, 4, "andelmac");
0655         QETH_CARD_TEXT_(card, 4,
0656                 "mc%012llx", ether_addr_to_u64(ntfy_mac));
0657     } else {
0658         call_switchdev_notifiers(SWITCHDEV_FDB_ADD_TO_BRIDGE,
0659                      card->dev, &info.info, NULL);
0660         QETH_CARD_TEXT(card, 4, "anaddmac");
0661         QETH_CARD_TEXT_(card, 4,
0662                 "mc%012llx", ether_addr_to_u64(ntfy_mac));
0663     }
0664 }
0665 
0666 static void qeth_l2_dev2br_an_set_cb(void *priv,
0667                      struct chsc_pnso_naid_l2 *entry)
0668 {
0669     u8 code = IPA_ADDR_CHANGE_CODE_MACADDR;
0670     struct qeth_card *card = priv;
0671 
0672     if (entry->addr_lnid.lnid < VLAN_N_VID)
0673         code |= IPA_ADDR_CHANGE_CODE_VLANID;
0674     qeth_l2_dev2br_fdb_notify(card, code,
0675                   (struct net_if_token *)&entry->nit,
0676                   (struct mac_addr_lnid *)&entry->addr_lnid);
0677 }
0678 
0679 /**
0680  *  qeth_l2_dev2br_an_set() -
0681  *  Enable or disable 'dev to bridge network address notification'
0682  *  @card: qeth_card structure pointer
0683  *  @enable: Enable or disable 'dev to bridge network address notification'
0684  *
0685  *  Returns negative errno-compatible error indication or 0 on success.
0686  *
0687  *  On enable, emits a series of address notifications for all
0688  *  currently registered hosts.
0689  */
0690 static int qeth_l2_dev2br_an_set(struct qeth_card *card, bool enable)
0691 {
0692     int rc;
0693 
0694     if (enable) {
0695         QETH_CARD_TEXT(card, 2, "anseton");
0696         rc = qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 1,
0697                   qeth_l2_dev2br_an_set_cb, card);
0698         if (rc == -EAGAIN)
0699             /* address notification enabled, but inconsistent
0700              * addresses reported -> disable address notification
0701              */
0702             qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 0,
0703                      NULL, NULL);
0704     } else {
0705         QETH_CARD_TEXT(card, 2, "ansetoff");
0706         rc = qeth_l2_pnso(card, PNSO_OC_NET_ADDR_INFO, 0, NULL, NULL);
0707     }
0708 
0709     return rc;
0710 }
0711 
0712 struct qeth_l2_br2dev_event_work {
0713     struct work_struct work;
0714     struct net_device *br_dev;
0715     struct net_device *lsync_dev;
0716     struct net_device *dst_dev;
0717     unsigned long event;
0718     unsigned char addr[ETH_ALEN];
0719 };
0720 
0721 static const struct net_device_ops qeth_l2_iqd_netdev_ops;
0722 static const struct net_device_ops qeth_l2_osa_netdev_ops;
0723 
0724 static bool qeth_l2_must_learn(struct net_device *netdev,
0725                    struct net_device *dstdev)
0726 {
0727     struct qeth_priv *priv;
0728 
0729     priv = netdev_priv(netdev);
0730     return (netdev != dstdev &&
0731         (priv->brport_features & BR_LEARNING_SYNC) &&
0732         !(br_port_flag_is_set(netdev, BR_ISOLATED) &&
0733           br_port_flag_is_set(dstdev, BR_ISOLATED)) &&
0734         (netdev->netdev_ops == &qeth_l2_iqd_netdev_ops ||
0735          netdev->netdev_ops == &qeth_l2_osa_netdev_ops));
0736 }
0737 
0738 /**
0739  *  qeth_l2_br2dev_worker() - update local MACs
0740  *  @work: bridge to device FDB update
0741  *
0742  *  Update local MACs of a learning_sync bridgeport so it can receive
0743  *  messages for a destination port.
0744  *  In case of an isolated learning_sync port, also update its isolated
0745  *  siblings.
0746  */
0747 static void qeth_l2_br2dev_worker(struct work_struct *work)
0748 {
0749     struct qeth_l2_br2dev_event_work *br2dev_event_work =
0750         container_of(work, struct qeth_l2_br2dev_event_work, work);
0751     struct net_device *lsyncdev = br2dev_event_work->lsync_dev;
0752     struct net_device *dstdev = br2dev_event_work->dst_dev;
0753     struct net_device *brdev = br2dev_event_work->br_dev;
0754     unsigned long event = br2dev_event_work->event;
0755     unsigned char *addr = br2dev_event_work->addr;
0756     struct qeth_card *card = lsyncdev->ml_priv;
0757     struct net_device *lowerdev;
0758     struct list_head *iter;
0759     int err = 0;
0760 
0761     kfree(br2dev_event_work);
0762     QETH_CARD_TEXT_(card, 4, "b2dw%04lx", event);
0763     QETH_CARD_TEXT_(card, 4, "ma%012llx", ether_addr_to_u64(addr));
0764 
0765     rcu_read_lock();
0766     /* Verify preconditions are still valid: */
0767     if (!netif_is_bridge_port(lsyncdev) ||
0768         brdev != netdev_master_upper_dev_get_rcu(lsyncdev))
0769         goto unlock;
0770     if (!qeth_l2_must_learn(lsyncdev, dstdev))
0771         goto unlock;
0772 
0773     if (br_port_flag_is_set(lsyncdev, BR_ISOLATED)) {
0774         /* Update lsyncdev and its isolated sibling(s): */
0775         iter = &brdev->adj_list.lower;
0776         lowerdev = netdev_next_lower_dev_rcu(brdev, &iter);
0777         while (lowerdev) {
0778             if (br_port_flag_is_set(lowerdev, BR_ISOLATED)) {
0779                 switch (event) {
0780                 case SWITCHDEV_FDB_ADD_TO_DEVICE:
0781                     err = dev_uc_add(lowerdev, addr);
0782                     break;
0783                 case SWITCHDEV_FDB_DEL_TO_DEVICE:
0784                     err = dev_uc_del(lowerdev, addr);
0785                     break;
0786                 default:
0787                     break;
0788                 }
0789                 if (err) {
0790                     QETH_CARD_TEXT(card, 2, "b2derris");
0791                     QETH_CARD_TEXT_(card, 2,
0792                             "err%02lx%03d", event,
0793                             lowerdev->ifindex);
0794                 }
0795             }
0796             lowerdev = netdev_next_lower_dev_rcu(brdev, &iter);
0797         }
0798     } else {
0799         switch (event) {
0800         case SWITCHDEV_FDB_ADD_TO_DEVICE:
0801             err = dev_uc_add(lsyncdev, addr);
0802             break;
0803         case SWITCHDEV_FDB_DEL_TO_DEVICE:
0804             err = dev_uc_del(lsyncdev, addr);
0805             break;
0806         default:
0807             break;
0808         }
0809         if (err)
0810             QETH_CARD_TEXT_(card, 2, "b2derr%02lx", event);
0811     }
0812 
0813 unlock:
0814     rcu_read_unlock();
0815     dev_put(brdev);
0816     dev_put(lsyncdev);
0817     dev_put(dstdev);
0818 }
0819 
0820 static int qeth_l2_br2dev_queue_work(struct net_device *brdev,
0821                      struct net_device *lsyncdev,
0822                      struct net_device *dstdev,
0823                      unsigned long event,
0824                      const unsigned char *addr)
0825 {
0826     struct qeth_l2_br2dev_event_work *worker_data;
0827     struct qeth_card *card;
0828 
0829     worker_data = kzalloc(sizeof(*worker_data), GFP_ATOMIC);
0830     if (!worker_data)
0831         return -ENOMEM;
0832     INIT_WORK(&worker_data->work, qeth_l2_br2dev_worker);
0833     worker_data->br_dev = brdev;
0834     worker_data->lsync_dev = lsyncdev;
0835     worker_data->dst_dev = dstdev;
0836     worker_data->event = event;
0837     ether_addr_copy(worker_data->addr, addr);
0838 
0839     card = lsyncdev->ml_priv;
0840     /* Take a reference on the sw port devices and the bridge */
0841     dev_hold(brdev);
0842     dev_hold(lsyncdev);
0843     dev_hold(dstdev);
0844     queue_work(card->event_wq, &worker_data->work);
0845     return 0;
0846 }
0847 
0848 /* Called under rtnl_lock */
0849 static int qeth_l2_switchdev_event(struct notifier_block *unused,
0850                    unsigned long event, void *ptr)
0851 {
0852     struct net_device *dstdev, *brdev, *lowerdev;
0853     struct switchdev_notifier_fdb_info *fdb_info;
0854     struct switchdev_notifier_info *info = ptr;
0855     struct list_head *iter;
0856     struct qeth_card *card;
0857     int rc;
0858 
0859     if (!(event == SWITCHDEV_FDB_ADD_TO_DEVICE ||
0860           event == SWITCHDEV_FDB_DEL_TO_DEVICE))
0861         return NOTIFY_DONE;
0862 
0863     dstdev = switchdev_notifier_info_to_dev(info);
0864     brdev = netdev_master_upper_dev_get_rcu(dstdev);
0865     if (!brdev || !netif_is_bridge_master(brdev))
0866         return NOTIFY_DONE;
0867     fdb_info = container_of(info,
0868                 struct switchdev_notifier_fdb_info,
0869                 info);
0870     iter = &brdev->adj_list.lower;
0871     lowerdev = netdev_next_lower_dev_rcu(brdev, &iter);
0872     while (lowerdev) {
0873         if (qeth_l2_must_learn(lowerdev, dstdev)) {
0874             card = lowerdev->ml_priv;
0875             QETH_CARD_TEXT_(card, 4, "b2dqw%03lx", event);
0876             rc = qeth_l2_br2dev_queue_work(brdev, lowerdev,
0877                                dstdev, event,
0878                                fdb_info->addr);
0879             if (rc) {
0880                 QETH_CARD_TEXT(card, 2, "b2dqwerr");
0881                 return NOTIFY_BAD;
0882             }
0883         }
0884         lowerdev = netdev_next_lower_dev_rcu(brdev, &iter);
0885     }
0886     return NOTIFY_DONE;
0887 }
0888 
0889 static struct notifier_block qeth_l2_sw_notifier = {
0890         .notifier_call = qeth_l2_switchdev_event,
0891 };
0892 
0893 static refcount_t qeth_l2_switchdev_notify_refcnt;
0894 
0895 /* Called under rtnl_lock */
0896 static void qeth_l2_br2dev_get(void)
0897 {
0898     int rc;
0899 
0900     if (!refcount_inc_not_zero(&qeth_l2_switchdev_notify_refcnt)) {
0901         rc = register_switchdev_notifier(&qeth_l2_sw_notifier);
0902         if (rc) {
0903             QETH_DBF_MESSAGE(2,
0904                      "failed to register qeth_l2_sw_notifier: %d\n",
0905                      rc);
0906         } else {
0907             refcount_set(&qeth_l2_switchdev_notify_refcnt, 1);
0908             QETH_DBF_MESSAGE(2, "qeth_l2_sw_notifier registered\n");
0909         }
0910     }
0911     QETH_DBF_TEXT_(SETUP, 2, "b2d+%04d",
0912                qeth_l2_switchdev_notify_refcnt.refs.counter);
0913 }
0914 
0915 /* Called under rtnl_lock */
0916 static void qeth_l2_br2dev_put(void)
0917 {
0918     int rc;
0919 
0920     if (refcount_dec_and_test(&qeth_l2_switchdev_notify_refcnt)) {
0921         rc = unregister_switchdev_notifier(&qeth_l2_sw_notifier);
0922         if (rc) {
0923             QETH_DBF_MESSAGE(2,
0924                      "failed to unregister qeth_l2_sw_notifier: %d\n",
0925                      rc);
0926         } else {
0927             QETH_DBF_MESSAGE(2,
0928                      "qeth_l2_sw_notifier unregistered\n");
0929         }
0930     }
0931     QETH_DBF_TEXT_(SETUP, 2, "b2d-%04d",
0932                qeth_l2_switchdev_notify_refcnt.refs.counter);
0933 }
0934 
0935 static int qeth_l2_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
0936                   struct net_device *dev, u32 filter_mask,
0937                   int nlflags)
0938 {
0939     struct qeth_priv *priv = netdev_priv(dev);
0940     struct qeth_card *card = dev->ml_priv;
0941     u16 mode = BRIDGE_MODE_UNDEF;
0942 
0943     /* Do not even show qeth devs that cannot do bridge_setlink */
0944     if (!priv->brport_hw_features || !netif_device_present(dev) ||
0945         qeth_bridgeport_is_in_use(card))
0946         return -EOPNOTSUPP;
0947 
0948     return ndo_dflt_bridge_getlink(skb, pid, seq, dev,
0949                        mode, priv->brport_features,
0950                        priv->brport_hw_features,
0951                        nlflags, filter_mask, NULL);
0952 }
0953 
0954 static const struct nla_policy qeth_brport_policy[IFLA_BRPORT_MAX + 1] = {
0955     [IFLA_BRPORT_LEARNING_SYNC] = { .type = NLA_U8 },
0956 };
0957 
0958 /**
0959  *  qeth_l2_bridge_setlink() - set bridgeport attributes
0960  *  @dev: netdevice
0961  *  @nlh: netlink message header
0962  *  @flags: bridge flags (here: BRIDGE_FLAGS_SELF)
0963  *  @extack: extended ACK report struct
0964  *
0965  *  Called under rtnl_lock
0966  */
0967 static int qeth_l2_bridge_setlink(struct net_device *dev, struct nlmsghdr *nlh,
0968                   u16 flags, struct netlink_ext_ack *extack)
0969 {
0970     struct qeth_priv *priv = netdev_priv(dev);
0971     struct nlattr *bp_tb[IFLA_BRPORT_MAX + 1];
0972     struct qeth_card *card = dev->ml_priv;
0973     struct nlattr *attr, *nested_attr;
0974     bool enable, has_protinfo = false;
0975     int rem1, rem2;
0976     int rc;
0977 
0978     if (!netif_device_present(dev))
0979         return -ENODEV;
0980 
0981     nlmsg_for_each_attr(attr, nlh, sizeof(struct ifinfomsg), rem1) {
0982         if (nla_type(attr) == IFLA_PROTINFO) {
0983             rc = nla_parse_nested(bp_tb, IFLA_BRPORT_MAX, attr,
0984                           qeth_brport_policy, extack);
0985             if (rc)
0986                 return rc;
0987             has_protinfo = true;
0988         } else if (nla_type(attr) == IFLA_AF_SPEC) {
0989             nla_for_each_nested(nested_attr, attr, rem2) {
0990                 if (nla_type(nested_attr) == IFLA_BRIDGE_FLAGS)
0991                     continue;
0992                 NL_SET_ERR_MSG_ATTR(extack, nested_attr,
0993                             "Unsupported attribute");
0994                 return -EINVAL;
0995             }
0996         } else {
0997             NL_SET_ERR_MSG_ATTR(extack, attr, "Unsupported attribute");
0998             return -EINVAL;
0999         }
1000     }
1001     if (!has_protinfo)
1002         return 0;
1003     if (!bp_tb[IFLA_BRPORT_LEARNING_SYNC])
1004         return -EINVAL;
1005     if (!(priv->brport_hw_features & BR_LEARNING_SYNC)) {
1006         NL_SET_ERR_MSG_ATTR(extack, bp_tb[IFLA_BRPORT_LEARNING_SYNC],
1007                     "Operation not supported by HW");
1008         return -EOPNOTSUPP;
1009     }
1010     if (!IS_ENABLED(CONFIG_NET_SWITCHDEV)) {
1011         NL_SET_ERR_MSG_ATTR(extack, bp_tb[IFLA_BRPORT_LEARNING_SYNC],
1012                     "Requires NET_SWITCHDEV");
1013         return -EOPNOTSUPP;
1014     }
1015     enable = !!nla_get_u8(bp_tb[IFLA_BRPORT_LEARNING_SYNC]);
1016 
1017     if (enable == !!(priv->brport_features & BR_LEARNING_SYNC))
1018         return 0;
1019 
1020     mutex_lock(&card->sbp_lock);
1021     /* do not change anything if BridgePort is enabled */
1022     if (qeth_bridgeport_is_in_use(card)) {
1023         NL_SET_ERR_MSG(extack, "n/a (BridgePort)");
1024         rc = -EBUSY;
1025     } else if (enable) {
1026         qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO);
1027         rc = qeth_l2_dev2br_an_set(card, true);
1028         if (rc) {
1029             qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1030         } else {
1031             priv->brport_features |= BR_LEARNING_SYNC;
1032             qeth_l2_br2dev_get();
1033         }
1034     } else {
1035         rc = qeth_l2_dev2br_an_set(card, false);
1036         if (!rc) {
1037             qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1038             priv->brport_features ^= BR_LEARNING_SYNC;
1039             qeth_l2_dev2br_fdb_flush(card);
1040             qeth_l2_br2dev_put();
1041         }
1042     }
1043     mutex_unlock(&card->sbp_lock);
1044 
1045     return rc;
1046 }
1047 
1048 static const struct net_device_ops qeth_l2_iqd_netdev_ops = {
1049     .ndo_open       = qeth_open,
1050     .ndo_stop       = qeth_stop,
1051     .ndo_get_stats64    = qeth_get_stats64,
1052     .ndo_start_xmit     = qeth_l2_hard_start_xmit,
1053     .ndo_features_check = qeth_features_check,
1054     .ndo_select_queue   = qeth_l2_iqd_select_queue,
1055     .ndo_validate_addr  = qeth_l2_validate_addr,
1056     .ndo_set_rx_mode    = qeth_l2_set_rx_mode,
1057     .ndo_eth_ioctl      = qeth_do_ioctl,
1058     .ndo_siocdevprivate = qeth_siocdevprivate,
1059     .ndo_set_mac_address    = qeth_l2_set_mac_address,
1060     .ndo_vlan_rx_add_vid    = qeth_l2_vlan_rx_add_vid,
1061     .ndo_vlan_rx_kill_vid   = qeth_l2_vlan_rx_kill_vid,
1062     .ndo_tx_timeout     = qeth_tx_timeout,
1063     .ndo_fix_features   = qeth_fix_features,
1064     .ndo_set_features   = qeth_set_features,
1065     .ndo_bridge_getlink = qeth_l2_bridge_getlink,
1066     .ndo_bridge_setlink = qeth_l2_bridge_setlink,
1067 };
1068 
1069 static const struct net_device_ops qeth_l2_osa_netdev_ops = {
1070     .ndo_open       = qeth_open,
1071     .ndo_stop       = qeth_stop,
1072     .ndo_get_stats64    = qeth_get_stats64,
1073     .ndo_start_xmit     = qeth_l2_hard_start_xmit,
1074     .ndo_features_check = qeth_features_check,
1075     .ndo_select_queue   = qeth_osa_select_queue,
1076     .ndo_validate_addr  = qeth_l2_validate_addr,
1077     .ndo_set_rx_mode    = qeth_l2_set_rx_mode,
1078     .ndo_eth_ioctl      = qeth_do_ioctl,
1079     .ndo_siocdevprivate = qeth_siocdevprivate,
1080     .ndo_set_mac_address    = qeth_l2_set_mac_address,
1081     .ndo_vlan_rx_add_vid    = qeth_l2_vlan_rx_add_vid,
1082     .ndo_vlan_rx_kill_vid   = qeth_l2_vlan_rx_kill_vid,
1083     .ndo_tx_timeout     = qeth_tx_timeout,
1084     .ndo_fix_features   = qeth_fix_features,
1085     .ndo_set_features   = qeth_set_features,
1086 };
1087 
1088 static int qeth_l2_setup_netdev(struct qeth_card *card)
1089 {
1090     card->dev->netdev_ops = IS_IQD(card) ? &qeth_l2_iqd_netdev_ops :
1091                            &qeth_l2_osa_netdev_ops;
1092     card->dev->needed_headroom = sizeof(struct qeth_hdr);
1093     card->dev->priv_flags |= IFF_UNICAST_FLT;
1094 
1095     if (IS_OSM(card)) {
1096         card->dev->features |= NETIF_F_VLAN_CHALLENGED;
1097     } else {
1098         if (!IS_VM_NIC(card))
1099             card->dev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
1100         card->dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
1101     }
1102 
1103     if (IS_OSD(card) && !IS_VM_NIC(card)) {
1104         card->dev->features |= NETIF_F_SG;
1105         /* OSA 3S and earlier has no RX/TX support */
1106         if (qeth_is_supported(card, IPA_OUTBOUND_CHECKSUM)) {
1107             card->dev->hw_features |= NETIF_F_IP_CSUM;
1108             card->dev->vlan_features |= NETIF_F_IP_CSUM;
1109         }
1110     }
1111     if (qeth_is_supported6(card, IPA_OUTBOUND_CHECKSUM_V6)) {
1112         card->dev->hw_features |= NETIF_F_IPV6_CSUM;
1113         card->dev->vlan_features |= NETIF_F_IPV6_CSUM;
1114     }
1115     if (qeth_is_supported(card, IPA_INBOUND_CHECKSUM) ||
1116         qeth_is_supported6(card, IPA_INBOUND_CHECKSUM_V6)) {
1117         card->dev->hw_features |= NETIF_F_RXCSUM;
1118         card->dev->vlan_features |= NETIF_F_RXCSUM;
1119     }
1120     if (qeth_is_supported(card, IPA_OUTBOUND_TSO)) {
1121         card->dev->hw_features |= NETIF_F_TSO;
1122         card->dev->vlan_features |= NETIF_F_TSO;
1123     }
1124     if (qeth_is_supported6(card, IPA_OUTBOUND_TSO)) {
1125         card->dev->hw_features |= NETIF_F_TSO6;
1126         card->dev->vlan_features |= NETIF_F_TSO6;
1127     }
1128 
1129     if (card->dev->hw_features & (NETIF_F_TSO | NETIF_F_TSO6)) {
1130         card->dev->needed_headroom = sizeof(struct qeth_hdr_tso);
1131         netif_keep_dst(card->dev);
1132         netif_set_tso_max_size(card->dev,
1133                        PAGE_SIZE * (QDIO_MAX_ELEMENTS_PER_BUFFER - 1));
1134     }
1135 
1136     netif_napi_add(card->dev, &card->napi, qeth_poll, NAPI_POLL_WEIGHT);
1137     return register_netdev(card->dev);
1138 }
1139 
1140 static void qeth_l2_trace_features(struct qeth_card *card)
1141 {
1142     /* Set BridgePort features */
1143     QETH_CARD_TEXT(card, 2, "featuSBP");
1144     QETH_CARD_HEX(card, 2, &card->options.sbp.supported_funcs,
1145               sizeof(card->options.sbp.supported_funcs));
1146     /* VNIC Characteristics features */
1147     QETH_CARD_TEXT(card, 2, "feaVNICC");
1148     QETH_CARD_HEX(card, 2, &card->options.vnicc.sup_chars,
1149               sizeof(card->options.vnicc.sup_chars));
1150 }
1151 
1152 static void qeth_l2_setup_bridgeport_attrs(struct qeth_card *card)
1153 {
1154     if (!card->options.sbp.reflect_promisc &&
1155         card->options.sbp.role != QETH_SBP_ROLE_NONE) {
1156         /* Conditional to avoid spurious error messages */
1157         qeth_bridgeport_setrole(card, card->options.sbp.role);
1158         /* Let the callback function refresh the stored role value. */
1159         qeth_bridgeport_query_ports(card, &card->options.sbp.role,
1160                         NULL);
1161     }
1162     if (card->options.sbp.hostnotification) {
1163         if (qeth_bridgeport_an_set(card, 1))
1164             card->options.sbp.hostnotification = 0;
1165     }
1166 }
1167 
1168 /**
1169  *  qeth_l2_detect_dev2br_support() -
1170  *  Detect whether this card supports 'dev to bridge fdb network address
1171  *  change notification' and thus can support the learning_sync bridgeport
1172  *  attribute
1173  *  @card: qeth_card structure pointer
1174  */
1175 static void qeth_l2_detect_dev2br_support(struct qeth_card *card)
1176 {
1177     struct qeth_priv *priv = netdev_priv(card->dev);
1178     bool dev2br_supported;
1179 
1180     QETH_CARD_TEXT(card, 2, "d2brsup");
1181     if (!IS_IQD(card))
1182         return;
1183 
1184     /* dev2br requires valid cssid,iid,chid */
1185     dev2br_supported = card->info.ids_valid &&
1186                css_general_characteristics.enarf;
1187     QETH_CARD_TEXT_(card, 2, "D2Bsup%02x", dev2br_supported);
1188 
1189     if (dev2br_supported)
1190         priv->brport_hw_features |= BR_LEARNING_SYNC;
1191     else
1192         priv->brport_hw_features &= ~BR_LEARNING_SYNC;
1193 }
1194 
1195 static void qeth_l2_enable_brport_features(struct qeth_card *card)
1196 {
1197     struct qeth_priv *priv = netdev_priv(card->dev);
1198     int rc;
1199 
1200     if (priv->brport_features & BR_LEARNING_SYNC) {
1201         if (priv->brport_hw_features & BR_LEARNING_SYNC) {
1202             qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO);
1203             rc = qeth_l2_dev2br_an_set(card, true);
1204             if (rc == -EAGAIN) {
1205                 /* Recoverable error, retry once */
1206                 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1207                 qeth_l2_dev2br_fdb_flush(card);
1208                 qeth_l2_set_pnso_mode(card, QETH_PNSO_ADDR_INFO);
1209                 rc = qeth_l2_dev2br_an_set(card, true);
1210             }
1211             if (rc) {
1212                 netdev_err(card->dev,
1213                        "failed to enable bridge learning_sync: %d\n",
1214                        rc);
1215                 qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1216                 qeth_l2_dev2br_fdb_flush(card);
1217                 priv->brport_features ^= BR_LEARNING_SYNC;
1218             }
1219         } else {
1220             dev_warn(&card->gdev->dev,
1221                 "bridge learning_sync not supported\n");
1222             priv->brport_features ^= BR_LEARNING_SYNC;
1223         }
1224     }
1225 }
1226 
1227 /* SETBRIDGEPORT support, async notifications */
1228 
1229 enum qeth_an_event_type {anev_reg_unreg, anev_abort, anev_reset};
1230 
1231 /**
1232  * qeth_bridge_emit_host_event() - bridgeport address change notification
1233  * @card:  qeth_card structure pointer, for udev events.
1234  * @evtype:  "normal" register/unregister, or abort, or reset. For abort
1235  *        and reset token and addr_lnid are unused and may be NULL.
1236  * @code:  event bitmask: high order bit 0x80 value 1 means removal of an
1237  *            object, 0 - addition of an object.
1238  *            0x01 - VLAN, 0x02 - MAC, 0x03 - VLAN and MAC.
1239  * @token: "network token" structure identifying physical address of the port.
1240  * @addr_lnid: pointer to structure with MAC address and VLAN ID.
1241  *
1242  * This function is called when registrations and deregistrations are
1243  * reported by the hardware, and also when notifications are enabled -
1244  * for all currently registered addresses.
1245  */
1246 static void qeth_bridge_emit_host_event(struct qeth_card *card,
1247                     enum qeth_an_event_type evtype,
1248                     u8 code,
1249                     struct net_if_token *token,
1250                     struct mac_addr_lnid *addr_lnid)
1251 {
1252     char str[7][32];
1253     char *env[8];
1254     int i = 0;
1255 
1256     switch (evtype) {
1257     case anev_reg_unreg:
1258         snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=%s",
1259                 (code & IPA_ADDR_CHANGE_CODE_REMOVAL)
1260                 ? "deregister" : "register");
1261         env[i] = str[i]; i++;
1262         if (code & IPA_ADDR_CHANGE_CODE_VLANID) {
1263             snprintf(str[i], sizeof(str[i]), "VLAN=%d",
1264                 addr_lnid->lnid);
1265             env[i] = str[i]; i++;
1266         }
1267         if (code & IPA_ADDR_CHANGE_CODE_MACADDR) {
1268             snprintf(str[i], sizeof(str[i]), "MAC=%pM",
1269                 addr_lnid->mac);
1270             env[i] = str[i]; i++;
1271         }
1272         snprintf(str[i], sizeof(str[i]), "NTOK_BUSID=%x.%x.%04x",
1273             token->cssid, token->ssid, token->devnum);
1274         env[i] = str[i]; i++;
1275         snprintf(str[i], sizeof(str[i]), "NTOK_IID=%02x", token->iid);
1276         env[i] = str[i]; i++;
1277         snprintf(str[i], sizeof(str[i]), "NTOK_CHPID=%02x",
1278                 token->chpid);
1279         env[i] = str[i]; i++;
1280         snprintf(str[i], sizeof(str[i]), "NTOK_CHID=%04x", token->chid);
1281         env[i] = str[i]; i++;
1282         break;
1283     case anev_abort:
1284         snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=abort");
1285         env[i] = str[i]; i++;
1286         break;
1287     case anev_reset:
1288         snprintf(str[i], sizeof(str[i]), "BRIDGEDHOST=reset");
1289         env[i] = str[i]; i++;
1290         break;
1291     }
1292     env[i] = NULL;
1293     kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env);
1294 }
1295 
1296 struct qeth_bridge_state_data {
1297     struct work_struct worker;
1298     struct qeth_card *card;
1299     u8 role;
1300     u8 state;
1301 };
1302 
1303 static void qeth_bridge_state_change_worker(struct work_struct *work)
1304 {
1305     struct qeth_bridge_state_data *data =
1306         container_of(work, struct qeth_bridge_state_data, worker);
1307     char env_locrem[32];
1308     char env_role[32];
1309     char env_state[32];
1310     char *env[] = {
1311         env_locrem,
1312         env_role,
1313         env_state,
1314         NULL
1315     };
1316 
1317     snprintf(env_locrem, sizeof(env_locrem), "BRIDGEPORT=statechange");
1318     snprintf(env_role, sizeof(env_role), "ROLE=%s",
1319         (data->role == QETH_SBP_ROLE_NONE) ? "none" :
1320         (data->role == QETH_SBP_ROLE_PRIMARY) ? "primary" :
1321         (data->role == QETH_SBP_ROLE_SECONDARY) ? "secondary" :
1322         "<INVALID>");
1323     snprintf(env_state, sizeof(env_state), "STATE=%s",
1324         (data->state == QETH_SBP_STATE_INACTIVE) ? "inactive" :
1325         (data->state == QETH_SBP_STATE_STANDBY) ? "standby" :
1326         (data->state == QETH_SBP_STATE_ACTIVE) ? "active" :
1327         "<INVALID>");
1328     kobject_uevent_env(&data->card->gdev->dev.kobj,
1329                 KOBJ_CHANGE, env);
1330     kfree(data);
1331 }
1332 
1333 static void qeth_bridge_state_change(struct qeth_card *card,
1334                     struct qeth_ipa_cmd *cmd)
1335 {
1336     struct qeth_sbp_port_data *qports = &cmd->data.sbp.data.port_data;
1337     struct qeth_bridge_state_data *data;
1338 
1339     QETH_CARD_TEXT(card, 2, "brstchng");
1340     if (qports->num_entries == 0) {
1341         QETH_CARD_TEXT(card, 2, "BPempty");
1342         return;
1343     }
1344     if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
1345         QETH_CARD_TEXT_(card, 2, "BPsz%04x", qports->entry_length);
1346         return;
1347     }
1348 
1349     data = kzalloc(sizeof(*data), GFP_ATOMIC);
1350     if (!data) {
1351         QETH_CARD_TEXT(card, 2, "BPSalloc");
1352         return;
1353     }
1354     INIT_WORK(&data->worker, qeth_bridge_state_change_worker);
1355     data->card = card;
1356     /* Information for the local port: */
1357     data->role = qports->entry[0].role;
1358     data->state = qports->entry[0].state;
1359 
1360     queue_work(card->event_wq, &data->worker);
1361 }
1362 
1363 struct qeth_addr_change_data {
1364     struct delayed_work dwork;
1365     struct qeth_card *card;
1366     struct qeth_ipacmd_addr_change ac_event;
1367 };
1368 
1369 static void qeth_l2_dev2br_worker(struct work_struct *work)
1370 {
1371     struct delayed_work *dwork = to_delayed_work(work);
1372     struct qeth_addr_change_data *data;
1373     struct qeth_card *card;
1374     struct qeth_priv *priv;
1375     unsigned int i;
1376     int rc;
1377 
1378     data = container_of(dwork, struct qeth_addr_change_data, dwork);
1379     card = data->card;
1380     priv = netdev_priv(card->dev);
1381 
1382     QETH_CARD_TEXT(card, 4, "dev2brew");
1383 
1384     if (READ_ONCE(card->info.pnso_mode) == QETH_PNSO_NONE)
1385         goto free;
1386 
1387     if (data->ac_event.lost_event_mask) {
1388         /* Potential re-config in progress, try again later: */
1389         if (!rtnl_trylock()) {
1390             queue_delayed_work(card->event_wq, dwork,
1391                        msecs_to_jiffies(100));
1392             return;
1393         }
1394 
1395         if (!netif_device_present(card->dev)) {
1396             rtnl_unlock();
1397             goto free;
1398         }
1399 
1400         QETH_DBF_MESSAGE(3,
1401                  "Address change notification overflow on device %x\n",
1402                  CARD_DEVID(card));
1403         /* Card fdb and bridge fdb are out of sync, card has stopped
1404          * notifications (no need to drain_workqueue). Purge all
1405          * 'extern_learn' entries from the parent bridge and restart
1406          * the notifications.
1407          */
1408         qeth_l2_dev2br_fdb_flush(card);
1409         rc = qeth_l2_dev2br_an_set(card, true);
1410         if (rc) {
1411             /* TODO: if we want to retry after -EAGAIN, be
1412              * aware there could be stale entries in the
1413              * workqueue now, that need to be drained.
1414              * For now we give up:
1415              */
1416             netdev_err(card->dev,
1417                    "bridge learning_sync failed to recover: %d\n",
1418                    rc);
1419             WRITE_ONCE(card->info.pnso_mode,
1420                    QETH_PNSO_NONE);
1421             /* To remove fdb entries reported by an_set: */
1422             qeth_l2_dev2br_fdb_flush(card);
1423             priv->brport_features ^= BR_LEARNING_SYNC;
1424         } else {
1425             QETH_DBF_MESSAGE(3,
1426                      "Address Notification resynced on device %x\n",
1427                      CARD_DEVID(card));
1428         }
1429 
1430         rtnl_unlock();
1431     } else {
1432         for (i = 0; i < data->ac_event.num_entries; i++) {
1433             struct qeth_ipacmd_addr_change_entry *entry =
1434                     &data->ac_event.entry[i];
1435             qeth_l2_dev2br_fdb_notify(card,
1436                           entry->change_code,
1437                           &entry->token,
1438                           &entry->addr_lnid);
1439         }
1440     }
1441 
1442 free:
1443     kfree(data);
1444 }
1445 
1446 static void qeth_addr_change_event_worker(struct work_struct *work)
1447 {
1448     struct delayed_work *dwork = to_delayed_work(work);
1449     struct qeth_addr_change_data *data;
1450     struct qeth_card *card;
1451     int i;
1452 
1453     data = container_of(dwork, struct qeth_addr_change_data, dwork);
1454     card = data->card;
1455 
1456     QETH_CARD_TEXT(data->card, 4, "adrchgew");
1457 
1458     if (READ_ONCE(card->info.pnso_mode) == QETH_PNSO_NONE)
1459         goto free;
1460 
1461     if (data->ac_event.lost_event_mask) {
1462         /* Potential re-config in progress, try again later: */
1463         if (!mutex_trylock(&card->sbp_lock)) {
1464             queue_delayed_work(card->event_wq, dwork,
1465                        msecs_to_jiffies(100));
1466             return;
1467         }
1468 
1469         dev_info(&data->card->gdev->dev,
1470              "Address change notification stopped on %s (%s)\n",
1471              netdev_name(card->dev),
1472             (data->ac_event.lost_event_mask == 0x01)
1473             ? "Overflow"
1474             : (data->ac_event.lost_event_mask == 0x02)
1475             ? "Bridge port state change"
1476             : "Unknown reason");
1477 
1478         data->card->options.sbp.hostnotification = 0;
1479         card->info.pnso_mode = QETH_PNSO_NONE;
1480         mutex_unlock(&data->card->sbp_lock);
1481         qeth_bridge_emit_host_event(data->card, anev_abort,
1482                         0, NULL, NULL);
1483     } else
1484         for (i = 0; i < data->ac_event.num_entries; i++) {
1485             struct qeth_ipacmd_addr_change_entry *entry =
1486                     &data->ac_event.entry[i];
1487             qeth_bridge_emit_host_event(data->card,
1488                             anev_reg_unreg,
1489                             entry->change_code,
1490                             &entry->token,
1491                             &entry->addr_lnid);
1492         }
1493 
1494 free:
1495     kfree(data);
1496 }
1497 
1498 static void qeth_addr_change_event(struct qeth_card *card,
1499                    struct qeth_ipa_cmd *cmd)
1500 {
1501     struct qeth_ipacmd_addr_change *hostevs =
1502          &cmd->data.addrchange;
1503     struct qeth_addr_change_data *data;
1504     int extrasize;
1505 
1506     if (card->info.pnso_mode == QETH_PNSO_NONE)
1507         return;
1508 
1509     QETH_CARD_TEXT(card, 4, "adrchgev");
1510     if (cmd->hdr.return_code != 0x0000) {
1511         if (cmd->hdr.return_code == 0x0010) {
1512             if (hostevs->lost_event_mask == 0x00)
1513                 hostevs->lost_event_mask = 0xff;
1514         } else {
1515             QETH_CARD_TEXT_(card, 2, "ACHN%04x",
1516                 cmd->hdr.return_code);
1517             return;
1518         }
1519     }
1520     extrasize = sizeof(struct qeth_ipacmd_addr_change_entry) *
1521                         hostevs->num_entries;
1522     data = kzalloc(sizeof(struct qeth_addr_change_data) + extrasize,
1523                GFP_ATOMIC);
1524     if (!data) {
1525         QETH_CARD_TEXT(card, 2, "ACNalloc");
1526         return;
1527     }
1528     if (card->info.pnso_mode == QETH_PNSO_BRIDGEPORT)
1529         INIT_DELAYED_WORK(&data->dwork, qeth_addr_change_event_worker);
1530     else
1531         INIT_DELAYED_WORK(&data->dwork, qeth_l2_dev2br_worker);
1532     data->card = card;
1533     memcpy(&data->ac_event, hostevs,
1534             sizeof(struct qeth_ipacmd_addr_change) + extrasize);
1535     queue_delayed_work(card->event_wq, &data->dwork, 0);
1536 }
1537 
1538 /* SETBRIDGEPORT support; sending commands */
1539 
1540 struct _qeth_sbp_cbctl {
1541     union {
1542         u32 supported;
1543         struct {
1544             enum qeth_sbp_roles *role;
1545             enum qeth_sbp_states *state;
1546         } qports;
1547     } data;
1548 };
1549 
1550 static int qeth_bridgeport_makerc(struct qeth_card *card,
1551                   struct qeth_ipa_cmd *cmd)
1552 {
1553     struct qeth_ipacmd_setbridgeport *sbp = &cmd->data.sbp;
1554     enum qeth_ipa_sbp_cmd setcmd = sbp->hdr.command_code;
1555     u16 ipa_rc = cmd->hdr.return_code;
1556     u16 sbp_rc = sbp->hdr.return_code;
1557     int rc;
1558 
1559     if (ipa_rc == IPA_RC_SUCCESS && sbp_rc == IPA_RC_SUCCESS)
1560         return 0;
1561 
1562     if ((IS_IQD(card) && ipa_rc == IPA_RC_SUCCESS) ||
1563         (!IS_IQD(card) && ipa_rc == sbp_rc)) {
1564         switch (sbp_rc) {
1565         case IPA_RC_SUCCESS:
1566             rc = 0;
1567             break;
1568         case IPA_RC_L2_UNSUPPORTED_CMD:
1569         case IPA_RC_UNSUPPORTED_COMMAND:
1570             rc = -EOPNOTSUPP;
1571             break;
1572         case IPA_RC_SBP_OSA_NOT_CONFIGURED:
1573         case IPA_RC_SBP_IQD_NOT_CONFIGURED:
1574             rc = -ENODEV; /* maybe not the best code here? */
1575             dev_err(&card->gdev->dev,
1576     "The device is not configured as a Bridge Port\n");
1577             break;
1578         case IPA_RC_SBP_OSA_OS_MISMATCH:
1579         case IPA_RC_SBP_IQD_OS_MISMATCH:
1580             rc = -EPERM;
1581             dev_err(&card->gdev->dev,
1582     "A Bridge Port is already configured by a different operating system\n");
1583             break;
1584         case IPA_RC_SBP_OSA_ANO_DEV_PRIMARY:
1585         case IPA_RC_SBP_IQD_ANO_DEV_PRIMARY:
1586             switch (setcmd) {
1587             case IPA_SBP_SET_PRIMARY_BRIDGE_PORT:
1588                 rc = -EEXIST;
1589                 dev_err(&card->gdev->dev,
1590     "The LAN already has a primary Bridge Port\n");
1591                 break;
1592             case IPA_SBP_SET_SECONDARY_BRIDGE_PORT:
1593                 rc = -EBUSY;
1594                 dev_err(&card->gdev->dev,
1595     "The device is already a primary Bridge Port\n");
1596                 break;
1597             default:
1598                 rc = -EIO;
1599             }
1600             break;
1601         case IPA_RC_SBP_OSA_CURRENT_SECOND:
1602         case IPA_RC_SBP_IQD_CURRENT_SECOND:
1603             rc = -EBUSY;
1604             dev_err(&card->gdev->dev,
1605     "The device is already a secondary Bridge Port\n");
1606             break;
1607         case IPA_RC_SBP_OSA_LIMIT_SECOND:
1608         case IPA_RC_SBP_IQD_LIMIT_SECOND:
1609             rc = -EEXIST;
1610             dev_err(&card->gdev->dev,
1611     "The LAN cannot have more secondary Bridge Ports\n");
1612             break;
1613         case IPA_RC_SBP_OSA_CURRENT_PRIMARY:
1614         case IPA_RC_SBP_IQD_CURRENT_PRIMARY:
1615             rc = -EBUSY;
1616             dev_err(&card->gdev->dev,
1617     "The device is already a primary Bridge Port\n");
1618             break;
1619         case IPA_RC_SBP_OSA_NOT_AUTHD_BY_ZMAN:
1620         case IPA_RC_SBP_IQD_NOT_AUTHD_BY_ZMAN:
1621             rc = -EACCES;
1622             dev_err(&card->gdev->dev,
1623     "The device is not authorized to be a Bridge Port\n");
1624             break;
1625         default:
1626             rc = -EIO;
1627         }
1628     } else {
1629         switch (ipa_rc) {
1630         case IPA_RC_NOTSUPP:
1631             rc = -EOPNOTSUPP;
1632             break;
1633         case IPA_RC_UNSUPPORTED_COMMAND:
1634             rc = -EOPNOTSUPP;
1635             break;
1636         default:
1637             rc = -EIO;
1638         }
1639     }
1640 
1641     if (rc) {
1642         QETH_CARD_TEXT_(card, 2, "SBPi%04x", ipa_rc);
1643         QETH_CARD_TEXT_(card, 2, "SBPc%04x", sbp_rc);
1644     }
1645     return rc;
1646 }
1647 
1648 static struct qeth_cmd_buffer *qeth_sbp_build_cmd(struct qeth_card *card,
1649                           enum qeth_ipa_sbp_cmd sbp_cmd,
1650                           unsigned int data_length)
1651 {
1652     enum qeth_ipa_cmds ipa_cmd = IS_IQD(card) ? IPA_CMD_SETBRIDGEPORT_IQD :
1653                             IPA_CMD_SETBRIDGEPORT_OSA;
1654     struct qeth_ipacmd_sbp_hdr *hdr;
1655     struct qeth_cmd_buffer *iob;
1656 
1657     iob = qeth_ipa_alloc_cmd(card, ipa_cmd, QETH_PROT_NONE,
1658                  data_length +
1659                  offsetof(struct qeth_ipacmd_setbridgeport,
1660                       data));
1661     if (!iob)
1662         return iob;
1663 
1664     hdr = &__ipa_cmd(iob)->data.sbp.hdr;
1665     hdr->cmdlength = sizeof(*hdr) + data_length;
1666     hdr->command_code = sbp_cmd;
1667     hdr->used_total = 1;
1668     hdr->seq_no = 1;
1669     return iob;
1670 }
1671 
1672 static int qeth_bridgeport_query_support_cb(struct qeth_card *card,
1673     struct qeth_reply *reply, unsigned long data)
1674 {
1675     struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1676     struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1677     int rc;
1678 
1679     QETH_CARD_TEXT(card, 2, "brqsupcb");
1680     rc = qeth_bridgeport_makerc(card, cmd);
1681     if (rc)
1682         return rc;
1683 
1684     cbctl->data.supported =
1685         cmd->data.sbp.data.query_cmds_supp.supported_cmds;
1686     return 0;
1687 }
1688 
1689 /**
1690  * qeth_bridgeport_query_support() - store bitmask of supported subfunctions.
1691  * @card:                qeth_card structure pointer.
1692  *
1693  * Sets bitmask of supported setbridgeport subfunctions in the qeth_card
1694  * strucutre: card->options.sbp.supported_funcs.
1695  */
1696 static void qeth_bridgeport_query_support(struct qeth_card *card)
1697 {
1698     struct qeth_cmd_buffer *iob;
1699     struct _qeth_sbp_cbctl cbctl;
1700 
1701     QETH_CARD_TEXT(card, 2, "brqsuppo");
1702     iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_COMMANDS_SUPPORTED,
1703                  SBP_DATA_SIZEOF(query_cmds_supp));
1704     if (!iob)
1705         return;
1706 
1707     if (qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_support_cb,
1708                   &cbctl)) {
1709         card->options.sbp.role = QETH_SBP_ROLE_NONE;
1710         card->options.sbp.supported_funcs = 0;
1711         return;
1712     }
1713     card->options.sbp.supported_funcs = cbctl.data.supported;
1714 }
1715 
1716 static int qeth_bridgeport_query_ports_cb(struct qeth_card *card,
1717     struct qeth_reply *reply, unsigned long data)
1718 {
1719     struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1720     struct _qeth_sbp_cbctl *cbctl = (struct _qeth_sbp_cbctl *)reply->param;
1721     struct qeth_sbp_port_data *qports;
1722     int rc;
1723 
1724     QETH_CARD_TEXT(card, 2, "brqprtcb");
1725     rc = qeth_bridgeport_makerc(card, cmd);
1726     if (rc)
1727         return rc;
1728 
1729     qports = &cmd->data.sbp.data.port_data;
1730     if (qports->entry_length != sizeof(struct qeth_sbp_port_entry)) {
1731         QETH_CARD_TEXT_(card, 2, "SBPs%04x", qports->entry_length);
1732         return -EINVAL;
1733     }
1734     /* first entry contains the state of the local port */
1735     if (qports->num_entries > 0) {
1736         if (cbctl->data.qports.role)
1737             *cbctl->data.qports.role = qports->entry[0].role;
1738         if (cbctl->data.qports.state)
1739             *cbctl->data.qports.state = qports->entry[0].state;
1740     }
1741     return 0;
1742 }
1743 
1744 /**
1745  * qeth_bridgeport_query_ports() - query local bridgeport status.
1746  * @card:              qeth_card structure pointer.
1747  * @role:   Role of the port: 0-none, 1-primary, 2-secondary.
1748  * @state:  State of the port: 0-inactive, 1-standby, 2-active.
1749  *
1750  * Returns negative errno-compatible error indication or 0 on success.
1751  *
1752  * 'role' and 'state' are not updated in case of hardware operation failure.
1753  */
1754 int qeth_bridgeport_query_ports(struct qeth_card *card,
1755     enum qeth_sbp_roles *role, enum qeth_sbp_states *state)
1756 {
1757     struct qeth_cmd_buffer *iob;
1758     struct _qeth_sbp_cbctl cbctl = {
1759         .data = {
1760             .qports = {
1761                 .role = role,
1762                 .state = state,
1763             },
1764         },
1765     };
1766 
1767     QETH_CARD_TEXT(card, 2, "brqports");
1768     if (!(card->options.sbp.supported_funcs & IPA_SBP_QUERY_BRIDGE_PORTS))
1769         return -EOPNOTSUPP;
1770     iob = qeth_sbp_build_cmd(card, IPA_SBP_QUERY_BRIDGE_PORTS, 0);
1771     if (!iob)
1772         return -ENOMEM;
1773 
1774     return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_query_ports_cb,
1775                  &cbctl);
1776 }
1777 
1778 static int qeth_bridgeport_set_cb(struct qeth_card *card,
1779     struct qeth_reply *reply, unsigned long data)
1780 {
1781     struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *)data;
1782 
1783     QETH_CARD_TEXT(card, 2, "brsetrcb");
1784     return qeth_bridgeport_makerc(card, cmd);
1785 }
1786 
1787 /**
1788  * qeth_bridgeport_setrole() - Assign primary role to the port.
1789  * @card:              qeth_card structure pointer.
1790  * @role:              Role to assign.
1791  *
1792  * Returns negative errno-compatible error indication or 0 on success.
1793  */
1794 int qeth_bridgeport_setrole(struct qeth_card *card, enum qeth_sbp_roles role)
1795 {
1796     struct qeth_cmd_buffer *iob;
1797     enum qeth_ipa_sbp_cmd setcmd;
1798     unsigned int cmdlength = 0;
1799 
1800     QETH_CARD_TEXT(card, 2, "brsetrol");
1801     switch (role) {
1802     case QETH_SBP_ROLE_NONE:
1803         setcmd = IPA_SBP_RESET_BRIDGE_PORT_ROLE;
1804         break;
1805     case QETH_SBP_ROLE_PRIMARY:
1806         setcmd = IPA_SBP_SET_PRIMARY_BRIDGE_PORT;
1807         cmdlength = SBP_DATA_SIZEOF(set_primary);
1808         break;
1809     case QETH_SBP_ROLE_SECONDARY:
1810         setcmd = IPA_SBP_SET_SECONDARY_BRIDGE_PORT;
1811         break;
1812     default:
1813         return -EINVAL;
1814     }
1815     if (!(card->options.sbp.supported_funcs & setcmd))
1816         return -EOPNOTSUPP;
1817     iob = qeth_sbp_build_cmd(card, setcmd, cmdlength);
1818     if (!iob)
1819         return -ENOMEM;
1820 
1821     return qeth_send_ipa_cmd(card, iob, qeth_bridgeport_set_cb, NULL);
1822 }
1823 
1824 static void qeth_bridgeport_an_set_cb(void *priv,
1825                       struct chsc_pnso_naid_l2 *entry)
1826 {
1827     struct qeth_card *card = (struct qeth_card *)priv;
1828     u8 code;
1829 
1830     code = IPA_ADDR_CHANGE_CODE_MACADDR;
1831     if (entry->addr_lnid.lnid < VLAN_N_VID)
1832         code |= IPA_ADDR_CHANGE_CODE_VLANID;
1833     qeth_bridge_emit_host_event(card, anev_reg_unreg, code,
1834                     (struct net_if_token *)&entry->nit,
1835                     (struct mac_addr_lnid *)&entry->addr_lnid);
1836 }
1837 
1838 /**
1839  * qeth_bridgeport_an_set() - Enable or disable bridgeport address notification
1840  * @card:             qeth_card structure pointer.
1841  * @enable:           0 - disable, non-zero - enable notifications
1842  *
1843  * Returns negative errno-compatible error indication or 0 on success.
1844  *
1845  * On enable, emits a series of address notifications udev events for all
1846  * currently registered hosts.
1847  */
1848 int qeth_bridgeport_an_set(struct qeth_card *card, int enable)
1849 {
1850     int rc;
1851 
1852     if (!card->options.sbp.supported_funcs)
1853         return -EOPNOTSUPP;
1854 
1855     if (enable) {
1856         qeth_bridge_emit_host_event(card, anev_reset, 0, NULL, NULL);
1857         qeth_l2_set_pnso_mode(card, QETH_PNSO_BRIDGEPORT);
1858         rc = qeth_l2_pnso(card, PNSO_OC_NET_BRIDGE_INFO, 1,
1859                   qeth_bridgeport_an_set_cb, card);
1860         if (rc)
1861             qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1862     } else {
1863         rc = qeth_l2_pnso(card, PNSO_OC_NET_BRIDGE_INFO, 0, NULL, NULL);
1864         qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
1865     }
1866     return rc;
1867 }
1868 
1869 /* VNIC Characteristics support */
1870 
1871 /* handle VNICC IPA command return codes; convert to error codes */
1872 static int qeth_l2_vnicc_makerc(struct qeth_card *card, u16 ipa_rc)
1873 {
1874     int rc;
1875 
1876     switch (ipa_rc) {
1877     case IPA_RC_SUCCESS:
1878         return ipa_rc;
1879     case IPA_RC_L2_UNSUPPORTED_CMD:
1880     case IPA_RC_NOTSUPP:
1881         rc = -EOPNOTSUPP;
1882         break;
1883     case IPA_RC_VNICC_OOSEQ:
1884         rc = -EALREADY;
1885         break;
1886     case IPA_RC_VNICC_VNICBP:
1887         rc = -EBUSY;
1888         break;
1889     case IPA_RC_L2_ADDR_TABLE_FULL:
1890         rc = -ENOSPC;
1891         break;
1892     case IPA_RC_L2_MAC_NOT_AUTH_BY_ADP:
1893         rc = -EACCES;
1894         break;
1895     default:
1896         rc = -EIO;
1897     }
1898 
1899     QETH_CARD_TEXT_(card, 2, "err%04x", ipa_rc);
1900     return rc;
1901 }
1902 
1903 /* generic VNICC request call back */
1904 static int qeth_l2_vnicc_request_cb(struct qeth_card *card,
1905                     struct qeth_reply *reply,
1906                     unsigned long data)
1907 {
1908     struct qeth_ipa_cmd *cmd = (struct qeth_ipa_cmd *) data;
1909     struct qeth_ipacmd_vnicc *rep = &cmd->data.vnicc;
1910     u32 sub_cmd = cmd->data.vnicc.hdr.sub_command;
1911 
1912     QETH_CARD_TEXT(card, 2, "vniccrcb");
1913     if (cmd->hdr.return_code)
1914         return qeth_l2_vnicc_makerc(card, cmd->hdr.return_code);
1915     /* return results to caller */
1916     card->options.vnicc.sup_chars = rep->vnicc_cmds.supported;
1917     card->options.vnicc.cur_chars = rep->vnicc_cmds.enabled;
1918 
1919     if (sub_cmd == IPA_VNICC_QUERY_CMDS)
1920         *(u32 *)reply->param = rep->data.query_cmds.sup_cmds;
1921     else if (sub_cmd == IPA_VNICC_GET_TIMEOUT)
1922         *(u32 *)reply->param = rep->data.getset_timeout.timeout;
1923 
1924     return 0;
1925 }
1926 
1927 static struct qeth_cmd_buffer *qeth_l2_vnicc_build_cmd(struct qeth_card *card,
1928                                u32 vnicc_cmd,
1929                                unsigned int data_length)
1930 {
1931     struct qeth_ipacmd_vnicc_hdr *hdr;
1932     struct qeth_cmd_buffer *iob;
1933 
1934     iob = qeth_ipa_alloc_cmd(card, IPA_CMD_VNICC, QETH_PROT_NONE,
1935                  data_length +
1936                  offsetof(struct qeth_ipacmd_vnicc, data));
1937     if (!iob)
1938         return NULL;
1939 
1940     hdr = &__ipa_cmd(iob)->data.vnicc.hdr;
1941     hdr->data_length = sizeof(*hdr) + data_length;
1942     hdr->sub_command = vnicc_cmd;
1943     return iob;
1944 }
1945 
1946 /* VNICC query VNIC characteristics request */
1947 static int qeth_l2_vnicc_query_chars(struct qeth_card *card)
1948 {
1949     struct qeth_cmd_buffer *iob;
1950 
1951     QETH_CARD_TEXT(card, 2, "vniccqch");
1952     iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CHARS, 0);
1953     if (!iob)
1954         return -ENOMEM;
1955 
1956     return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL);
1957 }
1958 
1959 /* VNICC query sub commands request */
1960 static int qeth_l2_vnicc_query_cmds(struct qeth_card *card, u32 vnic_char,
1961                     u32 *sup_cmds)
1962 {
1963     struct qeth_cmd_buffer *iob;
1964 
1965     QETH_CARD_TEXT(card, 2, "vniccqcm");
1966     iob = qeth_l2_vnicc_build_cmd(card, IPA_VNICC_QUERY_CMDS,
1967                       VNICC_DATA_SIZEOF(query_cmds));
1968     if (!iob)
1969         return -ENOMEM;
1970 
1971     __ipa_cmd(iob)->data.vnicc.data.query_cmds.vnic_char = vnic_char;
1972 
1973     return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, sup_cmds);
1974 }
1975 
1976 /* VNICC enable/disable characteristic request */
1977 static int qeth_l2_vnicc_set_char(struct qeth_card *card, u32 vnic_char,
1978                       u32 cmd)
1979 {
1980     struct qeth_cmd_buffer *iob;
1981 
1982     QETH_CARD_TEXT(card, 2, "vniccedc");
1983     iob = qeth_l2_vnicc_build_cmd(card, cmd, VNICC_DATA_SIZEOF(set_char));
1984     if (!iob)
1985         return -ENOMEM;
1986 
1987     __ipa_cmd(iob)->data.vnicc.data.set_char.vnic_char = vnic_char;
1988 
1989     return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, NULL);
1990 }
1991 
1992 /* VNICC get/set timeout for characteristic request */
1993 static int qeth_l2_vnicc_getset_timeout(struct qeth_card *card, u32 vnicc,
1994                     u32 cmd, u32 *timeout)
1995 {
1996     struct qeth_vnicc_getset_timeout *getset_timeout;
1997     struct qeth_cmd_buffer *iob;
1998 
1999     QETH_CARD_TEXT(card, 2, "vniccgst");
2000     iob = qeth_l2_vnicc_build_cmd(card, cmd,
2001                       VNICC_DATA_SIZEOF(getset_timeout));
2002     if (!iob)
2003         return -ENOMEM;
2004 
2005     getset_timeout = &__ipa_cmd(iob)->data.vnicc.data.getset_timeout;
2006     getset_timeout->vnic_char = vnicc;
2007 
2008     if (cmd == IPA_VNICC_SET_TIMEOUT)
2009         getset_timeout->timeout = *timeout;
2010 
2011     return qeth_send_ipa_cmd(card, iob, qeth_l2_vnicc_request_cb, timeout);
2012 }
2013 
2014 /* recover user timeout setting */
2015 static bool qeth_l2_vnicc_recover_timeout(struct qeth_card *card, u32 vnicc,
2016                       u32 *timeout)
2017 {
2018     if (card->options.vnicc.sup_chars & vnicc &&
2019         card->options.vnicc.getset_timeout_sup & vnicc &&
2020         !qeth_l2_vnicc_getset_timeout(card, vnicc, IPA_VNICC_SET_TIMEOUT,
2021                       timeout))
2022         return false;
2023     *timeout = QETH_VNICC_DEFAULT_TIMEOUT;
2024     return true;
2025 }
2026 
2027 /* set current VNICC flag state; called from sysfs store function */
2028 int qeth_l2_vnicc_set_state(struct qeth_card *card, u32 vnicc, bool state)
2029 {
2030     int rc = 0;
2031     u32 cmd;
2032 
2033     QETH_CARD_TEXT(card, 2, "vniccsch");
2034 
2035     /* check if characteristic and enable/disable are supported */
2036     if (!(card->options.vnicc.sup_chars & vnicc) ||
2037         !(card->options.vnicc.set_char_sup & vnicc))
2038         return -EOPNOTSUPP;
2039 
2040     if (qeth_bridgeport_is_in_use(card))
2041         return -EBUSY;
2042 
2043     /* set enable/disable command and store wanted characteristic */
2044     if (state) {
2045         cmd = IPA_VNICC_ENABLE;
2046         card->options.vnicc.wanted_chars |= vnicc;
2047     } else {
2048         cmd = IPA_VNICC_DISABLE;
2049         card->options.vnicc.wanted_chars &= ~vnicc;
2050     }
2051 
2052     /* do we need to do anything? */
2053     if (card->options.vnicc.cur_chars == card->options.vnicc.wanted_chars)
2054         return rc;
2055 
2056     /* if card is not ready, simply stop here */
2057     if (!qeth_card_hw_is_reachable(card)) {
2058         if (state)
2059             card->options.vnicc.cur_chars |= vnicc;
2060         else
2061             card->options.vnicc.cur_chars &= ~vnicc;
2062         return rc;
2063     }
2064 
2065     rc = qeth_l2_vnicc_set_char(card, vnicc, cmd);
2066     if (rc)
2067         card->options.vnicc.wanted_chars =
2068             card->options.vnicc.cur_chars;
2069     else {
2070         /* successful online VNICC change; handle special cases */
2071         if (state && vnicc == QETH_VNICC_RX_BCAST)
2072             card->options.vnicc.rx_bcast_enabled = true;
2073         if (!state && vnicc == QETH_VNICC_LEARNING)
2074             qeth_l2_vnicc_recover_timeout(card, vnicc,
2075                     &card->options.vnicc.learning_timeout);
2076     }
2077 
2078     return rc;
2079 }
2080 
2081 /* get current VNICC flag state; called from sysfs show function */
2082 int qeth_l2_vnicc_get_state(struct qeth_card *card, u32 vnicc, bool *state)
2083 {
2084     int rc = 0;
2085 
2086     QETH_CARD_TEXT(card, 2, "vniccgch");
2087 
2088     /* check if characteristic is supported */
2089     if (!(card->options.vnicc.sup_chars & vnicc))
2090         return -EOPNOTSUPP;
2091 
2092     if (qeth_bridgeport_is_in_use(card))
2093         return -EBUSY;
2094 
2095     /* if card is ready, query current VNICC state */
2096     if (qeth_card_hw_is_reachable(card))
2097         rc = qeth_l2_vnicc_query_chars(card);
2098 
2099     *state = (card->options.vnicc.cur_chars & vnicc) ? true : false;
2100     return rc;
2101 }
2102 
2103 /* set VNICC timeout; called from sysfs store function. Currently, only learning
2104  * supports timeout
2105  */
2106 int qeth_l2_vnicc_set_timeout(struct qeth_card *card, u32 timeout)
2107 {
2108     int rc = 0;
2109 
2110     QETH_CARD_TEXT(card, 2, "vniccsto");
2111 
2112     /* check if characteristic and set_timeout are supported */
2113     if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
2114         !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
2115         return -EOPNOTSUPP;
2116 
2117     if (qeth_bridgeport_is_in_use(card))
2118         return -EBUSY;
2119 
2120     /* do we need to do anything? */
2121     if (card->options.vnicc.learning_timeout == timeout)
2122         return rc;
2123 
2124     /* if card is not ready, simply store the value internally and return */
2125     if (!qeth_card_hw_is_reachable(card)) {
2126         card->options.vnicc.learning_timeout = timeout;
2127         return rc;
2128     }
2129 
2130     /* send timeout value to card; if successful, store value internally */
2131     rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
2132                       IPA_VNICC_SET_TIMEOUT, &timeout);
2133     if (!rc)
2134         card->options.vnicc.learning_timeout = timeout;
2135 
2136     return rc;
2137 }
2138 
2139 /* get current VNICC timeout; called from sysfs show function. Currently, only
2140  * learning supports timeout
2141  */
2142 int qeth_l2_vnicc_get_timeout(struct qeth_card *card, u32 *timeout)
2143 {
2144     int rc = 0;
2145 
2146     QETH_CARD_TEXT(card, 2, "vniccgto");
2147 
2148     /* check if characteristic and get_timeout are supported */
2149     if (!(card->options.vnicc.sup_chars & QETH_VNICC_LEARNING) ||
2150         !(card->options.vnicc.getset_timeout_sup & QETH_VNICC_LEARNING))
2151         return -EOPNOTSUPP;
2152 
2153     if (qeth_bridgeport_is_in_use(card))
2154         return -EBUSY;
2155 
2156     /* if card is ready, get timeout. Otherwise, just return stored value */
2157     *timeout = card->options.vnicc.learning_timeout;
2158     if (qeth_card_hw_is_reachable(card))
2159         rc = qeth_l2_vnicc_getset_timeout(card, QETH_VNICC_LEARNING,
2160                           IPA_VNICC_GET_TIMEOUT,
2161                           timeout);
2162 
2163     return rc;
2164 }
2165 
2166 /* check if VNICC is currently enabled */
2167 static bool _qeth_l2_vnicc_is_in_use(struct qeth_card *card)
2168 {
2169     if (!card->options.vnicc.sup_chars)
2170         return false;
2171     /* default values are only OK if rx_bcast was not enabled by user
2172      * or the card is offline.
2173      */
2174     if (card->options.vnicc.cur_chars == QETH_VNICC_DEFAULT) {
2175         if (!card->options.vnicc.rx_bcast_enabled ||
2176             !qeth_card_hw_is_reachable(card))
2177             return false;
2178     }
2179     return true;
2180 }
2181 
2182 /**
2183  *  qeth_bridgeport_allowed - are any qeth_bridgeport functions allowed?
2184  *  @card: qeth_card structure pointer
2185  *
2186  *  qeth_bridgeport functionality is mutually exclusive with usage of the
2187  *  VNIC Characteristics and dev2br address notifications
2188  */
2189 bool qeth_bridgeport_allowed(struct qeth_card *card)
2190 {
2191     struct qeth_priv *priv = netdev_priv(card->dev);
2192 
2193     return (!_qeth_l2_vnicc_is_in_use(card) &&
2194         !(priv->brport_features & BR_LEARNING_SYNC));
2195 }
2196 
2197 /* recover user characteristic setting */
2198 static bool qeth_l2_vnicc_recover_char(struct qeth_card *card, u32 vnicc,
2199                        bool enable)
2200 {
2201     u32 cmd = enable ? IPA_VNICC_ENABLE : IPA_VNICC_DISABLE;
2202 
2203     if (card->options.vnicc.sup_chars & vnicc &&
2204         card->options.vnicc.set_char_sup & vnicc &&
2205         !qeth_l2_vnicc_set_char(card, vnicc, cmd))
2206         return false;
2207     card->options.vnicc.wanted_chars &= ~vnicc;
2208     card->options.vnicc.wanted_chars |= QETH_VNICC_DEFAULT & vnicc;
2209     return true;
2210 }
2211 
2212 /* (re-)initialize VNICC */
2213 static void qeth_l2_vnicc_init(struct qeth_card *card)
2214 {
2215     u32 *timeout = &card->options.vnicc.learning_timeout;
2216     bool enable, error = false;
2217     unsigned int chars_len, i;
2218     unsigned long chars_tmp;
2219     u32 sup_cmds, vnicc;
2220 
2221     QETH_CARD_TEXT(card, 2, "vniccini");
2222     /* reset rx_bcast */
2223     card->options.vnicc.rx_bcast_enabled = 0;
2224     /* initial query and storage of VNIC characteristics */
2225     if (qeth_l2_vnicc_query_chars(card)) {
2226         if (card->options.vnicc.wanted_chars != QETH_VNICC_DEFAULT ||
2227             *timeout != QETH_VNICC_DEFAULT_TIMEOUT)
2228             dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
2229         /* fail quietly if user didn't change the default config */
2230         card->options.vnicc.sup_chars = 0;
2231         card->options.vnicc.cur_chars = 0;
2232         card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
2233         return;
2234     }
2235     /* get supported commands for each supported characteristic */
2236     chars_tmp = card->options.vnicc.sup_chars;
2237     chars_len = sizeof(card->options.vnicc.sup_chars) * BITS_PER_BYTE;
2238     for_each_set_bit(i, &chars_tmp, chars_len) {
2239         vnicc = BIT(i);
2240         if (qeth_l2_vnicc_query_cmds(card, vnicc, &sup_cmds)) {
2241             sup_cmds = 0;
2242             error = true;
2243         }
2244         if ((sup_cmds & IPA_VNICC_SET_TIMEOUT) &&
2245             (sup_cmds & IPA_VNICC_GET_TIMEOUT))
2246             card->options.vnicc.getset_timeout_sup |= vnicc;
2247         else
2248             card->options.vnicc.getset_timeout_sup &= ~vnicc;
2249         if ((sup_cmds & IPA_VNICC_ENABLE) &&
2250             (sup_cmds & IPA_VNICC_DISABLE))
2251             card->options.vnicc.set_char_sup |= vnicc;
2252         else
2253             card->options.vnicc.set_char_sup &= ~vnicc;
2254     }
2255     /* enforce assumed default values and recover settings, if changed  */
2256     error |= qeth_l2_vnicc_recover_timeout(card, QETH_VNICC_LEARNING,
2257                            timeout);
2258     /* Change chars, if necessary  */
2259     chars_tmp = card->options.vnicc.wanted_chars ^
2260             card->options.vnicc.cur_chars;
2261     chars_len = sizeof(card->options.vnicc.wanted_chars) * BITS_PER_BYTE;
2262     for_each_set_bit(i, &chars_tmp, chars_len) {
2263         vnicc = BIT(i);
2264         enable = card->options.vnicc.wanted_chars & vnicc;
2265         error |= qeth_l2_vnicc_recover_char(card, vnicc, enable);
2266     }
2267     if (error)
2268         dev_err(&card->gdev->dev, "Configuring the VNIC characteristics failed\n");
2269 }
2270 
2271 /* configure default values of VNIC characteristics */
2272 static void qeth_l2_vnicc_set_defaults(struct qeth_card *card)
2273 {
2274     /* characteristics values */
2275     card->options.vnicc.sup_chars = QETH_VNICC_ALL;
2276     card->options.vnicc.cur_chars = QETH_VNICC_DEFAULT;
2277     card->options.vnicc.learning_timeout = QETH_VNICC_DEFAULT_TIMEOUT;
2278     /* supported commands */
2279     card->options.vnicc.set_char_sup = QETH_VNICC_ALL;
2280     card->options.vnicc.getset_timeout_sup = QETH_VNICC_LEARNING;
2281     /* settings wanted by users */
2282     card->options.vnicc.wanted_chars = QETH_VNICC_DEFAULT;
2283 }
2284 
2285 static const struct device_type qeth_l2_devtype = {
2286     .name = "qeth_layer2",
2287     .groups = qeth_l2_attr_groups,
2288 };
2289 
2290 static int qeth_l2_probe_device(struct ccwgroup_device *gdev)
2291 {
2292     struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2293     int rc;
2294 
2295     qeth_l2_vnicc_set_defaults(card);
2296     mutex_init(&card->sbp_lock);
2297 
2298     if (gdev->dev.type) {
2299         rc = device_add_groups(&gdev->dev, qeth_l2_attr_groups);
2300         if (rc)
2301             return rc;
2302     } else {
2303         gdev->dev.type = &qeth_l2_devtype;
2304     }
2305 
2306     INIT_WORK(&card->rx_mode_work, qeth_l2_rx_mode_work);
2307     return 0;
2308 }
2309 
2310 static void qeth_l2_remove_device(struct ccwgroup_device *gdev)
2311 {
2312     struct qeth_card *card = dev_get_drvdata(&gdev->dev);
2313     struct qeth_priv *priv;
2314 
2315     if (gdev->dev.type != &qeth_l2_devtype)
2316         device_remove_groups(&gdev->dev, qeth_l2_attr_groups);
2317 
2318     qeth_set_allowed_threads(card, 0, 1);
2319     wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
2320 
2321     if (gdev->state == CCWGROUP_ONLINE)
2322         qeth_set_offline(card, card->discipline, false);
2323 
2324     if (card->dev->reg_state == NETREG_REGISTERED) {
2325         priv = netdev_priv(card->dev);
2326         if (priv->brport_features & BR_LEARNING_SYNC) {
2327             rtnl_lock();
2328             qeth_l2_br2dev_put();
2329             rtnl_unlock();
2330         }
2331         unregister_netdev(card->dev);
2332     }
2333 }
2334 
2335 static int qeth_l2_set_online(struct qeth_card *card, bool carrier_ok)
2336 {
2337     struct net_device *dev = card->dev;
2338     int rc = 0;
2339 
2340     qeth_l2_detect_dev2br_support(card);
2341 
2342     mutex_lock(&card->sbp_lock);
2343     qeth_bridgeport_query_support(card);
2344     if (card->options.sbp.supported_funcs) {
2345         qeth_l2_setup_bridgeport_attrs(card);
2346         dev_info(&card->gdev->dev,
2347              "The device represents a Bridge Capable Port\n");
2348     }
2349     mutex_unlock(&card->sbp_lock);
2350 
2351     qeth_l2_register_dev_addr(card);
2352 
2353     /* for the rx_bcast characteristic, init VNICC after setmac */
2354     qeth_l2_vnicc_init(card);
2355 
2356     qeth_l2_trace_features(card);
2357 
2358     /* softsetup */
2359     QETH_CARD_TEXT(card, 2, "softsetp");
2360 
2361     card->state = CARD_STATE_SOFTSETUP;
2362 
2363     qeth_set_allowed_threads(card, 0xffffffff, 0);
2364 
2365     if (dev->reg_state != NETREG_REGISTERED) {
2366         rc = qeth_l2_setup_netdev(card);
2367         if (rc)
2368             goto err_setup;
2369 
2370         if (carrier_ok)
2371             netif_carrier_on(dev);
2372     } else {
2373         rtnl_lock();
2374         rc = qeth_set_real_num_tx_queues(card,
2375                          qeth_tx_actual_queues(card));
2376         if (rc) {
2377             rtnl_unlock();
2378             goto err_set_queues;
2379         }
2380 
2381         if (carrier_ok)
2382             netif_carrier_on(dev);
2383         else
2384             netif_carrier_off(dev);
2385 
2386         netif_device_attach(dev);
2387         qeth_enable_hw_features(dev);
2388         qeth_l2_enable_brport_features(card);
2389 
2390         if (card->info.open_when_online) {
2391             card->info.open_when_online = 0;
2392             dev_open(dev, NULL);
2393         }
2394         rtnl_unlock();
2395     }
2396     return 0;
2397 
2398 err_set_queues:
2399 err_setup:
2400     qeth_set_allowed_threads(card, 0, 1);
2401     card->state = CARD_STATE_DOWN;
2402     return rc;
2403 }
2404 
2405 static void qeth_l2_set_offline(struct qeth_card *card)
2406 {
2407     struct qeth_priv *priv = netdev_priv(card->dev);
2408 
2409     qeth_set_allowed_threads(card, 0, 1);
2410     qeth_l2_drain_rx_mode_cache(card);
2411 
2412     if (card->state == CARD_STATE_SOFTSETUP)
2413         card->state = CARD_STATE_DOWN;
2414 
2415     qeth_l2_set_pnso_mode(card, QETH_PNSO_NONE);
2416     if (priv->brport_features & BR_LEARNING_SYNC)
2417         qeth_l2_dev2br_fdb_flush(card);
2418 }
2419 
2420 /* Returns zero if the command is successfully "consumed" */
2421 static int qeth_l2_control_event(struct qeth_card *card,
2422                  struct qeth_ipa_cmd *cmd)
2423 {
2424     switch (cmd->hdr.command) {
2425     case IPA_CMD_SETBRIDGEPORT_OSA:
2426     case IPA_CMD_SETBRIDGEPORT_IQD:
2427         if (cmd->data.sbp.hdr.command_code ==
2428             IPA_SBP_BRIDGE_PORT_STATE_CHANGE) {
2429             qeth_bridge_state_change(card, cmd);
2430             return 0;
2431         }
2432 
2433         return 1;
2434     case IPA_CMD_ADDRESS_CHANGE_NOTIF:
2435         qeth_addr_change_event(card, cmd);
2436         return 0;
2437     default:
2438         return 1;
2439     }
2440 }
2441 
2442 const struct qeth_discipline qeth_l2_discipline = {
2443     .setup = qeth_l2_probe_device,
2444     .remove = qeth_l2_remove_device,
2445     .set_online = qeth_l2_set_online,
2446     .set_offline = qeth_l2_set_offline,
2447     .control_event_handler = qeth_l2_control_event,
2448 };
2449 EXPORT_SYMBOL_GPL(qeth_l2_discipline);
2450 
2451 static int __init qeth_l2_init(void)
2452 {
2453     pr_info("register layer 2 discipline\n");
2454     refcount_set(&qeth_l2_switchdev_notify_refcnt, 0);
2455     return 0;
2456 }
2457 
2458 static void __exit qeth_l2_exit(void)
2459 {
2460     pr_info("unregister layer 2 discipline\n");
2461 }
2462 
2463 module_init(qeth_l2_init);
2464 module_exit(qeth_l2_exit);
2465 MODULE_AUTHOR("Frank Blaschka <frank.blaschka@de.ibm.com>");
2466 MODULE_DESCRIPTION("qeth layer 2 discipline");
2467 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!