nes_debug(NES_DBG_CQ, "%s: Reporting stripped VLAN packet. Tag = 0x%04X\n",
                                                        nesvnic->netdev->name, vlan_tag);
 
-                                       __vlan_hwaccel_put_tag(rx_skb, vlan_tag);
+                                       __vlan_hwaccel_put_tag(rx_skb, htons(ETH_P_8021Q), vlan_tag);
                                }
                                if (nes_use_lro)
                                        lro_receive_skb(&nesvnic->lro_mgr, rx_skb, NULL);
 
                skb->dev = client_info->slave->dev;
 
                if (client_info->tag) {
-                       skb = vlan_put_tag(skb, client_info->vlan_id);
+                       skb = vlan_put_tag(skb, htons(ETH_P_8021Q), client_info->vlan_id);
                        if (!skb) {
                                pr_err("%s: Error: failed to insert VLAN tag\n",
                                       client_info->slave->bond->dev->name);
                                continue;
                        }
 
-                       skb = vlan_put_tag(skb, vlan->vlan_id);
+                       skb = vlan_put_tag(skb, htons(ETH_P_8021Q), vlan->vlan_id);
                        if (!skb) {
                                pr_err("%s: Error: failed to insert VLAN tag\n",
                                       bond->dev->name);
 
                        skb_checksum_none_assert(new_skb);
 
                if (rx->rxStatus & TYPHOON_RX_VLAN)
-                       __vlan_hwaccel_put_tag(new_skb,
+                       __vlan_hwaccel_put_tag(new_skb, htons(ETH_P_8021Q),
                                               ntohl(rx->vlanTag) & 0xffff);
                netif_receive_skb(new_skb);
 
 
                                printk(KERN_DEBUG "  netdev_rx() vlanid = %d\n",
                                       vlid);
                        }
-                       __vlan_hwaccel_put_tag(skb, vlid);
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlid);
                }
 #endif /* VLAN_SUPPORT */
                netif_receive_skb(skb);
 
 
                /* send it up */
                if ((bd_flags & BD_FLG_VLAN_TAG))
-                       __vlan_hwaccel_put_tag(skb, retdesc->vlan);
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), retdesc->vlan);
                netif_rx(skb);
 
                dev->stats.rx_packets++;
 
 #if AMD8111E_VLAN_TAG_USED
                        if (vtag == TT_VLAN_TAGGED){
                                u16 vlan_tag = le16_to_cpu(lp->rx_ring[rx_index].tag_ctrl_info);
-                               __vlan_hwaccel_put_tag(skb, vlan_tag);
+                               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
                        }
 #endif
                        netif_receive_skb(skb);
 
 
                        AT_TAG_TO_VLAN(rrs->vlan_tag, vlan);
                        vlan = le16_to_cpu(vlan);
-                       __vlan_hwaccel_put_tag(skb, vlan);
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan);
                }
                netif_receive_skb(skb);
 
 
                                netdev_dbg(netdev,
                                           "RXD VLAN TAG<RRD>=0x%04x\n",
                                           prrs->vtag);
-                               __vlan_hwaccel_put_tag(skb, vlan_tag);
+                               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
                        }
                        netif_receive_skb(skb);
 
 
                                        ((rrd->vlan_tag & 7) << 13) |
                                        ((rrd->vlan_tag & 8) << 9);
 
-                       __vlan_hwaccel_put_tag(skb, vlan_tag);
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
                }
                netif_receive_skb(skb);
 
 
                                        ((rxd->status.vtag&7) << 13) |
                                        ((rxd->status.vtag&8) << 9);
 
-                               __vlan_hwaccel_put_tag(skb, vlan_tag);
+                               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
                        }
                        netif_rx(skb);
                        netdev->stats.rx_bytes += rx_size;
 
                }
                if ((status & L2_FHDR_STATUS_L2_VLAN_TAG) &&
                    !(bp->rx_mode & BNX2_EMAC_RX_MODE_KEEP_VLAN_TAG))
