1 /*-
2 * Copyright (c) 2015 Michal Meloun
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 #include <sys/cdefs.h>
28 #include <sys/param.h>
29 #include <sys/systm.h>
30 #include <sys/bus.h>
31 #include <sys/kernel.h>
32 #include <sys/malloc.h>
33
34 #include <machine/bus.h>
35
36 #include <dev/extres/clk/clk.h>
37 #include <dev/drm2/drmP.h>
38 #include <dev/drm2/drm_crtc_helper.h>
39 #include <dev/drm2/drm_fb_helper.h>
40
41 #include <arm/nvidia/drm2/tegra_drm.h>
42
43 #include <sys/vmem.h>
44 #include <sys/vmem.h>
45 #include <vm/vm.h>
46 #include <vm/vm_pageout.h>
47
48 static void
tegra_bo_destruct(struct tegra_bo * bo)49 tegra_bo_destruct(struct tegra_bo *bo)
50 {
51 vm_page_t m;
52 size_t size;
53 int i;
54
55 if (bo->cdev_pager == NULL)
56 return;
57
58 size = round_page(bo->gem_obj.size);
59 if (bo->vbase != 0)
60 pmap_qremove(bo->vbase, bo->npages);
61
62 VM_OBJECT_WLOCK(bo->cdev_pager);
63 for (i = 0; i < bo->npages; i++) {
64 m = bo->m[i];
65 vm_page_busy_acquire(m, 0);
66 cdev_pager_free_page(bo->cdev_pager, m);
67 m->flags &= ~PG_FICTITIOUS;
68 vm_page_unwire_noq(m);
69 vm_page_free(m);
70 }
71 VM_OBJECT_WUNLOCK(bo->cdev_pager);
72
73 vm_object_deallocate(bo->cdev_pager);
74 if (bo->vbase != 0)
75 vmem_free(kmem_arena, bo->vbase, size);
76 }
77
78 static void
tegra_bo_free_object(struct drm_gem_object * gem_obj)79 tegra_bo_free_object(struct drm_gem_object *gem_obj)
80 {
81 struct tegra_bo *bo;
82
83 bo = container_of(gem_obj, struct tegra_bo, gem_obj);
84 drm_gem_free_mmap_offset(gem_obj);
85 drm_gem_object_release(gem_obj);
86
87 tegra_bo_destruct(bo);
88
89 free(bo->m, DRM_MEM_DRIVER);
90 free(bo, DRM_MEM_DRIVER);
91 }
92
93 static int
tegra_bo_alloc_contig(size_t npages,u_long alignment,vm_memattr_t memattr,vm_page_t ** ret_page)94 tegra_bo_alloc_contig(size_t npages, u_long alignment, vm_memattr_t memattr,
95 vm_page_t **ret_page)
96 {
97 vm_page_t m;
98 int tries, i;
99 vm_paddr_t low, high, boundary;
100
101 low = 0;
102 high = -1UL;
103 boundary = 0;
104 tries = 0;
105 retry:
106 m = vm_page_alloc_noobj_contig(VM_ALLOC_WIRED | VM_ALLOC_ZERO, npages,
107 low, high, alignment, boundary, memattr);
108 if (m == NULL) {
109 if (tries < 3) {
110 if (!vm_page_reclaim_contig(0, npages, low, high,
111 alignment, boundary))
112 vm_wait(NULL);
113 tries++;
114 goto retry;
115 }
116 return (ENOMEM);
117 }
118
119 for (i = 0; i < npages; i++, m++) {
120 m->valid = VM_PAGE_BITS_ALL;
121 (*ret_page)[i] = m;
122 }
123
124 return (0);
125 }
126
127 /* Initialize pager and insert all object pages to it*/
128 static int
tegra_bo_init_pager(struct tegra_bo * bo)129 tegra_bo_init_pager(struct tegra_bo *bo)
130 {
131 vm_page_t m;
132 size_t size;
133 int i;
134
135 size = round_page(bo->gem_obj.size);
136
137 bo->pbase = VM_PAGE_TO_PHYS(bo->m[0]);
138 if (vmem_alloc(kmem_arena, size, M_WAITOK | M_BESTFIT, &bo->vbase))
139 return (ENOMEM);
140
141 VM_OBJECT_WLOCK(bo->cdev_pager);
142 for (i = 0; i < bo->npages; i++) {
143 m = bo->m[i];
144 /*
145 * XXX This is a temporary hack.
146 * We need pager suitable for paging (mmap) managed
147 * real (non-fictitious) pages.
148 * - managed pages are needed for clean module unload.
149 * - aliasing fictitious page to real one is bad,
150 * pmap cannot handle this situation without issues
151 * It expects that
152 * paddr = PHYS_TO_VM_PAGE(VM_PAGE_TO_PHYS(paddr))
153 * for every single page passed to pmap.
154 */
155 m->oflags &= ~VPO_UNMANAGED;
156 m->flags |= PG_FICTITIOUS;
157 if (vm_page_insert(m, bo->cdev_pager, i) != 0)
158 return (EINVAL);
159 }
160 VM_OBJECT_WUNLOCK(bo->cdev_pager);
161
162 pmap_qenter(bo->vbase, bo->m, bo->npages);
163 return (0);
164 }
165
166 /* Allocate memory for frame buffer */
167 static int
tegra_bo_alloc(struct drm_device * drm,struct tegra_bo * bo)168 tegra_bo_alloc(struct drm_device *drm, struct tegra_bo *bo)
169 {
170 size_t size;
171 int rv;
172
173 size = bo->gem_obj.size;
174
175 bo->npages = atop(size);
176 bo->m = malloc(sizeof(vm_page_t *) * bo->npages, DRM_MEM_DRIVER,
177 M_WAITOK | M_ZERO);
178
179 rv = tegra_bo_alloc_contig(bo->npages, PAGE_SIZE,
180 VM_MEMATTR_WRITE_COMBINING, &(bo->m));
181 if (rv != 0) {
182 DRM_WARNING("Cannot allocate memory for gem object.\n");
183 return (rv);
184 }
185 rv = tegra_bo_init_pager(bo);
186 if (rv != 0) {
187 DRM_WARNING("Cannot initialize gem object pager.\n");
188 return (rv);
189 }
190 return (0);
191 }
192
193 int
tegra_bo_create(struct drm_device * drm,size_t size,struct tegra_bo ** res_bo)194 tegra_bo_create(struct drm_device *drm, size_t size, struct tegra_bo **res_bo)
195 {
196 struct tegra_bo *bo;
197 int rv;
198
199 if (size <= 0)
200 return (-EINVAL);
201
202 bo = malloc(sizeof(*bo), DRM_MEM_DRIVER, M_WAITOK | M_ZERO);
203
204 size = round_page(size);
205 rv = drm_gem_object_init(drm, &bo->gem_obj, size);
206 if (rv != 0) {
207 free(bo, DRM_MEM_DRIVER);
208 return (rv);
209 }
210 rv = drm_gem_create_mmap_offset(&bo->gem_obj);
211 if (rv != 0) {
212 drm_gem_object_release(&bo->gem_obj);
213 free(bo, DRM_MEM_DRIVER);
214 return (rv);
215 }
216
217 bo->cdev_pager = cdev_pager_allocate(&bo->gem_obj, OBJT_MGTDEVICE,
218 drm->driver->gem_pager_ops, size, 0, 0, NULL);
219 rv = tegra_bo_alloc(drm, bo);
220 if (rv != 0) {
221 tegra_bo_free_object(&bo->gem_obj);
222 return (rv);
223 }
224
225 *res_bo = bo;
226 return (0);
227 }
228
229 static int
tegra_bo_create_with_handle(struct drm_file * file,struct drm_device * drm,size_t size,uint32_t * handle,struct tegra_bo ** res_bo)230 tegra_bo_create_with_handle(struct drm_file *file, struct drm_device *drm,
231 size_t size, uint32_t *handle, struct tegra_bo **res_bo)
232 {
233 int rv;
234 struct tegra_bo *bo;
235
236 rv = tegra_bo_create(drm, size, &bo);
237 if (rv != 0)
238 return (rv);
239
240 rv = drm_gem_handle_create(file, &bo->gem_obj, handle);
241 if (rv != 0) {
242 tegra_bo_free_object(&bo->gem_obj);
243 drm_gem_object_release(&bo->gem_obj);
244 return (rv);
245 }
246
247 drm_gem_object_unreference_unlocked(&bo->gem_obj);
248
249 *res_bo = bo;
250 return (0);
251 }
252
253 static int
tegra_bo_dumb_create(struct drm_file * file,struct drm_device * drm_dev,struct drm_mode_create_dumb * args)254 tegra_bo_dumb_create(struct drm_file *file, struct drm_device *drm_dev,
255 struct drm_mode_create_dumb *args)
256 {
257 struct tegra_drm *drm;
258 struct tegra_bo *bo;
259 int rv;
260
261 drm = container_of(drm_dev, struct tegra_drm, drm_dev);
262
263 args->pitch= (args->width * args->bpp + 7) / 8;
264 args->pitch = roundup(args->pitch, drm->pitch_align);
265 args->size = args->pitch * args->height;
266 rv = tegra_bo_create_with_handle(file, drm_dev, args->size,
267 &args->handle, &bo);
268
269 return (rv);
270 }
271
272 static int
tegra_bo_dumb_map_offset(struct drm_file * file_priv,struct drm_device * drm_dev,uint32_t handle,uint64_t * offset)273 tegra_bo_dumb_map_offset(struct drm_file *file_priv,
274 struct drm_device *drm_dev, uint32_t handle, uint64_t *offset)
275 {
276 struct drm_gem_object *gem_obj;
277 int rv;
278
279 DRM_LOCK(drm_dev);
280 gem_obj = drm_gem_object_lookup(drm_dev, file_priv, handle);
281 if (gem_obj == NULL) {
282 device_printf(drm_dev->dev, "Object not found\n");
283 DRM_UNLOCK(drm_dev);
284 return (-EINVAL);
285 }
286 rv = drm_gem_create_mmap_offset(gem_obj);
287 if (rv != 0)
288 goto fail;
289
290 *offset = DRM_GEM_MAPPING_OFF(gem_obj->map_list.key) |
291 DRM_GEM_MAPPING_KEY;
292
293 drm_gem_object_unreference(gem_obj);
294 DRM_UNLOCK(drm_dev);
295 return (0);
296
297 fail:
298 drm_gem_object_unreference(gem_obj);
299 DRM_UNLOCK(drm_dev);
300 return (rv);
301 }
302
303 static int
tegra_bo_dumb_destroy(struct drm_file * file_priv,struct drm_device * drm_dev,unsigned int handle)304 tegra_bo_dumb_destroy(struct drm_file *file_priv, struct drm_device *drm_dev,
305 unsigned int handle)
306 {
307 int rv;
308
309 rv = drm_gem_handle_delete(file_priv, handle);
310 return (rv);
311 }
312
313 /*
314 * mmap support
315 */
316 static int
tegra_gem_pager_fault(vm_object_t vm_obj,vm_ooffset_t offset,int prot,vm_page_t * mres)317 tegra_gem_pager_fault(vm_object_t vm_obj, vm_ooffset_t offset, int prot,
318 vm_page_t *mres)
319 {
320
321 #ifdef DRM_PAGER_DEBUG
322 DRM_DEBUG("object %p offset %jd prot %d mres %p\n",
323 vm_obj, (intmax_t)offset, prot, mres);
324 #endif
325 return (VM_PAGER_FAIL);
326
327 }
328
329 static int
tegra_gem_pager_ctor(void * handle,vm_ooffset_t size,vm_prot_t prot,vm_ooffset_t foff,struct ucred * cred,u_short * color)330 tegra_gem_pager_ctor(void *handle, vm_ooffset_t size, vm_prot_t prot,
331 vm_ooffset_t foff, struct ucred *cred, u_short *color)
332 {
333
334 if (color != NULL)
335 *color = 0;
336 return (0);
337 }
338
339 static void
tegra_gem_pager_dtor(void * handle)340 tegra_gem_pager_dtor(void *handle)
341 {
342
343 }
344
345 static struct cdev_pager_ops tegra_gem_pager_ops = {
346 .cdev_pg_fault = tegra_gem_pager_fault,
347 .cdev_pg_ctor = tegra_gem_pager_ctor,
348 .cdev_pg_dtor = tegra_gem_pager_dtor
349 };
350
351 /* Fill up relevant fields in drm_driver ops */
352 void
tegra_bo_driver_register(struct drm_driver * drm_drv)353 tegra_bo_driver_register(struct drm_driver *drm_drv)
354 {
355 drm_drv->gem_free_object = tegra_bo_free_object;
356 drm_drv->gem_pager_ops = &tegra_gem_pager_ops;
357 drm_drv->dumb_create = tegra_bo_dumb_create;
358 drm_drv->dumb_map_offset = tegra_bo_dumb_map_offset;
359 drm_drv->dumb_destroy = tegra_bo_dumb_destroy;
360 }
361