e1000e: use DMA API instead of PCI DMA functions (0be3f55f) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/net/e1000e/ethtool.c

+16 −14

Original line number	Original line	Diff line number	Diff line
	@@ -1069,10 +1069,10 @@ static void e1000_free_desc_rings(struct e1000_adapter *adapter)
	if (tx_ring->desc && tx_ring->buffer_info) {		if (tx_ring->desc && tx_ring->buffer_info) {
	for (i = 0; i < tx_ring->count; i++) {		for (i = 0; i < tx_ring->count; i++) {
	if (tx_ring->buffer_info[i].dma)		if (tx_ring->buffer_info[i].dma)
	pci_unmap_single(pdev,		dma_unmap_single(&pdev->dev,
	tx_ring->buffer_info[i].dma,		tx_ring->buffer_info[i].dma,
	tx_ring->buffer_info[i].length,		tx_ring->buffer_info[i].length,
	PCI_DMA_TODEVICE);		DMA_TO_DEVICE);
	if (tx_ring->buffer_info[i].skb)		if (tx_ring->buffer_info[i].skb)
	dev_kfree_skb(tx_ring->buffer_info[i].skb);		dev_kfree_skb(tx_ring->buffer_info[i].skb);
	}		}
	@@ -1081,9 +1081,9 @@ static void e1000_free_desc_rings(struct e1000_adapter *adapter)
	if (rx_ring->desc && rx_ring->buffer_info) {		if (rx_ring->desc && rx_ring->buffer_info) {
	for (i = 0; i < rx_ring->count; i++) {		for (i = 0; i < rx_ring->count; i++) {
	if (rx_ring->buffer_info[i].dma)		if (rx_ring->buffer_info[i].dma)
	pci_unmap_single(pdev,		dma_unmap_single(&pdev->dev,
	rx_ring->buffer_info[i].dma,		rx_ring->buffer_info[i].dma,
	2048, PCI_DMA_FROMDEVICE);		2048, DMA_FROM_DEVICE);
	if (rx_ring->buffer_info[i].skb)		if (rx_ring->buffer_info[i].skb)
	dev_kfree_skb(rx_ring->buffer_info[i].skb);		dev_kfree_skb(rx_ring->buffer_info[i].skb);
	}		}
	@@ -1163,9 +1163,10 @@ static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
	tx_ring->buffer_info[i].skb = skb;		tx_ring->buffer_info[i].skb = skb;
	tx_ring->buffer_info[i].length = skb->len;		tx_ring->buffer_info[i].length = skb->len;
	tx_ring->buffer_info[i].dma =		tx_ring->buffer_info[i].dma =
	pci_map_single(pdev, skb->data, skb->len,		dma_map_single(&pdev->dev, skb->data, skb->len,
	PCI_DMA_TODEVICE);		DMA_TO_DEVICE);
	if (pci_dma_mapping_error(pdev, tx_ring->buffer_info[i].dma)) {		if (dma_mapping_error(&pdev->dev,
			tx_ring->buffer_info[i].dma)) {
	ret_val = 4;		ret_val = 4;
	goto err_nomem;		goto err_nomem;
	}		}
	@@ -1226,9 +1227,10 @@ static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
	skb_reserve(skb, NET_IP_ALIGN);		skb_reserve(skb, NET_IP_ALIGN);
	rx_ring->buffer_info[i].skb = skb;		rx_ring->buffer_info[i].skb = skb;
	rx_ring->buffer_info[i].dma =		rx_ring->buffer_info[i].dma =
	pci_map_single(pdev, skb->data, 2048,		dma_map_single(&pdev->dev, skb->data, 2048,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);
	if (pci_dma_mapping_error(pdev, rx_ring->buffer_info[i].dma)) {		if (dma_mapping_error(&pdev->dev,
			rx_ring->buffer_info[i].dma)) {
	ret_val = 8;		ret_val = 8;
	goto err_nomem;		goto err_nomem;
	}		}
	@@ -1556,10 +1558,10 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter)
	for (i = 0; i < 64; i++) { /* send the packets */		for (i = 0; i < 64; i++) { /* send the packets */
	e1000_create_lbtest_frame(tx_ring->buffer_info[k].skb,		e1000_create_lbtest_frame(tx_ring->buffer_info[k].skb,
	1024);		1024);
	pci_dma_sync_single_for_device(pdev,		dma_sync_single_for_device(&pdev->dev,
	tx_ring->buffer_info[k].dma,		tx_ring->buffer_info[k].dma,
	tx_ring->buffer_info[k].length,		tx_ring->buffer_info[k].length,
	PCI_DMA_TODEVICE);		DMA_TO_DEVICE);
	k++;		k++;
	if (k == tx_ring->count)		if (k == tx_ring->count)
	k = 0;		k = 0;
	@@ -1569,9 +1571,9 @@ static int e1000_run_loopback_test(struct e1000_adapter *adapter)
	time = jiffies; /* set the start time for the receive */		time = jiffies; /* set the start time for the receive */
	good_cnt = 0;		good_cnt = 0;
	do { /* receive the sent packets */		do { /* receive the sent packets */
	pci_dma_sync_single_for_cpu(pdev,		dma_sync_single_for_cpu(&pdev->dev,
	rx_ring->buffer_info[l].dma, 2048,		rx_ring->buffer_info[l].dma, 2048,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);

	ret_val = e1000_check_lbtest_frame(		ret_val = e1000_check_lbtest_frame(
	rx_ring->buffer_info[l].skb, 1024);		rx_ring->buffer_info[l].skb, 1024);

drivers/net/e1000e/netdev.c

+50 −49

Original line number	Original line	Diff line number	Diff line
	@@ -181,10 +181,10 @@ static void e1000_alloc_rx_buffers(struct e1000_adapter *adapter,

	buffer_info->skb = skb;		buffer_info->skb = skb;
	map_skb:		map_skb:
	buffer_info->dma = pci_map_single(pdev, skb->data,		buffer_info->dma = dma_map_single(&pdev->dev, skb->data,
	adapter->rx_buffer_len,		adapter->rx_buffer_len,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);
	if (pci_dma_mapping_error(pdev, buffer_info->dma)) {		if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
	dev_err(&pdev->dev, "RX DMA map failed\n");		dev_err(&pdev->dev, "RX DMA map failed\n");
	adapter->rx_dma_failed++;		adapter->rx_dma_failed++;
	break;		break;
	@@ -250,11 +250,12 @@ static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
	adapter->alloc_rx_buff_failed++;		adapter->alloc_rx_buff_failed++;
	goto no_buffers;		goto no_buffers;
	}		}
	ps_page->dma = pci_map_page(pdev,		ps_page->dma = dma_map_page(&pdev->dev,
	ps_page->page,		ps_page->page,
	0, PAGE_SIZE,		0, PAGE_SIZE,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);
	if (pci_dma_mapping_error(pdev, ps_page->dma)) {		if (dma_mapping_error(&pdev->dev,
			ps_page->dma)) {
	dev_err(&adapter->pdev->dev,		dev_err(&adapter->pdev->dev,
	"RX DMA page map failed\n");		"RX DMA page map failed\n");
	adapter->rx_dma_failed++;		adapter->rx_dma_failed++;
	@@ -279,10 +280,10 @@ static void e1000_alloc_rx_buffers_ps(struct e1000_adapter *adapter,
	}		}

	buffer_info->skb = skb;		buffer_info->skb = skb;
	buffer_info->dma = pci_map_single(pdev, skb->data,		buffer_info->dma = dma_map_single(&pdev->dev, skb->data,
	adapter->rx_ps_bsize0,		adapter->rx_ps_bsize0,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);
	if (pci_dma_mapping_error(pdev, buffer_info->dma)) {		if (dma_mapping_error(&pdev->dev, buffer_info->dma)) {
	dev_err(&pdev->dev, "RX DMA map failed\n");		dev_err(&pdev->dev, "RX DMA map failed\n");
	adapter->rx_dma_failed++;		adapter->rx_dma_failed++;
	/* cleanup skb */		/* cleanup skb */
	@@ -369,10 +370,10 @@ check_page:
	}		}

	if (!buffer_info->dma)		if (!buffer_info->dma)
	buffer_info->dma = pci_map_page(pdev,		buffer_info->dma = dma_map_page(&pdev->dev,
	buffer_info->page, 0,		buffer_info->page, 0,
	PAGE_SIZE,		PAGE_SIZE,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);

	rx_desc = E1000_RX_DESC(*rx_ring, i);		rx_desc = E1000_RX_DESC(*rx_ring, i);
	rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);		rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
	@@ -446,10 +447,10 @@ static bool e1000_clean_rx_irq(struct e1000_adapter *adapter,

	cleaned = 1;		cleaned = 1;
	cleaned_count++;		cleaned_count++;
	pci_unmap_single(pdev,		dma_unmap_single(&pdev->dev,
	buffer_info->dma,		buffer_info->dma,
	adapter->rx_buffer_len,		adapter->rx_buffer_len,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);
	buffer_info->dma = 0;		buffer_info->dma = 0;

	length = le16_to_cpu(rx_desc->length);		length = le16_to_cpu(rx_desc->length);
	@@ -550,12 +551,11 @@ static void e1000_put_txbuf(struct e1000_adapter *adapter,
	{		{
	if (buffer_info->dma) {		if (buffer_info->dma) {
	if (buffer_info->mapped_as_page)		if (buffer_info->mapped_as_page)
	pci_unmap_page(adapter->pdev, buffer_info->dma,		dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
	buffer_info->length, PCI_DMA_TODEVICE);		buffer_info->length, DMA_TO_DEVICE);
	else		else
	pci_unmap_single(adapter->pdev, buffer_info->dma,		dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
	buffer_info->length,		buffer_info->length, DMA_TO_DEVICE);
	PCI_DMA_TODEVICE);
	buffer_info->dma = 0;		buffer_info->dma = 0;
	}		}
	if (buffer_info->skb) {		if (buffer_info->skb) {
	@@ -756,9 +756,9 @@ static bool e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,

	cleaned = 1;		cleaned = 1;
	cleaned_count++;		cleaned_count++;
	pci_unmap_single(pdev, buffer_info->dma,		dma_unmap_single(&pdev->dev, buffer_info->dma,
	adapter->rx_ps_bsize0,		adapter->rx_ps_bsize0,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);
	buffer_info->dma = 0;		buffer_info->dma = 0;

	/* see !EOP comment in other rx routine */		/* see !EOP comment in other rx routine */
	@@ -814,13 +814,13 @@ static bool e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
	* kmap_atomic, so we can't hold the mapping		* kmap_atomic, so we can't hold the mapping
	* very long		* very long
	*/		*/
	pci_dma_sync_single_for_cpu(pdev, ps_page->dma,		dma_sync_single_for_cpu(&pdev->dev, ps_page->dma,
	PAGE_SIZE, PCI_DMA_FROMDEVICE);		PAGE_SIZE, DMA_FROM_DEVICE);
	vaddr = kmap_atomic(ps_page->page, KM_SKB_DATA_SOFTIRQ);		vaddr = kmap_atomic(ps_page->page, KM_SKB_DATA_SOFTIRQ);
	memcpy(skb_tail_pointer(skb), vaddr, l1);		memcpy(skb_tail_pointer(skb), vaddr, l1);
	kunmap_atomic(vaddr, KM_SKB_DATA_SOFTIRQ);		kunmap_atomic(vaddr, KM_SKB_DATA_SOFTIRQ);
	pci_dma_sync_single_for_device(pdev, ps_page->dma,		dma_sync_single_for_device(&pdev->dev, ps_page->dma,
	PAGE_SIZE, PCI_DMA_FROMDEVICE);		PAGE_SIZE, DMA_FROM_DEVICE);

	/* remove the CRC */		/* remove the CRC */
	if (!(adapter->flags2 & FLAG2_CRC_STRIPPING))		if (!(adapter->flags2 & FLAG2_CRC_STRIPPING))
	@@ -837,8 +837,8 @@ static bool e1000_clean_rx_irq_ps(struct e1000_adapter *adapter,
	break;		break;

	ps_page = &buffer_info->ps_pages[j];		ps_page = &buffer_info->ps_pages[j];
	pci_unmap_page(pdev, ps_page->dma, PAGE_SIZE,		dma_unmap_page(&pdev->dev, ps_page->dma, PAGE_SIZE,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);
	ps_page->dma = 0;		ps_page->dma = 0;
	skb_fill_page_desc(skb, j, ps_page->page, 0, length);		skb_fill_page_desc(skb, j, ps_page->page, 0, length);
	ps_page->page = NULL;		ps_page->page = NULL;
	@@ -956,8 +956,8 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_adapter *adapter,

	cleaned = true;		cleaned = true;
	cleaned_count++;		cleaned_count++;
	pci_unmap_page(pdev, buffer_info->dma, PAGE_SIZE,		dma_unmap_page(&pdev->dev, buffer_info->dma, PAGE_SIZE,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);
	buffer_info->dma = 0;		buffer_info->dma = 0;

	length = le16_to_cpu(rx_desc->length);		length = le16_to_cpu(rx_desc->length);
	@@ -1093,17 +1093,17 @@ static void e1000_clean_rx_ring(struct e1000_adapter *adapter)
	buffer_info = &rx_ring->buffer_info[i];		buffer_info = &rx_ring->buffer_info[i];
	if (buffer_info->dma) {		if (buffer_info->dma) {
	if (adapter->clean_rx == e1000_clean_rx_irq)		if (adapter->clean_rx == e1000_clean_rx_irq)
	pci_unmap_single(pdev, buffer_info->dma,		dma_unmap_single(&pdev->dev, buffer_info->dma,
	adapter->rx_buffer_len,		adapter->rx_buffer_len,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);
	else if (adapter->clean_rx == e1000_clean_jumbo_rx_irq)		else if (adapter->clean_rx == e1000_clean_jumbo_rx_irq)
	pci_unmap_page(pdev, buffer_info->dma,		dma_unmap_page(&pdev->dev, buffer_info->dma,
	PAGE_SIZE,		PAGE_SIZE,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);
	else if (adapter->clean_rx == e1000_clean_rx_irq_ps)		else if (adapter->clean_rx == e1000_clean_rx_irq_ps)
	pci_unmap_single(pdev, buffer_info->dma,		dma_unmap_single(&pdev->dev, buffer_info->dma,
	adapter->rx_ps_bsize0,		adapter->rx_ps_bsize0,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);
	buffer_info->dma = 0;		buffer_info->dma = 0;
	}		}

	@@ -1121,8 +1121,8 @@ static void e1000_clean_rx_ring(struct e1000_adapter *adapter)
	ps_page = &buffer_info->ps_pages[j];		ps_page = &buffer_info->ps_pages[j];
	if (!ps_page->page)		if (!ps_page->page)
	break;		break;
	pci_unmap_page(pdev, ps_page->dma, PAGE_SIZE,		dma_unmap_page(&pdev->dev, ps_page->dma, PAGE_SIZE,
	PCI_DMA_FROMDEVICE);		DMA_FROM_DEVICE);
	ps_page->dma = 0;		ps_page->dma = 0;
	put_page(ps_page->page);		put_page(ps_page->page);
	ps_page->page = NULL;		ps_page->page = NULL;
	@@ -3917,10 +3917,11 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
	buffer_info->length = size;		buffer_info->length = size;
	buffer_info->time_stamp = jiffies;		buffer_info->time_stamp = jiffies;
	buffer_info->next_to_watch = i;		buffer_info->next_to_watch = i;
	buffer_info->dma = pci_map_single(pdev, skb->data + offset,		buffer_info->dma = dma_map_single(&pdev->dev,
	size, PCI_DMA_TODEVICE);		skb->data + offset,
			size, DMA_TO_DEVICE);
	buffer_info->mapped_as_page = false;		buffer_info->mapped_as_page = false;
	if (pci_dma_mapping_error(pdev, buffer_info->dma))		if (dma_mapping_error(&pdev->dev, buffer_info->dma))
	goto dma_error;		goto dma_error;

	len -= size;		len -= size;
	@@ -3952,11 +3953,11 @@ static int e1000_tx_map(struct e1000_adapter *adapter,
	buffer_info->length = size;		buffer_info->length = size;
	buffer_info->time_stamp = jiffies;		buffer_info->time_stamp = jiffies;
	buffer_info->next_to_watch = i;		buffer_info->next_to_watch = i;
	buffer_info->dma = pci_map_page(pdev, frag->page,		buffer_info->dma = dma_map_page(&pdev->dev, frag->page,
	offset, size,		offset, size,
	PCI_DMA_TODEVICE);		DMA_TO_DEVICE);
	buffer_info->mapped_as_page = true;		buffer_info->mapped_as_page = true;
	if (pci_dma_mapping_error(pdev, buffer_info->dma))		if (dma_mapping_error(&pdev->dev, buffer_info->dma))
	goto dma_error;		goto dma_error;

	len -= size;		len -= size;
	@@ -5050,15 +5051,15 @@ static int __devinit e1000_probe(struct pci_dev *pdev,
	return err;		return err;

	pci_using_dac = 0;		pci_using_dac = 0;
	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));		err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
	if (!err) {		if (!err) {
	err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));		err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
	if (!err)		if (!err)
	pci_using_dac = 1;		pci_using_dac = 1;
	} else {		} else {
	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));		err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
	if (err) {		if (err) {
	err = pci_set_consistent_dma_mask(pdev,		err = dma_set_coherent_mask(&pdev->dev,
	DMA_BIT_MASK(32));		DMA_BIT_MASK(32));
	if (err) {		if (err) {
	dev_err(&pdev->dev, "No usable DMA "		dev_err(&pdev->dev, "No usable DMA "