-                       __vlan_hwaccel_put_tag(skb, rx_hdr->l2_fhdr_vlan_tag);
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rx_hdr->l2_fhdr_vlan_tag);
 
                skb->protocol = eth_type_trans(skb, bp->dev);
 
 
                if (!bnx2x_fill_frag_skb(bp, fp, tpa_info, pages,
                                         skb, cqe, cqe_idx)) {
                        if (tpa_info->parsing_flags & PARSING_FLAGS_VLAN)
-                               __vlan_hwaccel_put_tag(skb, tpa_info->vlan_tag);
+                               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), tpa_info->vlan_tag);
                        bnx2x_gro_receive(bp, fp, skb);
                } else {
                        DP(NETIF_MSG_RX_STATUS,
 
                if (le16_to_cpu(cqe_fp->pars_flags.flags) &
                    PARSING_FLAGS_VLAN)
-                       __vlan_hwaccel_put_tag(skb,
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
                                               le16_to_cpu(cqe_fp->vlan_tag));
                napi_gro_receive(&fp->napi, skb);
 
 
 
                if (desc->type_flags & RXD_FLAG_VLAN &&
                    !(tp->rx_mode & RX_MODE_KEEP_VLAN_TAG))
-                       __vlan_hwaccel_put_tag(skb,
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
                                               desc->err_vlan & RXD_VLAN_MASK);
 
                napi_gro_receive(&tnapi->napi, skb);
 
                rcb->rxq->rx_bytes += length;
 
                if (flags & BNA_CQ_EF_VLAN)
-                       __vlan_hwaccel_put_tag(skb, ntohs(cmpl->vlan_tag));
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), ntohs(cmpl->vlan_tag));
 
                if (BNAD_RXBUF_IS_PAGE(unmap_q->type))
                        napi_gro_frags(&rx_ctrl->napi);
 
 
        if (p->vlan_valid) {
                st->vlan_xtract++;
-               __vlan_hwaccel_put_tag(skb, ntohs(p->vlan));
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), ntohs(p->vlan));
        }
        netif_receive_skb(skb);
 }
 
 
        if (p->vlan_valid) {
                qs->port_stats[SGE_PSTAT_VLANEX]++;
-               __vlan_hwaccel_put_tag(skb, ntohs(p->vlan));
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), ntohs(p->vlan));
        }
        if (rq->polling) {
                if (lro)
 
        if (cpl->vlan_valid) {
                qs->port_stats[SGE_PSTAT_VLANEX]++;
-               __vlan_hwaccel_put_tag(skb, ntohs(cpl->vlan));
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), ntohs(cpl->vlan));
        }
        napi_gro_frags(&qs->napi);
 }
 
                skb->rxhash = (__force u32)pkt->rsshdr.hash_val;
 
        if (unlikely(pkt->vlan_ex)) {
-               __vlan_hwaccel_put_tag(skb, ntohs(pkt->vlan));
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), ntohs(pkt->vlan));
                rxq->stats.vlan_ex++;
        }
        ret = napi_gro_frags(&rxq->rspq.napi);
                skb_checksum_none_assert(skb);
 
        if (unlikely(pkt->vlan_ex)) {
-               __vlan_hwaccel_put_tag(skb, ntohs(pkt->vlan));
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), ntohs(pkt->vlan));
                rxq->stats.vlan_ex++;
        }
        netif_receive_skb(skb);
 
        skb_record_rx_queue(skb, rxq->rspq.idx);
 
        if (pkt->vlan_ex) {
-               __vlan_hwaccel_put_tag(skb, be16_to_cpu(pkt->vlan));
+               __vlan_hwaccel_put_tag(skb, cpu_to_be16(ETH_P_8021Q),
+                                       be16_to_cpu(pkt->vlan));
                rxq->stats.vlan_ex++;
        }
        ret = napi_gro_frags(&rxq->rspq.napi);
 
        if (pkt->vlan_ex) {
                rxq->stats.vlan_ex++;
-               __vlan_hwaccel_put_tag(skb, be16_to_cpu(pkt->vlan));
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), be16_to_cpu(pkt->vlan));
        }
 
        netif_receive_skb(skb);
 
                }
 
                if (vlan_stripped)
