1/*
  2 * OpenRISC Linux
  3 *
  4 * Linux architectural port borrowing liberally from similar works of
  5 * others.  All original copyrights apply as per the original source
  6 * declaration.
  7 *
  8 * OpenRISC implementation:
  9 * Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se>
 10 *
 11 * This program is free software; you can redistribute it and/or modify
 12 * it under the terms of the GNU General Public License as published by
 13 * the Free Software Foundation; either version 2 of the License, or
 14 * (at your option) any later version.
 15 */
 16
 17#ifndef __ASM_OPENRISC_DMA_MAPPING_H
 18#define __ASM_OPENRISC_DMA_MAPPING_H
 19
 20/*
 21 * See Documentation/PCI/PCI-DMA-mapping.txt and
 22 * Documentation/DMA-API.txt for documentation.
 23 *
 24 * This file is written with the intention of eventually moving over
 25 * to largely using asm-generic/dma-mapping-common.h in its place.
 26 */
 27
 28#include <linux/dma-debug.h>
 29#include <asm-generic/dma-coherent.h>
 30#include <linux/kmemcheck.h>
 31
 32#define DMA_ERROR_CODE		(~(dma_addr_t)0x0)
 33
 34
 35#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
 36#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
 37
 38void *or1k_dma_alloc_coherent(struct device *dev, size_t size,
 39			      dma_addr_t *dma_handle, gfp_t flag);
 40void or1k_dma_free_coherent(struct device *dev, size_t size, void *vaddr,
 41			    dma_addr_t dma_handle);
 42dma_addr_t or1k_map_page(struct device *dev, struct page *page,
 43			 unsigned long offset, size_t size,
 44			 enum dma_data_direction dir,
 45			 struct dma_attrs *attrs);
 46void or1k_unmap_page(struct device *dev, dma_addr_t dma_handle,
 47		     size_t size, enum dma_data_direction dir,
 48		     struct dma_attrs *attrs);
 49int or1k_map_sg(struct device *dev, struct scatterlist *sg,
 50		int nents, enum dma_data_direction dir,
 51		struct dma_attrs *attrs);
 52void or1k_unmap_sg(struct device *dev, struct scatterlist *sg,
 53		   int nents, enum dma_data_direction dir,
 54		   struct dma_attrs *attrs);
 55void or1k_sync_single_for_cpu(struct device *dev,
 56			      dma_addr_t dma_handle, size_t size,
 57			      enum dma_data_direction dir);
 58void or1k_sync_single_for_device(struct device *dev,
 59			         dma_addr_t dma_handle, size_t size,
 60			         enum dma_data_direction dir);
 61
 62static inline void *dma_alloc_coherent(struct device *dev, size_t size,
 63					dma_addr_t *dma_handle, gfp_t flag)
 64{
 65	void *memory;
 66
 67	memory = or1k_dma_alloc_coherent(dev, size, dma_handle, flag);
 68
 69	debug_dma_alloc_coherent(dev, size, *dma_handle, memory);
 70	return memory;
 71}
 72
 73static inline void dma_free_coherent(struct device *dev, size_t size,
 74				     void *cpu_addr, dma_addr_t dma_handle)
 75{
 76	debug_dma_free_coherent(dev, size, cpu_addr, dma_handle);
 77	or1k_dma_free_coherent(dev, size, cpu_addr, dma_handle);
 78}
 79
 80static inline dma_addr_t dma_map_single(struct device *dev, void *ptr,
 81					size_t size,
 82					enum dma_data_direction dir)
 83{
 84	dma_addr_t addr;
 85
 86	kmemcheck_mark_initialized(ptr, size);
 87	BUG_ON(!valid_dma_direction(dir));
 88	addr = or1k_map_page(dev, virt_to_page(ptr),
 89			     (unsigned long)ptr & ~PAGE_MASK, size,
 90			     dir, NULL);
 91	debug_dma_map_page(dev, virt_to_page(ptr),
 92			   (unsigned long)ptr & ~PAGE_MASK, size,
 93			   dir, addr, true);
 94	return addr;
 95}
 96
 97static inline void dma_unmap_single(struct device *dev, dma_addr_t addr,
 98					  size_t size,
 99					  enum dma_data_direction dir)
100{
101	BUG_ON(!valid_dma_direction(dir));
102	or1k_unmap_page(dev, addr, size, dir, NULL);
103	debug_dma_unmap_page(dev, addr, size, dir, true);
104}
105
106static inline int dma_map_sg(struct device *dev, struct scatterlist *sg,
107				   int nents, enum dma_data_direction dir)
108{
109	int i, ents;
110	struct scatterlist *s;
111
112	for_each_sg(sg, s, nents, i)
113		kmemcheck_mark_initialized(sg_virt(s), s->length);
114	BUG_ON(!valid_dma_direction(dir));
115	ents = or1k_map_sg(dev, sg, nents, dir, NULL);
116	debug_dma_map_sg(dev, sg, nents, ents, dir);
117
118	return ents;
119}
120
121static inline void dma_unmap_sg(struct device *dev, struct scatterlist *sg,
122				      int nents, enum dma_data_direction dir)
123{
124	BUG_ON(!valid_dma_direction(dir));
125	debug_dma_unmap_sg(dev, sg, nents, dir);
126	or1k_unmap_sg(dev, sg, nents, dir, NULL);
127}
128
129static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
130				      size_t offset, size_t size,
131				      enum dma_data_direction dir)
132{
133	dma_addr_t addr;
134
135	kmemcheck_mark_initialized(page_address(page) + offset, size);
136	BUG_ON(!valid_dma_direction(dir));
137	addr = or1k_map_page(dev, page, offset, size, dir, NULL);
138	debug_dma_map_page(dev, page, offset, size, dir, addr, false);
139
140	return addr;
141}
142
143static inline void dma_unmap_page(struct device *dev, dma_addr_t addr,
144				  size_t size, enum dma_data_direction dir)
145{
146	BUG_ON(!valid_dma_direction(dir));
147	or1k_unmap_page(dev, addr, size, dir, NULL);
148	debug_dma_unmap_page(dev, addr, size, dir, true);
149}
150
151static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
152					   size_t size,
153					   enum dma_data_direction dir)
154{
155	BUG_ON(!valid_dma_direction(dir));
156	or1k_sync_single_for_cpu(dev, addr, size, dir);
157	debug_dma_sync_single_for_cpu(dev, addr, size, dir);
158}
159
160static inline void dma_sync_single_for_device(struct device *dev,
161					      dma_addr_t addr, size_t size,
162					      enum dma_data_direction dir)
163{
164	BUG_ON(!valid_dma_direction(dir));
165	or1k_sync_single_for_device(dev, addr, size, dir);
166	debug_dma_sync_single_for_device(dev, addr, size, dir);
167}
168
169static inline int dma_supported(struct device *dev, u64 dma_mask)
170{
171	/* Support 32 bit DMA mask exclusively */
172	return dma_mask == DMA_BIT_MASK(32);
173}
174
175static inline int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
176{
177	return 0;
178}
179
180static inline int dma_set_mask(struct device *dev, u64 dma_mask)
181{
182	if (!dev->dma_mask || !dma_supported(dev, dma_mask))
183		return -EIO;
184
185	*dev->dma_mask = dma_mask;
186
187	return 0;
188}
189#endif	/* __ASM_OPENRISC_DMA_MAPPING_H */