mlx4_en_deactivate_cq(priv, cq);
                        goto tx_err;
                }
+               tx_ring->tx_queue = netdev_get_tx_queue(dev, i);
 
                /* Arm CQ for TX completions */
                mlx4_en_arm_cq(priv, cq);
                                                 watchdog_task);
        struct mlx4_en_dev *mdev = priv->mdev;
        struct net_device *dev = priv->dev;
+       int i;
 
        en_dbg(DRV, priv, "Watchdog task called for port %d\n", priv->port);
 
        mutex_lock(&mdev->state_lock);
        if (priv->port_up) {
                mlx4_en_stop_port(dev);
+               for (i = 0; i < priv->tx_ring_num; i++)
+                       netdev_tx_reset_queue(priv->tx_ring[i].tx_queue);
                if (mlx4_en_start_port(dev))
                        en_err(priv, "Failed restarting port %d\n", priv->port);
        }
 
        int size = cq->size;
        u32 size_mask = ring->size_mask;
        struct mlx4_cqe *buf = cq->buf;
+       u32 packets = 0;
+       u32 bytes = 0;
 
        if (!priv->port_up)
                return;
                                        priv, ring, ring_index,
                                        !!((ring->cons + txbbs_skipped) &
                                                        ring->size));
+                       packets++;
+                       bytes += ring->tx_info[ring_index].nr_bytes;
                } while (ring_index != new_index);
 
                ++cons_index;
        mlx4_cq_set_ci(mcq);
        wmb();
        ring->cons += txbbs_skipped;
+       netdev_tx_completed_queue(ring->tx_queue, packets, bytes);
 
        /* Wakeup Tx queue if this ring stopped it */
        if (unlikely(ring->blocked)) {
                if ((u32) (ring->prod - ring->cons) <=
                     ring->size - HEADROOM - MAX_DESC_TXBBS) {
                        ring->blocked = 0;
-                       netif_tx_wake_queue(netdev_get_tx_queue(dev, cq->ring));
+                       netif_tx_wake_queue(ring->tx_queue);
                        priv->port_stats.wake_queue++;
                }
        }
        if (unlikely(((int)(ring->prod - ring->cons)) >
                     ring->size - HEADROOM - MAX_DESC_TXBBS)) {
                /* every full Tx ring stops queue */
-               netif_tx_stop_queue(netdev_get_tx_queue(dev, tx_ind));
+               netif_tx_stop_queue(ring->tx_queue);
                ring->blocked = 1;
                priv->port_stats.queue_stopped++;
 
                priv->port_stats.tso_packets++;
                i = ((skb->len - lso_header_size) / skb_shinfo(skb)->gso_size) +
                        !!((skb->len - lso_header_size) % skb_shinfo(skb)->gso_size);
-               ring->bytes += skb->len + (i - 1) * lso_header_size;
+               tx_info->nr_bytes = skb->len + (i - 1) * lso_header_size;
                ring->packets += i;
        } else {
                /* Normal (Non LSO) packet */
                        ((ring->prod & ring->size) ?
                         cpu_to_be32(MLX4_EN_BIT_DESC_OWN) : 0);
                data = &tx_desc->data;
-               ring->bytes += max(skb->len, (unsigned int) ETH_ZLEN);
+               tx_info->nr_bytes = max_t(unsigned int, skb->len, ETH_ZLEN);
                ring->packets++;
 
        }
+       ring->bytes += tx_info->nr_bytes;
+       netdev_tx_sent_queue(ring->tx_queue, tx_info->nr_bytes);
        AVG_PERF_COUNTER(priv->pstats.tx_pktsz_avg, skb->len);