-                       __vlan_hwaccel_put_tag(skb, vlan_tci);
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tci);
 
                if (netdev->features & NETIF_F_GRO)
                        napi_gro_receive(&enic->napi[q_number], skb);
 
 
        if (vlan_tx_tag_present(skb)) {
                vlan_tag = be_get_tx_vlan_tag(adapter, skb);
-               __vlan_put_tag(skb, vlan_tag);
+               __vlan_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
                skb->vlan_tci = 0;
        }
 
 
 
        if (rxcp->vlanf)
-               __vlan_hwaccel_put_tag(skb, rxcp->vlan_tag);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);
 
        netif_receive_skb(skb);
 }
                skb->rxhash = rxcp->rss_hash;
 
        if (rxcp->vlanf)
-               __vlan_hwaccel_put_tag(skb, rxcp->vlan_tag);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rxcp->vlan_tag);
 
        napi_gro_frags(napi);
 }
 
        if (status & E1000_RXD_STAT_VP) {
                u16 vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK;
 
-               __vlan_hwaccel_put_tag(skb, vid);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
        }
        napi_gro_receive(&adapter->napi, skb);
 }
 
        skb->protocol = eth_type_trans(skb, netdev);
 
        if (staterr & E1000_RXD_STAT_VP)
-               __vlan_hwaccel_put_tag(skb, tag);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), tag);
 
        napi_gro_receive(&adapter->napi, skb);
 }
 
                else
                        vid = le16_to_cpu(rx_desc->wb.upper.vlan);
 
-               __vlan_hwaccel_put_tag(skb, vid);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
        }
 
        skb_record_rx_queue(skb, rx_ring->queue_index);
 
                else
                        vid = le16_to_cpu(vlan) & E1000_RXD_SPC_VLAN_MASK;
                if (test_bit(vid, adapter->active_vlans))
-                       __vlan_hwaccel_put_tag(skb, vid);
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
        }
 
        napi_gro_receive(&adapter->rx_ring->napi, skb);
 
 
                skb->protocol = eth_type_trans(skb, netdev);
                if (status & IXGB_RX_DESC_STATUS_VP)
-                       __vlan_hwaccel_put_tag(skb,
-                                              le16_to_cpu(rx_desc->special));
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q),
+                                      le16_to_cpu(rx_desc->special));
 
                netif_receive_skb(skb);
 
 
        if ((dev->features & NETIF_F_HW_VLAN_CTAG_RX) &&
            ixgbe_test_staterr(rx_desc, IXGBE_RXD_STAT_VP)) {
                u16 vid = le16_to_cpu(rx_desc->wb.upper.vlan);
-               __vlan_hwaccel_put_tag(skb, vid);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
        }
 
        skb_record_rx_queue(skb, rx_ring->queue_index);
 
        u16 tag = le16_to_cpu(rx_desc->wb.upper.vlan);
 
        if (is_vlan && test_bit(tag & VLAN_VID_MASK, adapter->active_vlans))
-               __vlan_hwaccel_put_tag(skb, tag);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), tag);
 
        if (!(adapter->flags & IXGBE_FLAG_IN_NETPOLL))
                napi_gro_receive(&q_vector->napi, skb);
 
                if (rxdesc->descwb.flags & cpu_to_le16(RXWBFLAG_TAGON)) {
                        u16 vid = le16_to_cpu(rxdesc->descwb.vlan);
 
-                       __vlan_hwaccel_put_tag(skb, vid);
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
                        NET_STAT(jme).rx_bytes += 4;
                }
                jme->jme_rx(skb);
 
        struct sk_buff *skb;
 
        skb = sky2->rx_ring[sky2->rx_next].skb;
-       __vlan_hwaccel_put_tag(skb, be16_to_cpu(length));
+       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), be16_to_cpu(length));
 }
 
 static void sky2_rx_hash(struct sky2_port *sky2, u32 status)
 
                                            cpu_to_be32(MLX4_CQE_VLAN_PRESENT_MASK)) {
                                                u16 vid = be16_to_cpu(cqe->sl_vid);
 
-                                               __vlan_hwaccel_put_tag(gro_skb, vid);
+                                               __vlan_hwaccel_put_tag(gro_skb, htons(ETH_P_8021Q), vid);
                                        }
 
                                        if (dev->features & NETIF_F_RXHASH)
 
                if (be32_to_cpu(cqe->vlan_my_qpn) &
                    MLX4_CQE_VLAN_PRESENT_MASK)
