Merge tag 'pci-v5.15-changes' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaa...

[linux-2.6-microblaze.git] / drivers / net / ethernet / broadcom / tg3.c

diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index 8b08c1d..5e0e0e7 100644 (file)
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -6564,10 +6564,8 @@ static void tg3_tx(struct tg3_napi *tnapi)
                        skb_tstamp_tx(skb, &timestamp);
                }
 
-               pci_unmap_single(tp->pdev,
-                                dma_unmap_addr(ri, mapping),
-                                skb_headlen(skb),
-                                PCI_DMA_TODEVICE);
+               dma_unmap_single(&tp->pdev->dev, dma_unmap_addr(ri, mapping),
+                                skb_headlen(skb), DMA_TO_DEVICE);
 
                ri->skb = NULL;
 
@@ -6584,10 +6582,10 @@ static void tg3_tx(struct tg3_napi *tnapi)
                        if (unlikely(ri->skb != NULL || sw_idx == hw_idx))
                                tx_bug = 1;
 
-                       pci_unmap_page(tp->pdev,
+                       dma_unmap_page(&tp->pdev->dev,
                                       dma_unmap_addr(ri, mapping),
                                       skb_frag_size(&skb_shinfo(skb)->frags[i]),
-                                      PCI_DMA_TODEVICE);
+                                      DMA_TO_DEVICE);
 
                        while (ri->fragmented) {
                                ri->fragmented = false;
@@ -6646,8 +6644,8 @@ static void tg3_rx_data_free(struct tg3 *tp, struct ring_info *ri, u32 map_sz)
        if (!ri->data)
                return;
 
-       pci_unmap_single(tp->pdev, dma_unmap_addr(ri, mapping),
-                        map_sz, PCI_DMA_FROMDEVICE);
+       dma_unmap_single(&tp->pdev->dev, dma_unmap_addr(ri, mapping), map_sz,
+                        DMA_FROM_DEVICE);
        tg3_frag_free(skb_size <= PAGE_SIZE, ri->data);
        ri->data = NULL;
 }
