sys/dev/drm/drm_prime.c

   1 /*
   2  * Copyright © 2012 Red Hat
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *      Dave Airlie <airlied@redhat.com>
  25  *      Rob Clark <rob.clark@linaro.org>
  26  *
  27  */
  28
  29 #include <linux/export.h>
  30 #include <linux/dma-buf.h>
  31 #include <drm/drmP.h>
  32 #include <drm/drm_gem.h>
  33
  34 #include "drm_internal.h"
  35
  36 /*
  37  * DMA-BUF/GEM Object references and lifetime overview:
  38  *
  39  * On the export the dma_buf holds a reference to the exporting GEM
  40  * object. It takes this reference in handle_to_fd_ioctl, when it
  41  * first calls .prime_export and stores the exporting GEM object in
  42  * the dma_buf priv. This reference is released when the dma_buf
  43  * object goes away in the driver .release function.
  44  *
  45  * On the import the importing GEM object holds a reference to the
  46  * dma_buf (which in turn holds a ref to the exporting GEM object).
  47  * It takes that reference in the fd_to_handle ioctl.
  48  * It calls dma_buf_get, creates an attachment to it and stores the
  49  * attachment in the GEM object. When this attachment is destroyed
  50  * when the imported object is destroyed, we remove the attachment
  51  * and drop the reference to the dma_buf.
  52  *
  53  * Thus the chain of references always flows in one direction
  54  * (avoiding loops): importing_gem -> dmabuf -> exporting_gem
  55  *
  56  * Self-importing: if userspace is using PRIME as a replacement for flink
  57  * then it will get a fd->handle request for a GEM object that it created.
  58  * Drivers should detect this situation and return back the gem object
  59  * from the dma-buf private.  Prime will do this automatically for drivers that
  60  * use the drm_gem_prime_{import,export} helpers.
  61  */
  62
  63 struct drm_prime_member {
  64         struct list_head entry;
  65         struct dma_buf *dma_buf;
  66         uint32_t handle;
  67 };
  68
  69 struct drm_prime_attachment {
  70         struct sg_table *sgt;
  71         enum dma_data_direction dir;
  72 };
  73
  74 #if 0
  75 static int drm_prime_add_buf_handle(struct drm_prime_file_private *prime_fpriv,
  76                                     struct dma_buf *dma_buf, uint32_t handle)
  77 {
  78         struct drm_prime_member *member;
  79
  80         member = kmalloc(sizeof(*member), GFP_KERNEL);
  81         if (!member)
  82                 return -ENOMEM;
  83
  84         get_dma_buf(dma_buf);
  85         member->dma_buf = dma_buf;
  86         member->handle = handle;
  87         list_add(&member->entry, &prime_fpriv->head);
  88         return 0;
  89 }
  90
  91 static struct dma_buf *drm_prime_lookup_buf_by_handle(struct drm_prime_file_private *prime_fpriv,
  92                                                       uint32_t handle)
  93 {
  94         struct drm_prime_member *member;
  95
  96         list_for_each_entry(member, &prime_fpriv->head, entry) {
  97                 if (member->handle == handle)
  98                         return member->dma_buf;
  99         }
 100
 101         return NULL;
 102 }
 103
 104 static int drm_prime_lookup_buf_handle(struct drm_prime_file_private *prime_fpriv,
 105                                        struct dma_buf *dma_buf,
 106                                        uint32_t *handle)
 107 {
 108         struct drm_prime_member *member;
 109
 110         list_for_each_entry(member, &prime_fpriv->head, entry) {
 111                 if (member->dma_buf == dma_buf) {
 112                         *handle = member->handle;
 113                         return 0;
 114                 }
 115         }
 116         return -ENOENT;
 117 }
 118 #endif
 119
 120 static int drm_gem_map_attach(struct dma_buf *dma_buf,
 121                               struct device *target_dev,
 122                               struct dma_buf_attachment *attach)
 123 {
 124         struct drm_prime_attachment *prime_attach;
 125         struct drm_gem_object *obj = dma_buf->priv;
 126         struct drm_device *dev = obj->dev;
 127
 128         prime_attach = kzalloc(sizeof(*prime_attach), GFP_KERNEL);
 129         if (!prime_attach)
 130                 return -ENOMEM;
 131
 132         prime_attach->dir = DMA_NONE;
 133         attach->priv = prime_attach;
 134
 135         if (!dev->driver->gem_prime_pin)
 136                 return 0;
 137
 138         return dev->driver->gem_prime_pin(obj);
 139 }
 140
 141 static void drm_gem_map_detach(struct dma_buf *dma_buf,
 142                                struct dma_buf_attachment *attach)
 143 {
 144         struct drm_prime_attachment *prime_attach = attach->priv;
 145         struct drm_gem_object *obj = dma_buf->priv;
 146         struct drm_device *dev = obj->dev;
 147         struct sg_table *sgt;
 148
 149         if (dev->driver->gem_prime_unpin)
 150                 dev->driver->gem_prime_unpin(obj);
 151
 152         if (!prime_attach)
 153                 return;
 154
 155         sgt = prime_attach->sgt;
 156         if (sgt) {
 157                 if (prime_attach->dir != DMA_NONE)
 158                         dma_unmap_sg(attach->dev, sgt->sgl, sgt->nents,
 159                                         prime_attach->dir);
 160                 sg_free_table(sgt);
 161         }
 162
 163         kfree(sgt);
 164         kfree(prime_attach);
 165         attach->priv = NULL;
 166 }
 167
 168 #if 0
 169 void drm_prime_remove_buf_handle_locked(struct drm_prime_file_private *prime_fpriv,
 170                                         struct dma_buf *dma_buf)
 171 {
 172         struct drm_prime_member *member, *safe;
 173
 174         list_for_each_entry_safe(member, safe, &prime_fpriv->head, entry) {
 175                 if (member->dma_buf == dma_buf) {
 176                         dma_buf_put(dma_buf);
 177                         list_del(&member->entry);
 178                         kfree(member);
 179                 }
 180         }
 181 }
 182 #endif
 183
 184 static struct sg_table *drm_gem_map_dma_buf(struct dma_buf_attachment *attach,
 185                                             enum dma_data_direction dir)
 186 {
 187         struct drm_prime_attachment *prime_attach = attach->priv;
 188         struct drm_gem_object *obj = attach->dmabuf->priv;
 189         struct sg_table *sgt;
 190
 191         if (WARN_ON(dir == DMA_NONE || !prime_attach))
 192                 return ERR_PTR(-EINVAL);
 193
 194         /* return the cached mapping when possible */
 195         if (prime_attach->dir == dir)
 196                 return prime_attach->sgt;
 197
 198         /*
 199          * two mappings with different directions for the same attachment are
 200          * not allowed
 201          */
 202         if (WARN_ON(prime_attach->dir != DMA_NONE))
 203                 return ERR_PTR(-EBUSY);
 204
 205         sgt = obj->dev->driver->gem_prime_get_sg_table(obj);
 206
 207         if (!IS_ERR(sgt)) {
 208                 if (!dma_map_sg(attach->dev, sgt->sgl, sgt->nents, dir)) {
 209                         sg_free_table(sgt);
 210                         kfree(sgt);
 211                         sgt = ERR_PTR(-ENOMEM);
 212                 } else {
 213                         prime_attach->sgt = sgt;
 214                         prime_attach->dir = dir;
 215                 }
 216         }
 217
 218         return sgt;
 219 }
 220
 221 static void drm_gem_unmap_dma_buf(struct dma_buf_attachment *attach,
 222                                   struct sg_table *sgt,
 223                                   enum dma_data_direction dir)
 224 {
 225         /* nothing to be done here */
 226 }
 227
 228 /**
 229  * drm_gem_dmabuf_release - dma_buf release implementation for GEM
 230  * @dma_buf: buffer to be released
 231  *
 232  * Generic release function for dma_bufs exported as PRIME buffers. GEM drivers
 233  * must use this in their dma_buf ops structure as the release callback.
 234  */
 235 void drm_gem_dmabuf_release(struct dma_buf *dma_buf)
 236 {
 237         struct drm_gem_object *obj = dma_buf->priv;
 238
 239         /* drop the reference on the export fd holds */
 240         drm_gem_object_unreference_unlocked(obj);
 241 }
 242 EXPORT_SYMBOL(drm_gem_dmabuf_release);
 243
 244 static void *drm_gem_dmabuf_vmap(struct dma_buf *dma_buf)
 245 {
 246         struct drm_gem_object *obj = dma_buf->priv;
 247         struct drm_device *dev = obj->dev;
 248
 249         return dev->driver->gem_prime_vmap(obj);
 250 }
 251
 252 static void drm_gem_dmabuf_vunmap(struct dma_buf *dma_buf, void *vaddr)
 253 {
 254         struct drm_gem_object *obj = dma_buf->priv;
 255         struct drm_device *dev = obj->dev;
 256
 257         dev->driver->gem_prime_vunmap(obj, vaddr);
 258 }
 259
 260 static void *drm_gem_dmabuf_kmap_atomic(struct dma_buf *dma_buf,
 261                                         unsigned long page_num)
 262 {
 263         return NULL;
 264 }
 265
 266 static void drm_gem_dmabuf_kunmap_atomic(struct dma_buf *dma_buf,
 267                                          unsigned long page_num, void *addr)
 268 {
 269
 270 }
 271 static void *drm_gem_dmabuf_kmap(struct dma_buf *dma_buf,
 272                                  unsigned long page_num)
 273 {
 274         return NULL;
 275 }
 276
 277 static void drm_gem_dmabuf_kunmap(struct dma_buf *dma_buf,
 278                                   unsigned long page_num, void *addr)
 279 {
 280
 281 }
 282
 283 static int drm_gem_dmabuf_mmap(struct dma_buf *dma_buf,
 284                                struct vm_area_struct *vma)
 285 {
 286         struct drm_gem_object *obj = dma_buf->priv;
 287         struct drm_device *dev = obj->dev;
 288
 289         if (!dev->driver->gem_prime_mmap)
 290                 return -ENOSYS;
 291
 292         return dev->driver->gem_prime_mmap(obj, vma);
 293 }
 294
 295 static const struct dma_buf_ops drm_gem_prime_dmabuf_ops =  {
 296         .attach = drm_gem_map_attach,
 297         .detach = drm_gem_map_detach,
 298         .map_dma_buf = drm_gem_map_dma_buf,
 299         .unmap_dma_buf = drm_gem_unmap_dma_buf,
 300         .release = drm_gem_dmabuf_release,
 301         .kmap = drm_gem_dmabuf_kmap,
 302         .kmap_atomic = drm_gem_dmabuf_kmap_atomic,
 303         .kunmap = drm_gem_dmabuf_kunmap,
 304         .kunmap_atomic = drm_gem_dmabuf_kunmap_atomic,
 305         .mmap = drm_gem_dmabuf_mmap,
 306         .vmap = drm_gem_dmabuf_vmap,
 307         .vunmap = drm_gem_dmabuf_vunmap,
 308 };
 309
 310 /**
 311  * DOC: PRIME Helpers
 312  *
 313  * Drivers can implement @gem_prime_export and @gem_prime_import in terms of
 314  * simpler APIs by using the helper functions @drm_gem_prime_export and
 315  * @drm_gem_prime_import.  These functions implement dma-buf support in terms of
 316  * six lower-level driver callbacks:
 317  *
 318  * Export callbacks:
 319  *
 320  *  * @gem_prime_pin (optional): prepare a GEM object for exporting
 321  *  * @gem_prime_get_sg_table: provide a scatter/gather table of pinned pages
 322  *  * @gem_prime_vmap: vmap a buffer exported by your driver
 323  *  * @gem_prime_vunmap: vunmap a buffer exported by your driver
 324  *  * @gem_prime_mmap (optional): mmap a buffer exported by your driver
 325  *
 326  * Import callback:
 327  *
 328  *  * @gem_prime_import_sg_table (import): produce a GEM object from another
 329  *    driver's scatter/gather table
 330  */
 331
 332 /**
 333  * drm_gem_prime_export - helper library implementation of the export callback
 334  * @dev: drm_device to export from
 335  * @obj: GEM object to export
 336  * @flags: flags like DRM_CLOEXEC and DRM_RDWR
 337  *
 338  * This is the implementation of the gem_prime_export functions for GEM drivers
 339  * using the PRIME helpers.
 340  */
 341 struct dma_buf *drm_gem_prime_export(struct drm_device *dev,
 342                                      struct drm_gem_object *obj, int flags)
 343 {
 344         DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
 345
 346         exp_info.ops = &drm_gem_prime_dmabuf_ops;
 347         exp_info.size = obj->size;
 348         exp_info.flags = flags;
 349         exp_info.priv = obj;
 350
 351         if (dev->driver->gem_prime_res_obj)
 352                 exp_info.resv = dev->driver->gem_prime_res_obj(obj);
 353
 354         return dma_buf_export(&exp_info);
 355 }
 356 EXPORT_SYMBOL(drm_gem_prime_export);
 357
 358 #if 0
 359 static struct dma_buf *export_and_register_object(struct drm_device *dev,
 360                                                   struct drm_gem_object *obj,
 361                                                   uint32_t flags)
 362 {
 363         struct dma_buf *dmabuf;
 364
 365         /* prevent races with concurrent gem_close. */
 366         if (obj->handle_count == 0) {
 367                 dmabuf = ERR_PTR(-ENOENT);
 368                 return dmabuf;
 369         }
 370
 371         dmabuf = dev->driver->gem_prime_export(dev, obj, flags);
 372         if (IS_ERR(dmabuf)) {
 373                 /* normally the created dma-buf takes ownership of the ref,
 374                  * but if that fails then drop the ref
 375                  */
 376                 return dmabuf;
 377         }
 378
 379         /*
 380          * Note that callers do not need to clean up the export cache
 381          * since the check for obj->handle_count guarantees that someone
 382          * will clean it up.
 383          */
 384         obj->dma_buf = dmabuf;
 385         get_dma_buf(obj->dma_buf);
 386         /* Grab a new ref since the callers is now used by the dma-buf */
 387         drm_gem_object_reference(obj);
 388
 389         return dmabuf;
 390 }
 391 #endif
 392
 393 /**
 394  * drm_gem_prime_handle_to_fd - PRIME export function for GEM drivers
 395  * @dev: dev to export the buffer from
 396  * @file_priv: drm file-private structure
 397  * @handle: buffer handle to export
 398  * @flags: flags like DRM_CLOEXEC
 399  * @prime_fd: pointer to storage for the fd id of the create dma-buf
 400  *
 401  * This is the PRIME export function which must be used mandatorily by GEM
 402  * drivers to ensure correct lifetime management of the underlying GEM object.
 403  * The actual exporting from GEM object to a dma-buf is done through the
 404  * gem_prime_export driver callback.
 405  */
 406 int drm_gem_prime_handle_to_fd(struct drm_device *dev,
 407                                struct drm_file *file_priv, uint32_t handle,
 408                                uint32_t flags,
 409                                int *prime_fd)
 410 {
 411 #if 0
 412         struct drm_gem_object *obj;
 413 #endif
 414         int ret = 0;
 415 #if 0
 416         struct dma_buf *dmabuf;
 417
 418         mutex_lock(&file_priv->prime.lock);
 419         obj = drm_gem_object_lookup(file_priv, handle);
 420         if (!obj)  {
 421 #endif
 422                 ret = -ENOENT;
 423 #if 0
 424                 goto out_unlock;
 425         }
 426
 427         dmabuf = drm_prime_lookup_buf_by_handle(&file_priv->prime, handle);
 428         if (dmabuf) {
 429                 get_dma_buf(dmabuf);
 430                 goto out_have_handle;
 431         }
 432
 433         mutex_lock(&dev->object_name_lock);
 434         /* re-export the original imported object */
 435         if (obj->import_attach) {
 436                 dmabuf = obj->import_attach->dmabuf;
 437                 get_dma_buf(dmabuf);
 438                 goto out_have_obj;
 439         }
 440
 441         if (obj->dma_buf) {
 442                 get_dma_buf(obj->dma_buf);
 443                 dmabuf = obj->dma_buf;
 444                 goto out_have_obj;
 445         }
 446
 447         dmabuf = export_and_register_object(dev, obj, flags);
 448         if (IS_ERR(dmabuf)) {
 449                 /* normally the created dma-buf takes ownership of the ref,
 450                  * but if that fails then drop the ref
 451                  */
 452                 ret = PTR_ERR(dmabuf);
 453                 mutex_unlock(&dev->object_name_lock);
 454                 goto out;
 455         }
 456
 457 out_have_obj:
 458         /*
 459          * If we've exported this buffer then cheat and add it to the import list
 460          * so we get the correct handle back. We must do this under the
 461          * protection of dev->object_name_lock to ensure that a racing gem close
 462          * ioctl doesn't miss to remove this buffer handle from the cache.
 463          */
 464         ret = drm_prime_add_buf_handle(&file_priv->prime,
 465                                        dmabuf, handle);
 466         mutex_unlock(&dev->object_name_lock);
 467         if (ret)
 468                 goto fail_put_dmabuf;
 469
 470 out_have_handle:
 471         ret = dma_buf_fd(dmabuf, flags);
 472         /*
 473          * We must _not_ remove the buffer from the handle cache since the newly
 474          * created dma buf is already linked in the global obj->dma_buf pointer,
 475          * and that is invariant as long as a userspace gem handle exists.
 476          * Closing the handle will clean out the cache anyway, so we don't leak.
 477          */
 478         if (ret < 0) {
 479                 goto fail_put_dmabuf;
 480         } else {
 481                 *prime_fd = ret;
 482                 ret = 0;
 483         }
 484
 485         goto out;
 486
 487 fail_put_dmabuf:
 488         dma_buf_put(dmabuf);
 489 out:
 490         drm_gem_object_unreference_unlocked(obj);
 491 out_unlock:
 492         mutex_unlock(&file_priv->prime.lock);
 493 #endif
 494
 495         return ret;
 496 }
 497 EXPORT_SYMBOL(drm_gem_prime_handle_to_fd);
 498
 499 /**
 500  * drm_gem_prime_import - helper library implementation of the import callback
 501  * @dev: drm_device to import into
 502  * @dma_buf: dma-buf object to import
 503  *
 504  * This is the implementation of the gem_prime_import functions for GEM drivers
 505  * using the PRIME helpers.
 506  */
 507 struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev,
 508                                             struct dma_buf *dma_buf)
 509 {
 510 #if 0
 511         struct dma_buf_attachment *attach;
 512         struct sg_table *sgt;
 513         struct drm_gem_object *obj;
 514         int ret;
 515
 516         if (dma_buf->ops == &drm_gem_prime_dmabuf_ops) {
 517                 obj = dma_buf->priv;
 518                 if (obj->dev == dev) {
 519                         /*
 520                          * Importing dmabuf exported from out own gem increases
 521                          * refcount on gem itself instead of f_count of dmabuf.
 522                          */
 523                         drm_gem_object_reference(obj);
 524                         return obj;
 525                 }
 526         }
 527
 528         if (!dev->driver->gem_prime_import_sg_table)
 529 #endif
 530                 return ERR_PTR(-EINVAL);
 531
 532 #if 0
 533         attach = dma_buf_attach(dma_buf, dev->dev);
 534         if (IS_ERR(attach))
 535                 return ERR_CAST(attach);
 536
 537         get_dma_buf(dma_buf);
 538
 539         sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
 540         if (IS_ERR(sgt)) {
 541                 ret = PTR_ERR(sgt);
 542                 goto fail_detach;
 543         }
 544
 545         obj = dev->driver->gem_prime_import_sg_table(dev, attach, sgt);
 546         if (IS_ERR(obj)) {
 547                 ret = PTR_ERR(obj);
 548                 goto fail_unmap;
 549         }
 550
 551         obj->import_attach = attach;
 552
 553         return obj;
 554
 555 fail_unmap:
 556         dma_buf_unmap_attachment(attach, sgt, DMA_BIDIRECTIONAL);
 557 fail_detach:
 558         dma_buf_detach(dma_buf, attach);
 559         dma_buf_put(dma_buf);
 560
 561         return ERR_PTR(ret);
 562 #endif
 563 }
 564 EXPORT_SYMBOL(drm_gem_prime_import);
 565
 566 /**
 567  * drm_gem_prime_fd_to_handle - PRIME import function for GEM drivers
 568  * @dev: dev to export the buffer from
 569  * @file_priv: drm file-private structure
 570  * @prime_fd: fd id of the dma-buf which should be imported
 571  * @handle: pointer to storage for the handle of the imported buffer object
 572  *
 573  * This is the PRIME import function which must be used mandatorily by GEM
 574  * drivers to ensure correct lifetime management of the underlying GEM object.
 575  * The actual importing of GEM object from the dma-buf is done through the
 576  * gem_import_export driver callback.
 577  */
 578 int drm_gem_prime_fd_to_handle(struct drm_device *dev,
 579                                struct drm_file *file_priv, int prime_fd,
 580                                uint32_t *handle)
 581 {
 582 #if 0
 583         struct dma_buf *dma_buf;
 584         struct drm_gem_object *obj;
 585         int ret;
 586
 587         dma_buf = dma_buf_get(prime_fd);
 588         if (IS_ERR(dma_buf))
 589                 return PTR_ERR(dma_buf);
 590
 591         mutex_lock(&file_priv->prime.lock);
 592
 593         ret = drm_prime_lookup_buf_handle(&file_priv->prime,
 594                         dma_buf, handle);
 595         if (ret == 0)
 596                 goto out_put;
 597
 598         /* never seen this one, need to import */
 599         mutex_lock(&dev->object_name_lock);
 600         obj = dev->driver->gem_prime_import(dev, dma_buf);
 601         if (IS_ERR(obj)) {
 602                 ret = PTR_ERR(obj);
 603                 goto out_unlock;
 604         }
 605
 606         if (obj->dma_buf) {
 607                 WARN_ON(obj->dma_buf != dma_buf);
 608         } else {
 609                 obj->dma_buf = dma_buf;
 610                 get_dma_buf(dma_buf);
 611         }
 612
 613         /* drm_gem_handle_create_tail unlocks dev->object_name_lock. */
 614         ret = drm_gem_handle_create_tail(file_priv, obj, handle);
 615         drm_gem_object_unreference_unlocked(obj);
 616         if (ret)
 617                 goto out_put;
 618
 619         ret = drm_prime_add_buf_handle(&file_priv->prime,
 620                         dma_buf, *handle);
 621         if (ret)
 622                 goto fail;
 623
 624         mutex_unlock(&file_priv->prime.lock);
 625
 626         dma_buf_put(dma_buf);
 627
 628         return 0;
 629
 630 fail:
 631         /* hmm, if driver attached, we are relying on the free-object path
 632          * to detach.. which seems ok..
 633          */
 634         drm_gem_handle_delete(file_priv, *handle);
 635 out_unlock:
 636         mutex_unlock(&dev->object_name_lock);
 637 out_put:
 638         dma_buf_put(dma_buf);
 639         mutex_unlock(&file_priv->prime.lock);
 640         return ret;
 641 #endif
 642         return -EINVAL;
 643 }
 644 EXPORT_SYMBOL(drm_gem_prime_fd_to_handle);
 645
 646 int drm_prime_handle_to_fd_ioctl(struct drm_device *dev, void *data,
 647                                  struct drm_file *file_priv)
 648 {
 649         struct drm_prime_handle *args = data;
 650
 651         if (!drm_core_check_feature(dev, DRIVER_PRIME))
 652                 return -EINVAL;
 653
 654         if (!dev->driver->prime_handle_to_fd)
 655                 return -ENOSYS;
 656
 657         /* check flags are valid */
 658         if (args->flags & ~(DRM_CLOEXEC | DRM_RDWR))
 659                 return -EINVAL;
 660
 661         return dev->driver->prime_handle_to_fd(dev, file_priv,
 662                         args->handle, args->flags, &args->fd);
 663 }
 664
 665 int drm_prime_fd_to_handle_ioctl(struct drm_device *dev, void *data,
 666                                  struct drm_file *file_priv)
 667 {
 668         struct drm_prime_handle *args = data;
 669
 670         if (!drm_core_check_feature(dev, DRIVER_PRIME))
 671                 return -EINVAL;
 672
 673         if (!dev->driver->prime_fd_to_handle)
 674                 return -ENOSYS;
 675
 676         return dev->driver->prime_fd_to_handle(dev, file_priv,
 677                         args->fd, &args->handle);
 678 }
 679
 680 /**
 681  * drm_prime_pages_to_sg - converts a page array into an sg list
 682  * @pages: pointer to the array of page pointers to convert
 683  * @nr_pages: length of the page vector
 684  *
 685  * This helper creates an sg table object from a set of pages
 686  * the driver is responsible for mapping the pages into the
 687  * importers address space for use with dma_buf itself.
 688  */
 689 struct sg_table *drm_prime_pages_to_sg(struct page **pages, unsigned int nr_pages)
 690 {
 691 #if 0
 692         struct sg_table *sg = NULL;
 693 #endif
 694         int ret;
 695
 696 #if 0
 697         sg = kmalloc(sizeof(struct sg_table), GFP_KERNEL);
 698         if (!sg) {
 699 #endif
 700                 ret = -ENOMEM;
 701 #if 0
 702                 goto out;
 703         }
 704
 705         ret = sg_alloc_table_from_pages(sg, pages, nr_pages, 0,
 706                                 nr_pages << PAGE_SHIFT, GFP_KERNEL);
 707         if (ret)
 708                 goto out;
 709
 710         return sg;
 711 out:
 712         kfree(sg);
 713 #endif
 714         return ERR_PTR(ret);
 715 }
 716 EXPORT_SYMBOL(drm_prime_pages_to_sg);
 717
 718 /**
 719  * drm_prime_sg_to_page_addr_arrays - convert an sg table into a page array
 720  * @sgt: scatter-gather table to convert
 721  * @pages: array of page pointers to store the page array in
 722  * @addrs: optional array to store the dma bus address of each page
 723  * @max_pages: size of both the passed-in arrays
 724  *
 725  * Exports an sg table into an array of pages and addresses. This is currently
 726  * required by the TTM driver in order to do correct fault handling.
 727  */
 728 int drm_prime_sg_to_page_addr_arrays(struct sg_table *sgt, struct page **pages,
 729                                      dma_addr_t *addrs, int max_pages)
 730 {
 731         unsigned count;
 732         struct scatterlist *sg;
 733         struct page *page;
 734         u32 len;
 735         int pg_index;
 736         dma_addr_t addr;
 737
 738         pg_index = 0;
 739         for_each_sg(sgt->sgl, sg, sgt->nents, count) {
 740                 len = sg->length;
 741                 page = sg_page(sg);
 742                 addr = sg_dma_address(sg);
 743
 744                 while (len > 0) {
 745                         if (WARN_ON(pg_index >= max_pages))
 746                                 return -1;
 747                         pages[pg_index] = page;
 748                         if (addrs)
 749                                 addrs[pg_index] = addr;
 750
 751                         page++;
 752                         addr += PAGE_SIZE;
 753                         len -= PAGE_SIZE;
 754                         pg_index++;
 755                 }
 756         }
 757         return 0;
 758 }
 759 EXPORT_SYMBOL(drm_prime_sg_to_page_addr_arrays);
 760
 761 /**
 762  * drm_prime_gem_destroy - helper to clean up a PRIME-imported GEM object
 763  * @obj: GEM object which was created from a dma-buf
 764  * @sg: the sg-table which was pinned at import time
 765  *
 766  * This is the cleanup functions which GEM drivers need to call when they use
 767  * @drm_gem_prime_import to import dma-bufs.
 768  */
 769 void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg)
 770 {
 771         struct dma_buf_attachment *attach;
 772         struct dma_buf *dma_buf;
 773         attach = obj->import_attach;
 774         if (sg)
 775                 dma_buf_unmap_attachment(attach, sg, DMA_BIDIRECTIONAL);
 776         dma_buf = attach->dmabuf;
 777 #if 0
 778         dma_buf_detach(attach->dmabuf, attach);
 779         /* remove the reference */
 780         dma_buf_put(dma_buf);
 781 #endif
 782 }
 783 EXPORT_SYMBOL(drm_prime_gem_destroy);
 784
 785 void drm_prime_init_file_private(struct drm_prime_file_private *prime_fpriv)
 786 {
 787         INIT_LIST_HEAD(&prime_fpriv->head);
 788         lockinit(&prime_fpriv->lock, "drmpfpl", 0, LK_CANRECURSE);
 789 }
 790
 791 void drm_prime_destroy_file_private(struct drm_prime_file_private *prime_fpriv)
 792 {
 793         /* by now drm_gem_release should've made sure the list is empty */
 794         WARN_ON(!list_empty(&prime_fpriv->head));
 795 }