-                       __vlan_hwaccel_put_tag(skb, be16_to_cpu(cqe->sl_vid));
+                       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), be16_to_cpu(cqe->sl_vid));
 
                /* Push it up the stack */
                netif_receive_skb(skb);
 
                        skb->csum = csum_sub(skb->csum, vsum);
                }
                /* pop tag */
-               __vlan_hwaccel_put_tag(skb, ntohs(veh->h_vlan_TCI));
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), ntohs(veh->h_vlan_TCI));
                memmove(va + VLAN_HLEN, va, 2 * ETH_ALEN);
                skb->len -= VLAN_HLEN;
                skb->data_len -= VLAN_HLEN;
 
                                unsigned short tag;
 
                                tag = ntohs(extsts & EXTSTS_VTG_MASK);
-                               __vlan_hwaccel_put_tag(skb, tag);
+                               __vlan_hwaccel_put_tag(skb, htons(ETH_P_IPV6), tag);
                        }
 #endif
                        rx_rc = netif_rx(skb);
 
 
        skb->protocol = eth_type_trans(skb, dev);
        if (vlan_tag && sp->vlan_strip_flag)
-               __vlan_hwaccel_put_tag(skb, vlan_tag);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tag);
        if (sp->config.napi)
                netif_receive_skb(skb);
        else
 
 
        if (ext_info->vlan &&
            ring->vlan_tag_strip == VXGE_HW_VPATH_RPA_STRIP_VLAN_TAG_ENABLE)
-               __vlan_hwaccel_put_tag(skb, ext_info->vlan);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), ext_info->vlan);
        napi_gro_receive(ring->napi_p, skb);
 
        vxge_debug_entryexit(VXGE_TRACE,
 
                            vlanflags & NV_RX3_VLAN_TAG_PRESENT) {
                                u16 vid = vlanflags & NV_RX3_VLAN_TAG_MASK;
 
-                               __vlan_hwaccel_put_tag(skb, vid);
+                               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
                        }
                        napi_gro_receive(&np->napi, skb);
                        u64_stats_update_begin(&np->swstats_rx_syncp);
 
        skb->protocol = eth_type_trans(skb, netdev);
 
        if (vid != 0xffff)
-               __vlan_hwaccel_put_tag(skb, vid);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
 
        napi_gro_receive(&sds_ring->napi, skb);
 
        }
 
        if (vid != 0xffff)
-               __vlan_hwaccel_put_tag(skb, vid);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
        netif_receive_skb(skb);
 
        adapter->stats.lro_pkts++;
        skb->protocol = eth_type_trans(skb, netdev);
 
        if (vid != 0xffff)
-               __vlan_hwaccel_put_tag(skb, vid);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
 
        napi_gro_receive(&sds_ring->napi, skb);
 
        }
 
        if (vid != 0xffff)
-               __vlan_hwaccel_put_tag(skb, vid);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
 
        netif_receive_skb(skb);
 
 
        skb->ip_summed = CHECKSUM_UNNECESSARY;
        skb_record_rx_queue(skb, rx_ring->cq_id);
        if (vlan_id != 0xffff)
-               __vlan_hwaccel_put_tag(skb, vlan_id);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_id);
        napi_gro_frags(napi);
 }
 
 
        skb_record_rx_queue(skb, rx_ring->cq_id);
        if (vlan_id != 0xffff)
-               __vlan_hwaccel_put_tag(skb, vlan_id);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_id);
        if (skb->ip_summed == CHECKSUM_UNNECESSARY)
                napi_gro_receive(napi, skb);
        else
 
        skb_record_rx_queue(skb, rx_ring->cq_id);
        if (vlan_id != 0xffff)
