return map->agg_id_tbl[agg_id];
 }
 
+static void bnxt_tpa_metadata(struct bnxt_tpa_info *tpa_info,
+                             struct rx_tpa_start_cmp *tpa_start,
+                             struct rx_tpa_start_cmp_ext *tpa_start1)
+{
+       tpa_info->cfa_code_valid = 1;
+       tpa_info->cfa_code = TPA_START_CFA_CODE(tpa_start1);
+       tpa_info->vlan_valid = 0;
+       if (tpa_info->flags2 & RX_CMP_FLAGS2_META_FORMAT_VLAN) {
+               tpa_info->vlan_valid = 1;
+               tpa_info->metadata =
+                       le32_to_cpu(tpa_start1->rx_tpa_start_cmp_metadata);
+       }
+}
+
 static void bnxt_tpa_start(struct bnxt *bp, struct bnxt_rx_ring_info *rxr,
-                          struct rx_tpa_start_cmp *tpa_start,
+                          u8 cmp_type, struct rx_tpa_start_cmp *tpa_start,
                           struct rx_tpa_start_cmp_ext *tpa_start1)
 {
        struct bnxt_sw_rx_bd *cons_rx_buf, *prod_rx_buf;
                bnxt_sched_reset_rxr(bp, rxr);
                return;
        }
-       /* Store cfa_code in tpa_info to use in tpa_end
-        * completion processing.
-        */
-       tpa_info->cfa_code = TPA_START_CFA_CODE(tpa_start1);
        prod_rx_buf->data = tpa_info->data;
        prod_rx_buf->data_ptr = tpa_info->data_ptr;
 
                netif_warn(bp, rx_err, bp->dev, "TPA packet without valid hash\n");
        }
        tpa_info->flags2 = le32_to_cpu(tpa_start1->rx_tpa_start_cmp_flags2);
-       tpa_info->metadata = le32_to_cpu(tpa_start1->rx_tpa_start_cmp_metadata);
        tpa_info->hdr_info = le32_to_cpu(tpa_start1->rx_tpa_start_cmp_hdr_info);
+       bnxt_tpa_metadata(tpa_info, tpa_start, tpa_start1);
        tpa_info->agg_count = 0;
 
        rxr->rx_prod = NEXT_RX(prod);
 {
        struct bnxt_napi *bnapi = cpr->bnapi;
        struct bnxt_rx_ring_info *rxr = bnapi->rx_ring;
+       struct net_device *dev = bp->dev;
        u8 *data_ptr, agg_bufs;
        unsigned int len;
        struct bnxt_tpa_info *tpa_info;
                }
        }
 
-       skb->protocol =
-               eth_type_trans(skb, bnxt_get_pkt_dev(bp, tpa_info->cfa_code));
+       if (tpa_info->cfa_code_valid)
+               dev = bnxt_get_pkt_dev(bp, tpa_info->cfa_code);
+       skb->protocol = eth_type_trans(skb, dev);
 
        if (tpa_info->hash_type != PKT_HASH_TYPE_NONE)
                skb_set_hash(skb, tpa_info->rss_hash, tpa_info->hash_type);
 
-       if ((tpa_info->flags2 & RX_CMP_FLAGS2_META_FORMAT_VLAN) &&
-           (skb->dev->features & BNXT_HW_FEATURE_VLAN_ALL_RX)) {
+       if (tpa_info->vlan_valid &&
+           (dev->features & BNXT_HW_FEATURE_VLAN_ALL_RX)) {
                __be16 vlan_proto = htons(tpa_info->metadata >>
                                          RX_CMP_FLAGS2_METADATA_TPID_SFT);
                u16 vtag = tpa_info->metadata & RX_CMP_FLAGS2_METADATA_TCI_MASK;
        prod = rxr->rx_prod;
 
        if (cmp_type == CMP_TYPE_RX_L2_TPA_START_CMP) {
-               bnxt_tpa_start(bp, rxr, (struct rx_tpa_start_cmp *)rxcmp,
+               bnxt_tpa_start(bp, rxr, cmp_type,
+                              (struct rx_tpa_start_cmp *)rxcmp,
                               (struct rx_tpa_start_cmp_ext *)rxcmp1);
 
                *event |= BNXT_RX_EVENT;