brain-hackers_pepepper-mirror/u-boot-brain
1
0
Fork 0
mirror of https://github.com/brain-hackers/u-boot-brain synced 2024-06-09 23:36:03 +09:00
Code Issues Projects Releases Wiki Activity

dma-mapping: move dma_map_(un)single() to <linux/dma-mapping.h>

Browse Source 
The implementation of dma_map_single() and dma_unmap_single() is
exactly the same for all the architectures that support them.

Factor them out to <linux/dma-mapping.h>, and make all drivers to
include <linux/dma-mapping.h> instead of <asm/dma-mapping.h>.

If we need to differentiate them for some architectures, we can
move the generic definitions to <asm-generic/dma-mapping.h>.

Add some comments to the helpers. The concept is quite similar to
the DMA-API of Linux kernel. Drivers are agnostic about what is
going on behind the scene. Just call dma_map_single() before the
DMA, and dma_unmap_single() after it.

Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
This commit is contained in:
Masahiro Yamada 2020-02-14 16:40:19 +09:00 committed by Peng Fan
parent 950c596867
commit 9d86b89c59
17 changed files with 75 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
arch/arm/include/asm/dma-mapping.h
View File

@ -14,8 +14,6 @@
#include <linux/types.h>
#include <malloc.h>
#define dma_mapping_error(x, y) 0
static inline void *dma_alloc_coherent(size_t len, unsigned long *handle)
{
*handle = (unsigned long)memalign(ARCH_DMA_MINALIGN, ROUND(len, ARCH_DMA_MINALIGN));
@ -27,28 +25,4 @@ static inline void dma_free_coherent(void *addr)
free(addr);
}
static inline dma_addr_t dma_map_single(void *vaddr, size_t len,
enum dma_data_direction dir)
{
unsigned long addr = (unsigned long)vaddr;
len = ALIGN(len, ARCH_DMA_MINALIGN);
if (dir == DMA_FROM_DEVICE)
invalidate_dcache_range(addr, addr + len);
else
flush_dcache_range(addr, addr + len);
return addr;
}
static inline void dma_unmap_single(dma_addr_t addr, size_t len,
enum dma_data_direction dir)
{
len = ALIGN(len, ARCH_DMA_MINALIGN);
if (dir != DMA_TO_DEVICE)
invalidate_dcache_range(addr, addr + len);
}
#endif /* __ASM_ARM_DMA_MAPPING_H */

24
arch/nds32/include/asm/dma-mapping.h
View File

@ -19,28 +19,4 @@ static void *dma_alloc_coherent(size_t len, unsigned long *handle)
return (void *)*handle;
}
static inline dma_addr_t dma_map_single(void *vaddr, size_t len,
enum dma_data_direction dir)
{
unsigned long addr = (unsigned long)vaddr;
len = ALIGN(len, ARCH_DMA_MINALIGN);
if (dir == DMA_FROM_DEVICE)
invalidate_dcache_range(addr, addr + len);
else
flush_dcache_range(addr, addr + len);
return addr;
}
static inline void dma_unmap_single(dma_addr_t addr, size_t len,
enum dma_data_direction dir)
{
len = ALIGN(len, ARCH_DMA_MINALIGN);
if (dir != DMA_TO_DEVICE)
invalidate_dcache_range(addr, addr + len);
}
#endif /* __ASM_NDS_DMA_MAPPING_H */

26
arch/riscv/include/asm/dma-mapping.h
View File

@ -16,8 +16,6 @@
#include <linux/dma-direction.h>
#include <malloc.h>
#define dma_mapping_error(x, y) 0
static inline void *dma_alloc_coherent(size_t len, unsigned long *handle)
{
*handle = (unsigned long)memalign(ARCH_DMA_MINALIGN, len);
@ -29,28 +27,4 @@ static inline void dma_free_coherent(void *addr)
free(addr);
}
static inline dma_addr_t dma_map_single(void *vaddr, size_t len,
enum dma_data_direction dir)
{
unsigned long addr = (unsigned long)vaddr;
len = ALIGN(len, ARCH_DMA_MINALIGN);
if (dir == DMA_FROM_DEVICE)
invalidate_dcache_range(addr, addr + len);
else
flush_dcache_range(addr, addr + len);
return addr;
}
static inline void dma_unmap_single(dma_addr_t addr, size_t len,
enum dma_data_direction dir)
{
len = ALIGN(len, ARCH_DMA_MINALIGN);
if (dir != DMA_TO_DEVICE)
invalidate_dcache_range(addr, addr + len);
}
#endif /* __ASM_RISCV_DMA_MAPPING_H */