-               __vlan_hwaccel_put_tag(skb, vlan_id);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_id);
        if (skb->ip_summed == CHECKSUM_UNNECESSARY)
                napi_gro_receive(&rx_ring->napi, skb);
        else
        rx_ring->rx_bytes += skb->len;
        skb_record_rx_queue(skb, rx_ring->cq_id);
        if ((ib_mac_rsp->flags2 & IB_MAC_IOCB_RSP_V) && (vlan_id != 0))
-               __vlan_hwaccel_put_tag(skb, vlan_id);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_id);
        if (skb->ip_summed == CHECKSUM_UNNECESSARY)
                napi_gro_receive(&rx_ring->napi, skb);
        else
 
        cp->dev->stats.rx_bytes += skb->len;
 
        if (opts2 & RxVlanTagged)
-               __vlan_hwaccel_put_tag(skb, swab16(opts2 & 0xffff));
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), swab16(opts2 & 0xffff));
 
        napi_gro_receive(&cp->napi, skb);
 }
 
        u32 opts2 = le32_to_cpu(desc->opts2);
 
        if (opts2 & RxVlanTag)
-               __vlan_hwaccel_put_tag(skb, swab16(opts2 & 0xffff));
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), swab16(opts2 & 0xffff));
 }
 
 static int rtl8169_gset_tbi(struct net_device *dev, struct ethtool_cmd *cmd)
 
                    priv->ndev->name,
                    GET_RXD_VLAN_ID(rxd_vlan),
                    GET_RXD_VTAG(rxd_val1));
-               __vlan_hwaccel_put_tag(skb, GET_RXD_VLAN_TCI(rxd_vlan));
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), GET_RXD_VLAN_TCI(rxd_vlan));
        }
        netif_receive_skb(skb);
 }
 
                        skb->protocol = eth_type_trans(skb, dev);
 
                        if (unlikely(desc_length & DescTag))
-                               __vlan_hwaccel_put_tag(skb, vlan_tci);
+                               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vlan_tci);
                        netif_receive_skb(skb);
 
                        u64_stats_update_begin(&rp->rx_stats.syncp);
 
        if (rd->rdesc0.RSR & RSR_DETAG) {
                u16 vid = swab16(le16_to_cpu(rd->rdesc1.PQTAG));
 
-               __vlan_hwaccel_put_tag(skb, vid);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), vid);
        }
        netif_rx(skb);
 
 
 
        /* map MBIM session to VLAN */
        if (tci)
-               vlan_put_tag(skb, tci);
+               vlan_put_tag(skb, htons(ETH_P_8021Q), tci);
 err:
        return skb;
 }
 
                        skb->protocol = eth_type_trans(skb, adapter->netdev);
 
                        if (unlikely(rcd->ts))
-                               __vlan_hwaccel_put_tag(skb, rcd->tci);
+                               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), rcd->tci);
 
                        if (adapter->netdev->features & NETIF_F_LRO)
                                netif_receive_skb(skb);
 
 }
 #endif
 
+static inline bool vlan_hw_offload_capable(netdev_features_t features,
+                                          __be16 proto)
+{
+       if (proto == htons(ETH_P_8021Q) && features & NETIF_F_HW_VLAN_CTAG_TX)
+               return true;
+       return false;
+}
+
 /**
  * vlan_insert_tag - regular VLAN tag inserting
  * @skb: skbuff to tag
+ * @vlan_proto: VLAN encapsulation protocol
  * @vlan_tci: VLAN TCI to insert
  *
  * Inserts the VLAN tag into @skb as part of the payload
  *
  * Does not change skb->protocol so this function can be used during receive.
  */
