Eric Lee / smarc-fsl-linux-kernel

Blame view

include/asm-generic/dma-mapping-common.h 5.24 KB
edit raw normal view history
c147d8ea3   FUJITA Tomonori   dma-mapping: add ... 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
  #ifndef _ASM_GENERIC_DMA_MAPPING_H
  #define _ASM_GENERIC_DMA_MAPPING_H
  
  #include <linux/kmemcheck.h>
  #include <linux/scatterlist.h>
  #include <linux/dma-debug.h>
  #include <linux/dma-attrs.h>
  
  static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
  					      size_t size,
  					      enum dma_data_direction dir,
  					      struct dma_attrs *attrs)
  {
  	struct dma_map_ops *ops = get_dma_ops(dev);
  	dma_addr_t addr;
  
  	kmemcheck_mark_initialized(ptr, size);
  	BUG_ON(!valid_dma_direction(dir));
  	addr = ops->map_page(dev, virt_to_page(ptr),
  			     (unsigned long)ptr & ~PAGE_MASK, size,
  			     dir, attrs);
  	debug_dma_map_page(dev, virt_to_page(ptr),
  			   (unsigned long)ptr & ~PAGE_MASK, size,
  			   dir, addr, true);
  	return addr;
  }
  
  static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
  					  size_t size,
  					  enum dma_data_direction dir,
  					  struct dma_attrs *attrs)
  {
  	struct dma_map_ops *ops = get_dma_ops(dev);
  
  	BUG_ON(!valid_dma_direction(dir));
  	if (ops->unmap_page)
  		ops->unmap_page(dev, addr, size, dir, attrs);
  	debug_dma_unmap_page(dev, addr, size, dir, true);
  }
  
  static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg,
  				   int nents, enum dma_data_direction dir,
  				   struct dma_attrs *attrs)
  {
  	struct dma_map_ops *ops = get_dma_ops(dev);
  	int i, ents;
  	struct scatterlist *s;
  
  	for_each_sg(sg, s, nents, i)
  		kmemcheck_mark_initialized(sg_virt(s), s->length);
  	BUG_ON(!valid_dma_direction(dir));
  	ents = ops->map_sg(dev, sg, nents, dir, attrs);
  	debug_dma_map_sg(dev, sg, nents, ents, dir);
  
  	return ents;
  }
  
  static inline void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg,
  				      int nents, enum dma_data_direction dir,
  				      struct dma_attrs *attrs)
  {
  	struct dma_map_ops *ops = get_dma_ops(dev);
  
  	BUG_ON(!valid_dma_direction(dir));
  	debug_dma_unmap_sg(dev, sg, nents, dir);
  	if (ops->unmap_sg)
  		ops->unmap_sg(dev, sg, nents, dir, attrs);
  }
  
  static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
  				      size_t offset, size_t size,
  				      enum dma_data_direction dir)
  {
  	struct dma_map_ops *ops = get_dma_ops(dev);
  	dma_addr_t addr;
  
  	kmemcheck_mark_initialized(page_address(page) + offset, size);
  	BUG_ON(!valid_dma_direction(dir));
  	addr = ops->map_page(dev, page, offset, size, dir, NULL);
  	debug_dma_map_page(dev, page, offset, size, dir, addr, false);
  
  	return addr;
  }
  
  static inline void dma_unmap_page(struct device *dev, dma_addr_t addr,
  				  size_t size, enum dma_data_direction dir)
  {
  	struct dma_map_ops *ops = get_dma_ops(dev);
  
  	BUG_ON(!valid_dma_direction(dir));
  	if (ops->unmap_page)
  		ops->unmap_page(dev, addr, size, dir, NULL);
  	debug_dma_unmap_page(dev, addr, size, dir, false);
  }
  
  static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr,
  					   size_t size,
  					   enum dma_data_direction dir)
  {
  	struct dma_map_ops *ops = get_dma_ops(dev);
  
  	BUG_ON(!valid_dma_direction(dir));
  	if (ops->sync_single_for_cpu)
  		ops->sync_single_for_cpu(dev, addr, size, dir);
  	debug_dma_sync_single_for_cpu(dev, addr, size, dir);
c147d8ea3   FUJITA Tomonori   dma-mapping: add ... 
106
107
108
109
110
111
112
113
114
115
116
117
 
  }
  
  static inline void dma_sync_single_for_device(struct device *dev,
  					      dma_addr_t addr, size_t size,
  					      enum dma_data_direction dir)
  {
  	struct dma_map_ops *ops = get_dma_ops(dev);
  
  	BUG_ON(!valid_dma_direction(dir));
  	if (ops->sync_single_for_device)
  		ops->sync_single_for_device(dev, addr, size, dir);
  	debug_dma_sync_single_for_device(dev, addr, size, dir);
c147d8ea3   FUJITA Tomonori   dma-mapping: add ... 
118
119
120
121
122
123
124
125
 
  }
  
  static inline void dma_sync_single_range_for_cpu(struct device *dev,
  						 dma_addr_t addr,
  						 unsigned long offset,
  						 size_t size,
  						 enum dma_data_direction dir)
  {
07a723097   Clemens Ladisch   dma-mapping: fix ... 
126
127
128
129
130
131
 
  	const struct dma_map_ops *ops = get_dma_ops(dev);
  
  	BUG_ON(!valid_dma_direction(dir));
  	if (ops->sync_single_for_cpu)
  		ops->sync_single_for_cpu(dev, addr + offset, size, dir);
  	debug_dma_sync_single_range_for_cpu(dev, addr, offset, size, dir);
c147d8ea3   FUJITA Tomonori   dma-mapping: add ... 
132
133
134
135
136
137
138
139
 
  }
  
  static inline void dma_sync_single_range_for_device(struct device *dev,
  						    dma_addr_t addr,
  						    unsigned long offset,
  						    size_t size,
  						    enum dma_data_direction dir)
  {
07a723097   Clemens Ladisch   dma-mapping: fix ... 
140
141
142
143
144
145
 
  	const struct dma_map_ops *ops = get_dma_ops(dev);
  
  	BUG_ON(!valid_dma_direction(dir));
  	if (ops->sync_single_for_device)
  		ops->sync_single_for_device(dev, addr + offset, size, dir);
  	debug_dma_sync_single_range_for_device(dev, addr, offset, size, dir);
c147d8ea3   FUJITA Tomonori   dma-mapping: add ... 
146
147
148
149
150
151
152
153
154
155
156
157
 
  }
  
  static inline void
  dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
  		    int nelems, enum dma_data_direction dir)
  {
  	struct dma_map_ops *ops = get_dma_ops(dev);
  
  	BUG_ON(!valid_dma_direction(dir));
  	if (ops->sync_sg_for_cpu)
  		ops->sync_sg_for_cpu(dev, sg, nelems, dir);
  	debug_dma_sync_sg_for_cpu(dev, sg, nelems, dir);
c147d8ea3   FUJITA Tomonori   dma-mapping: add ... 
158
159
160
161
162
163
164
165
166
167
168
169
 
  }
  
  static inline void
  dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
  		       int nelems, enum dma_data_direction dir)
  {
  	struct dma_map_ops *ops = get_dma_ops(dev);
  
  	BUG_ON(!valid_dma_direction(dir));
  	if (ops->sync_sg_for_device)
  		ops->sync_sg_for_device(dev, sg, nelems, dir);
  	debug_dma_sync_sg_for_device(dev, sg, nelems, dir);
c147d8ea3   FUJITA Tomonori   dma-mapping: add ... 
170
171
172
173
174
175
176
177
 
  }
  
  #define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, NULL)
  #define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, NULL)
  #define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, NULL)
  #define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, NULL)
  
  #endif