26
arch/x86/include/asm/dma-mapping.h
View File

@ -14,8 +14,6 @@
#include <linux/types.h>
#include <malloc.h>
#define dma_mapping_error(x, y) 0
static inline void *dma_alloc_coherent(size_t len, unsigned long *handle)
{
*handle = (unsigned long)memalign(ARCH_DMA_MINALIGN, len);
@ -27,28 +25,4 @@ static inline void dma_free_coherent(void *addr)
free(addr);
}
static inline dma_addr_t dma_map_single(void *vaddr, size_t len,
enum dma_data_direction dir)
{
unsigned long addr = (unsigned long)vaddr;
len = ALIGN(len, ARCH_DMA_MINALIGN);
if (dir == DMA_FROM_DEVICE)
invalidate_dcache_range(addr, addr + len);
else
flush_dcache_range(addr, addr + len);
return addr;
}
static inline void dma_unmap_single(dma_addr_t addr, size_t len,
enum dma_data_direction dir)
{
len = ALIGN(len, ARCH_DMA_MINALIGN);
if (dir != DMA_TO_DEVICE)
invalidate_dcache_range(addr, addr + len);
}
#endif /* __ASM_X86_DMA_MAPPING_H */

2
drivers/dma/ti/k3-udma.c
View File

@ -10,7 +10,7 @@
#include <asm/io.h>
#include <asm/bitops.h>
#include <malloc.h>
#include <asm/dma-mapping.h>
#include <linux/dma-mapping.h>
#include <dm.h>
#include <dm/device_compat.h>
#include <dm/devres.h>

3
drivers/mmc/tmio-common.c
View File

@ -4,7 +4,6 @@
* Author: Masahiro Yamada <yamada.masahiro@socionext.com>
*/
#include <asm/dma-mapping.h>
#include <common.h>
#include <clk.h>
#include <cpu_func.h>
@ -14,7 +13,7 @@
#include <dm/device_compat.h>
#include <dm/pinctrl.h>
#include <linux/compat.h>
#include <linux/dma-direction.h>
#include <linux/dma-mapping.h>
#include <linux/io.h>
#include <linux/sizes.h>
#include <power/regulator.h>

3
drivers/mtd/nand/raw/denali.c
View File

@ -5,14 +5,13 @@
* Copyright (C) 2009-2010, Intel Corporation and its suppliers.
*/
#include <asm/dma-mapping.h>
#include <dm.h>
#include <malloc.h>
#include <nand.h>
#include <dm/device_compat.h>
#include <dm/devres.h>
#include <linux/bitfield.h>
#include <linux/dma-direction.h>
#include <linux/dma-mapping.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/io.h>

2
drivers/net/altera_tse.c
View File

@ -17,7 +17,7 @@
#include <miiphy.h>
#include <net.h>
#include <asm/cache.h>
#include <asm/dma-mapping.h>
#include <linux/dma-mapping.h>
#include <asm/io.h>
#include "altera_tse.h"

2
drivers/net/ftmac110.c
View File

@ -12,7 +12,7 @@
#include <net.h>
#include <linux/errno.h>
#include <asm/io.h>
#include <asm/dma-mapping.h>
#include <linux/dma-mapping.h>
#if defined(CONFIG_MII) || defined(CONFIG_CMD_MII)
#include <miiphy.h>

2
drivers/net/macb.c
View File

@ -38,7 +38,7 @@
#include <linux/mii.h>
#include <asm/io.h>
#include <asm/dma-mapping.h>
#include <linux/dma-mapping.h>
#include <asm/arch/clk.h>
#include <linux/errno.h>

2
drivers/soc/ti/k3-navss-ringacc.c
View File

