forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f 
 kernel/drivers/net/wireless/realtek/rtl818x/rtl8180/dev.c
....@@ -260,20 +260,20 @@
260260 			if (unlikely(!new_skb))
261261 				goto done;
262262 
263
-			mapping = pci_map_single(priv->pdev,
264
-					       skb_tail_pointer(new_skb),
265
-					       MAX_RX_SIZE, PCI_DMA_FROMDEVICE);
263
+			mapping = dma_map_single(&priv->pdev->dev,
264
+						 skb_tail_pointer(new_skb),
265
+						 MAX_RX_SIZE, DMA_FROM_DEVICE);
266266 
267
-			if (pci_dma_mapping_error(priv->pdev, mapping)) {
267
+			if (dma_mapping_error(&priv->pdev->dev, mapping)) {
268268 				kfree_skb(new_skb);
269269 				dev_err(&priv->pdev->dev, "RX DMA map error\n");
270270 
271271 				goto done;
272272 			}
273273 
274
-			pci_unmap_single(priv->pdev,
274
+			dma_unmap_single(&priv->pdev->dev,
275275 					 *((dma_addr_t *)skb->cb),
276
-					 MAX_RX_SIZE, PCI_DMA_FROMDEVICE);
276
+					 MAX_RX_SIZE, DMA_FROM_DEVICE);
277277 			skb_put(skb, flags & 0xFFF);
278278 
279279 			rx_status.antenna = (flags2 >> 15) & 1;
....@@ -355,8 +355,8 @@
355355 
356356 		ring->idx = (ring->idx + 1) % ring->entries;
357357 		skb = __skb_dequeue(&ring->queue);
358
-		pci_unmap_single(priv->pdev, le32_to_cpu(entry->tx_buf),
359
-				 skb->len, PCI_DMA_TODEVICE);
358
+		dma_unmap_single(&priv->pdev->dev, le32_to_cpu(entry->tx_buf),
359
+				 skb->len, DMA_TO_DEVICE);
360360 
361361 		info = IEEE80211_SKB_CB(skb);
362362 		ieee80211_tx_info_clear_status(info);
....@@ -460,8 +460,10 @@
460460 	struct rtl8180_priv *priv = dev->priv;
461461 	struct rtl8180_tx_ring *ring;
462462 	struct rtl8180_tx_desc *entry;
463
+	unsigned int prio = 0;
463464 	unsigned long flags;
464
-	unsigned int idx, prio, hw_prio;
465
+	unsigned int idx, hw_prio;
466
+
465467 	dma_addr_t mapping;
466468 	u32 tx_flags;
467469 	u8 rc_flags;
....@@ -470,13 +472,15 @@
470472 	/* do arithmetic and then convert to le16 */
471473 	u16 frame_duration = 0;
472474 
473
-	prio = skb_get_queue_mapping(skb);
475
+	/* rtl8180/rtl8185 only has one useable tx queue */
476
+	if (dev->queues > IEEE80211_AC_BK)
477
+		prio = skb_get_queue_mapping(skb);
474478 	ring = &priv->tx_ring[prio];
475479 
476
-	mapping = pci_map_single(priv->pdev, skb->data,
477
-				 skb->len, PCI_DMA_TODEVICE);
480
+	mapping = dma_map_single(&priv->pdev->dev, skb->data, skb->len,
481
+				 DMA_TO_DEVICE);
478482 
479
-	if (pci_dma_mapping_error(priv->pdev, mapping)) {
483
+	if (dma_mapping_error(&priv->pdev->dev, mapping)) {
480484 		kfree_skb(skb);
481485 		dev_err(&priv->pdev->dev, "TX DMA mapping error\n");
482486 		return;
....@@ -803,7 +807,7 @@
803807 		rtl818x_iowrite16(priv, FEMR_SE, 0xffff);
804808 	} else {
805809 		reg16 = rtl818x_ioread16(priv, &priv->map->FEMR);
806
-			reg16 |= (1 << 15) | (1 << 14) | (1 << 4);
810
+		reg16 |= (1 << 15) | (1 << 14) | (1 << 4);
807811 		rtl818x_iowrite16(priv, &priv->map->FEMR, reg16);
808812 	}
809813 
....@@ -1004,8 +1008,9 @@
10041008 	else
10051009 		priv->rx_ring_sz = sizeof(struct rtl8180_rx_desc);
10061010 
1007
-	priv->rx_ring = pci_zalloc_consistent(priv->pdev, priv->rx_ring_sz * 32,
1008
-					      &priv->rx_ring_dma);
1011
+	priv->rx_ring = dma_alloc_coherent(&priv->pdev->dev,
1012
+					   priv->rx_ring_sz * 32,
1013
+					   &priv->rx_ring_dma, GFP_KERNEL);
10091014 	if (!priv->rx_ring || (unsigned long)priv->rx_ring & 0xFF) {
10101015 		wiphy_err(dev->wiphy, "Cannot allocate RX ring\n");
10111016 		return -ENOMEM;
....@@ -1018,20 +1023,23 @@
10181023 		dma_addr_t *mapping;
10191024 		entry = priv->rx_ring + priv->rx_ring_sz*i;
10201025 		if (!skb) {
1021
-			pci_free_consistent(priv->pdev, priv->rx_ring_sz * 32,
1022
-					priv->rx_ring, priv->rx_ring_dma);
1026
+			dma_free_coherent(&priv->pdev->dev,
1027
+					  priv->rx_ring_sz * 32,
1028
+					  priv->rx_ring, priv->rx_ring_dma);
10231029 			wiphy_err(dev->wiphy, "Cannot allocate RX skb\n");
10241030 			return -ENOMEM;
10251031 		}
10261032 		priv->rx_buf[i] = skb;
10271033 		mapping = (dma_addr_t *)skb->cb;
1028
-		*mapping = pci_map_single(priv->pdev, skb_tail_pointer(skb),
1029
-					  MAX_RX_SIZE, PCI_DMA_FROMDEVICE);
1034
+		*mapping = dma_map_single(&priv->pdev->dev,
1035
+					  skb_tail_pointer(skb), MAX_RX_SIZE,
1036
+					  DMA_FROM_DEVICE);
10301037 
1031
-		if (pci_dma_mapping_error(priv->pdev, *mapping)) {
1038
+		if (dma_mapping_error(&priv->pdev->dev, *mapping)) {
10321039 			kfree_skb(skb);
1033
-			pci_free_consistent(priv->pdev, priv->rx_ring_sz * 32,
1034
-					priv->rx_ring, priv->rx_ring_dma);
1040
+			dma_free_coherent(&priv->pdev->dev,
1041
+					  priv->rx_ring_sz * 32,
1042
+					  priv->rx_ring, priv->rx_ring_dma);
10351043 			wiphy_err(dev->wiphy, "Cannot map DMA for RX skb\n");
10361044 			return -ENOMEM;
10371045 		}
....@@ -1054,14 +1062,13 @@
10541062 		if (!skb)
10551063 			continue;
10561064 
1057
-		pci_unmap_single(priv->pdev,
1058
-				 *((dma_addr_t *)skb->cb),
1059
-				 MAX_RX_SIZE, PCI_DMA_FROMDEVICE);
1065
+		dma_unmap_single(&priv->pdev->dev, *((dma_addr_t *)skb->cb),
1066
+				 MAX_RX_SIZE, DMA_FROM_DEVICE);
10601067 		kfree_skb(skb);
10611068 	}
10621069 
1063
-	pci_free_consistent(priv->pdev, priv->rx_ring_sz * 32,
1064
-			    priv->rx_ring, priv->rx_ring_dma);
1070
+	dma_free_coherent(&priv->pdev->dev, priv->rx_ring_sz * 32,
1071
+			  priv->rx_ring, priv->rx_ring_dma);
10651072 	priv->rx_ring = NULL;
10661073 }
10671074 
....@@ -1073,8 +1080,8 @@
10731080 	dma_addr_t dma;
10741081 	int i;
10751082 
1076
-	ring = pci_zalloc_consistent(priv->pdev, sizeof(*ring) * entries,
1077
-				     &dma);
1083
+	ring = dma_alloc_coherent(&priv->pdev->dev, sizeof(*ring) * entries,
1084
+				  &dma, GFP_KERNEL);
10781085 	if (!ring || (unsigned long)ring & 0xFF) {
10791086 		wiphy_err(dev->wiphy, "Cannot allocate TX ring (prio = %d)\n",
10801087 			  prio);
....@@ -1103,14 +1110,15 @@
11031110 		struct rtl8180_tx_desc *entry = &ring->desc[ring->idx];
11041111 		struct sk_buff *skb = __skb_dequeue(&ring->queue);
11051112 
1106
-		pci_unmap_single(priv->pdev, le32_to_cpu(entry->tx_buf),
1107
-				 skb->len, PCI_DMA_TODEVICE);
1113
+		dma_unmap_single(&priv->pdev->dev, le32_to_cpu(entry->tx_buf),
1114
+				 skb->len, DMA_TO_DEVICE);
11081115 		kfree_skb(skb);
11091116 		ring->idx = (ring->idx + 1) % ring->entries;
11101117 	}
11111118 
1112
-	pci_free_consistent(priv->pdev, sizeof(*ring->desc)*ring->entries,
1113
-			    ring->desc, ring->dma);
1119
+	dma_free_coherent(&priv->pdev->dev,
1120
+			  sizeof(*ring->desc) * ring->entries, ring->desc,
1121
+			  ring->dma);
11141122 	ring->desc = NULL;
11151123 }
11161124 
....@@ -1723,8 +1731,8 @@
17231731 {
17241732 	struct ieee80211_hw *dev;
17251733 	struct rtl8180_priv *priv;
1726
-	unsigned long mem_addr, mem_len;
1727
-	unsigned int io_addr, io_len;
1734
+	unsigned long mem_len;
1735
+	unsigned int io_len;
17281736 	int err;
17291737 	const char *chip_name, *rf_name = NULL;
17301738 	u32 reg;
....@@ -1743,9 +1751,7 @@
17431751 		goto err_disable_dev;
17441752 	}
17451753 
1746
-	io_addr = pci_resource_start(pdev, 0);
17471754 	io_len = pci_resource_len(pdev, 0);
1748
-	mem_addr = pci_resource_start(pdev, 1);
17491755 	mem_len = pci_resource_len(pdev, 1);
17501756 
17511757 	if (mem_len < sizeof(struct rtl818x_csr) ||
....@@ -1756,8 +1762,8 @@
17561762 		goto err_free_reg;
17571763 	}
17581764 
1759
-	if ((err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) ||
1760
-	    (err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))) {
1765
+	if ((err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32))) ||
1766
+	    (err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32)))) {
17611767 		printk(KERN_ERR "%s (rtl8180): No suitable DMA available\n",
17621768 		       pci_name(pdev));
17631769 		goto err_free_reg;
....@@ -1968,32 +1974,17 @@
19681974 	ieee80211_free_hw(dev);
19691975 }
19701976 
1971
-#ifdef CONFIG_PM
1972
-static int rtl8180_suspend(struct pci_dev *pdev, pm_message_t state)
1973
-{
1974
-	pci_save_state(pdev);
1975
-	pci_set_power_state(pdev, pci_choose_state(pdev, state));
1976
-	return 0;
1977
-}
1977
+#define rtl8180_suspend NULL
1978
+#define rtl8180_resume NULL
19781979 
1979
-static int rtl8180_resume(struct pci_dev *pdev)
1980
-{
1981
-	pci_set_power_state(pdev, PCI_D0);
1982
-	pci_restore_state(pdev);
1983
-	return 0;
1984
-}
1985
-
1986
-#endif /* CONFIG_PM */
1980
+static SIMPLE_DEV_PM_OPS(rtl8180_pm_ops, rtl8180_suspend, rtl8180_resume);
19871981 
19881982 static struct pci_driver rtl8180_driver = {
19891983 	.name		= KBUILD_MODNAME,
19901984 	.id_table	= rtl8180_table,
19911985 	.probe		= rtl8180_probe,
19921986 	.remove		= rtl8180_remove,
1993
-#ifdef CONFIG_PM
1994
-	.suspend	= rtl8180_suspend,
1995
-	.resume		= rtl8180_resume,
1996
-#endif /* CONFIG_PM */
1987
+	.driver.pm	= &rtl8180_pm_ops,
19971988 };
19981989 
19991990 module_pci_driver(rtl8180_driver);