2 * Copyright (c) 2011 The FreeBSD Foundation
5 * This software was developed by Konstantin Belousov under sponsorship from
6 * the FreeBSD Foundation.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/limits.h>
39 #include <sys/mutex.h>
42 #include <vm/vm_page.h>
44 #include <dev/drm2/drmP.h>
45 #include <dev/drm2/drm.h>
46 #include <dev/drm2/drm_sarea.h>
49 * We make up offsets for buffer objects so we can recognize them at
53 /* pgoff in mmap is an unsigned long, so we need to make sure that
54 * the faked up offset will fit
57 #if ULONG_MAX == UINT64_MAX
58 #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFFUL >> PAGE_SHIFT) + 1)
59 #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFFUL >> PAGE_SHIFT) * 16)
61 #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFUL >> PAGE_SHIFT) + 1)
62 #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFUL >> PAGE_SHIFT) * 16)
66 drm_gem_init(struct drm_device *dev)
68 struct drm_gem_mm *mm;
70 drm_gem_names_init(&dev->object_names);
71 mm = malloc(sizeof(*mm), DRM_MEM_DRIVER, M_WAITOK);
73 if (drm_ht_create(&mm->offset_hash, 19) != 0) {
74 free(mm, DRM_MEM_DRIVER);
77 mm->idxunr = new_unrhdr(0, DRM_GEM_MAX_IDX, NULL);
82 drm_gem_destroy(struct drm_device *dev)
84 struct drm_gem_mm *mm;
87 dev->mm_private = NULL;
88 drm_ht_remove(&mm->offset_hash);
89 delete_unrhdr(mm->idxunr);
90 free(mm, DRM_MEM_DRIVER);
91 drm_gem_names_fini(&dev->object_names);
95 drm_gem_object_init(struct drm_device *dev, struct drm_gem_object *obj,
99 KASSERT((size & (PAGE_SIZE - 1)) == 0,
100 ("Bad size %ju", (uintmax_t)size));
103 obj->vm_obj = vm_pager_allocate(OBJT_DEFAULT, NULL, size,
104 VM_PROT_READ | VM_PROT_WRITE, 0, curthread->td_ucred);
107 obj->handle_count = 0;
114 drm_gem_private_object_init(struct drm_device *dev, struct drm_gem_object *obj,
118 MPASS((size & (PAGE_SIZE - 1)) == 0);
124 atomic_store_rel_int(&obj->handle_count, 0);
131 struct drm_gem_object *
132 drm_gem_object_alloc(struct drm_device *dev, size_t size)
134 struct drm_gem_object *obj;
136 obj = malloc(sizeof(*obj), DRM_MEM_DRIVER, M_WAITOK | M_ZERO);
137 if (drm_gem_object_init(dev, obj, size) != 0)
140 if (dev->driver->gem_init_object != NULL &&
141 dev->driver->gem_init_object(obj) != 0)
145 vm_object_deallocate(obj->vm_obj);
147 free(obj, DRM_MEM_DRIVER);
152 drm_gem_object_free(struct drm_gem_object *obj)
154 struct drm_device *dev;
157 DRM_LOCK_ASSERT(dev);
158 if (dev->driver->gem_free_object != NULL)
159 dev->driver->gem_free_object(obj);
163 drm_gem_object_reference(struct drm_gem_object *obj)
166 KASSERT(obj->refcount > 0, ("Dangling obj %p", obj));
167 refcount_acquire(&obj->refcount);
171 drm_gem_object_unreference(struct drm_gem_object *obj)
176 if (refcount_release(&obj->refcount))
177 drm_gem_object_free(obj);
181 drm_gem_object_unreference_unlocked(struct drm_gem_object *obj)
183 struct drm_device *dev;
189 drm_gem_object_unreference(obj);
194 drm_gem_object_handle_reference(struct drm_gem_object *obj)
197 drm_gem_object_reference(obj);
198 atomic_add_rel_int(&obj->handle_count, 1);
202 drm_gem_object_handle_free(struct drm_gem_object *obj)
204 struct drm_device *dev;
205 struct drm_gem_object *obj1;
208 if (obj->name != 0) {
209 obj1 = drm_gem_names_remove(&dev->object_names, obj->name);
211 drm_gem_object_unreference(obj1);
216 drm_gem_object_handle_unreference(struct drm_gem_object *obj)
220 atomic_load_acq_int(&obj->handle_count) == 0)
223 if (atomic_fetchadd_int(&obj->handle_count, -1) == 1)
224 drm_gem_object_handle_free(obj);
225 drm_gem_object_unreference(obj);
229 drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj)
233 atomic_load_acq_int(&obj->handle_count) == 0)
236 if (atomic_fetchadd_int(&obj->handle_count, -1) == 1)
237 drm_gem_object_handle_free(obj);
238 drm_gem_object_unreference_unlocked(obj);
242 drm_gem_handle_create(struct drm_file *file_priv, struct drm_gem_object *obj,
245 struct drm_device *dev = obj->dev;
248 ret = drm_gem_name_create(&file_priv->object_names, obj, handle);
251 drm_gem_object_handle_reference(obj);
253 if (dev->driver->gem_open_object) {
254 ret = dev->driver->gem_open_object(obj, file_priv);
256 drm_gem_handle_delete(file_priv, *handle);
265 drm_gem_handle_delete(struct drm_file *file_priv, uint32_t handle)
267 struct drm_device *dev;
268 struct drm_gem_object *obj;
270 obj = drm_gem_names_remove(&file_priv->object_names, handle);
275 if (dev->driver->gem_close_object)
276 dev->driver->gem_close_object(obj, file_priv);
277 drm_gem_object_handle_unreference_unlocked(obj);
283 drm_gem_object_release(struct drm_gem_object *obj)
287 * obj->vm_obj can be NULL for private gem objects.
289 vm_object_deallocate(obj->vm_obj);
293 drm_gem_open_ioctl(struct drm_device *dev, void *data,
294 struct drm_file *file_priv)
296 struct drm_gem_open *args;
297 struct drm_gem_object *obj;
301 if (!drm_core_check_feature(dev, DRIVER_GEM))
305 obj = drm_gem_name_ref(&dev->object_names, args->name,
306 (void (*)(void *))drm_gem_object_reference);
310 ret = drm_gem_handle_create(file_priv, obj, &handle);
311 drm_gem_object_unreference_unlocked(obj);
315 args->handle = handle;
316 args->size = obj->size;
322 drm_gem_open(struct drm_device *dev, struct drm_file *file_priv)
325 drm_gem_names_init(&file_priv->object_names);
329 drm_gem_object_release_handle(uint32_t name, void *ptr, void *arg)
331 struct drm_file *file_priv;
332 struct drm_gem_object *obj;
333 struct drm_device *dev;
339 if (dev->driver->gem_close_object)
340 dev->driver->gem_close_object(obj, file_priv);
342 drm_gem_object_handle_unreference(obj);
347 drm_gem_release(struct drm_device *dev, struct drm_file *file_priv)
350 drm_gem_names_foreach(&file_priv->object_names,
351 drm_gem_object_release_handle, file_priv);
352 drm_gem_names_fini(&file_priv->object_names);
356 drm_gem_close_ioctl(struct drm_device *dev, void *data,
357 struct drm_file *file_priv)
359 struct drm_gem_close *args;
361 if (!drm_core_check_feature(dev, DRIVER_GEM))
365 return (drm_gem_handle_delete(file_priv, args->handle));
369 drm_gem_flink_ioctl(struct drm_device *dev, void *data,
370 struct drm_file *file_priv)
372 struct drm_gem_flink *args;
373 struct drm_gem_object *obj;
376 if (!drm_core_check_feature(dev, DRIVER_GEM))
380 obj = drm_gem_name_ref(&file_priv->object_names, args->handle,
381 (void (*)(void *))drm_gem_object_reference);
384 error = drm_gem_name_create(&dev->object_names, obj, &obj->name);
386 if (error == EALREADY)
388 drm_gem_object_unreference_unlocked(obj);
391 args->name = obj->name;
395 struct drm_gem_object *
396 drm_gem_object_lookup(struct drm_device *dev, struct drm_file *file_priv,
399 struct drm_gem_object *obj;
401 obj = drm_gem_name_ref(&file_priv->object_names, handle,
402 (void (*)(void *))drm_gem_object_reference);
406 static struct drm_gem_object *
407 drm_gem_object_from_offset(struct drm_device *dev, vm_ooffset_t offset)
409 struct drm_gem_object *obj;
410 struct drm_gem_mm *mm;
411 struct drm_hash_item *map_list;
413 if ((offset & DRM_GEM_MAPPING_MASK) != DRM_GEM_MAPPING_KEY)
415 offset &= ~DRM_GEM_MAPPING_KEY;
416 mm = dev->mm_private;
417 if (drm_ht_find_item(&mm->offset_hash, DRM_GEM_MAPPING_IDX(offset),
419 DRM_DEBUG("drm_gem_object_from_offset: offset 0x%jx obj not found\n",
423 obj = __containerof(map_list, struct drm_gem_object, map_list);
428 drm_gem_create_mmap_offset(struct drm_gem_object *obj)
430 struct drm_device *dev;
431 struct drm_gem_mm *mm;
437 mm = dev->mm_private;
440 obj->map_list.key = alloc_unr(mm->idxunr);
441 ret = drm_ht_insert_item(&mm->offset_hash, &obj->map_list);
443 DRM_ERROR("failed to add to map hash\n");
444 free_unr(mm->idxunr, obj->map_list.key);
452 drm_gem_free_mmap_offset(struct drm_gem_object *obj)
454 struct drm_hash_item *list;
455 struct drm_gem_mm *mm;
459 mm = obj->dev->mm_private;
460 list = &obj->map_list;
462 drm_ht_remove_item(&mm->offset_hash, list);
463 free_unr(mm->idxunr, list->key);
468 drm_gem_mmap_single(struct drm_device *dev, vm_ooffset_t *offset, vm_size_t size,
469 struct vm_object **obj_res, int nprot)
471 struct drm_gem_object *gem_obj;
472 struct vm_object *vm_obj;
475 gem_obj = drm_gem_object_from_offset(dev, *offset);
476 if (gem_obj == NULL) {
480 drm_gem_object_reference(gem_obj);
482 vm_obj = cdev_pager_allocate(gem_obj, OBJT_MGTDEVICE,
483 dev->driver->gem_pager_ops, size, nprot,
484 DRM_GEM_MAPPING_MAPOFF(*offset), curthread->td_ucred);
485 if (vm_obj == NULL) {
486 drm_gem_object_unreference_unlocked(gem_obj);
489 *offset = DRM_GEM_MAPPING_MAPOFF(*offset);
495 drm_gem_pager_dtr(void *handle)
497 struct drm_gem_object *obj;
498 struct drm_device *dev;
504 drm_gem_free_mmap_offset(obj);
505 drm_gem_object_unreference(obj);