[mirror_ubuntu-artful-kernel.git] / drivers / base / dma-mapping.c

/*
 * drivers/base/dma-mapping.c - arch-independent dma-mapping routines
 *
 * Copyright (c) 2006  SUSE Linux Products GmbH
 * Copyright (c) 2006  Tejun Heo <teheo@suse.de>
 *
 * This file is released under the GPLv2.
 */

#include <linux/acpi.h>
#include <linux/dma-mapping.h>
#include <linux/export.h>
#include <linux/gfp.h>
#include <linux/of_device.h>
#include <linux/slab.h>
#include <linux/vmalloc.h>

/*
 * Managed DMA API
 */
struct dma_devres {
	size_t		size;
	void		*vaddr;
	dma_addr_t	dma_handle;
	unsigned long	attrs;
};

static void dmam_release(struct device *dev, void *res)
{
	struct dma_devres *this = res;

	dma_free_attrs(dev, this->size, this->vaddr, this->dma_handle,
			this->attrs);
}

static int dmam_match(struct device *dev, void *res, void *match_data)
{
	struct dma_devres *this = res, *match = match_data;

	if (this->vaddr == match->vaddr) {
		WARN_ON(this->size != match->size ||
			this->dma_handle != match->dma_handle);
		return 1;
	}
	return 0;
}

/**
 * dmam_alloc_coherent - Managed dma_alloc_coherent()
 * @dev: Device to allocate coherent memory for
 * @size: Size of allocation
 * @dma_handle: Out argument for allocated DMA handle
 * @gfp: Allocation flags
 *
 * Managed dma_alloc_coherent().  Memory allocated using this function
 * will be automatically released on driver detach.
 *
 * RETURNS:
 * Pointer to allocated memory on success, NULL on failure.
 */
void *dmam_alloc_coherent(struct device *dev, size_t size,
			   dma_addr_t *dma_handle, gfp_t gfp)
{
	struct dma_devres *dr;
	void *vaddr;

	dr = devres_alloc(dmam_release, sizeof(*dr), gfp);
	if (!dr)
		return NULL;

	vaddr = dma_alloc_coherent(dev, size, dma_handle, gfp);
	if (!vaddr) {
		devres_free(dr);
		return NULL;
	}

	dr->vaddr = vaddr;
	dr->dma_handle = *dma_handle;
	dr->size = size;

	devres_add(dev, dr);

	return vaddr;
}
EXPORT_SYMBOL(dmam_alloc_coherent);

/**
 * dmam_free_coherent - Managed dma_free_coherent()
 * @dev: Device to free coherent memory for
 * @size: Size of allocation
 * @vaddr: Virtual address of the memory to free
 * @dma_handle: DMA handle of the memory to free
 *
 * Managed dma_free_coherent().
 */
void dmam_free_coherent(struct device *dev, size_t size, void *vaddr,
			dma_addr_t dma_handle)
{
	struct dma_devres match_data = { size, vaddr, dma_handle };

	dma_free_coherent(dev, size, vaddr, dma_handle);
	WARN_ON(devres_destroy(dev, dmam_release, dmam_match, &match_data));
}
EXPORT_SYMBOL(dmam_free_coherent);

/**
 * dmam_alloc_attrs - Managed dma_alloc_attrs()
 * @dev: Device to allocate non_coherent memory for
 * @size: Size of allocation
 * @dma_handle: Out argument for allocated DMA handle
 * @gfp: Allocation flags
 * @attrs: Flags in the DMA_ATTR_* namespace.
 *
 * Managed dma_alloc_attrs().  Memory allocated using this function will be
 * automatically released on driver detach.
 *
 * RETURNS:
 * Pointer to allocated memory on success, NULL on failure.
 */
void *dmam_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
		gfp_t gfp, unsigned long attrs)
{
	struct dma_devres *dr;
	void *vaddr;

	dr = devres_alloc(dmam_release, sizeof(*dr), gfp);
	if (!dr)
		return NULL;

	vaddr = dma_alloc_attrs(dev, size, dma_handle, gfp, attrs);
	if (!vaddr) {
		devres_free(dr);
		return NULL;
	}

	dr->vaddr = vaddr;
	dr->dma_handle = *dma_handle;
	dr->size = size;
	dr->attrs = attrs;

	devres_add(dev, dr);

	return vaddr;
}
EXPORT_SYMBOL(dmam_alloc_attrs);