@@ -6711,11 +6709,9 @@ static int tg3_alloc_rx_data(struct tg3 *tp, struct tg3_rx_prodring_set *tpr,
        if (!data)
                return -ENOMEM;
 
-       mapping = pci_map_single(tp->pdev,
-                                data + TG3_RX_OFFSET(tp),
-                                data_size,
-                                PCI_DMA_FROMDEVICE);
-       if (unlikely(pci_dma_mapping_error(tp->pdev, mapping))) {
+       mapping = dma_map_single(&tp->pdev->dev, data + TG3_RX_OFFSET(tp),
+                                data_size, DMA_FROM_DEVICE);
+       if (unlikely(dma_mapping_error(&tp->pdev->dev, mapping))) {
                tg3_frag_free(skb_size <= PAGE_SIZE, data);
                return -EIO;
        }
@@ -6882,8 +6878,8 @@ static int tg3_rx(struct tg3_napi *tnapi, int budget)
                        if (skb_size < 0)
                                goto drop_it;
 
-                       pci_unmap_single(tp->pdev, dma_addr, skb_size,
-                                        PCI_DMA_FROMDEVICE);
+                       dma_unmap_single(&tp->pdev->dev, dma_addr, skb_size,
+                                        DMA_FROM_DEVICE);
 
                        /* Ensure that the update to the data happens
                         * after the usage of the old DMA mapping.
@@ -6908,11 +6904,13 @@ static int tg3_rx(struct tg3_napi *tnapi, int budget)
                                goto drop_it_no_recycle;
 
                        skb_reserve(skb, TG3_RAW_IP_ALIGN);
-                       pci_dma_sync_single_for_cpu(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
+                       dma_sync_single_for_cpu(&tp->pdev->dev, dma_addr, len,
+                                               DMA_FROM_DEVICE);
                        memcpy(skb->data,
                               data + TG3_RX_OFFSET(tp),
                               len);
-                       pci_dma_sync_single_for_device(tp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
+                       dma_sync_single_for_device(&tp->pdev->dev, dma_addr,
+                                                  len, DMA_FROM_DEVICE);
                }
 
                skb_put(skb, len);
@@ -7762,10 +7760,8 @@ static void tg3_tx_skb_unmap(struct tg3_napi *tnapi, u32 entry, int last)
        skb = txb->skb;
        txb->skb = NULL;
 
-       pci_unmap_single(tnapi->tp->pdev,
-                        dma_unmap_addr(txb, mapping),
-                        skb_headlen(skb),
-                        PCI_DMA_TODEVICE);
+       dma_unmap_single(&tnapi->tp->pdev->dev, dma_unmap_addr(txb, mapping),
+                        skb_headlen(skb), DMA_TO_DEVICE);
 
        while (txb->fragmented) {
                txb->fragmented = false;
@@ -7779,9 +7775,9 @@ static void tg3_tx_skb_unmap(struct tg3_napi *tnapi, u32 entry, int last)
                entry = NEXT_TX(entry);
                txb = &tnapi->tx_buffers[entry];
 
-               pci_unmap_page(tnapi->tp->pdev,
+               dma_unmap_page(&tnapi->tp->pdev->dev,
                               dma_unmap_addr(txb, mapping),
-                              skb_frag_size(frag), PCI_DMA_TODEVICE);
+                              skb_frag_size(frag), DMA_TO_DEVICE);
 
                while (txb->fragmented) {
                        txb->fragmented = false;
@@ -7816,10 +7812,10 @@ static int tigon3_dma_hwbug_workaround(struct tg3_napi *tnapi,
                ret = -1;
        } else {
                /* New SKB is guaranteed to be linear. */
-               new_addr = pci_map_single(tp->pdev, new_skb->data, new_skb->len,
-                                         PCI_DMA_TODEVICE);
+               new_addr = dma_map_single(&tp->pdev->dev, new_skb->data,
+                                         new_skb->len, DMA_TO_DEVICE);
                /* Make sure the mapping succeeded */
-               if (pci_dma_mapping_error(tp->pdev, new_addr)) {
+               if (dma_mapping_error(&tp->pdev->dev, new_addr)) {
                        dev_kfree_skb_any(new_skb);
                        ret = -1;
                } else {
@@ -8043,8 +8039,9 @@ static netdev_tx_t tg3_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
        len = skb_headlen(skb);
 
-       mapping = pci_map_single(tp->pdev, skb->data, len, PCI_DMA_TODEVICE);
-       if (pci_dma_mapping_error(tp->pdev, mapping))
+       mapping = dma_map_single(&tp->pdev->dev, skb->data, len,
+                                DMA_TO_DEVICE);
+       if (dma_mapping_error(&tp->pdev->dev, mapping))
                goto drop;
 
 
@@ -13470,8 +13467,8 @@ static int tg3_run_loopback(struct tg3 *tp, u32 pktsz, bool tso_loopback)
        for (i = data_off; i < tx_len; i++)
                tx_data[i] = (u8) (i & 0xff);
 
-       map = pci_map_single(tp->pdev, skb->data, tx_len, PCI_DMA_TODEVICE);
-       if (pci_dma_mapping_error(tp->pdev, map)) {
+       map = dma_map_single(&tp->pdev->dev, skb->data, tx_len, DMA_TO_DEVICE);
+       if (dma_mapping_error(&tp->pdev->dev, map)) {
                dev_kfree_skb(skb);
                return -EIO;
        }
@@ -13569,8 +13566,8 @@ static int tg3_run_loopback(struct tg3 *tp, u32 pktsz, bool tso_loopback)
                } else
                        goto out;
 
-               pci_dma_sync_single_for_cpu(tp->pdev, map, rx_len,
-                                           PCI_DMA_FROMDEVICE);
+               dma_sync_single_for_cpu(&tp->pdev->dev, map, rx_len,
+                                       DMA_FROM_DEVICE);
 
                rx_data += TG3_RX_OFFSET(tp);
                for (i = data_off; i < rx_len; i++, val++) {
@@ -14011,7 +14008,10 @@ static int tg3_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
        return -EOPNOTSUPP;
 }
 
-static int tg3_get_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
+static int tg3_get_coalesce(struct net_device *dev,
+                           struct ethtool_coalesce *ec,
+                           struct kernel_ethtool_coalesce *kernel_coal,
+                           struct netlink_ext_ack *extack)
 {
        struct tg3 *tp = netdev_priv(dev);
 
@@ -14019,7 +14019,10 @@ static int tg3_get_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
        return 0;
 }
 
-static int tg3_set_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
+static int tg3_set_coalesce(struct net_device *dev,
+                           struct ethtool_coalesce *ec,
+                           struct kernel_ethtool_coalesce *kernel_coal,
+                           struct netlink_ext_ack *extack)
 {
        struct tg3 *tp = netdev_priv(dev);
        u32 max_rxcoal_tick_int = 0, max_txcoal_tick_int = 0;
@@ -14261,7 +14264,7 @@ static const struct net_device_ops tg3_netdev_ops = {
        .ndo_validate_addr      = eth_validate_addr,
        .ndo_set_rx_mode        = tg3_set_rx_mode,
        .ndo_set_mac_address    = tg3_set_mac_addr,
-       .ndo_do_ioctl           = tg3_ioctl,
+       .ndo_eth_ioctl          = tg3_ioctl,
        .ndo_tx_timeout         = tg3_tx_timeout,
        .ndo_change_mtu         = tg3_change_mtu,
        .ndo_fix_features       = tg3_fix_features,
@@ -17698,11 +17701,11 @@ static int tg3_init_one(struct pci_dev *pdev,
 
        /* Configure DMA attributes. */
        if (dma_mask > DMA_BIT_MASK(32)) {
-               err = pci_set_dma_mask(pdev, dma_mask);
+               err = dma_set_mask(&pdev->dev, dma_mask);
                if (!err) {
                        features |= NETIF_F_HIGHDMA;
-                       err = pci_set_consistent_dma_mask(pdev,
-                                                         persist_dma_mask);
+                       err = dma_set_coherent_mask(&pdev->dev,
+                                                   persist_dma_mask);
                        if (err < 0) {
                                dev_err(&pdev->dev, "Unable to obtain 64 bit "
                                        "DMA for consistent allocations\n");
@@ -17711,7 +17714,7 @@ static int tg3_init_one(struct pci_dev *pdev,
                }
        }
        if (err || dma_mask == DMA_BIT_MASK(32)) {
-               err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+               err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
                if (err) {
                        dev_err(&pdev->dev,
                                "No usable DMA configuration, aborting\n");