omap/omap_drm.c

   1 /* -*- mode: C; c-file-style: "k&r"; tab-width 4; indent-tabs-mode: t; -*- */
   2
   3 /*
   4  * Copyright (C) 2011 Texas Instruments, Inc
   5  *
   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:
  12  *
  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
  15  * Software.
  16  *
  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
  23  * SOFTWARE.
  24  *
  25  * Authors:
  26  *    Rob Clark <rob@ti.com>
  27  */
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include <stdlib.h>
  34 #include <linux/stddef.h>
  35 #include <linux/types.h>
  36 #include <errno.h>
  37 #include <sys/mman.h>
  38 #include <fcntl.h>
  39 #include <unistd.h>
  40 #include <pthread.h>
  41
  42 #include <xf86drm.h>
  43 #include <xf86atomic.h>
  44
  45 #include "omap_drm.h"
  46 #include "omap_drmif.h"
  47
  48 #define __round_mask(x, y) ((__typeof__(x))((y)-1))
  49 #define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
  50 #define PAGE_SIZE 4096
  51
  52 static pthread_mutex_t table_lock = PTHREAD_MUTEX_INITIALIZER;
  53 static void * dev_table;
  54
  55 struct omap_device {
  56         int fd;
  57         atomic_t refcnt;
  58
  59         /* The handle_table is used to track GEM bo handles associated w/
  60          * this fd.  This is needed, in particular, when importing
  61          * dmabuf's because we don't want multiple 'struct omap_bo's
  62          * floating around with the same handle.  Otherwise, when the
  63          * first one is omap_bo_del()'d the handle becomes no longer
  64          * valid, and the remaining 'struct omap_bo's are left pointing
  65          * to an invalid handle (and possible a GEM bo that is already
  66          * free'd).
  67          */
  68         void *handle_table;
  69 };
  70
  71 /* a GEM buffer object allocated from the DRM device */
  72 struct omap_bo {
  73         struct omap_device      *dev;
  74         void            *map;           /* userspace mmap'ing (if there is one) */
  75         uint32_t        size;
  76         uint32_t        handle;
  77         uint32_t        name;           /* flink global handle (DRI2 name) */
  78         uint64_t        offset;         /* offset to mmap() */
  79         int             fd;             /* dmabuf handle */
  80         atomic_t        refcnt;
  81 };
  82
  83 static struct omap_device * omap_device_new_impl(int fd)
  84 {
  85         struct omap_device *dev = calloc(sizeof(*dev), 1);
  86         if (!dev)
  87                 return NULL;
  88         dev->fd = fd;
  89         atomic_set(&dev->refcnt, 1);
  90         dev->handle_table = drmHashCreate();
  91         return dev;
  92 }
  93
  94 struct omap_device * omap_device_new(int fd)
  95 {
  96         struct omap_device *dev = NULL;
  97
  98         pthread_mutex_lock(&table_lock);
  99
 100         if (!dev_table)
 101                 dev_table = drmHashCreate();
 102
 103         if (drmHashLookup(dev_table, fd, (void **)&dev)) {
 104                 /* not found, create new device */
 105                 dev = omap_device_new_impl(fd);
 106                 drmHashInsert(dev_table, fd, dev);
 107         } else {
 108                 /* found, just incr refcnt */
 109                 dev = omap_device_ref(dev);
 110         }
 111
 112         pthread_mutex_unlock(&table_lock);
 113
 114         return dev;
 115 }
 116
 117 struct omap_device * omap_device_ref(struct omap_device *dev)
 118 {
 119         atomic_inc(&dev->refcnt);
 120         return dev;
 121 }
 122
 123 void omap_device_del(struct omap_device *dev)
 124 {
 125         if (!atomic_dec_and_test(&dev->refcnt))
 126                 return;
 127         pthread_mutex_lock(&table_lock);
 128         drmHashDestroy(dev->handle_table);
 129         drmHashDelete(dev_table, dev->fd);
 130         pthread_mutex_unlock(&table_lock);
 131         free(dev);
 132 }
 133
 134 int omap_get_param(struct omap_device *dev, uint64_t param, uint64_t *value)
 135 {
 136         struct drm_omap_param req = {
 137                         .param = param,
 138         };
 139         int ret;
 140
 141         ret = drmCommandWriteRead(dev->fd, DRM_OMAP_GET_PARAM, &req, sizeof(req));
 142         if (ret) {
 143                 return ret;
 144         }
 145
 146         *value = req.value;
 147
 148         return 0;
 149 }
 150
 151 int omap_set_param(struct omap_device *dev, uint64_t param, uint64_t value)
 152 {
 153         struct drm_omap_param req = {
 154                         .param = param,
 155                         .value = value,
 156         };
 157         return drmCommandWrite(dev->fd, DRM_OMAP_SET_PARAM, &req, sizeof(req));
 158 }
 159
 160 /* lookup a buffer from it's handle, call w/ table_lock held: */
 161 static struct omap_bo * lookup_bo(struct omap_device *dev,
 162                 uint32_t handle)
 163 {
 164         struct omap_bo *bo = NULL;
 165         if (!drmHashLookup(dev->handle_table, handle, (void **)&bo)) {
 166                 /* found, incr refcnt and return: */
 167                 bo = omap_bo_ref(bo);
 168         }
 169         return bo;
 170 }
 171
 172 /* allocate a new buffer object, call w/ table_lock held */
 173 static struct omap_bo * bo_from_handle(struct omap_device *dev,
 174                 uint32_t handle)
 175 {
 176         struct omap_bo *bo = calloc(sizeof(*bo), 1);
 177         if (!bo) {
 178                 struct drm_gem_close req = {
 179                                 .handle = handle,
 180                 };
 181                 drmIoctl(dev->fd, DRM_IOCTL_GEM_CLOSE, &req);
 182                 return NULL;
 183         }
 184         bo->dev = omap_device_ref(dev);
 185         bo->handle = handle;
 186         atomic_set(&bo->refcnt, 1);
 187         /* add ourselves to the handle table: */
 188         drmHashInsert(dev->handle_table, handle, bo);
 189         return bo;
 190 }
 191
 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)
 195 {
 196         struct omap_bo *bo = NULL;
 197         struct drm_omap_gem_new req = {
 198                         .size = size,
 199                         .flags = flags,
 200         };
 201
 202         if (size.bytes == 0) {
 203                 goto fail;
 204         }
 205
 206         if (drmCommandWriteRead(dev->fd, DRM_OMAP_GEM_NEW, &req, sizeof(req))) {
 207                 goto fail;
 208         }
 209
 210         pthread_mutex_lock(&table_lock);
 211         bo = bo_from_handle(dev, req.handle);
 212         pthread_mutex_unlock(&table_lock);
 213
 214         if (flags & OMAP_BO_TILED) {
 215                 bo->size = round_up(size.tiled.width, PAGE_SIZE) * size.tiled.height;
 216         } else {
 217                 bo->size = size.bytes;
 218         }
 219
 220         return bo;
 221
 222 fail:
 223         free(bo);
 224         return NULL;
 225 }
 226
 227
 228 /* allocate a new (un-tiled) buffer object */
 229 struct omap_bo * omap_bo_new(struct omap_device *dev,
 230                 uint32_t size, uint32_t flags)
 231 {
 232         union omap_gem_size gsize = {
 233                         .bytes = size,
 234         };
 235         if (flags & OMAP_BO_TILED) {
 236                 return NULL;
 237         }
 238         return omap_bo_new_impl(dev, gsize, flags);
 239 }
 240
 241 /* allocate a new buffer object */
 242 struct omap_bo * omap_bo_new_tiled(struct omap_device *dev,
 243                 uint32_t width, uint32_t height, uint32_t flags)
 244 {
 245         union omap_gem_size gsize = {
 246                         .tiled = {
 247                                 .width = width,
 248                                 .height = height,
 249                         },
 250         };
 251         if (!(flags & OMAP_BO_TILED)) {
 252                 return NULL;
 253         }
 254         return omap_bo_new_impl(dev, gsize, flags);
 255 }
 256
 257 struct omap_bo * omap_bo_ref(struct omap_bo *bo)
 258 {
 259         atomic_inc(&bo->refcnt);
 260         return bo;
 261 }
 262
 263 /* get buffer info */
 264 static int get_buffer_info(struct omap_bo *bo)
 265 {
 266         struct drm_omap_gem_info req = {
 267                         .handle = bo->handle,
 268         };
 269         int ret = drmCommandWriteRead(bo->dev->fd, DRM_OMAP_GEM_INFO,
 270                         &req, sizeof(req));
 271         if (ret) {
 272                 return ret;
 273         }
 274
 275         /* really all we need for now is mmap offset */
 276         bo->offset = req.offset;
 277         bo->size = req.size;
 278
 279         return 0;
 280 }
 281
 282 /* import a buffer object from DRI2 name */
 283 struct omap_bo * omap_bo_from_name(struct omap_device *dev, uint32_t name)
 284 {
 285         struct omap_bo *bo = NULL;
 286         struct drm_gem_open req = {
 287                         .name = name,
 288         };
 289
 290         pthread_mutex_lock(&table_lock);
 291
 292         if (drmIoctl(dev->fd, DRM_IOCTL_GEM_OPEN, &req)) {
 293                 goto fail;
 294         }
 295
 296         bo = lookup_bo(dev, req.handle);
 297         if (!bo) {
 298                 bo = bo_from_handle(dev, req.handle);
 299                 bo->name = name;
 300         }
 301
 302         pthread_mutex_unlock(&table_lock);
 303
 304         return bo;
 305
 306 fail:
 307         free(bo);
 308         return NULL;
 309 }
 310
 311 /* import a buffer from dmabuf fd, does not take ownership of the
 312  * fd so caller should close() the fd when it is otherwise done
 313  * with it (even if it is still using the 'struct omap_bo *')
 314  */
 315 struct omap_bo * omap_bo_from_dmabuf(struct omap_device *dev, int fd)
 316 {
 317         struct omap_bo *bo = NULL;
 318         struct drm_prime_handle req = {
 319                         .fd = fd,
 320         };
 321         int ret;
 322
 323         pthread_mutex_lock(&table_lock);
 324
 325         ret = drmIoctl(dev->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &req);
 326         if (ret) {
 327                 goto fail;
 328         }
 329
 330         bo = lookup_bo(dev, req.handle);
 331         if (!bo) {
 332                 bo = bo_from_handle(dev, req.handle);
 333         }
 334
 335         pthread_mutex_unlock(&table_lock);
 336
 337         return bo;
 338
 339 fail:
 340         free(bo);
 341         return NULL;
 342 }
 343
 344 /* destroy a buffer object */
 345 void omap_bo_del(struct omap_bo *bo)
 346 {
 347         if (!bo) {
 348                 return;
 349         }
 350
 351         if (!atomic_dec_and_test(&bo->refcnt))
 352                 return;
 353
 354         if (bo->map) {
 355                 munmap(bo->map, bo->size);
 356         }
 357
 358         if (bo->fd) {
 359                 close(bo->fd);
 360         }
 361
 362         if (bo->handle) {
 363                 struct drm_gem_close req = {
 364                                 .handle = bo->handle,
 365                 };
 366                 pthread_mutex_lock(&table_lock);
 367                 drmHashDelete(bo->dev->handle_table, bo->handle);
 368                 drmIoctl(bo->dev->fd, DRM_IOCTL_GEM_CLOSE, &req);
 369                 pthread_mutex_unlock(&table_lock);
 370         }
 371
 372         omap_device_del(bo->dev);
 373
 374         free(bo);
 375 }
 376
 377 /* get the global flink/DRI2 buffer name */
 378 int omap_bo_get_name(struct omap_bo *bo, uint32_t *name)
 379 {
 380         if (!bo->name) {
 381                 struct drm_gem_flink req = {
 382                                 .handle = bo->handle,
 383                 };
 384                 int ret;
 385
 386                 ret = drmIoctl(bo->dev->fd, DRM_IOCTL_GEM_FLINK, &req);
 387                 if (ret) {
 388                         return ret;
 389                 }
 390
 391                 bo->name = req.name;
 392         }
 393
 394         *name = bo->name;
 395
 396         return 0;
 397 }
 398
 399 uint32_t omap_bo_handle(struct omap_bo *bo)
 400 {
 401         return bo->handle;
 402 }
 403
 404 /* caller owns the dmabuf fd that is returned and is responsible
 405  * to close() it when done
 406  */
 407 int omap_bo_dmabuf(struct omap_bo *bo)
 408 {
 409         if (!bo->fd) {
 410                 struct drm_prime_handle req = {
 411                                 .handle = bo->handle,
 412                                 .flags = DRM_CLOEXEC,
 413                 };
 414                 int ret;
 415
 416                 ret = drmIoctl(bo->dev->fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &req);
 417                 if (ret) {
 418                         return ret;
 419                 }
 420
 421                 bo->fd = req.fd;
 422         }
 423         return dup(bo->fd);
 424 }
 425
 426 uint32_t omap_bo_size(struct omap_bo *bo)
 427 {
 428         if (!bo->size) {
 429                 get_buffer_info(bo);
 430         }
 431         return bo->size;
 432 }
 433
 434 void * omap_bo_map(struct omap_bo *bo)
 435 {
 436         if (!bo->map) {
 437                 if (!bo->offset) {
 438                         get_buffer_info(bo);
 439                 }
 440
 441                 bo->map = mmap(0, bo->size, PROT_READ | PROT_WRITE,
 442                                 MAP_SHARED, bo->dev->fd, bo->offset);
 443                 if (bo->map == MAP_FAILED) {
 444                         bo->map = NULL;
 445                 }
 446         }
 447         return bo->map;
 448 }
 449
 450 int omap_bo_cpu_prep(struct omap_bo *bo, enum omap_gem_op op)
 451 {
 452         struct drm_omap_gem_cpu_prep req = {
 453                         .handle = bo->handle,
 454                         .op = op,
 455         };
 456         return drmCommandWrite(bo->dev->fd,
 457                         DRM_OMAP_GEM_CPU_PREP, &req, sizeof(req));
 458 }
 459
 460 int omap_bo_cpu_fini(struct omap_bo *bo, enum omap_gem_op op)
 461 {
 462         struct drm_omap_gem_cpu_fini req = {
 463                         .handle = bo->handle,
 464                         .op = op,
 465                         .nregions = 0,
 466         };
 467         return drmCommandWrite(bo->dev->fd,
 468                         DRM_OMAP_GEM_CPU_FINI, &req, sizeof(req));
 469 }