-static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb, u16 vlan_tci)
+static inline struct sk_buff *vlan_insert_tag(struct sk_buff *skb,
+                                             __be16 vlan_proto, u16 vlan_tci)
 {
        struct vlan_ethhdr *veth;
 
        skb->mac_header -= VLAN_HLEN;
 
        /* first, the ethernet type */
-       veth->h_vlan_proto = htons(ETH_P_8021Q);
+       veth->h_vlan_proto = vlan_proto;
 
        /* now, the TCI */
        veth->h_vlan_TCI = htons(vlan_tci);
  * Following the skb_unshare() example, in case of error, the calling function
  * doesn't have to worry about freeing the original skb.
  */
-static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb, u16 vlan_tci)
+static inline struct sk_buff *__vlan_put_tag(struct sk_buff *skb,
+                                            __be16 vlan_proto, u16 vlan_tci)
 {
-       skb = vlan_insert_tag(skb, vlan_tci);
+       skb = vlan_insert_tag(skb, vlan_proto, vlan_tci);
        if (skb)
-               skb->protocol = htons(ETH_P_8021Q);
+               skb->protocol = vlan_proto;
        return skb;
 }
 
 /**
  * __vlan_hwaccel_put_tag - hardware accelerated VLAN inserting
  * @skb: skbuff to tag
+ * @vlan_proto: VLAN encapsulation protocol
  * @vlan_tci: VLAN TCI to insert
  *
  * Puts the VLAN TCI in @skb->vlan_tci and lets the device do the rest
  */
 static inline struct sk_buff *__vlan_hwaccel_put_tag(struct sk_buff *skb,
+                                                    __be16 vlan_proto,
                                                     u16 vlan_tci)
 {
+       skb->vlan_proto = vlan_proto;
        skb->vlan_tci = VLAN_TAG_PRESENT | vlan_tci;
        return skb;
 }
  * Assumes skb->dev is the target that will xmit this frame.
  * Returns a VLAN tagged skb.
  */
-static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb, u16 vlan_tci)
+static inline struct sk_buff *vlan_put_tag(struct sk_buff *skb,
+                                          __be16 vlan_proto, u16 vlan_tci)
 {
-       if (skb->dev->features & NETIF_F_HW_VLAN_CTAG_TX) {
-               return __vlan_hwaccel_put_tag(skb, vlan_tci);
+       if (vlan_hw_offload_capable(skb->dev->features, vlan_proto)) {
+               return __vlan_hwaccel_put_tag(skb, vlan_proto, vlan_tci);
        } else {
-               return __vlan_put_tag(skb, vlan_tci);
+               return __vlan_put_tag(skb, vlan_proto, vlan_tci);
        }
 }
 
 
  *     @secmark: security marking
  *     @mark: Generic packet mark
  *     @dropcount: total number of sk_receive_queue overflows
+ *     @vlan_proto: vlan encapsulation protocol
  *     @vlan_tci: vlan tag control information
  *     @inner_transport_header: Inner transport layer header (encapsulation)
  *     @inner_network_header: Network layer header (encapsulation)
 
        __u32                   rxhash;
 
+       __be16                  vlan_proto;
        __u16                   vlan_tci;
 
 #ifdef CONFIG_NET_SCHED
 
 bool vlan_do_receive(struct sk_buff **skbp)
 {
        struct sk_buff *skb = *skbp;
+       __be16 vlan_proto = skb->vlan_proto;
        u16 vlan_id = skb->vlan_tci & VLAN_VID_MASK;
        struct net_device *vlan_dev;
        struct vlan_pcpu_stats *rx_stats;
 
-       vlan_dev = vlan_find_dev(skb->dev, htons(ETH_P_8021Q), vlan_id);
+       vlan_dev = vlan_find_dev(skb->dev, vlan_proto, vlan_id);
        if (!vlan_dev)
                return false;
 
                 * original position later
                 */
                skb_push(skb, offset);
-               skb = *skbp = vlan_insert_tag(skb, skb->vlan_tci);
+               skb = *skbp = vlan_insert_tag(skb, skb->vlan_proto,
+                                             skb->vlan_tci);
                if (!skb)
                        return false;
                skb_pull(skb, offset + VLAN_HLEN);
 
        vhdr = (struct vlan_hdr *) skb->data;
        vlan_tci = ntohs(vhdr->h_vlan_TCI);
-       __vlan_hwaccel_put_tag(skb, vlan_tci);
+       __vlan_hwaccel_put_tag(skb, skb->protocol, vlan_tci);
 
        skb_pull_rcsum(skb, VLAN_HLEN);
        vlan_set_encap_proto(skb, vhdr);
 
                u16 vlan_tci;
                vlan_tci = vlan->vlan_id;
                vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb);
-               skb = __vlan_hwaccel_put_tag(skb, vlan_tci);
+               skb = __vlan_hwaccel_put_tag(skb, vlan->vlan_proto, vlan_tci);
        }
 
        skb->dev = vlan->real_dev;
 
        }
 
        if (vid != -1)
