2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2011 The FreeBSD Foundation
7 * This software was developed by Konstantin Belousov under sponsorship from
8 * the FreeBSD Foundation.
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/limits.h>
41 #include <sys/mutex.h>
44 #include <vm/vm_page.h>
46 #include <dev/drm2/drmP.h>
47 #include <dev/drm2/drm.h>
48 #include <dev/drm2/drm_sarea.h>
51 * We make up offsets for buffer objects so we can recognize them at
55 /* pgoff in mmap is an unsigned long, so we need to make sure that
56 * the faked up offset will fit
59 #if BITS_PER_LONG == 64
60 #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFFUL >> PAGE_SHIFT) + 1)
61 #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFFUL >> PAGE_SHIFT) * 16)
63 #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFUL >> PAGE_SHIFT) + 1)
64 #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFUL >> PAGE_SHIFT) * 16)
68 * Initialize the GEM device fields
72 drm_gem_init(struct drm_device *dev)
74 struct drm_gem_mm *mm;
76 drm_gem_names_init(&dev->object_names);
78 mm = malloc(sizeof(*mm), DRM_MEM_DRIVER, M_NOWAIT);
80 DRM_ERROR("out of memory\n");
86 if (drm_ht_create(&mm->offset_hash, 19)) {
87 free(mm, DRM_MEM_DRIVER);
91 mm->idxunr = new_unrhdr(0, DRM_GEM_MAX_IDX, NULL);
97 drm_gem_destroy(struct drm_device *dev)
99 struct drm_gem_mm *mm = dev->mm_private;
101 dev->mm_private = NULL;
102 drm_ht_remove(&mm->offset_hash);
103 delete_unrhdr(mm->idxunr);
104 free(mm, DRM_MEM_DRIVER);
105 drm_gem_names_fini(&dev->object_names);
108 int drm_gem_object_init(struct drm_device *dev,
109 struct drm_gem_object *obj, size_t size)
111 KASSERT((size & (PAGE_SIZE - 1)) == 0,
112 ("Bad size %ju", (uintmax_t)size));
115 obj->vm_obj = vm_pager_allocate(OBJT_DEFAULT, NULL, size,
116 VM_PROT_READ | VM_PROT_WRITE, 0, curthread->td_ucred);
119 obj->handle_count = 0;
124 EXPORT_SYMBOL(drm_gem_object_init);
127 * Initialize an already allocated GEM object of the specified size with
128 * no GEM provided backing store. Instead the caller is responsible for
129 * backing the object and handling it.
131 int drm_gem_private_object_init(struct drm_device *dev,
132 struct drm_gem_object *obj, size_t size)
134 MPASS((size & (PAGE_SIZE - 1)) == 0);
140 atomic_store_rel_int(&obj->handle_count, 0);
145 EXPORT_SYMBOL(drm_gem_private_object_init);
147 struct drm_gem_object *
148 drm_gem_object_alloc(struct drm_device *dev, size_t size)
150 struct drm_gem_object *obj;
152 obj = malloc(sizeof(*obj), DRM_MEM_DRIVER, M_NOWAIT | M_ZERO);
156 if (drm_gem_object_init(dev, obj, size) != 0)
159 if (dev->driver->gem_init_object != NULL &&
160 dev->driver->gem_init_object(obj) != 0) {
165 vm_object_deallocate(obj->vm_obj);
167 free(obj, DRM_MEM_DRIVER);
170 EXPORT_SYMBOL(drm_gem_object_alloc);
172 #if defined(FREEBSD_NOTYET)
174 drm_gem_remove_prime_handles(struct drm_gem_object *obj, struct drm_file *filp)
176 if (obj->import_attach) {
177 drm_prime_remove_buf_handle(&filp->prime,
178 obj->import_attach->dmabuf);
180 if (obj->export_dma_buf) {
181 drm_prime_remove_buf_handle(&filp->prime,
182 obj->export_dma_buf);
188 * Removes the mapping from handle to filp for this object.
191 drm_gem_handle_delete(struct drm_file *filp, u32 handle)
193 struct drm_device *dev;
194 struct drm_gem_object *obj;
196 obj = drm_gem_names_remove(&filp->object_names, handle);
202 #if defined(FREEBSD_NOTYET)
203 drm_gem_remove_prime_handles(obj, filp);
206 if (dev->driver->gem_close_object)
207 dev->driver->gem_close_object(obj, filp);
208 drm_gem_object_handle_unreference_unlocked(obj);
212 EXPORT_SYMBOL(drm_gem_handle_delete);
215 * Create a handle for this object. This adds a handle reference
216 * to the object, which includes a regular reference count. Callers
217 * will likely want to dereference the object afterwards.
220 drm_gem_handle_create(struct drm_file *file_priv,
221 struct drm_gem_object *obj,
224 struct drm_device *dev = obj->dev;
228 ret = drm_gem_name_create(&file_priv->object_names, obj, handlep);
232 drm_gem_object_handle_reference(obj);
234 if (dev->driver->gem_open_object) {
235 ret = dev->driver->gem_open_object(obj, file_priv);
237 drm_gem_handle_delete(file_priv, *handlep);
244 EXPORT_SYMBOL(drm_gem_handle_create);
247 drm_gem_free_mmap_offset(struct drm_gem_object *obj)
249 struct drm_device *dev = obj->dev;
250 struct drm_gem_mm *mm = dev->mm_private;
251 struct drm_hash_item *list = &obj->map_list;
256 drm_ht_remove_item(&mm->offset_hash, list);
257 free_unr(mm->idxunr, list->key);
260 EXPORT_SYMBOL(drm_gem_free_mmap_offset);
263 drm_gem_create_mmap_offset(struct drm_gem_object *obj)
265 struct drm_device *dev = obj->dev;
266 struct drm_gem_mm *mm = dev->mm_private;
272 obj->map_list.key = alloc_unr(mm->idxunr);
273 ret = drm_ht_insert_item(&mm->offset_hash, &obj->map_list);
275 DRM_ERROR("failed to add to map hash\n");
276 free_unr(mm->idxunr, obj->map_list.key);
283 EXPORT_SYMBOL(drm_gem_create_mmap_offset);
285 /** Returns a reference to the object named by the handle. */
286 struct drm_gem_object *
287 drm_gem_object_lookup(struct drm_device *dev, struct drm_file *filp,
290 struct drm_gem_object *obj;
292 obj = drm_gem_name_ref(&filp->object_names, handle,
293 (void (*)(void *))drm_gem_object_reference);
297 EXPORT_SYMBOL(drm_gem_object_lookup);
300 drm_gem_close_ioctl(struct drm_device *dev, void *data,
301 struct drm_file *file_priv)
303 struct drm_gem_close *args = data;
306 if (!(dev->driver->driver_features & DRIVER_GEM))
309 ret = drm_gem_handle_delete(file_priv, args->handle);
315 drm_gem_flink_ioctl(struct drm_device *dev, void *data,
316 struct drm_file *file_priv)
318 struct drm_gem_flink *args = data;
319 struct drm_gem_object *obj;
322 if (!(dev->driver->driver_features & DRIVER_GEM))
325 obj = drm_gem_object_lookup(dev, file_priv, args->handle);
329 ret = drm_gem_name_create(&dev->object_names, obj, &obj->name);
331 if (ret == -EALREADY)
333 drm_gem_object_unreference_unlocked(obj);
336 args->name = obj->name;
341 drm_gem_open_ioctl(struct drm_device *dev, void *data,
342 struct drm_file *file_priv)
344 struct drm_gem_open *args = data;
345 struct drm_gem_object *obj;
349 if (!(dev->driver->driver_features & DRIVER_GEM))
352 obj = drm_gem_name_ref(&dev->object_names, args->name,
353 (void (*)(void *))drm_gem_object_reference);
357 ret = drm_gem_handle_create(file_priv, obj, &handle);
358 drm_gem_object_unreference_unlocked(obj);
362 args->handle = handle;
363 args->size = obj->size;
369 drm_gem_open(struct drm_device *dev, struct drm_file *file_private)
372 drm_gem_names_init(&file_private->object_names);
376 drm_gem_object_release_handle(uint32_t name, void *ptr, void *data)
378 struct drm_file *file_priv = data;
379 struct drm_gem_object *obj = ptr;
380 struct drm_device *dev = obj->dev;
382 #if defined(FREEBSD_NOTYET)
383 drm_gem_remove_prime_handles(obj, file_priv);
386 if (dev->driver->gem_close_object)
387 dev->driver->gem_close_object(obj, file_priv);
389 drm_gem_object_handle_unreference_unlocked(obj);
395 drm_gem_release(struct drm_device *dev, struct drm_file *file_private)
397 drm_gem_names_foreach(&file_private->object_names,
398 drm_gem_object_release_handle, file_private);
400 drm_gem_names_fini(&file_private->object_names);
404 drm_gem_object_release(struct drm_gem_object *obj)
408 * obj->vm_obj can be NULL for private gem objects.
410 vm_object_deallocate(obj->vm_obj);
412 EXPORT_SYMBOL(drm_gem_object_release);
415 drm_gem_object_free(struct drm_gem_object *obj)
417 struct drm_device *dev = obj->dev;
419 DRM_LOCK_ASSERT(dev);
420 if (dev->driver->gem_free_object != NULL)
421 dev->driver->gem_free_object(obj);
423 EXPORT_SYMBOL(drm_gem_object_free);
425 void drm_gem_object_handle_free(struct drm_gem_object *obj)
427 struct drm_device *dev = obj->dev;
428 struct drm_gem_object *obj1;
431 obj1 = drm_gem_names_remove(&dev->object_names, obj->name);
433 drm_gem_object_unreference(obj1);
437 static struct drm_gem_object *
438 drm_gem_object_from_offset(struct drm_device *dev, vm_ooffset_t offset)
440 struct drm_gem_object *obj;
441 struct drm_gem_mm *mm;
442 struct drm_hash_item *map_list;
444 if ((offset & DRM_GEM_MAPPING_MASK) != DRM_GEM_MAPPING_KEY)
446 offset &= ~DRM_GEM_MAPPING_KEY;
447 mm = dev->mm_private;
448 if (drm_ht_find_item(&mm->offset_hash, DRM_GEM_MAPPING_IDX(offset),
450 DRM_DEBUG("drm_gem_object_from_offset: offset 0x%jx obj not found\n",
454 obj = __containerof(map_list, struct drm_gem_object, map_list);
459 drm_gem_mmap_single(struct drm_device *dev, vm_ooffset_t *offset, vm_size_t size,
460 struct vm_object **obj_res, int nprot)
462 struct drm_gem_object *gem_obj;
463 struct vm_object *vm_obj;
466 gem_obj = drm_gem_object_from_offset(dev, *offset);
467 if (gem_obj == NULL) {
471 drm_gem_object_reference(gem_obj);
473 vm_obj = cdev_pager_allocate(gem_obj, OBJT_MGTDEVICE,
474 dev->driver->gem_pager_ops, size, nprot,
475 DRM_GEM_MAPPING_MAPOFF(*offset), curthread->td_ucred);
476 if (vm_obj == NULL) {
477 drm_gem_object_unreference_unlocked(gem_obj);
480 *offset = DRM_GEM_MAPPING_MAPOFF(*offset);
486 drm_gem_pager_dtr(void *handle)
488 struct drm_gem_object *obj;
489 struct drm_device *dev;
495 drm_gem_free_mmap_offset(obj);
496 drm_gem_object_unreference(obj);