#ifdef CONFIG_HAVE_GENERIC_DMA_COHERENT

static void dmam_coherent_decl_release(struct device *dev, void *res)
{
	dma_release_declared_memory(dev);
}

/**
 * dmam_declare_coherent_memory - Managed dma_declare_coherent_memory()
 * @dev: Device to declare coherent memory for
 * @phys_addr: Physical address of coherent memory to be declared
 * @device_addr: Device address of coherent memory to be declared
 * @size: Size of coherent memory to be declared
 * @flags: Flags
 *
 * Managed dma_declare_coherent_memory().
 *
 * RETURNS:
 * 0 on success, -errno on failure.
 */
int dmam_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr,
				 dma_addr_t device_addr, size_t size, int flags)
{
	void *res;
	int rc;

	res = devres_alloc(dmam_coherent_decl_release, 0, GFP_KERNEL);
	if (!res)
		return -ENOMEM;

	rc = dma_declare_coherent_memory(dev, phys_addr, device_addr, size,
					 flags);
	if (rc) {
		devres_add(dev, res);
		rc = 0;
	} else {
		devres_free(res);
		rc = -ENOMEM;
	}

	return rc;
}
EXPORT_SYMBOL(dmam_declare_coherent_memory);

/**
 * dmam_release_declared_memory - Managed dma_release_declared_memory().
 * @dev: Device to release declared coherent memory for
 *
 * Managed dmam_release_declared_memory().
 */
void dmam_release_declared_memory(struct device *dev)
{
	WARN_ON(devres_destroy(dev, dmam_coherent_decl_release, NULL, NULL));
}
EXPORT_SYMBOL(dmam_release_declared_memory);

#endif

/*
 * Create scatter-list for the already allocated DMA buffer.
 */
int dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
		 void *cpu_addr, dma_addr_t handle, size_t size)
{
	struct page *page = virt_to_page(cpu_addr);
	int ret;

	ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
	if (unlikely(ret))
		return ret;

	sg_set_page(sgt->sgl, page, PAGE_ALIGN(size), 0);
	return 0;
}
EXPORT_SYMBOL(dma_common_get_sgtable);

/*
 * Create userspace mapping for the DMA-coherent memory.
 */
int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
		    void *cpu_addr, dma_addr_t dma_addr, size_t size)
{
	int ret = -ENXIO;
#ifndef CONFIG_ARCH_NO_COHERENT_DMA_MMAP
	unsigned long user_count = vma_pages(vma);
	unsigned long count = PAGE_ALIGN(size) >> PAGE_SHIFT;
	unsigned long pfn = page_to_pfn(virt_to_page(cpu_addr));
	unsigned long off = vma->vm_pgoff;

	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

	if (dma_mmap_from_dev_coherent(dev, vma, cpu_addr, size, &ret))
		return ret;

	if (off < count && user_count <= (count - off)) {
		ret = remap_pfn_range(vma, vma->vm_start,
				      pfn + off,
				      user_count << PAGE_SHIFT,
				      vma->vm_page_prot);
	}
#endif	/* !CONFIG_ARCH_NO_COHERENT_DMA_MMAP */

	return ret;
}
EXPORT_SYMBOL(dma_common_mmap);

#ifdef CONFIG_MMU
static struct vm_struct *__dma_common_pages_remap(struct page **pages,
			size_t size, unsigned long vm_flags, pgprot_t prot,
			const void *caller)
{
	struct vm_struct *area;

	area = get_vm_area_caller(size, vm_flags, caller);
	if (!area)
		return NULL;

	if (map_vm_area(area, prot, pages)) {
		vunmap(area->addr);
		return NULL;
	}

	return area;
}

/*
 * remaps an array of PAGE_SIZE pages into another vm_area
 * Cannot be used in non-sleeping contexts
 */
void *dma_common_pages_remap(struct page **pages, size_t size,
			unsigned long vm_flags, pgprot_t prot,
			const void *caller)
{
	struct vm_struct *area;

	area = __dma_common_pages_remap(pages, size, vm_flags, prot, caller);
	if (!area)
		return NULL;

	area->pages = pages;

	return area->addr;
}

/*
 * remaps an allocated contiguous region into another vm_area.
 * Cannot be used in non-sleeping contexts
 */

