移去rt

hc

2023-12-08 01573e231f18eb2d99162747186f59511f56b64d

 kernel/drivers/net/ethernet/packetengines/hamachi.c
..
..
@@ -548,7 +548,7 @@
548
548
 static int hamachi_open(struct net_device *dev);
549
549
 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
550
550
 static void hamachi_timer(struct timer_list *t);
551
-static void hamachi_tx_timeout(struct net_device *dev);
551
+static void hamachi_tx_timeout(struct net_device *dev, unsigned int txqueue);
552
552
 static void hamachi_init_ring(struct net_device *dev);
553
553
 static netdev_tx_t hamachi_start_xmit(struct sk_buff *skb,
554
554
 				      struct net_device *dev);
..
..
@@ -644,13 +644,15 @@
644
644
 	hmp->mii_if.phy_id_mask = 0x1f;
645
645
 	hmp->mii_if.reg_num_mask = 0x1f;
646
646
 
647
-	ring_space = pci_alloc_consistent(pdev, TX_TOTAL_SIZE, &ring_dma);
647
+	ring_space = dma_alloc_coherent(&pdev->dev, TX_TOTAL_SIZE, &ring_dma,
648
+					GFP_KERNEL);
648
649
 	if (!ring_space)
649
650
 		goto err_out_cleardev;
650
651
 	hmp->tx_ring = ring_space;
651
652
 	hmp->tx_ring_dma = ring_dma;
652
653
 
653
-	ring_space = pci_alloc_consistent(pdev, RX_TOTAL_SIZE, &ring_dma);
654
+	ring_space = dma_alloc_coherent(&pdev->dev, RX_TOTAL_SIZE, &ring_dma,
655
+					GFP_KERNEL);
654
656
 	if (!ring_space)
655
657
 		goto err_out_unmap_tx;
656
658
 	hmp->rx_ring = ring_space;
..
..
@@ -773,11 +775,11 @@
773
775
 	return 0;
774
776
 
775
777
 err_out_unmap_rx:
776
-	pci_free_consistent(pdev, RX_TOTAL_SIZE, hmp->rx_ring,
777
-		hmp->rx_ring_dma);
778
+	dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE, hmp->rx_ring,
779
+			  hmp->rx_ring_dma);
778
780
 err_out_unmap_tx:
779
-	pci_free_consistent(pdev, TX_TOTAL_SIZE, hmp->tx_ring,
780
-		hmp->tx_ring_dma);
781
+	dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE, hmp->tx_ring,
782
+			  hmp->tx_ring_dma);
781
783
 err_out_cleardev:
782
784
 	free_netdev (dev);
783
785
 err_out_iounmap:
..
..
@@ -1001,9 +1003,9 @@
1001
1003
 		/* Free the original skb. */
1002
1004
 		skb = hmp->tx_skbuff[entry];
1003
1005
 		if (skb) {
1004
-			pci_unmap_single(hmp->pci_dev,
1005
-				leXX_to_cpu(hmp->tx_ring[entry].addr),
1006
-				skb->len, PCI_DMA_TODEVICE);
1006
+			dma_unmap_single(&hmp->pci_dev->dev,
1007
+					 leXX_to_cpu(hmp->tx_ring[entry].addr),
1008
+					 skb->len, DMA_TO_DEVICE);
1007
1009
 			dev_kfree_skb(skb);
1008
1010
 			hmp->tx_skbuff[entry] = NULL;
1009
1011
 		}
..
..
@@ -1042,7 +1044,7 @@
1042
1044
 	add_timer(&hmp->timer);
1043
1045
 }
1044
1046
 
