video: tegra: host: Tegra12 updates to host
[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)
91 {
92         struct mem_handle *h = NULL;
93 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
94         h = nvhost_nvmap_alloc(mgr, size, align, flags);
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)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)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)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)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)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 void *nvhost_memmgr_kmap(struct mem_handle *handle, unsigned int pagenum)
223 {
224         switch (nvhost_memmgr_type((u32)handle)) {
225 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
226         case mem_mgr_type_nvmap:
227                 return nvhost_nvmap_kmap(handle, pagenum);
228                 break;
229 #endif
230 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
231         case mem_mgr_type_dmabuf:
232                 return nvhost_dmabuf_kmap(handle, pagenum);
233                 break;
234 #endif
235         default:
236                 return 0;
237                 break;
238         }
239 }
240
241 void nvhost_memmgr_kunmap(struct mem_handle *handle, unsigned int pagenum,
242                 void *addr)
243 {
244         switch (nvhost_memmgr_type((u32)handle)) {
245 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
246         case mem_mgr_type_nvmap:
247                 nvhost_nvmap_kunmap(handle, pagenum, addr);
248                 break;
249 #endif
250 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
251         case mem_mgr_type_dmabuf:
252                 nvhost_dmabuf_kunmap(handle, pagenum, addr);
253                 break;
254 #endif
255         default:
256                 break;
257         }
258 }
259
260 int nvhost_memmgr_pin_array_ids(struct mem_mgr *mgr,
261                 struct platform_device *dev,
262                 u32 *ids,
263                 dma_addr_t *phys_addr,
264                 u32 count,
265                 struct nvhost_job_unpin *unpin_data)
266 {
267         int pin_count = 0;
268
269 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
270         {
271                 int nvmap_count = 0;
272                 nvmap_count = nvhost_nvmap_pin_array_ids(mgr,
273                         ids, MEMMGR_TYPE_MASK,
274                         mem_mgr_type_nvmap,
275                         count, unpin_data,
276                         phys_addr);
277                 if (nvmap_count < 0)
278                         return nvmap_count;
279                 pin_count += nvmap_count;
280         }
281 #endif
282 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
283         {
284                 int dmabuf_count = 0;
285                 dmabuf_count = nvhost_dmabuf_pin_array_ids(dev,
286                         ids, MEMMGR_TYPE_MASK,
287                         mem_mgr_type_dmabuf,
288                         count, &unpin_data[pin_count],
289                         phys_addr);
290
291                 if (dmabuf_count < 0) {
292                         /* clean up previous handles */
293                         while (pin_count) {
294                                 pin_count--;
295                                 /* unpin, put */
296                                 nvhost_memmgr_unpin(mgr,
297                                         unpin_data[pin_count].h, &dev->dev,
298                                         unpin_data[pin_count].mem);
299                                 nvhost_memmgr_put(mgr,
300                                         unpin_data[pin_count].h);
301                         }
302                         return dmabuf_count;
303                 }
304                 pin_count += dmabuf_count;
305         }
306 #endif
307         return pin_count;
308 }
309
310 u32 nvhost_memmgr_handle_to_id(struct mem_handle *handle)
311 {
312         switch (nvhost_memmgr_type((u32)handle)) {
313 #ifdef CONFIG_TEGRA_GRHOST_USE_NVMAP
314         case mem_mgr_type_nvmap:
315                 return (u32)nvmap_ref_to_user_id(
316                                 (struct nvmap_handle_ref *)handle);
317                 break;
318 #endif
319 #ifdef CONFIG_TEGRA_GRHOST_USE_DMABUF
320         case mem_mgr_type_dmabuf:
321                 WARN_ON(1);
322                 break;
323 #endif
324         default:
325                 break;
326         }
327
328         return 0;
329 }
330
331 int nvhost_memmgr_init(struct nvhost_chip_support *chip)
332 {
333         return 0;
334 }
335