Consistently use pdev as the variable of type struct pci_dev *.

	dma_addr_t dma_handle;

	cpu_addr = pci_alloc_consistent(dev, size, &dma_handle);

	cpu_addr = pci_alloc_consistent(pdev, size, &dma_handle);

where dev is a struct pci_dev *. You should pass NULL for PCI like buses

where pdev is a struct pci_dev *. You should pass NULL for PCI like buses

where devices don't have struct pci_dev (like ISA, EISA).  This may be

called in interrupt context. 

To unmap and free such a DMA region, you call:

	pci_free_consistent(dev, size, cpu_addr, dma_handle);

	pci_free_consistent(pdev, size, cpu_addr, dma_handle);

where dev, size are the same as in the above call and cpu_addr and

where pdev, size are the same as in the above call and cpu_addr and

dma_handle are the values pci_alloc_consistent returned to you.

This function may not be called in interrupt context.

	struct pci_pool *pool;

	pool = pci_pool_create(name, dev, size, align, alloc);

	pool = pci_pool_create(name, pdev, size, align, alloc);

The "name" is for diagnostics (like a kmem_cache name); dev and size

The "name" is for diagnostics (like a kmem_cache name); pdev and size

are as above.  The device's hardware alignment requirement for this

type of data is "align" (which is expressed in bytes, and must be a

power of two).  If your device has no boundary crossing restrictions,

	void *addr = buffer->ptr;

	size_t size = buffer->len;

	dma_handle = pci_map_single(dev, addr, size, direction);

	dma_handle = pci_map_single(pdev, addr, size, direction);

and to unmap it:

	pci_unmap_single(dev, dma_handle, size, direction);

	pci_unmap_single(pdev, dma_handle, size, direction);

You should call pci_unmap_single when the DMA activity is finished, e.g.

from the interrupt which told you that the DMA transfer is done.

	unsigned long offset = buffer->offset;

	size_t size = buffer->len;

	dma_handle = pci_map_page(dev, page, offset, size, direction);

	dma_handle = pci_map_page(pdev, page, offset, size, direction);

	...

	pci_unmap_page(dev, dma_handle, size, direction);

	pci_unmap_page(pdev, dma_handle, size, direction);

Here, "offset" means byte offset within the given page.

With scatterlists, you map a region gathered from several regions by:

	int i, count = pci_map_sg(dev, sglist, nents, direction);

	int i, count = pci_map_sg(pdev, sglist, nents, direction);

	struct scatterlist *sg;

	for_each_sg(sglist, sg, count, i) {

To unmap a scatterlist, just call:

	pci_unmap_sg(dev, sglist, nents, direction);

	pci_unmap_sg(pdev, sglist, nents, direction);

Again, make sure DMA activity has already finished.

So, firstly, just map it with pci_map_{single,sg}, and after each DMA

transfer call either:

	pci_dma_sync_single_for_cpu(dev, dma_handle, size, direction);

	pci_dma_sync_single_for_cpu(pdev, dma_handle, size, direction);

or:

	pci_dma_sync_sg_for_cpu(dev, sglist, nents, direction);

	pci_dma_sync_sg_for_cpu(pdev, sglist, nents, direction);

as appropriate.

finish accessing the data with the cpu, and then before actually

giving the buffer to the hardware call either:

	pci_dma_sync_single_for_device(dev, dma_handle, size, direction);

	pci_dma_sync_single_for_device(pdev, dma_handle, size, direction);

or:

	dma_addr_t dma_handle;

	dma_handle = pci_map_single(dev, addr, size, direction);

	dma_handle = pci_map_single(pdev, addr, size, direction);

	if (pci_dma_mapping_error(dma_handle)) {

		/*

		 * reduce current DMA mapping usage,