1045
-static void hamachi_tx_timeout(struct net_device *dev)
1047
+static void hamachi_tx_timeout(struct net_device *dev, unsigned int txqueue)
1046
1048
 {
1047
1049
 	int i;
1048
1050
 	struct hamachi_private *hmp = netdev_priv(dev);
..
..
@@ -1093,8 +1095,9 @@
1093
1095
 			hmp->tx_ring[i].status_n_length &= cpu_to_le32(0x0000ffff);
1094
1096
 		skb = hmp->tx_skbuff[i];
1095
1097
 		if (skb){
1096
-			pci_unmap_single(hmp->pci_dev, leXX_to_cpu(hmp->tx_ring[i].addr),
1097
-				skb->len, PCI_DMA_TODEVICE);
1098
+			dma_unmap_single(&hmp->pci_dev->dev,
1099
+					 leXX_to_cpu(hmp->tx_ring[i].addr),
1100
+					 skb->len, DMA_TO_DEVICE);
1098
1101
 			dev_kfree_skb(skb);
1099
1102
 			hmp->tx_skbuff[i] = NULL;
1100
1103
 		}
..
..
@@ -1115,9 +1118,9 @@
1115
1118
 		struct sk_buff *skb = hmp->rx_skbuff[i];
1116
1119
 
1117
1120
 		if (skb){
1118
-			pci_unmap_single(hmp->pci_dev,
1119
-				leXX_to_cpu(hmp->rx_ring[i].addr),
1120
-				hmp->rx_buf_sz, PCI_DMA_FROMDEVICE);
1121
+			dma_unmap_single(&hmp->pci_dev->dev,
1122
+					 leXX_to_cpu(hmp->rx_ring[i].addr),
1123
+					 hmp->rx_buf_sz, DMA_FROM_DEVICE);
1121
1124
 			dev_kfree_skb(skb);
1122
1125
 			hmp->rx_skbuff[i] = NULL;
1123
1126
 		}
..
..
@@ -1131,8 +1134,10 @@
1131
1134
 		if (skb == NULL)
1132
1135
 			break;
1133
1136
 
1134
-                hmp->rx_ring[i].addr = cpu_to_leXX(pci_map_single(hmp->pci_dev,
1135
-			skb->data, hmp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1137
+		hmp->rx_ring[i].addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1138
+								  skb->data,
1139
+								  hmp->rx_buf_sz,
1140
+								  DMA_FROM_DEVICE));
1136
1141
 		hmp->rx_ring[i].status_n_length = cpu_to_le32(DescOwn |
1137
1142
 			DescEndPacket | DescIntr | (hmp->rx_buf_sz - 2));
1138
1143
 	}
..
..
@@ -1183,8 +1188,10 @@
1183
1188
 		if (skb == NULL)
1184
1189
 			break;
1185
1190
 		skb_reserve(skb, 2); /* 16 byte align the IP header. */
1186
-                hmp->rx_ring[i].addr = cpu_to_leXX(pci_map_single(hmp->pci_dev,
1187
-			skb->data, hmp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1191
+		hmp->rx_ring[i].addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1192
+								  skb->data,
1193
+								  hmp->rx_buf_sz,
1194
+								  DMA_FROM_DEVICE));
1188
1195
 		/* -2 because it doesn't REALLY have that first 2 bytes -KDU */
1189
1196
 		hmp->rx_ring[i].status_n_length = cpu_to_le32(DescOwn |
1190
1197
 			DescEndPacket | DescIntr | (hmp->rx_buf_sz -2));
..
..
@@ -1233,8 +1240,10 @@
1233
1240
 
1234
1241
 	hmp->tx_skbuff[entry] = skb;
1235
1242
 
1236
-        hmp->tx_ring[entry].addr = cpu_to_leXX(pci_map_single(hmp->pci_dev,
1237
-		skb->data, skb->len, PCI_DMA_TODEVICE));
1243
+	hmp->tx_ring[entry].addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1244
+							      skb->data,
1245
+							      skb->len,
1246
+							      DMA_TO_DEVICE));
1238
1247
 