void *dma_common_contiguous_remap(struct page *page, size_t size,
			unsigned long vm_flags,
			pgprot_t prot, const void *caller)
{
	int i;
	struct page **pages;
	struct vm_struct *area;

	pages = kmalloc(sizeof(struct page *) << get_order(size), GFP_KERNEL);
	if (!pages)
		return NULL;

	for (i = 0; i < (size >> PAGE_SHIFT); i++)
		pages[i] = nth_page(page, i);

	area = __dma_common_pages_remap(pages, size, vm_flags, prot, caller);

	kfree(pages);

	if (!area)
		return NULL;
	return area->addr;
}

/*
 * unmaps a range previously mapped by dma_common_*_remap
 */
void dma_common_free_remap(void *cpu_addr, size_t size, unsigned long vm_flags)
{
	struct vm_struct *area = find_vm_area(cpu_addr);

	if (!area || (area->flags & vm_flags) != vm_flags) {
		WARN(1, "trying to free invalid coherent area: %p\n", cpu_addr);
		return;
	}

	unmap_kernel_range((unsigned long)cpu_addr, PAGE_ALIGN(size));
	vunmap(cpu_addr);
}
#endif

/*
 * Common configuration to enable DMA API use for a device
 */
#include <linux/pci.h>

int dma_configure(struct device *dev)
{
	struct device *bridge = NULL, *dma_dev = dev;
	enum dev_dma_attr attr;
	int ret = 0;

	if (dev_is_pci(dev)) {
		bridge = pci_get_host_bridge_device(to_pci_dev(dev));
		dma_dev = bridge;
		if (IS_ENABLED(CONFIG_OF) && dma_dev->parent &&
		    dma_dev->parent->of_node)
			dma_dev = dma_dev->parent;
	}

	if (dma_dev->of_node) {
		ret = of_dma_configure(dev, dma_dev->of_node);
	} else if (has_acpi_companion(dma_dev)) {
		attr = acpi_get_dma_attr(to_acpi_device_node(dma_dev->fwnode));
		if (attr != DEV_DMA_NOT_SUPPORTED)
			ret = acpi_dma_configure(dev, attr);
	}

	if (bridge)
		pci_put_host_bridge_device(bridge);

	return ret;
}

void dma_deconfigure(struct device *dev)
{
	of_dma_deconfigure(dev);
	acpi_dma_deconfigure(dev);
}
Commit	Line	Data
9ac7849e TH	1	/*
	2	* drivers/base/dma-mapping.c - arch-independent dma-mapping routines
	3	*
	4	* Copyright (c) 2006 SUSE Linux Products GmbH
	5	* Copyright (c) 2006 Tejun Heo <teheo@suse.de>
	6	*
	7	* This file is released under the GPLv2.
	8	*/
	9
09515ef5	10	#include <linux/acpi.h>
9ac7849e	11	#include <linux/dma-mapping.h>
1b6bc32f	12	#include <linux/export.h>
5a0e3ad6	13	#include <linux/gfp.h>
09515ef5	14	#include <linux/of_device.h>
513510dd LA	15	#include <linux/slab.h>
513510dd LA	16	#include <linux/vmalloc.h>
9ac7849e TH	17
	18	/*
	19	* Managed DMA API
	20	*/
	21	struct dma_devres {
	22	size_t size;
	23	void *vaddr;
	24	dma_addr_t dma_handle;
63d36c95	25	unsigned long attrs;
9ac7849e TH	26	};
9ac7849e TH	27
63d36c95	28	static void dmam_release(struct device dev, void res)
9ac7849e TH	29	{
	30	struct dma_devres *this = res;
	31
63d36c95 CH	32	dma_free_attrs(dev, this->size, this->vaddr, this->dma_handle,
63d36c95 CH	33	this->attrs);
9ac7849e TH	34	}
	35
	36	static int dmam_match(struct device dev, void res, void *match_data)
	37	{
	38	struct dma_devres this = res, match = match_data;
	39
	40	if (this->vaddr == match->vaddr) {
	41	WARN_ON(this->size != match->size \|\|
	42	this->dma_handle != match->dma_handle);
	43	return 1;
	44	}
	45	return 0;
	46	}
	47
	48	/**
	49	* dmam_alloc_coherent - Managed dma_alloc_coherent()
	50	* @dev: Device to allocate coherent memory for
	51	* @size: Size of allocation
	52	* @dma_handle: Out argument for allocated DMA handle
	53	* @gfp: Allocation flags
	54	*
	55	* Managed dma_alloc_coherent(). Memory allocated using this function
	56	* will be automatically released on driver detach.
	57	*
	58	* RETURNS:
	59	* Pointer to allocated memory on success, NULL on failure.
	60	*/
