forked from ~ljy/RK356X_SDK_RELEASE

blame | history | patch | commit | commitdiff
hc
2023-12-11 6778948f9de86c3cfaf36725a7c87dcff9ba247f 
 kernel/drivers/net/wireless/admtek/adm8211.c
....@@ -1,3 +1,4 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
12 
23 /*
34  * Linux device driver for ADMtek ADM8211 (IEEE 802.11b MAC/BBP)
....@@ -8,11 +9,6 @@
89  * and used with permission.
910  *
1011  * Much thanks to Infineon-ADMtek for their support of this driver.
11
- *
12
- * This program is free software; you can redistribute it and/or modify
13
- * it under the terms of the GNU General Public License version 2 as
14
- * published by the Free Software Foundation. See README and COPYING for
15
- * more details.
1612  */
1713 
1814 #include <linux/interrupt.h>
....@@ -328,8 +324,8 @@
328324 
329325 		/* TODO: check TDES0_STATUS_TUF and TDES0_STATUS_TRO */
330326 
331
-		pci_unmap_single(priv->pdev, info->mapping,
332
-				 info->skb->len, PCI_DMA_TODEVICE);
327
+		dma_unmap_single(&priv->pdev->dev, info->mapping,
328
+				 info->skb->len, DMA_TO_DEVICE);
333329 
334330 		ieee80211_tx_info_clear_status(txi);
335331 
....@@ -386,35 +382,34 @@
386382 		} else if (pktlen < RX_COPY_BREAK) {
387383 			skb = dev_alloc_skb(pktlen);
388384 			if (skb) {
389
-				pci_dma_sync_single_for_cpu(
390
-					priv->pdev,
391
-					priv->rx_buffers[entry].mapping,
392
-					pktlen, PCI_DMA_FROMDEVICE);
385
+				dma_sync_single_for_cpu(&priv->pdev->dev,
386
+							priv->rx_buffers[entry].mapping,
387
+							pktlen,
388
+							DMA_FROM_DEVICE);
393389 				skb_put_data(skb,
394390 					     skb_tail_pointer(priv->rx_buffers[entry].skb),
395391 					     pktlen);
396
-				pci_dma_sync_single_for_device(
397
-					priv->pdev,
398
-					priv->rx_buffers[entry].mapping,
399
-					RX_PKT_SIZE, PCI_DMA_FROMDEVICE);
392
+				dma_sync_single_for_device(&priv->pdev->dev,
393
+							   priv->rx_buffers[entry].mapping,
394
+							   RX_PKT_SIZE,
395
+							   DMA_FROM_DEVICE);
400396 			}
401397 		} else {
402398 			newskb = dev_alloc_skb(RX_PKT_SIZE);
403399 			if (newskb) {
404400 				skb = priv->rx_buffers[entry].skb;
405401 				skb_put(skb, pktlen);
406
-				pci_unmap_single(
407
-					priv->pdev,
408
-					priv->rx_buffers[entry].mapping,
409
-					RX_PKT_SIZE, PCI_DMA_FROMDEVICE);
402
+				dma_unmap_single(&priv->pdev->dev,
403
+						 priv->rx_buffers[entry].mapping,
404
+						 RX_PKT_SIZE, DMA_FROM_DEVICE);
410405 				priv->rx_buffers[entry].skb = newskb;
411406 				priv->rx_buffers[entry].mapping =
412
-					pci_map_single(priv->pdev,
407
+					dma_map_single(&priv->pdev->dev,
413408 						       skb_tail_pointer(newskb),
414409 						       RX_PKT_SIZE,
415
-						       PCI_DMA_FROMDEVICE);
416
-				if (pci_dma_mapping_error(priv->pdev,
417
-					   priv->rx_buffers[entry].mapping)) {
410
+						       DMA_FROM_DEVICE);
411
+				if (dma_mapping_error(&priv->pdev->dev,
412
+						      priv->rx_buffers[entry].mapping)) {
418413 					priv->rx_buffers[entry].skb = NULL;
419414 					dev_kfree_skb(newskb);
420415 					skb = NULL;
....@@ -1453,11 +1448,11 @@
14531448 		rx_info->skb = dev_alloc_skb(RX_PKT_SIZE);
14541449 		if (rx_info->skb == NULL)
14551450 			break;
1456
-		rx_info->mapping = pci_map_single(priv->pdev,
1451
+		rx_info->mapping = dma_map_single(&priv->pdev->dev,
14571452 						  skb_tail_pointer(rx_info->skb),
14581453 						  RX_PKT_SIZE,
1459
-						  PCI_DMA_FROMDEVICE);
1460
-		if (pci_dma_mapping_error(priv->pdev, rx_info->mapping)) {
1454
+						  DMA_FROM_DEVICE);
1455
+		if (dma_mapping_error(&priv->pdev->dev, rx_info->mapping)) {
14611456 			dev_kfree_skb(rx_info->skb);
14621457 			rx_info->skb = NULL;
14631458 			break;
....@@ -1494,10 +1489,9 @@
14941489 		if (!priv->rx_buffers[i].skb)
14951490 			continue;
14961491 
1497
-		pci_unmap_single(
1498
-			priv->pdev,
1499
-			priv->rx_buffers[i].mapping,
1500
-			RX_PKT_SIZE, PCI_DMA_FROMDEVICE);
1492
+		dma_unmap_single(&priv->pdev->dev,
1493
+				 priv->rx_buffers[i].mapping, RX_PKT_SIZE,
1494
+				 DMA_FROM_DEVICE);
15011495 
15021496 		dev_kfree_skb(priv->rx_buffers[i].skb);
15031497 	}
....@@ -1506,10 +1500,9 @@
15061500 		if (!priv->tx_buffers[i].skb)
15071501 			continue;
15081502 
1509
-		pci_unmap_single(priv->pdev,
1503
+		dma_unmap_single(&priv->pdev->dev,
15101504 				 priv->tx_buffers[i].mapping,
1511
-				 priv->tx_buffers[i].skb->len,
1512
-				 PCI_DMA_TODEVICE);
1505
+				 priv->tx_buffers[i].skb->len, DMA_TO_DEVICE);
15131506 
15141507 		dev_kfree_skb(priv->tx_buffers[i].skb);
15151508 	}
....@@ -1636,9 +1629,9 @@
16361629 	unsigned int entry;
16371630 	u32 flag;
16381631 
1639
-	mapping = pci_map_single(priv->pdev, skb->data, skb->len,
1640
-				 PCI_DMA_TODEVICE);
1641
-	if (pci_dma_mapping_error(priv->pdev, mapping))
1632
+	mapping = dma_map_single(&priv->pdev->dev, skb->data, skb->len,
1633
+				 DMA_TO_DEVICE);
1634
+	if (dma_mapping_error(&priv->pdev->dev, mapping))
16421635 		return -ENOMEM;
16431636 
16441637 	spin_lock_irqsave(&priv->lock, flags);
....@@ -1749,8 +1742,8 @@
17491742 	/* Allocate TX/RX descriptors */
17501743 	ring_size = sizeof(struct adm8211_desc) * priv->rx_ring_size +
17511744 		    sizeof(struct adm8211_desc) * priv->tx_ring_size;
1752
-	priv->rx_ring = pci_alloc_consistent(priv->pdev, ring_size,
1753
-					     &priv->rx_ring_dma);
1745
+	priv->rx_ring = dma_alloc_coherent(&priv->pdev->dev, ring_size,
1746
+					   &priv->rx_ring_dma, GFP_KERNEL);
17541747 
17551748 	if (!priv->rx_ring) {
17561749 		kfree(priv->rx_buffers);
....@@ -1785,8 +1778,8 @@
17851778 {
17861779 	struct ieee80211_hw *dev;
17871780 	struct adm8211_priv *priv;
1788
-	unsigned long mem_addr, mem_len;
1789
-	unsigned int io_addr, io_len;
1781
+	unsigned long mem_len;
1782
+	unsigned int io_len;
17901783 	int err;
17911784 	u32 reg;
17921785 	u8 perm_addr[ETH_ALEN];
....@@ -1798,13 +1791,12 @@
17981791 		return err;
17991792 	}
18001793 
1801
-	io_addr = pci_resource_start(pdev, 0);
18021794 	io_len = pci_resource_len(pdev, 0);
1803
-	mem_addr = pci_resource_start(pdev, 1);
18041795 	mem_len = pci_resource_len(pdev, 1);
18051796 	if (io_len < 256 || mem_len < 1024) {
18061797 		printk(KERN_ERR "%s (adm8211): Too short PCI resources\n",
18071798 		       pci_name(pdev));
1799
+		err = -ENOMEM;
18081800 		goto err_disable_pdev;
18091801 	}
18101802 
....@@ -1814,6 +1806,7 @@
18141806 	if (reg != ADM8211_SIG1 && reg != ADM8211_SIG2) {
18151807 		printk(KERN_ERR "%s (adm8211): Invalid signature (0x%x)\n",
18161808 		       pci_name(pdev), reg);
1809
+		err = -EINVAL;
18171810 		goto err_disable_pdev;
18181811 	}
18191812 
....@@ -1824,8 +1817,8 @@
18241817 		return err; /* someone else grabbed it? don't disable it */
18251818 	}
18261819 
1827
-	if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) ||
1828
-	    pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
1820
+	err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
1821
+	if (err) {
18291822 		printk(KERN_ERR "%s (adm8211): No suitable DMA available\n",
18301823 		       pci_name(pdev));
18311824 		goto err_free_reg;
....@@ -1935,10 +1928,10 @@
19351928 	kfree(priv->eeprom);
19361929 
19371930  err_free_desc:
1938
-	pci_free_consistent(pdev,
1939
-			    sizeof(struct adm8211_desc) * priv->rx_ring_size +
1940
-			    sizeof(struct adm8211_desc) * priv->tx_ring_size,
1941
-			    priv->rx_ring, priv->rx_ring_dma);
1931
+	dma_free_coherent(&pdev->dev,
1932
+			  sizeof(struct adm8211_desc) * priv->rx_ring_size +
1933
+			  sizeof(struct adm8211_desc) * priv->tx_ring_size,
1934
+			  priv->rx_ring, priv->rx_ring_dma);
19421935 	kfree(priv->rx_buffers);
19431936 
19441937  err_iounmap:
....@@ -1968,10 +1961,10 @@
19681961 
19691962 	priv = dev->priv;
19701963 
1971
-	pci_free_consistent(pdev,
1972
-			    sizeof(struct adm8211_desc) * priv->rx_ring_size +
1973
-			    sizeof(struct adm8211_desc) * priv->tx_ring_size,
1974
-			    priv->rx_ring, priv->rx_ring_dma);
1964
+	dma_free_coherent(&pdev->dev,
1965
+			  sizeof(struct adm8211_desc) * priv->rx_ring_size +
1966
+			  sizeof(struct adm8211_desc) * priv->tx_ring_size,
1967
+			  priv->rx_ring, priv->rx_ring_dma);
19751968 
19761969 	kfree(priv->rx_buffers);
19771970 	kfree(priv->eeprom);
....@@ -1982,24 +1975,12 @@
19821975 }
19831976 
19841977 
1985
-#ifdef CONFIG_PM
1986
-static int adm8211_suspend(struct pci_dev *pdev, pm_message_t state)
1987
-{
1988
-	pci_save_state(pdev);
1989
-	pci_set_power_state(pdev, pci_choose_state(pdev, state));
1990
-	return 0;
1991
-}
1992
-
1993
-static int adm8211_resume(struct pci_dev *pdev)
1994
-{
1995
-	pci_set_power_state(pdev, PCI_D0);
1996
-	pci_restore_state(pdev);
1997
-	return 0;
1998
-}
1999
-#endif /* CONFIG_PM */
2000
-
1978
+#define adm8211_suspend NULL
1979
+#define adm8211_resume NULL
20011980 
20021981 MODULE_DEVICE_TABLE(pci, adm8211_pci_id_table);
1982
+
1983
+static SIMPLE_DEV_PM_OPS(adm8211_pm_ops, adm8211_suspend, adm8211_resume);
20031984 
20041985 /* TODO: implement enable_wake */
20051986 static struct pci_driver adm8211_driver = {
....@@ -2007,10 +1988,7 @@
20071988 	.id_table	= adm8211_pci_id_table,
20081989 	.probe		= adm8211_probe,
20091990 	.remove		= adm8211_remove,
2010
-#ifdef CONFIG_PM
2011
-	.suspend	= adm8211_suspend,
2012
-	.resume		= adm8211_resume,
2013
-#endif /* CONFIG_PM */
1991
+	.driver.pm	= &adm8211_pm_ops,
20141992 };
20151993 
20161994 module_pci_driver(adm8211_driver);