-               skb = vlan_insert_tag(skb, vid);
+               skb = vlan_insert_tag(skb, htons(ETH_P_8021Q), vid);
 
        skb_reset_mac_header(skb);
        skb->protocol = eth_type_trans(skb, soft_iface);
 
        if (brnf_pass_vlan_indev == 0 || !vlan_tx_tag_present(skb))
                return br;
 
-       vlan = __vlan_find_dev_deep(br, htons(ETH_P_8021Q),
+       vlan = __vlan_find_dev_deep(br, skb->vlan_proto,
                                    vlan_tx_tag_get(skb) & VLAN_VID_MASK);
 
        return vlan ? vlan : br;
 
                         * mac header.
                         */
                        skb_push(skb, ETH_HLEN);
-                       skb = __vlan_put_tag(skb, skb->vlan_tci);
+                       skb = __vlan_put_tag(skb, skb->vlan_proto, skb->vlan_tci);
                        if (!skb)
                                goto out;
                        /* put skb->data back to where it was */
                /* PVID is set on this port.  Any untagged ingress
                 * frame is considered to belong to this vlan.
                 */
-               __vlan_hwaccel_put_tag(skb, pvid);
+               __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), pvid);
                return true;
        }
 
 
                features = netif_skb_features(skb);
 
                if (vlan_tx_tag_present(skb) &&
-                   !(features & NETIF_F_HW_VLAN_CTAG_TX)) {
-                       skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb));
+                   !vlan_hw_offload_capable(features, skb->vlan_proto)) {
+                       skb = __vlan_put_tag(skb, skb->vlan_proto,
+                                            vlan_tx_tag_get(skb));
                        if (unlikely(!skb))
                                goto out;
 
 
                        if (__netif_tx_trylock(txq)) {
                                if (!netif_xmit_stopped(txq)) {
                                        if (vlan_tx_tag_present(skb) &&
-                                           !(netif_skb_features(skb) & NETIF_F_HW_VLAN_CTAG_TX)) {
-                                               skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb));
+                                           !vlan_hw_offload_capable(netif_skb_features(skb),
+                                                                    skb->vlan_proto)) {
+                                               skb = __vlan_put_tag(skb, skb->vlan_proto, vlan_tx_tag_get(skb));
                                                if (unlikely(!skb))
                                                        break;
                                                skb->vlan_tci = 0;
 
        new->tc_verd            = old->tc_verd;
 #endif
 #endif
+       new->vlan_proto         = old->vlan_proto;
        new->vlan_tci           = old->vlan_tci;
 
        skb_copy_secmark(new, old);
 
        if (unlikely(err))
                return err;
 
-       __vlan_hwaccel_put_tag(skb, ntohs(tci));
+       __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), ntohs(tci));
        return 0;
 }
 
                /* push down current VLAN tag */
                current_tag = vlan_tx_tag_get(skb);
 
-               if (!__vlan_put_tag(skb, current_tag))
+               if (!__vlan_put_tag(skb, skb->vlan_proto, current_tag))
                        return -ENOMEM;
 
                if (skb->ip_summed == CHECKSUM_COMPLETE)
                                        + (2 * ETH_ALEN), VLAN_HLEN, 0));
 
        }
-       __vlan_hwaccel_put_tag(skb, ntohs(vlan->vlan_tci) & ~VLAN_TAG_PRESENT);
+       __vlan_hwaccel_put_tag(skb, vlan->vlan_tpid, ntohs(vlan->vlan_tci) & ~VLAN_TAG_PRESENT);
        return 0;
 }
 
 
                if (!nskb)
                        return -ENOMEM;
 
-               nskb = __vlan_put_tag(nskb, vlan_tx_tag_get(nskb));
+               nskb = __vlan_put_tag(nskb, nskb->vlan_proto, vlan_tx_tag_get(nskb));
                if (!nskb)
                        return -ENOMEM;