@ -9,7 +9,6 @@
#include <cpu_func.h>
#include <asm/io.h>
#include <malloc.h>
#include <asm/dma-mapping.h>
#include <asm/bitops.h>
#include <dm.h>
#include <dm/device_compat.h>
@ -17,6 +16,7 @@
#include <dm/read.h>
#include <dm/uclass.h>
#include <linux/compat.h>
#include <linux/dma-mapping.h>
#include <linux/err.h>
#include <linux/soc/ti/k3-navss-ringacc.h>
#include <linux/soc/ti/ti_sci_protocol.h>

2
drivers/ufs/ufs.c
View File

@ -19,7 +19,7 @@
#include <hexdump.h>
#include <scsi.h>
#include <asm/dma-mapping.h>
#include <linux/dma-mapping.h>
#include "ufs.h"

2
drivers/usb/cdns3/gadget.c
View File

@ -63,7 +63,7 @@
#include <linux/usb/gadget.h>
#include <linux/compat.h>
#include <linux/iopoll.h>
#include <asm/dma-mapping.h>
#include <linux/dma-mapping.h>
#include <linux/bitmap.h>
#include <linux/bug.h>

2
drivers/usb/dwc3/core.c
View File

@ -17,9 +17,9 @@
#include <cpu_func.h>
#include <malloc.h>
#include <dwc3-uboot.h>
#include <asm/dma-mapping.h>
#include <dm/device_compat.h>
#include <dm/devres.h>
#include <linux/dma-mapping.h>
#include <linux/err.h>
#include <linux/ioport.h>
#include <dm.h>

2
drivers/usb/dwc3/gadget.c
View File

@ -16,10 +16,10 @@
#include <common.h>
#include <cpu_func.h>
#include <malloc.h>
#include <asm/dma-mapping.h>
#include <dm/device_compat.h>
#include <dm/devres.h>
#include <linux/bug.h>
#include <linux/dma-mapping.h>
#include <linux/list.h>
#include <linux/usb/ch9.h>

2
drivers/usb/gadget/udc/udc-core.c
View File

@ -18,7 +18,7 @@
#include <linux/compat.h>
#include <malloc.h>
#include <asm/cache.h>
#include <asm/dma-mapping.h>
#include <linux/dma-mapping.h>
#include <common.h>
#include <dm.h>
#include <dm/device-internal.h>

63
include/linux/dma-mapping.h Normal file
View File

@ -0,0 +1,63 @@
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_DMA_MAPPING_H
#define _LINUX_DMA_MAPPING_H
#include <linux/dma-direction.h>
#include <linux/types.h>
#include <asm/dma-mapping.h>
#include <cpu_func.h>
#define dma_mapping_error(x, y) 0
/**
* Map a buffer to make it available to the DMA device
*
* Linux-like DMA API that is intended to be used from drivers. This hides the
* underlying cache operation from drivers. Call this before starting the DMA
* transfer. In most of architectures in U-Boot, the virtual address matches to
* the physical address (but we have exceptions like sandbox). U-Boot does not
* support iommu at the driver level, so it also matches to the DMA address.
* Hence, this helper currently just performs the cache operation, then returns
* straight-mapped dma_address, which is intended to be set to the register of
* the DMA device.
*
* @vaddr: address of the buffer
* @len: length of the buffer
* @dir: the direction of DMA
*/
static inline dma_addr_t dma_map_single(void *vaddr, size_t len,
enum dma_data_direction dir)
{
unsigned long addr = (unsigned long)vaddr;
len = ALIGN(len, ARCH_DMA_MINALIGN);
if (dir == DMA_FROM_DEVICE)
invalidate_dcache_range(addr, addr + len);
else
flush_dcache_range(addr, addr + len);
return addr;
}
/**
* Unmap a buffer to make it available to CPU
*
* Linux-like DMA API that is intended to be used from drivers. This hides the
* underlying cache operation from drivers. Call this after finishin the DMA
* transfer.
*
* @addr: DMA address
* @len: length of the buffer
* @dir: the direction of DMA
*/
static inline void dma_unmap_single(dma_addr_t addr, size_t len,
enum dma_data_direction dir)
{
len = ALIGN(len, ARCH_DMA_MINALIGN);
if (dir != DMA_TO_DEVICE)
invalidate_dcache_range(addr, addr + len);
}
#endif