1239
1248
 	/* Hmmmm, could probably put a DescIntr on these, but the way
1240
1249
 		the driver is currently coded makes Tx interrupts unnecessary
..
..
@@ -1333,11 +1342,11 @@
1333
1342
 					skb = hmp->tx_skbuff[entry];
1334
1343
 					/* Free the original skb. */
1335
1344
 					if (skb){
1336
-						pci_unmap_single(hmp->pci_dev,
1337
-							leXX_to_cpu(hmp->tx_ring[entry].addr),
1338
-							skb->len,
1339
-							PCI_DMA_TODEVICE);
1340
-						dev_kfree_skb_irq(skb);
1345
+						dma_unmap_single(&hmp->pci_dev->dev,
1346
+								 leXX_to_cpu(hmp->tx_ring[entry].addr),
1347
+								 skb->len,
1348
+								 DMA_TO_DEVICE);
1349
+						dev_consume_skb_irq(skb);
1341
1350
 						hmp->tx_skbuff[entry] = NULL;
1342
1351
 					}
1343
1352
 					hmp->tx_ring[entry].status_n_length = 0;
..
..
@@ -1413,10 +1422,9 @@
1413
1422
 
1414
1423
 		if (desc_status & DescOwn)
1415
1424
 			break;
1416
-		pci_dma_sync_single_for_cpu(hmp->pci_dev,
1417
-					    leXX_to_cpu(desc->addr),
1418
-					    hmp->rx_buf_sz,
1419
-					    PCI_DMA_FROMDEVICE);
1425
+		dma_sync_single_for_cpu(&hmp->pci_dev->dev,
1426
+					leXX_to_cpu(desc->addr),
1427
+					hmp->rx_buf_sz, DMA_FROM_DEVICE);
1420
1428
 		buf_addr = (u8 *) hmp->rx_skbuff[entry]->data;
1421
1429
 		frame_status = get_unaligned_le32(&(buf_addr[data_size - 12]));
1422
1430
 		if (hamachi_debug > 4)
..
..
@@ -1483,10 +1491,10 @@
1483
1491
 				  "not good with RX_CHECKSUM\n", dev->name);
1484
1492
 #endif
1485
1493
 				skb_reserve(skb, 2);	/* 16 byte align the IP header */
1486
-				pci_dma_sync_single_for_cpu(hmp->pci_dev,
1487
-							    leXX_to_cpu(hmp->rx_ring[entry].addr),
1488
-							    hmp->rx_buf_sz,
1489
-							    PCI_DMA_FROMDEVICE);
1494
+				dma_sync_single_for_cpu(&hmp->pci_dev->dev,
1495
+							leXX_to_cpu(hmp->rx_ring[entry].addr),
1496
+							hmp->rx_buf_sz,
1497
+							DMA_FROM_DEVICE);
1490
1498
 				/* Call copy + cksum if available. */
1491
1499
 #if 1 || USE_IP_COPYSUM
1492
1500
 				skb_copy_to_linear_data(skb,
..
..
@@ -1496,14 +1504,15 @@
1496
1504
 				skb_put_data(skb, hmp->rx_ring_dma
1497
1505
 					     + entry*sizeof(*desc), pkt_len);
1498
1506
 #endif
1499
-				pci_dma_sync_single_for_device(hmp->pci_dev,
1500
-							       leXX_to_cpu(hmp->rx_ring[entry].addr),
1501
-							       hmp->rx_buf_sz,
1502
-							       PCI_DMA_FROMDEVICE);
1507
+				dma_sync_single_for_device(&hmp->pci_dev->dev,
1508
+							   leXX_to_cpu(hmp->rx_ring[entry].addr),
1509
+							   hmp->rx_buf_sz,
1510
+							   DMA_FROM_DEVICE);
1503
1511
 			} else {
1504
-				pci_unmap_single(hmp->pci_dev,
1512
+				dma_unmap_single(&hmp->pci_dev->dev,
1505
1513
 						 leXX_to_cpu(hmp->rx_ring[entry].addr),
1506
-						 hmp->rx_buf_sz, PCI_DMA_FROMDEVICE);
1514
+						 hmp->rx_buf_sz,
1515
+						 DMA_FROM_DEVICE);
1507
1516
 				skb_put(skb = hmp->rx_skbuff[entry], pkt_len);
1508
1517
 				hmp->rx_skbuff[entry] = NULL;
1509
1518
 			}