6d42d79e	61	void dmam_alloc_coherent(struct device dev, size_t size,
9ac7849e TH	62	dma_addr_t *dma_handle, gfp_t gfp)
	63	{
	64	struct dma_devres *dr;
	65	void *vaddr;
	66
63d36c95	67	dr = devres_alloc(dmam_release, sizeof(*dr), gfp);
9ac7849e TH	68	if (!dr)
	69	return NULL;
	70
	71	vaddr = dma_alloc_coherent(dev, size, dma_handle, gfp);
	72	if (!vaddr) {
	73	devres_free(dr);
	74	return NULL;
	75	}
	76
	77	dr->vaddr = vaddr;
	78	dr->dma_handle = *dma_handle;
	79	dr->size = size;
	80
	81	devres_add(dev, dr);
	82
	83	return vaddr;
	84	}
	85	EXPORT_SYMBOL(dmam_alloc_coherent);
	86
	87	/**
	88	* dmam_free_coherent - Managed dma_free_coherent()
	89	* @dev: Device to free coherent memory for
	90	* @size: Size of allocation
	91	* @vaddr: Virtual address of the memory to free
	92	* @dma_handle: DMA handle of the memory to free
	93	*
	94	* Managed dma_free_coherent().
	95	*/
	96	void dmam_free_coherent(struct device dev, size_t size, void vaddr,
	97	dma_addr_t dma_handle)
	98	{
	99	struct dma_devres match_data = { size, vaddr, dma_handle };
	100
	101	dma_free_coherent(dev, size, vaddr, dma_handle);
63d36c95	102	WARN_ON(devres_destroy(dev, dmam_release, dmam_match, &match_data));
9ac7849e TH	103	}
	104	EXPORT_SYMBOL(dmam_free_coherent);
	105
	106	/**
63d36c95	107	* dmam_alloc_attrs - Managed dma_alloc_attrs()
9ac7849e TH	108	* @dev: Device to allocate non_coherent memory for
	109	* @size: Size of allocation
	110	* @dma_handle: Out argument for allocated DMA handle
	111	* @gfp: Allocation flags
63d36c95	112	* @attrs: Flags in the DMA_ATTR_* namespace.
9ac7849e	113	*
63d36c95 CH	114	* Managed dma_alloc_attrs(). Memory allocated using this function will be
63d36c95 CH	115	* automatically released on driver detach.
9ac7849e TH	116	*
	117	* RETURNS:
	118	* Pointer to allocated memory on success, NULL on failure.
	119	*/
63d36c95 CH	120	void dmam_alloc_attrs(struct device dev, size_t size, dma_addr_t *dma_handle,
63d36c95 CH	121	gfp_t gfp, unsigned long attrs)
9ac7849e TH	122	{
	123	struct dma_devres *dr;
	124	void *vaddr;
	125
63d36c95	126	dr = devres_alloc(dmam_release, sizeof(*dr), gfp);
9ac7849e TH	127	if (!dr)
	128	return NULL;
	129
63d36c95	130	vaddr = dma_alloc_attrs(dev, size, dma_handle, gfp, attrs);
9ac7849e TH	131	if (!vaddr) {
	132	devres_free(dr);
	133	return NULL;
	134	}
	135
	136	dr->vaddr = vaddr;
	137	dr->dma_handle = *dma_handle;
	138	dr->size = size;
63d36c95	139	dr->attrs = attrs;
9ac7849e TH	140
	141	devres_add(dev, dr);
	142
	143	return vaddr;
	144	}
63d36c95	145	EXPORT_SYMBOL(dmam_alloc_attrs);
9ac7849e	146
20d666e4	147	#ifdef CONFIG_HAVE_GENERIC_DMA_COHERENT
9ac7849e TH	148
	149	static void dmam_coherent_decl_release(struct device dev, void res)
	150	{
	151	dma_release_declared_memory(dev);
	152	}
	153
	154	/**
	155	* dmam_declare_coherent_memory - Managed dma_declare_coherent_memory()
	156	* @dev: Device to declare coherent memory for
88a984ba	157	* @phys_addr: Physical address of coherent memory to be declared
9ac7849e TH	158	* @device_addr: Device address of coherent memory to be declared
	159	* @size: Size of coherent memory to be declared
	160	* @flags: Flags
	161	*
	162	* Managed dma_declare_coherent_memory().
	163	*
	164	* RETURNS:
	165	* 0 on success, -errno on failure.
	166	*/
