1 /* -*- mode: C; c-file-style: "k&r"; tab-width 4; indent-tabs-mode: t; -*- */
4 * Copyright (C) 2011 Texas Instruments, Inc
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice (including the next
14 * paragraph) shall be included in all copies or substantial portions of the
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
26 * Rob Clark <rob@ti.com>
30 #include <linux/stddef.h>
31 #include <linux/types.h>
38 #include <libdrm_macros.h>
40 #include <xf86atomic.h>
43 #include "omap_drmif.h"
45 #define __round_mask(x, y) ((__typeof__(x))((y)-1))
46 #define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
47 #define PAGE_SIZE 4096
49 static pthread_mutex_t table_lock = PTHREAD_MUTEX_INITIALIZER;
50 static void * dev_table;
56 /* The handle_table is used to track GEM bo handles associated w/
57 * this fd. This is needed, in particular, when importing
58 * dmabuf's because we don't want multiple 'struct omap_bo's
59 * floating around with the same handle. Otherwise, when the
60 * first one is omap_bo_del()'d the handle becomes no longer
61 * valid, and the remaining 'struct omap_bo's are left pointing
62 * to an invalid handle (and possible a GEM bo that is already
68 /* a GEM buffer object allocated from the DRM device */
70 struct omap_device *dev;
71 void *map; /* userspace mmap'ing (if there is one) */
74 uint32_t name; /* flink global handle (DRI2 name) */
75 uint64_t offset; /* offset to mmap() */
76 int fd; /* dmabuf handle */
80 static struct omap_device * omap_device_new_impl(int fd)
82 struct omap_device *dev = calloc(sizeof(*dev), 1);
86 atomic_set(&dev->refcnt, 1);
87 dev->handle_table = drmHashCreate();
91 drm_public struct omap_device * omap_device_new(int fd)
93 struct omap_device *dev = NULL;
95 pthread_mutex_lock(&table_lock);
98 dev_table = drmHashCreate();
100 if (drmHashLookup(dev_table, fd, (void **)&dev)) {
101 /* not found, create new device */
102 dev = omap_device_new_impl(fd);
103 drmHashInsert(dev_table, fd, dev);
105 /* found, just incr refcnt */
106 dev = omap_device_ref(dev);
109 pthread_mutex_unlock(&table_lock);
114 drm_public struct omap_device * omap_device_ref(struct omap_device *dev)
116 atomic_inc(&dev->refcnt);
120 drm_public void omap_device_del(struct omap_device *dev)
122 if (!atomic_dec_and_test(&dev->refcnt))
124 pthread_mutex_lock(&table_lock);
125 drmHashDestroy(dev->handle_table);
126 drmHashDelete(dev_table, dev->fd);
127 pthread_mutex_unlock(&table_lock);
132 omap_get_param(struct omap_device *dev, uint64_t param, uint64_t *value)
134 struct drm_omap_param req = {
139 ret = drmCommandWriteRead(dev->fd, DRM_OMAP_GET_PARAM, &req, sizeof(req));
150 omap_set_param(struct omap_device *dev, uint64_t param, uint64_t value)
152 struct drm_omap_param req = {
156 return drmCommandWrite(dev->fd, DRM_OMAP_SET_PARAM, &req, sizeof(req));
159 /* lookup a buffer from it's handle, call w/ table_lock held: */
160 static struct omap_bo * lookup_bo(struct omap_device *dev,
163 struct omap_bo *bo = NULL;
164 if (!drmHashLookup(dev->handle_table, handle, (void **)&bo)) {
165 /* found, incr refcnt and return: */
166 bo = omap_bo_ref(bo);
171 /* allocate a new buffer object, call w/ table_lock held */
172 static struct omap_bo * bo_from_handle(struct omap_device *dev,
175 struct omap_bo *bo = calloc(sizeof(*bo), 1);
177 struct drm_gem_close req = {
180 drmIoctl(dev->fd, DRM_IOCTL_GEM_CLOSE, &req);
183 bo->dev = omap_device_ref(dev);
186 atomic_set(&bo->refcnt, 1);
187 /* add ourselves to the handle table: */
188 drmHashInsert(dev->handle_table, handle, bo);
192 /* allocate a new buffer object */
193 static struct omap_bo * omap_bo_new_impl(struct omap_device *dev,
194 union omap_gem_size size, uint32_t flags)
196 struct omap_bo *bo = NULL;
197 struct drm_omap_gem_new req = {
202 if (size.bytes == 0) {
206 if (drmCommandWriteRead(dev->fd, DRM_OMAP_GEM_NEW, &req, sizeof(req))) {
210 pthread_mutex_lock(&table_lock);
211 bo = bo_from_handle(dev, req.handle);
212 pthread_mutex_unlock(&table_lock);
214 if (flags & OMAP_BO_TILED) {
215 bo->size = round_up(size.tiled.width, PAGE_SIZE) * size.tiled.height;
217 bo->size = size.bytes;
228 /* allocate a new (un-tiled) buffer object */
229 drm_public struct omap_bo *
230 omap_bo_new(struct omap_device *dev, uint32_t size, uint32_t flags)
232 union omap_gem_size gsize = {
235 if (flags & OMAP_BO_TILED) {
238 return omap_bo_new_impl(dev, gsize, flags);
241 /* allocate a new buffer object */
242 drm_public struct omap_bo *
243 omap_bo_new_tiled(struct omap_device *dev, uint32_t width,
244 uint32_t height, uint32_t flags)
246 union omap_gem_size gsize = {
252 if (!(flags & OMAP_BO_TILED)) {
255 return omap_bo_new_impl(dev, gsize, flags);
258 drm_public struct omap_bo *omap_bo_ref(struct omap_bo *bo)
260 atomic_inc(&bo->refcnt);
264 /* get buffer info */
265 static int get_buffer_info(struct omap_bo *bo)
267 struct drm_omap_gem_info req = {
268 .handle = bo->handle,
270 int ret = drmCommandWriteRead(bo->dev->fd, DRM_OMAP_GEM_INFO,
276 /* really all we need for now is mmap offset */
277 bo->offset = req.offset;
283 /* import a buffer object from DRI2 name */
284 drm_public struct omap_bo *
285 omap_bo_from_name(struct omap_device *dev, uint32_t name)
287 struct omap_bo *bo = NULL;
288 struct drm_gem_open req = {
292 pthread_mutex_lock(&table_lock);
294 if (drmIoctl(dev->fd, DRM_IOCTL_GEM_OPEN, &req)) {
298 bo = lookup_bo(dev, req.handle);
300 bo = bo_from_handle(dev, req.handle);
304 pthread_mutex_unlock(&table_lock);
309 pthread_mutex_unlock(&table_lock);
314 /* import a buffer from dmabuf fd, does not take ownership of the
315 * fd so caller should close() the fd when it is otherwise done
316 * with it (even if it is still using the 'struct omap_bo *')
318 drm_public struct omap_bo *
319 omap_bo_from_dmabuf(struct omap_device *dev, int fd)
321 struct omap_bo *bo = NULL;
322 struct drm_prime_handle req = {
327 pthread_mutex_lock(&table_lock);
329 ret = drmIoctl(dev->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &req);
334 bo = lookup_bo(dev, req.handle);
336 bo = bo_from_handle(dev, req.handle);
339 pthread_mutex_unlock(&table_lock);
344 pthread_mutex_unlock(&table_lock);
349 /* destroy a buffer object */
350 drm_public void omap_bo_del(struct omap_bo *bo)
356 if (!atomic_dec_and_test(&bo->refcnt))
360 munmap(bo->map, bo->size);
368 struct drm_gem_close req = {
369 .handle = bo->handle,
371 pthread_mutex_lock(&table_lock);
372 drmHashDelete(bo->dev->handle_table, bo->handle);
373 drmIoctl(bo->dev->fd, DRM_IOCTL_GEM_CLOSE, &req);
374 pthread_mutex_unlock(&table_lock);
377 omap_device_del(bo->dev);
382 /* get the global flink/DRI2 buffer name */
383 drm_public int omap_bo_get_name(struct omap_bo *bo, uint32_t *name)
386 struct drm_gem_flink req = {
387 .handle = bo->handle,
391 ret = drmIoctl(bo->dev->fd, DRM_IOCTL_GEM_FLINK, &req);
404 drm_public uint32_t omap_bo_handle(struct omap_bo *bo)
409 /* caller owns the dmabuf fd that is returned and is responsible
410 * to close() it when done
412 drm_public int omap_bo_dmabuf(struct omap_bo *bo)
415 struct drm_prime_handle req = {
416 .handle = bo->handle,
417 .flags = DRM_CLOEXEC | DRM_RDWR,
421 ret = drmIoctl(bo->dev->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &req);
431 drm_public uint32_t omap_bo_size(struct omap_bo *bo)
439 drm_public void *omap_bo_map(struct omap_bo *bo)
446 bo->map = mmap(0, bo->size, PROT_READ | PROT_WRITE,
447 MAP_SHARED, bo->dev->fd, bo->offset);
448 if (bo->map == MAP_FAILED) {
455 drm_public int omap_bo_cpu_prep(struct omap_bo *bo, enum omap_gem_op op)
457 struct drm_omap_gem_cpu_prep req = {
458 .handle = bo->handle,
461 return drmCommandWrite(bo->dev->fd,
462 DRM_OMAP_GEM_CPU_PREP, &req, sizeof(req));
465 drm_public int omap_bo_cpu_fini(struct omap_bo *bo, enum omap_gem_op op)
467 struct drm_omap_gem_cpu_fini req = {
468 .handle = bo->handle,
472 return drmCommandWrite(bo->dev->fd,
473 DRM_OMAP_GEM_CPU_FINI, &req, sizeof(req));