struct bufdesc *bdp = txq->bd.cur;
        struct bufdesc_ex *ebdp;
        int nr_frags = skb_shinfo(skb)->nr_frags;
-       unsigned short queue = skb_get_queue_mapping(skb);
        int frag, frag_len;
        unsigned short status;
        unsigned int estatus = 0;
 
                if (fep->bufdesc_ex) {
                        if (fep->quirks & FEC_QUIRK_HAS_AVB)
-                               estatus |= FEC_TX_BD_FTYPE(queue);
+                               estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
                        if (skb->ip_summed == CHECKSUM_PARTIAL)
                                estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS;
                        ebdp->cbd_bdu = 0;
        dma_addr_t addr;
        unsigned short status;
        unsigned short buflen;
-       unsigned short queue;
        unsigned int estatus = 0;
        unsigned int index;
        int entries_free;
        bufaddr = skb->data;
        buflen = skb_headlen(skb);
 
-       queue = skb_get_queue_mapping(skb);
        index = fec_enet_get_bd_index(bdp, &txq->bd);
        if (((unsigned long) bufaddr) & fep->tx_align ||
                fep->quirks & FEC_QUIRK_SWAP_FRAME) {
                        skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
 
                if (fep->quirks & FEC_QUIRK_HAS_AVB)
-                       estatus |= FEC_TX_BD_FTYPE(queue);
+                       estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
 
                if (skb->ip_summed == CHECKSUM_PARTIAL)
                        estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS;
        txq->bd.cur = bdp;
 
        /* Trigger transmission start */
-       writel(0, fep->hwp + FEC_X_DES_ACTIVE(queue));
+       writel(0, txq->bd.reg_desc_active);
 
        return 0;
 }
 {
        struct fec_enet_private *fep = netdev_priv(ndev);
        struct bufdesc_ex *ebdp = container_of(bdp, struct bufdesc_ex, desc);
-       unsigned short queue = skb_get_queue_mapping(skb);
        unsigned short status;
        unsigned int estatus = 0;
        dma_addr_t addr;
 
        if (fep->bufdesc_ex) {
                if (fep->quirks & FEC_QUIRK_HAS_AVB)
-                       estatus |= FEC_TX_BD_FTYPE(queue);
+                       estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
                if (skb->ip_summed == CHECKSUM_PARTIAL)
                        estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS;
                ebdp->cbd_bdu = 0;
        struct fec_enet_private *fep = netdev_priv(ndev);
        int hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
        struct bufdesc_ex *ebdp = container_of(bdp, struct bufdesc_ex, desc);
-       unsigned short queue = skb_get_queue_mapping(skb);
        void *bufaddr;
        unsigned long dmabuf;
        unsigned short status;
 
        if (fep->bufdesc_ex) {
                if (fep->quirks & FEC_QUIRK_HAS_AVB)
-                       estatus |= FEC_TX_BD_FTYPE(queue);
+                       estatus |= FEC_TX_BD_FTYPE(txq->bd.qid);
                if (skb->ip_summed == CHECKSUM_PARTIAL)
                        estatus |= BD_ENET_TX_PINS | BD_ENET_TX_IINS;
                ebdp->cbd_bdu = 0;
        int hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
        int total_len, data_left;
        struct bufdesc *bdp = txq->bd.cur;
-       unsigned short queue = skb_get_queue_mapping(skb);
        struct tso_t tso;
        unsigned int index = 0;
        int ret;
 
        /* Trigger transmission start */
        if (!(fep->quirks & FEC_QUIRK_ERR007885) ||
-           !readl(fep->hwp + FEC_X_DES_ACTIVE(queue)) ||
-           !readl(fep->hwp + FEC_X_DES_ACTIVE(queue)) ||
-           !readl(fep->hwp + FEC_X_DES_ACTIVE(queue)) ||
-           !readl(fep->hwp + FEC_X_DES_ACTIVE(queue)))
-               writel(0, fep->hwp + FEC_X_DES_ACTIVE(queue));
+           !readl(txq->bd.reg_desc_active) ||
+           !readl(txq->bd.reg_desc_active) ||
+           !readl(txq->bd.reg_desc_active) ||
+           !readl(txq->bd.reg_desc_active))
+               writel(0, txq->bd.reg_desc_active);
 
        return 0;
 
        int i;
 
        for (i = 0; i < fep->num_rx_queues; i++)
-               writel(0, fep->hwp + FEC_R_DES_ACTIVE(i));
+               writel(0, fep->rx_queue[i]->bd.reg_desc_active);
 }
 
 static void fec_enet_enable_ring(struct net_device *ndev)
 
        /* ERR006538: Keep the transmitter going */
        if (bdp != txq->bd.cur &&
-           readl(fep->hwp + FEC_X_DES_ACTIVE(queue_id)) == 0)
-               writel(0, fep->hwp + FEC_X_DES_ACTIVE(queue_id));
+           readl(txq->bd.reg_desc_active) == 0)
+               writel(0, txq->bd.reg_desc_active);
 }
 
 static void
                 * incoming frames.  On a heavily loaded network, we should be
                 * able to keep up at the expense of system resources.
                 */
-               writel(0, fep->hwp + FEC_R_DES_ACTIVE(queue_id));
+               writel(0, rxq->bd.reg_desc_active);
        }
        rxq->bd.cur = bdp;
        return pkt_received;
        .ndo_set_features       = fec_set_features,
 };
 
+static const unsigned short offset_des_active_rxq[] = {
+       FEC_R_DES_ACTIVE_0, FEC_R_DES_ACTIVE_1, FEC_R_DES_ACTIVE_2
+};
+
+static const unsigned short offset_des_active_txq[] = {
+       FEC_X_DES_ACTIVE_0, FEC_X_DES_ACTIVE_1, FEC_X_DES_ACTIVE_2
+};
+
  /*
   * XXX:  We need to clean up on failure exits here.
   *
                rxq->bd.dma = bd_dma;
                rxq->bd.dsize = dsize;
                rxq->bd.dsize_log2 = dsize_log2;
+               rxq->bd.reg_desc_active = fep->hwp + offset_des_active_rxq[i];
                bd_dma += size;
                cbd_base = (struct bufdesc *)(((void *)cbd_base) + size);
                rxq->bd.last = (struct bufdesc *)(((void *)cbd_base) - dsize);
                txq->bd.dma = bd_dma;
                txq->bd.dsize = dsize;
                txq->bd.dsize_log2 = dsize_log2;
+               txq->bd.reg_desc_active = fep->hwp + offset_des_active_txq[i];
                bd_dma += size;
                cbd_base = (struct bufdesc *)(((void *)cbd_base) + size);
                txq->bd.last = (struct bufdesc *)(((void *)cbd_base) - dsize);