88a984ba	167	int dmam_declare_coherent_memory(struct device *dev, phys_addr_t phys_addr,
9ac7849e TH	168	dma_addr_t device_addr, size_t size, int flags)
	169	{
	170	void *res;
	171	int rc;
	172
	173	res = devres_alloc(dmam_coherent_decl_release, 0, GFP_KERNEL);
	174	if (!res)
	175	return -ENOMEM;
	176
88a984ba	177	rc = dma_declare_coherent_memory(dev, phys_addr, device_addr, size,
9ac7849e	178	flags);
775115c0	179	if (rc) {
9ac7849e	180	devres_add(dev, res);
775115c0 VY	181	rc = 0;
775115c0 VY	182	} else {
9ac7849e	183	devres_free(res);
775115c0 VY	184	rc = -ENOMEM;
775115c0 VY	185	}
9ac7849e TH	186
	187	return rc;
	188	}
	189	EXPORT_SYMBOL(dmam_declare_coherent_memory);
	190
	191	/**
	192	* dmam_release_declared_memory - Managed dma_release_declared_memory().
	193	* @dev: Device to release declared coherent memory for
	194	*
	195	* Managed dmam_release_declared_memory().
	196	*/
	197	void dmam_release_declared_memory(struct device *dev)
	198	{
	199	WARN_ON(devres_destroy(dev, dmam_coherent_decl_release, NULL, NULL));
	200	}
	201	EXPORT_SYMBOL(dmam_release_declared_memory);
	202
c6c22955 MS	203	#endif
c6c22955 MS	204
d2b7428e MS	205	/*
	206	* Create scatter-list for the already allocated DMA buffer.
	207	*/
	208	int dma_common_get_sgtable(struct device dev, struct sg_table sgt,
	209	void *cpu_addr, dma_addr_t handle, size_t size)
	210	{
	211	struct page *page = virt_to_page(cpu_addr);
	212	int ret;
	213
	214	ret = sg_alloc_table(sgt, 1, GFP_KERNEL);
	215	if (unlikely(ret))
	216	return ret;
	217
	218	sg_set_page(sgt->sgl, page, PAGE_ALIGN(size), 0);
	219	return 0;
	220	}
	221	EXPORT_SYMBOL(dma_common_get_sgtable);
	222
64ccc9c0 MS	223	/*
	224	* Create userspace mapping for the DMA-coherent memory.
	225	*/
	226	int dma_common_mmap(struct device dev, struct vm_area_struct vma,
	227	void *cpu_addr, dma_addr_t dma_addr, size_t size)
	228	{
	229	int ret = -ENXIO;
07c75d7a	230	#ifndef CONFIG_ARCH_NO_COHERENT_DMA_MMAP
95da00e3	231	unsigned long user_count = vma_pages(vma);
64ccc9c0 MS	232	unsigned long count = PAGE_ALIGN(size) >> PAGE_SHIFT;
	233	unsigned long pfn = page_to_pfn(virt_to_page(cpu_addr));
	234	unsigned long off = vma->vm_pgoff;
	235
	236	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
	237
43fc509c	238	if (dma_mmap_from_dev_coherent(dev, vma, cpu_addr, size, &ret))
64ccc9c0 MS	239	return ret;
	240
	241	if (off < count && user_count <= (count - off)) {
	242	ret = remap_pfn_range(vma, vma->vm_start,
	243	pfn + off,
	244	user_count << PAGE_SHIFT,
	245	vma->vm_page_prot);
	246	}
07c75d7a	247	#endif /* !CONFIG_ARCH_NO_COHERENT_DMA_MMAP */
64ccc9c0 MS	248
	249	return ret;
	250	}
	251	EXPORT_SYMBOL(dma_common_mmap);
