video: tegra: bitness sanitary cleanup
[linux-3.10.git] / drivers / video / tegra / host / nvhost_memmgr.c
1 /*
2  * drivers/video/tegra/host/nvhost_memmgr.c
3  *
4  * Tegra Graphics Host Memory Management Abstraction
5  *
6  * Copyright (c) 2012-2013, NVIDIA Corporation.
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms and conditions of the GNU General Public License,
10  * version 2, as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
15  * more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <linux/kernel.h>
22 #include <linux/platform_device.h>
23 #include <linux/err.h>
24 #include <linux/bug.h>
25
26 #include "nvhost_memmgr.h"
27 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
28 #include "nvmap.h"
29 #include <linux/nvmap.h>
30 #endif
31 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
32 #include "dmabuf.h"
33 #endif
34 #include "chip_support.h"
35
36 struct mem_mgr *nvhost_memmgr_alloc_mgr(void)
37 {
38         struct mem_mgr *mgr = NULL;
39 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
40         mgr = nvhost_nvmap_alloc_mgr();
41 #else
42 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
43         mgr = (struct mem_mgr)1;
44 #endif
45 #endif
46
47         return mgr;
48 }
49
50 void nvhost_memmgr_put_mgr(struct mem_mgr *mgr)
51 {
52 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
53         nvhost_nvmap_put_mgr(mgr);
54 #else
55 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
56         mgr = (struct mem_mgr)1;
57 #endif
58 #endif
59 }
60
61 struct mem_mgr *nvhost_memmgr_get_mgr(struct mem_mgr *_mgr)
62 {
63         struct mem_mgr *mgr = NULL;
64 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
65         mgr = nvhost_nvmap_get_mgr(_mgr);
66 #else
67 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
68         mgr = (struct mem_mgr)1;
69 #endif
70 #endif
71
72         return mgr;
73 }
74
75 struct mem_mgr *nvhost_memmgr_get_mgr_file(int fd)
76 {
77         struct mem_mgr *mgr = NULL;
78 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
79         mgr = nvhost_nvmap_get_mgr_file(fd);
80 #else
81 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
82         mgr = (struct mem_mgr)1;
83 #endif
84 #endif
85
86         return mgr;
87 }
88
89 struct mem_handle *nvhost_memmgr_alloc(struct mem_mgr *mgr,
90        size_t size, size_t align, int flags, unsigned int heap_mask)
91 {
92         struct mem_handle *h = NULL;
93 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
94         h = nvhost_nvmap_alloc(mgr, size, align, flags, heap_mask);
95 #else
96 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
97         h = nvhost_dmabuf_alloc(mgr, size, align, flags);
98 #endif
99 #endif
100
101         return h;
102 }
103
104 struct mem_handle *nvhost_memmgr_get(struct mem_mgr *mgr,
105                 u32 id, struct platform_device *dev)
106 {
107         struct mem_handle *h = NULL;
108
109         switch (nvhost_memmgr_type(id)) {
110 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
111         case mem_mgr_type_nvmap:
112                 h = (struct mem_handle *) nvhost_nvmap_get(mgr, id, dev);
113                 break;
114 #endif
115 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
116         case mem_mgr_type_dmabuf:
117                 h = (struct mem_handle *) nvhost_dmabuf_get(id, dev);
118                 break;
119 #endif
120         default:
121                 break;
122         }
123
124         return h;
125 }
126
127 void nvhost_memmgr_put(struct mem_mgr *mgr, struct mem_handle *handle)
128 {
129         switch (nvhost_memmgr_type((u32)((uintptr_t)handle))) {
130 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
131         case mem_mgr_type_nvmap:
132                 nvhost_nvmap_put(mgr, handle);
133                 break;
134 #endif
135 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
136         case mem_mgr_type_dmabuf:
137                 nvhost_dmabuf_put(handle);
138                 break;
139 #endif
140         default:
141                 break;
142         }
143 }
144
145 struct sg_table *nvhost_memmgr_pin(struct mem_mgr *mgr,
146                 struct mem_handle *handle, struct device *dev)
147 {
148         switch (nvhost_memmgr_type((u32)((uintptr_t)handle))) {
149 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
150         case mem_mgr_type_nvmap:
151                 return nvhost_nvmap_pin(mgr, handle);
152                 break;
153 #endif
154 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
155         case mem_mgr_type_dmabuf:
156                 return nvhost_dmabuf_pin(handle);
157                 break;
158 #endif
159         default:
160                 return 0;
161                 break;
162         }
163 }
164
165 void nvhost_memmgr_unpin(struct mem_mgr *mgr,
166                 struct mem_handle *handle, struct device *dev,
167                 struct sg_table *sgt)
168 {
169         switch (nvhost_memmgr_type((u32)((uintptr_t)handle))) {
170 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
171         case mem_mgr_type_nvmap:
172                 nvhost_nvmap_unpin(mgr, handle, sgt);
173                 break;
174 #endif
175 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
176         case mem_mgr_type_dmabuf:
177                 nvhost_dmabuf_unpin(handle, sgt);
178                 break;
179 #endif
180         default:
181                 break;
182         }
183 }
184
185 void *nvhost_memmgr_mmap(struct mem_handle *handle)
186 {
187         switch (nvhost_memmgr_type((u32)((uintptr_t)handle))) {
188 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
189         case mem_mgr_type_nvmap:
190                 return nvhost_nvmap_mmap(handle);
191                 break;
192 #endif
193 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
194         case mem_mgr_type_dmabuf:
195                 return nvhost_dmabuf_mmap(handle);
196                 break;
197 #endif
198         default:
199                 return 0;
200                 break;
201         }
202 }
203
204 void nvhost_memmgr_munmap(struct mem_handle *handle, void *addr)
205 {
206         switch (nvhost_memmgr_type((u32)((uintptr_t)handle))) {
207 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
208         case mem_mgr_type_nvmap:
209                 nvhost_nvmap_munmap(handle, addr);
210                 break;
211 #endif
212 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
213         case mem_mgr_type_dmabuf:
214                 nvhost_dmabuf_munmap(handle, addr);
215                 break;
216 #endif
217         default:
218                 break;
219         }
220 }
221
222 int nvhost_memmgr_get_param(struct mem_mgr *mem_mgr,
223                             struct mem_handle *mem_handle,
224                             u32 param, u32 *result)
225 {
226 #ifndef CONFIG_ARM64
227         switch (nvhost_memmgr_type((u32)mem_handle)) {
228 #else
229         switch (nvhost_memmgr_type((u32)((uintptr_t)mem_handle))) {
230 #endif
231 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
232         case mem_mgr_type_nvmap:
233                 return nvhost_nvmap_get_param(mem_mgr, mem_handle,
234                                               param, result);
235                 break;
236 #endif
237 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
238         case mem_mgr_type_dmabuf:
239                 return nvhost_dmabuf_get_param(mem_mgr, mem_handle,
240                                                param, result);
241                 break;
242 #endif
243         default:
244                 break;
245         }
246         return -EINVAL;
247 }
248
249 void *nvhost_memmgr_kmap(struct mem_handle *handle, unsigned int pagenum)
250 {
251         switch (nvhost_memmgr_type((u32)((uintptr_t)handle))) {
252 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
253         case mem_mgr_type_nvmap:
254                 return nvhost_nvmap_kmap(handle, pagenum);
255                 break;
256 #endif
257 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
258         case mem_mgr_type_dmabuf:
259                 return nvhost_dmabuf_kmap(handle, pagenum);
260                 break;
261 #endif
262         default:
263                 return 0;
264                 break;
265         }
266 }
267
268 void nvhost_memmgr_kunmap(struct mem_handle *handle, unsigned int pagenum,
269                 void *addr)
270 {
271         switch (nvhost_memmgr_type((u32)((uintptr_t)handle))) {
272 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
273         case mem_mgr_type_nvmap:
274                 nvhost_nvmap_kunmap(handle, pagenum, addr);
275                 break;
276 #endif
277 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
278         case mem_mgr_type_dmabuf:
279                 nvhost_dmabuf_kunmap(handle, pagenum, addr);
280                 break;
281 #endif
282         default:
283                 break;
284         }
285 }
286
287 int nvhost_memmgr_pin_array_ids(struct mem_mgr *mgr,
288                 struct platform_device *dev,
289                 u32 *ids,
290                 dma_addr_t *phys_addr,
291                 u32 count,
292                 struct nvhost_job_unpin *unpin_data)
293 {
294         int pin_count = 0;
295
296 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
297         {
298                 int nvmap_count = 0;
299                 nvmap_count = nvhost_nvmap_pin_array_ids(mgr,
300                         ids, MEMMGR_TYPE_MASK,
301                         mem_mgr_type_nvmap,
302                         count, unpin_data,
303                         phys_addr);
304                 if (nvmap_count < 0)
305                         return nvmap_count;
306                 pin_count += nvmap_count;
307         }
308 #endif
309 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
310         {
311                 int dmabuf_count = 0;
312                 dmabuf_count = nvhost_dmabuf_pin_array_ids(dev,
313                         ids, MEMMGR_TYPE_MASK,
314                         mem_mgr_type_dmabuf,
315                         count, &unpin_data[pin_count],
316                         phys_addr);
317
318                 if (dmabuf_count < 0) {
319                         /* clean up previous handles */
320                         while (pin_count) {
321                                 pin_count--;
322                                 /* unpin, put */
323                                 nvhost_memmgr_unpin(mgr,
324                                         unpin_data[pin_count].h, &dev->dev,
325                                         unpin_data[pin_count].mem);
326                                 nvhost_memmgr_put(mgr,
327                                         unpin_data[pin_count].h);
328                         }
329                         return dmabuf_count;
330                 }
331                 pin_count += dmabuf_count;
332         }
333 #endif
334         return pin_count;
335 }
336
337 u32 nvhost_memmgr_handle_to_id(struct mem_handle *handle)
338 {
339         switch (nvhost_memmgr_type((u32)handle)) {
340 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
341         case mem_mgr_type_nvmap:
342                 return (u32)nvmap_ref_to_user_id(
343                                 (struct nvmap_handle_ref *)handle);
344                 break;
345 #endif
346 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
347         case mem_mgr_type_dmabuf:
348                 WARN_ON(1);
349                 break;
350 #endif
351         default:
352                 break;
353         }
354
355         return 0;
356 }
357
358 int nvhost_memmgr_init(struct nvhost_chip_support *chip)
359 {
360         return 0;
361 }
362