..
..
@@ -1586,8 +1595,10 @@
1586
1595
 			if (skb == NULL)
1587
1596
 				break;		/* Better luck next round. */
1588
1597
 			skb_reserve(skb, 2);	/* Align IP on 16 byte boundaries */
1589
-                	desc->addr = cpu_to_leXX(pci_map_single(hmp->pci_dev,
1590
-				skb->data, hmp->rx_buf_sz, PCI_DMA_FROMDEVICE));
1598
+			desc->addr = cpu_to_leXX(dma_map_single(&hmp->pci_dev->dev,
1599
+								skb->data,
1600
+								hmp->rx_buf_sz,
1601
+								DMA_FROM_DEVICE));
1591
1602
 		}
1592
1603
 		desc->status_n_length = cpu_to_le32(hmp->rx_buf_sz);
1593
1604
 		if (entry >= RX_RING_SIZE-1)
..
..
@@ -1704,9 +1715,9 @@
1704
1715
 		skb = hmp->rx_skbuff[i];
1705
1716
 		hmp->rx_ring[i].status_n_length = 0;
1706
1717
 		if (skb) {
1707
-			pci_unmap_single(hmp->pci_dev,
1708
-				leXX_to_cpu(hmp->rx_ring[i].addr),
1709
-				hmp->rx_buf_sz, PCI_DMA_FROMDEVICE);
1718
+			dma_unmap_single(&hmp->pci_dev->dev,
1719
+					 leXX_to_cpu(hmp->rx_ring[i].addr),
1720
+					 hmp->rx_buf_sz, DMA_FROM_DEVICE);
1710
1721
 			dev_kfree_skb(skb);
1711
1722
 			hmp->rx_skbuff[i] = NULL;
1712
1723
 		}
..
..
@@ -1715,9 +1726,9 @@
1715
1726
 	for (i = 0; i < TX_RING_SIZE; i++) {
1716
1727
 		skb = hmp->tx_skbuff[i];
1717
1728
 		if (skb) {
1718
-			pci_unmap_single(hmp->pci_dev,
1719
-				leXX_to_cpu(hmp->tx_ring[i].addr),
1720
-				skb->len, PCI_DMA_TODEVICE);
1729
+			dma_unmap_single(&hmp->pci_dev->dev,
1730
+					 leXX_to_cpu(hmp->tx_ring[i].addr),
1731
+					 skb->len, DMA_TO_DEVICE);
1721
1732
 			dev_kfree_skb(skb);
1722
1733
 			hmp->tx_skbuff[i] = NULL;
1723
1734
 		}
..
..
@@ -1899,10 +1910,10 @@
1899
1910
 	if (dev) {
1900
1911
 		struct hamachi_private *hmp = netdev_priv(dev);
1901
1912
 
1902
-		pci_free_consistent(pdev, RX_TOTAL_SIZE, hmp->rx_ring,
1903
-			hmp->rx_ring_dma);
1904
-		pci_free_consistent(pdev, TX_TOTAL_SIZE, hmp->tx_ring,
1905
-			hmp->tx_ring_dma);
1913
+		dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE, hmp->rx_ring,
1914
+				  hmp->rx_ring_dma);
1915
+		dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE, hmp->tx_ring,
1916
+				  hmp->tx_ring_dma);
1906
1917
 		unregister_netdev(dev);
1907
1918
 		iounmap(hmp->base);
1908
1919
 		free_netdev(dev);