513510dd LA	252
513510dd LA	253	#ifdef CONFIG_MMU
1a3389ff CM	254	static struct vm_struct __dma_common_pages_remap(struct page *pages,
	255	size_t size, unsigned long vm_flags, pgprot_t prot,
	256	const void *caller)
	257	{
	258	struct vm_struct *area;
	259
	260	area = get_vm_area_caller(size, vm_flags, caller);
	261	if (!area)
	262	return NULL;
	263
	264	if (map_vm_area(area, prot, pages)) {
	265	vunmap(area->addr);
	266	return NULL;
	267	}
	268
	269	return area;
	270	}
	271
513510dd LA	272	/*
	273	* remaps an array of PAGE_SIZE pages into another vm_area
	274	* Cannot be used in non-sleeping contexts
	275	*/
	276	void dma_common_pages_remap(struct page *pages, size_t size,
	277	unsigned long vm_flags, pgprot_t prot,
	278	const void *caller)
	279	{
	280	struct vm_struct *area;
	281
1a3389ff	282	area = __dma_common_pages_remap(pages, size, vm_flags, prot, caller);
513510dd LA	283	if (!area)
	284	return NULL;
	285
	286	area->pages = pages;
	287
513510dd LA	288	return area->addr;
	289	}
	290
	291	/*
	292	* remaps an allocated contiguous region into another vm_area.
	293	* Cannot be used in non-sleeping contexts
	294	*/
	295
	296	void dma_common_contiguous_remap(struct page page, size_t size,
	297	unsigned long vm_flags,
	298	pgprot_t prot, const void *caller)
	299	{
	300	int i;
	301	struct page **pages;
1a3389ff	302	struct vm_struct *area;
513510dd LA	303
	304	pages = kmalloc(sizeof(struct page *) << get_order(size), GFP_KERNEL);
	305	if (!pages)
	306	return NULL;
	307
0dd89119 GT	308	for (i = 0; i < (size >> PAGE_SHIFT); i++)
0dd89119 GT	309	pages[i] = nth_page(page, i);
513510dd	310
1a3389ff	311	area = __dma_common_pages_remap(pages, size, vm_flags, prot, caller);
513510dd LA	312
	313	kfree(pages);
	314
1a3389ff CM	315	if (!area)
	316	return NULL;
	317	return area->addr;
513510dd LA	318	}
	319
	320	/*
	321	* unmaps a range previously mapped by dma_common_*_remap
	322	*/
	323	void dma_common_free_remap(void *cpu_addr, size_t size, unsigned long vm_flags)
	324	{
	325	struct vm_struct *area = find_vm_area(cpu_addr);
	326
	327	if (!area \|\| (area->flags & vm_flags) != vm_flags) {
	328	WARN(1, "trying to free invalid coherent area: %p\n", cpu_addr);
	329	return;
	330	}
	331
85714108	332	unmap_kernel_range((unsigned long)cpu_addr, PAGE_ALIGN(size));
513510dd LA	333	vunmap(cpu_addr);
	334	}
	335	#endif
09515ef5 S	336
	337	/*
	338	* Common configuration to enable DMA API use for a device
	339	*/
	340	#include <linux/pci.h>
	341
	342	int dma_configure(struct device *dev)
	343	{
	344	struct device bridge = NULL, dma_dev = dev;
	345	enum dev_dma_attr attr;
7b07cbef	346	int ret = 0;
09515ef5 S	347
	348	if (dev_is_pci(dev)) {
	349	bridge = pci_get_host_bridge_device(to_pci_dev(dev));
	350	dma_dev = bridge;
	351	if (IS_ENABLED(CONFIG_OF) && dma_dev->parent &&
	352	dma_dev->parent->of_node)
	353	dma_dev = dma_dev->parent;
	354	}
	355
	356	if (dma_dev->of_node) {
7b07cbef	357	ret = of_dma_configure(dev, dma_dev->of_node);
09515ef5 S	358	} else if (has_acpi_companion(dma_dev)) {
	359	attr = acpi_get_dma_attr(to_acpi_device_node(dma_dev->fwnode));
	360	if (attr != DEV_DMA_NOT_SUPPORTED)
5a1bb638	361	ret = acpi_dma_configure(dev, attr);
09515ef5 S	362	}
	363
	364	if (bridge)
	365	pci_put_host_bridge_device(bridge);
	366
7b07cbef	367	return ret;
09515ef5 S	368	}
	369
	370	void dma_deconfigure(struct device *dev)
	371	{
	372	of_dma_deconfigure(dev);
	373	acpi_dma_deconfigure(dev);
	374	}