__u32 hwtrap;
 };
 
+enum qeth_discipline_id {
+       QETH_DISCIPLINE_UNDETERMINED = -1,
+       QETH_DISCIPLINE_LAYER3 = 0,
+       QETH_DISCIPLINE_LAYER2 = 1,
+};
+
 struct qeth_card_options {
        struct qeth_routing_info route4;
        struct qeth_ipa_info ipa4;
        struct qeth_sbp_info sbp; /* SETBRIDGEPORT options */
        struct qeth_vnicc_info vnicc; /* VNICC options */
        int fake_broadcast;
-       int layer2;
+       enum qeth_discipline_id layer;
        int performance_stats;
        int rx_sg_cb;
        enum qeth_ipa_isolation_modes isolation;
        char hsuid[9];
 };
 
+#define        IS_LAYER2(card) ((card)->options.layer == QETH_DISCIPLINE_LAYER2)
+#define        IS_LAYER3(card) ((card)->options.layer == QETH_DISCIPLINE_LAYER3)
+
 /*
  * thread bits for qeth_card thread masks
  */
        int (*data_cb)(struct sk_buff *skb);
 };
 
-enum qeth_discipline_id {
-       QETH_DISCIPLINE_UNDETERMINED = -1,
-       QETH_DISCIPLINE_LAYER3 = 0,
-       QETH_DISCIPLINE_LAYER2 = 1,
-};
-
 struct qeth_discipline {
        const struct device_type *devtype;
        int (*process_rx_buffer)(struct qeth_card *card, int budget, int *done);
 
        card->options.rx_sg_cb = QETH_RX_SG_CB;
        card->options.isolation = ISOLATION_MODE_NONE;
        card->options.cq = QETH_CQ_DISABLED;
+       card->options.layer = QETH_DISCIPLINE_UNDETERMINED;
 }
 
 static int qeth_do_start_thread(struct qeth_card *card, unsigned long thread)
                goto out_channel;
        if (qeth_setup_channel(&card->data, false))
                goto out_data;
-       card->options.layer2 = -1;
        card->qeth_service_level.seq_print = qeth_core_sl_print;
        register_service_level(&card->qeth_service_level);
        return card;
                if (dev->mtu)
                        new_mtu = dev->mtu;
                /* default MTUs for first setup: */
-               else if (card->options.layer2)
+               else if (IS_LAYER2(card))
                        new_mtu = ETH_DATA_LEN;
                else
                        new_mtu = ETH_DATA_LEN - 8; /* allow for LLC + SNAP */
 {
        if (IS_OSN(card))
                return QETH_PROT_OSN2;
-       return (card->options.layer2 == 1) ? QETH_PROT_LAYER2 : QETH_PROT_TCPIP;
+       return IS_LAYER2(card) ? QETH_PROT_LAYER2 : QETH_PROT_TCPIP;
 }
 
 static int qeth_ulp_enable(struct qeth_card *card)
        /* cmd->hdr.seqno is set by qeth_send_control_data() */
        cmd->hdr.adapter_type = qeth_get_ipa_adp_type(card->info.link_type);
        cmd->hdr.rel_adapter_no = (u8) card->dev->dev_port;
-       if (card->options.layer2)
-               cmd->hdr.prim_version_no = 2;
-       else
-               cmd->hdr.prim_version_no = 1;
+       cmd->hdr.prim_version_no = IS_LAYER2(card) ? 2 : 1;
        cmd->hdr.param_count = 1;
        cmd->hdr.prot_version = prot;
 }
        if (qeth_setadpparms_inspect_rc(cmd))
                return 0;
 
-       if (!card->options.layer2 ||
-           !(card->info.mac_bits & QETH_LAYER2_MAC_READ)) {
+       if (IS_LAYER3(card) || !(card->info.mac_bits & QETH_LAYER2_MAC_READ)) {
                ether_addr_copy(card->dev->dev_addr,
                                cmd->data.setadapterparms.data.change_addr.addr);
                card->info.mac_bits |= QETH_LAYER2_MAC_READ;
                return -EOPNOTSUPP;
 
        if ((!qeth_adp_supported(card, IPA_SETADP_SET_SNMP_CONTROL)) &&
-           (!card->options.layer2)) {
+           IS_LAYER3(card))
                return -EOPNOTSUPP;
-       }
+
        /* skip 4 bytes (data_len struct member) to get req_len */
        if (copy_from_user(&req_len, udata + sizeof(int), sizeof(int)))
                return -EFAULT;
 
 void qeth_core_free_discipline(struct qeth_card *card)
 {
-       if (card->options.layer2)
+       if (IS_LAYER2(card))
                symbol_put(qeth_l2_discipline);
        else
                symbol_put(qeth_l3_discipline);
 {
        struct qeth_card *card = dev->ml_priv;
 
-       strlcpy(info->driver, card->options.layer2 ? "qeth_l2" : "qeth_l3",
+       strlcpy(info->driver, IS_LAYER2(card) ? "qeth_l2" : "qeth_l3",
                sizeof(info->driver));
        strlcpy(info->version, "1.0", sizeof(info->version));
        strlcpy(info->fw_version, card->info.mcl_level,
 
                card->qdio.do_prio_queueing = QETH_PRIO_Q_ING_TOS;
                card->qdio.default_out_queue = QETH_DEFAULT_QUEUE;
        } else if (sysfs_streq(buf, "prio_queueing_vlan")) {
-               if (!card->options.layer2) {
+               if (IS_LAYER3(card)) {
                        rc = -ENOTSUPP;
                        goto out;
                }
        if (!card)
                return -EINVAL;
 
-       return sprintf(buf, "%i\n", card->options.layer2);
+       return sprintf(buf, "%i\n", card->options.layer);
 }
 
 static ssize_t qeth_dev_layer2_store(struct device *dev,
                goto out;
        }
 
-       if (card->options.layer2 == newdis)
+       if (card->options.layer == newdis)
                goto out;
        if (card->info.layer_enforced) {
                /* fixed layer, can't switch */
 
                card->discipline->remove(card->gdev);
                qeth_core_free_discipline(card);
-               card->options.layer2 = -1;
+               card->options.layer = QETH_DISCIPLINE_UNDETERMINED;
 
                free_netdev(card->dev);
                card->dev = ndev;