forked from ~ljy/RK356X_SDK_RELEASE
blame | history | patch | commit | commitdiff
hc
2023-12-11 072de836f53be56a70cecf70b43ae43b7ce17376 
 kernel/drivers/net/ethernet/sun/sungem.c
....@@ -545,37 +545,25 @@
545545 	}
546546 
547547 	if (pci_estat & GREG_PCIESTAT_OTHER) {
548
-		u16 pci_cfg_stat;
548
+		int pci_errs;
549549 
550550 		/* Interrogate PCI config space for the
551551 		 * true cause.
552552 		 */
553
-		pci_read_config_word(gp->pdev, PCI_STATUS,
554
-				     &pci_cfg_stat);
555
-		netdev_err(dev, "Read PCI cfg space status [%04x]\n",
556
-			   pci_cfg_stat);
557
-		if (pci_cfg_stat & PCI_STATUS_PARITY)
553
+		pci_errs = pci_status_get_and_clear_errors(gp->pdev);
554
+		netdev_err(dev, "PCI status errors[%04x]\n", pci_errs);
555
+		if (pci_errs & PCI_STATUS_PARITY)
558556 			netdev_err(dev, "PCI parity error detected\n");
559
-		if (pci_cfg_stat & PCI_STATUS_SIG_TARGET_ABORT)
557
+		if (pci_errs & PCI_STATUS_SIG_TARGET_ABORT)
560558 			netdev_err(dev, "PCI target abort\n");
561
-		if (pci_cfg_stat & PCI_STATUS_REC_TARGET_ABORT)
559
+		if (pci_errs & PCI_STATUS_REC_TARGET_ABORT)
562560 			netdev_err(dev, "PCI master acks target abort\n");
563
-		if (pci_cfg_stat & PCI_STATUS_REC_MASTER_ABORT)
561
+		if (pci_errs & PCI_STATUS_REC_MASTER_ABORT)
564562 			netdev_err(dev, "PCI master abort\n");
565
-		if (pci_cfg_stat & PCI_STATUS_SIG_SYSTEM_ERROR)
563
+		if (pci_errs & PCI_STATUS_SIG_SYSTEM_ERROR)
566564 			netdev_err(dev, "PCI system error SERR#\n");
567
-		if (pci_cfg_stat & PCI_STATUS_DETECTED_PARITY)
565
+		if (pci_errs & PCI_STATUS_DETECTED_PARITY)
568566 			netdev_err(dev, "PCI parity error\n");
569
-
570
-		/* Write the error bits back to clear them. */
571
-		pci_cfg_stat &= (PCI_STATUS_PARITY |
572
-				 PCI_STATUS_SIG_TARGET_ABORT |
573
-				 PCI_STATUS_REC_TARGET_ABORT |
574
-				 PCI_STATUS_REC_MASTER_ABORT |
575
-				 PCI_STATUS_SIG_SYSTEM_ERROR |
576
-				 PCI_STATUS_DETECTED_PARITY);
577
-		pci_write_config_word(gp->pdev,
578
-				      PCI_STATUS, pci_cfg_stat);
579567 	}
580568 
581569 	/* For all PCI errors, we should reset the chip. */
....@@ -682,7 +670,8 @@
682670 			dma_addr = le64_to_cpu(txd->buffer);
683671 			dma_len = le64_to_cpu(txd->control_word) & TXDCTRL_BUFSZ;
684672 
685
-			pci_unmap_page(gp->pdev, dma_addr, dma_len, PCI_DMA_TODEVICE);
673
+			dma_unmap_page(&gp->pdev->dev, dma_addr, dma_len,
674
+				       DMA_TO_DEVICE);
686675 			entry = NEXT_TX(entry);
687676 		}
688677 
....@@ -821,16 +810,15 @@
821810 				drops++;
822811 				goto drop_it;
823812 			}
824
-			pci_unmap_page(gp->pdev, dma_addr,
825
-				       RX_BUF_ALLOC_SIZE(gp),
826
-				       PCI_DMA_FROMDEVICE);
813
+			dma_unmap_page(&gp->pdev->dev, dma_addr,
814
+				       RX_BUF_ALLOC_SIZE(gp), DMA_FROM_DEVICE);
827815 			gp->rx_skbs[entry] = new_skb;
828816 			skb_put(new_skb, (gp->rx_buf_sz + RX_OFFSET));
829
-			rxd->buffer = cpu_to_le64(pci_map_page(gp->pdev,
817
+			rxd->buffer = cpu_to_le64(dma_map_page(&gp->pdev->dev,
830818 							       virt_to_page(new_skb->data),
831819 							       offset_in_page(new_skb->data),
832820 							       RX_BUF_ALLOC_SIZE(gp),
833
-							       PCI_DMA_FROMDEVICE));
821
+							       DMA_FROM_DEVICE));
834822 			skb_reserve(new_skb, RX_OFFSET);
835823 
836824 			/* Trim the original skb for the netif. */
....@@ -845,9 +833,11 @@
845833 
846834 			skb_reserve(copy_skb, 2);
847835 			skb_put(copy_skb, len);
848
-			pci_dma_sync_single_for_cpu(gp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
836
+			dma_sync_single_for_cpu(&gp->pdev->dev, dma_addr, len,
837
+						DMA_FROM_DEVICE);
849838 			skb_copy_from_linear_data(skb, copy_skb->data, len);
850
-			pci_dma_sync_single_for_device(gp->pdev, dma_addr, len, PCI_DMA_FROMDEVICE);
839
+			dma_sync_single_for_device(&gp->pdev->dev, dma_addr,
840
+						   len, DMA_FROM_DEVICE);
851841 
852842 			/* We'll reuse the original ring buffer. */
853843 			skb = copy_skb;
....@@ -970,7 +960,7 @@
970960 }
971961 #endif
972962 
973
-static void gem_tx_timeout(struct net_device *dev)
963
+static void gem_tx_timeout(struct net_device *dev, unsigned int txqueue)
974964 {
975965 	struct gem *gp = netdev_priv(dev);
976966 
....@@ -1032,10 +1022,10 @@
10321022 		u32 len;
10331023 
10341024 		len = skb->len;
1035
-		mapping = pci_map_page(gp->pdev,
1025
+		mapping = dma_map_page(&gp->pdev->dev,
10361026 				       virt_to_page(skb->data),
10371027 				       offset_in_page(skb->data),
1038
-				       len, PCI_DMA_TODEVICE);
1028
+				       len, DMA_TO_DEVICE);
10391029 		ctrl |= TXDCTRL_SOF | TXDCTRL_EOF | len;
10401030 		if (gem_intme(entry))
10411031 			ctrl |= TXDCTRL_INTME;
....@@ -1058,9 +1048,10 @@
10581048 		 * Otherwise we could race with the device.
10591049 		 */
10601050 		first_len = skb_headlen(skb);
1061
-		first_mapping = pci_map_page(gp->pdev, virt_to_page(skb->data),
1051
+		first_mapping = dma_map_page(&gp->pdev->dev,
1052
+					     virt_to_page(skb->data),
10621053 					     offset_in_page(skb->data),
1063
-					     first_len, PCI_DMA_TODEVICE);
1054
+					     first_len, DMA_TO_DEVICE);
10641055 		entry = NEXT_TX(entry);
10651056 
10661057 		for (frag = 0; frag < skb_shinfo(skb)->nr_frags; frag++) {
....@@ -1586,9 +1577,9 @@
15861577 		if (gp->rx_skbs[i] != NULL) {
15871578 			skb = gp->rx_skbs[i];
15881579 			dma_addr = le64_to_cpu(rxd->buffer);
1589
-			pci_unmap_page(gp->pdev, dma_addr,
1580
+			dma_unmap_page(&gp->pdev->dev, dma_addr,
15901581 				       RX_BUF_ALLOC_SIZE(gp),
1591
-				       PCI_DMA_FROMDEVICE);
1582
+				       DMA_FROM_DEVICE);
15921583 			dev_kfree_skb_any(skb);
15931584 			gp->rx_skbs[i] = NULL;
15941585 		}
....@@ -1610,9 +1601,9 @@
16101601 
16111602 				txd = &gb->txd[ent];
16121603 				dma_addr = le64_to_cpu(txd->buffer);
1613
-				pci_unmap_page(gp->pdev, dma_addr,
1604
+				dma_unmap_page(&gp->pdev->dev, dma_addr,
16141605 					       le64_to_cpu(txd->control_word) &
1615
-					       TXDCTRL_BUFSZ, PCI_DMA_TODEVICE);
1606
+					       TXDCTRL_BUFSZ, DMA_TO_DEVICE);
16161607 
16171608 				if (frag != skb_shinfo(skb)->nr_frags)
16181609 					i++;
....@@ -1649,11 +1640,11 @@
16491640 
16501641 		gp->rx_skbs[i] = skb;
16511642 		skb_put(skb, (gp->rx_buf_sz + RX_OFFSET));
1652
-		dma_addr = pci_map_page(gp->pdev,
1643
+		dma_addr = dma_map_page(&gp->pdev->dev,
16531644 					virt_to_page(skb->data),
16541645 					offset_in_page(skb->data),
16551646 					RX_BUF_ALLOC_SIZE(gp),
1656
-					PCI_DMA_FROMDEVICE);
1647
+					DMA_FROM_DEVICE);
16571648 		rxd->buffer = cpu_to_le64(dma_addr);
16581649 		dma_wmb();
16591650 		rxd->status_word = cpu_to_le64(RXDCTRL_FRESH(gp));
....@@ -2151,20 +2142,6 @@
21512142 	struct gem *gp = netdev_priv(dev);
21522143 	int rc;
21532144 
2154
-	/* Enable the cell */
2155
-	gem_get_cell(gp);
2156
-
2157
-	/* Make sure PCI access and bus master are enabled */
2158
-	rc = pci_enable_device(gp->pdev);
2159
-	if (rc) {
2160
-		netdev_err(dev, "Failed to enable chip on PCI bus !\n");
2161
-
2162
-		/* Put cell and forget it for now, it will be considered as
2163
-		 * still asleep, a new sleep cycle may bring it back
2164
-		 */
2165
-		gem_put_cell(gp);
2166
-		return -ENXIO;
2167
-	}
21682145 	pci_set_master(gp->pdev);
21692146 
21702147 	/* Init & setup chip hardware */
....@@ -2242,13 +2219,6 @@
22422219 
22432220 	/* Shut the PHY down eventually and setup WOL */
22442221 	gem_stop_phy(gp, wol);
2245
-
2246
-	/* Make sure bus master is disabled */
2247
-	pci_disable_device(gp->pdev);
2248
-
2249
-	/* Cell not needed neither if no WOL */
2250
-	if (!wol)
2251
-		gem_put_cell(gp);
22522222 }
22532223 
22542224 static void gem_reset_task(struct work_struct *work)
....@@ -2300,26 +2270,53 @@
23002270 
23012271 static int gem_open(struct net_device *dev)
23022272 {
2273
+	struct gem *gp = netdev_priv(dev);
2274
+	int rc;
2275
+
23032276 	/* We allow open while suspended, we just do nothing,
23042277 	 * the chip will be initialized in resume()
23052278 	 */
2306
-	if (netif_device_present(dev))
2279
+	if (netif_device_present(dev)) {
2280
+		/* Enable the cell */
2281
+		gem_get_cell(gp);
2282
+
2283
+		/* Make sure PCI access and bus master are enabled */
2284
+		rc = pci_enable_device(gp->pdev);
2285
+		if (rc) {
2286
+			netdev_err(dev, "Failed to enable chip on PCI bus !\n");
2287
+
2288
+			/* Put cell and forget it for now, it will be considered
2289
+			 *as still asleep, a new sleep cycle may bring it back
2290
+			 */
2291
+			gem_put_cell(gp);
2292
+			return -ENXIO;
2293
+		}
23072294 		return gem_do_start(dev);
2295
+	}
2296
+
23082297 	return 0;
23092298 }
23102299 
23112300 static int gem_close(struct net_device *dev)
23122301 {
2313
-	if (netif_device_present(dev))
2302
+	struct gem *gp = netdev_priv(dev);
2303
+
2304
+	if (netif_device_present(dev)) {
23142305 		gem_do_stop(dev, 0);
23152306 
2307
+		/* Make sure bus master is disabled */
2308
+		pci_disable_device(gp->pdev);
2309
+
2310
+		/* Cell not needed neither if no WOL */
2311
+		if (!gp->asleep_wol)
2312
+			gem_put_cell(gp);
2313
+	}
23162314 	return 0;
23172315 }
23182316 
2319
-#ifdef CONFIG_PM
2320
-static int gem_suspend(struct pci_dev *pdev, pm_message_t state)
2317
+static int __maybe_unused gem_suspend(struct device *dev_d)
23212318 {
2322
-	struct net_device *dev = pci_get_drvdata(pdev);
2319
+	struct net_device *dev = dev_get_drvdata(dev_d);
23232320 	struct gem *gp = netdev_priv(dev);
23242321 
23252322 	/* Lock the network stack first to avoid racing with open/close,
....@@ -2348,15 +2345,19 @@
23482345 	gp->asleep_wol = !!gp->wake_on_lan;
23492346 	gem_do_stop(dev, gp->asleep_wol);
23502347 
2348
+	/* Cell not needed neither if no WOL */
2349
+	if (!gp->asleep_wol)
2350
+		gem_put_cell(gp);
2351
+
23512352 	/* Unlock the network stack */
23522353 	rtnl_unlock();
23532354 
23542355 	return 0;
23552356 }
23562357 
2357
-static int gem_resume(struct pci_dev *pdev)
2358
+static int __maybe_unused gem_resume(struct device *dev_d)
23582359 {
2359
-	struct net_device *dev = pci_get_drvdata(pdev);
2360
+	struct net_device *dev = dev_get_drvdata(dev_d);
23602361 	struct gem *gp = netdev_priv(dev);
23612362 
23622363 	/* See locking comment in gem_suspend */
....@@ -2370,6 +2371,9 @@
23702371 		rtnl_unlock();
23712372 		return 0;
23722373 	}
2374
+
2375
+	/* Enable the cell */
2376
+	gem_get_cell(gp);
23732377 
23742378 	/* Restart chip. If that fails there isn't much we can do, we
23752379 	 * leave things stopped.
....@@ -2387,7 +2391,6 @@
23872391 
23882392 	return 0;
23892393 }
2390
-#endif /* CONFIG_PM */
23912394 
23922395 static struct net_device_stats *gem_get_stats(struct net_device *dev)
23932396 {
....@@ -2709,7 +2712,7 @@
27092712 	switch (cmd) {
27102713 	case SIOCGMIIPHY:		/* Get address of MII PHY in use. */
27112714 		data->phy_id = gp->mii_phy_addr;
2712
-		/* Fallthrough... */
2715
+		fallthrough;
27132716 
27142717 	case SIOCGMIIREG:		/* Read MII PHY register. */
27152718 		data->val_out = __sungem_phy_read(gp, data->phy_id & 0x1f,
....@@ -2760,7 +2763,7 @@
27602763 	void __iomem *p = pci_map_rom(pdev, &size);
27612764 
27622765 	if (p) {
2763
-			int found;
2766
+		int found;
27642767 
27652768 		found = readb(p) == 0x55 &&
27662769 			readb(p + 1) == 0xaa &&
....@@ -2814,10 +2817,8 @@
28142817 		cancel_work_sync(&gp->reset_task);
28152818 
28162819 		/* Free resources */
2817
-		pci_free_consistent(pdev,
2818
-				    sizeof(struct gem_init_block),
2819
-				    gp->init_block,
2820
-				    gp->gblock_dvma);
2820
+		dma_free_coherent(&pdev->dev, sizeof(struct gem_init_block),
2821
+				  gp->init_block, gp->gblock_dvma);
28212822 		iounmap(gp->regs);
28222823 		pci_release_regions(pdev);
28232824 		free_netdev(dev);
....@@ -2873,10 +2874,10 @@
28732874 	 */
28742875 	if (pdev->vendor == PCI_VENDOR_ID_SUN &&
28752876 	    pdev->device == PCI_DEVICE_ID_SUN_GEM &&
2876
-	    !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
2877
+	    !dma_set_mask(&pdev->dev, DMA_BIT_MASK(64))) {
28772878 		pci_using_dac = 1;
28782879 	} else {
2879
-		err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
2880
+		err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
28802881 		if (err) {
28812882 			pr_err("No usable DMA configuration, aborting\n");
28822883 			goto err_disable_device;
....@@ -2964,9 +2965,8 @@
29642965 	/* It is guaranteed that the returned buffer will be at least
29652966 	 * PAGE_SIZE aligned.
29662967 	 */
2967
-	gp->init_block = (struct gem_init_block *)
2968
-		pci_alloc_consistent(pdev, sizeof(struct gem_init_block),
2969
-				     &gp->gblock_dvma);
2968
+	gp->init_block = dma_alloc_coherent(&pdev->dev, sizeof(struct gem_init_block),
2969
+					    &gp->gblock_dvma, GFP_KERNEL);
29702970 	if (!gp->init_block) {
29712971 		pr_err("Cannot allocate init block, aborting\n");
29722972 		err = -ENOMEM;
....@@ -3031,16 +3031,14 @@
30313031 
30323032 }
30333033 
3034
+static SIMPLE_DEV_PM_OPS(gem_pm_ops, gem_suspend, gem_resume);
30343035 
30353036 static struct pci_driver gem_driver = {
30363037 	.name		= GEM_MODULE_NAME,
30373038 	.id_table	= gem_pci_tbl,
30383039 	.probe		= gem_init_one,
30393040 	.remove		= gem_remove_one,
3040
-#ifdef CONFIG_PM
3041
-	.suspend	= gem_suspend,
3042
-	.resume		= gem_resume,
3043
-#endif /* CONFIG_PM */
3041
+	.driver.pm	= &gem_pm_ops,
30443042 };
30453043 
30463044 module_pci_driver(gem_driver);