drivers/gpu/drm/rockchip/rockchip_drm_gem.c

   1 /*
   2  * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd
   3  * Author:Mark Yao <mark.yao@rock-chips.com>
   4  *
   5  * This software is licensed under the terms of the GNU General Public
   6  * License version 2, as published by the Free Software Foundation, and
   7  * may be copied, distributed, and modified under those terms.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14
  15 #include <drm/drm.h>
  16 #include <drm/drmP.h>
  17 #include <drm/drm_gem.h>
  18 #include <drm/drm_sync_helper.h>
  19 #include <drm/drm_vma_manager.h>
  20 #include <drm/rockchip_drm.h>
  21
  22 #include <linux/completion.h>
  23 #include <linux/dma-attrs.h>
  24 #include <linux/dma-buf.h>
  25 #include <linux/reservation.h>
  26
  27 #include "rockchip_drm_drv.h"
  28 #include "rockchip_drm_gem.h"
  29
  30 static int rockchip_gem_alloc_buf(struct rockchip_gem_object *rk_obj,
  31                                   bool alloc_kmap)
  32 {
  33         struct drm_gem_object *obj = &rk_obj->base;
  34         struct drm_device *drm = obj->dev;
  35
  36         init_dma_attrs(&rk_obj->dma_attrs);
  37         dma_set_attr(DMA_ATTR_WRITE_COMBINE, &rk_obj->dma_attrs);
  38
  39         if (!alloc_kmap)
  40                 dma_set_attr(DMA_ATTR_NO_KERNEL_MAPPING, &rk_obj->dma_attrs);
  41
  42         rk_obj->kvaddr = dma_alloc_attrs(drm->dev, obj->size,
  43                                          &rk_obj->dma_addr, GFP_KERNEL,
  44                                          &rk_obj->dma_attrs);
  45         if (!rk_obj->kvaddr) {
  46                 DRM_ERROR("failed to allocate %zu byte dma buffer", obj->size);
  47                 return -ENOMEM;
  48         }
  49
  50         return 0;
  51 }
  52
  53 static void rockchip_gem_free_buf(struct rockchip_gem_object *rk_obj)
  54 {
  55         struct drm_gem_object *obj = &rk_obj->base;
  56         struct drm_device *drm = obj->dev;
  57
  58         dma_free_attrs(drm->dev, obj->size, rk_obj->kvaddr, rk_obj->dma_addr,
  59                        &rk_obj->dma_attrs);
  60 }
  61
  62 static int rockchip_drm_gem_object_mmap(struct drm_gem_object *obj,
  63                                         struct vm_area_struct *vma)
  64
  65 {
  66         int ret;
  67         struct rockchip_gem_object *rk_obj = to_rockchip_obj(obj);
  68         struct drm_device *drm = obj->dev;
  69
  70         /*
  71          * dma_alloc_attrs() allocated a struct page table for rk_obj, so clear
  72          * VM_PFNMAP flag that was set by drm_gem_mmap_obj()/drm_gem_mmap().
  73          */
  74         vma->vm_flags &= ~VM_PFNMAP;
  75         vma->vm_pgoff = 0;
  76
  77         ret = dma_mmap_attrs(drm->dev, vma, rk_obj->kvaddr, rk_obj->dma_addr,
  78                              obj->size, &rk_obj->dma_attrs);
  79         if (ret)
  80                 drm_gem_vm_close(vma);
  81
  82         return ret;
  83 }
  84
  85 int rockchip_gem_mmap_buf(struct drm_gem_object *obj,
  86                           struct vm_area_struct *vma)
  87 {
  88         int ret;
  89
  90         ret = drm_gem_mmap_obj(obj, obj->size, vma);
  91         if (ret)
  92                 return ret;
  93
  94         return rockchip_drm_gem_object_mmap(obj, vma);
  95 }
  96
  97 /* drm driver mmap file operations */
  98 int rockchip_gem_mmap(struct file *filp, struct vm_area_struct *vma)
  99 {
 100         struct drm_gem_object *obj;
 101         int ret;
 102
 103         ret = drm_gem_mmap(filp, vma);
 104         if (ret)
 105                 return ret;
 106
 107         obj = vma->vm_private_data;
 108
 109         return rockchip_drm_gem_object_mmap(obj, vma);
 110 }
 111
 112 struct drm_gem_object *
 113 rockchip_gem_prime_import_sg_table(struct drm_device *drm,
 114                                    struct dma_buf_attachment *attach,
 115                                    struct sg_table *sgt)
 116 {
 117         struct rockchip_gem_object *rk_obj;
 118         struct drm_gem_object *obj;
 119
 120         rk_obj = kzalloc(sizeof(*rk_obj), GFP_KERNEL);
 121         if (!rk_obj)
 122                 return ERR_PTR(-ENOMEM);
 123
 124         obj = &rk_obj->base;
 125
 126         drm_gem_private_object_init(drm, obj, attach->dmabuf->size);
 127
 128         rk_obj->dma_addr = sg_dma_address(sgt->sgl);
 129         rk_obj->sgt = sgt;
 130         sg_dma_len(sgt->sgl) = obj->size;
 131
 132         return obj;
 133 }
 134
 135 struct rockchip_gem_object *
 136         rockchip_gem_create_object(struct drm_device *drm, unsigned int size,
 137                                    bool alloc_kmap)
 138 {
 139         struct rockchip_gem_object *rk_obj;
 140         struct drm_gem_object *obj;
 141         int ret;
 142
 143         size = round_up(size, PAGE_SIZE);
 144
 145         rk_obj = kzalloc(sizeof(*rk_obj), GFP_KERNEL);
 146         if (!rk_obj)
 147                 return ERR_PTR(-ENOMEM);
 148
 149         obj = &rk_obj->base;
 150
 151         drm_gem_private_object_init(drm, obj, size);
 152
 153         ret = rockchip_gem_alloc_buf(rk_obj, alloc_kmap);
 154         if (ret)
 155                 goto err_free_rk_obj;
 156
 157         return rk_obj;
 158
 159 err_free_rk_obj:
 160         kfree(rk_obj);
 161         return ERR_PTR(ret);
 162 }
 163
 164 /*
 165  * rockchip_gem_free_object - (struct drm_driver)->gem_free_object callback
 166  * function
 167  */
 168 void rockchip_gem_free_object(struct drm_gem_object *obj)
 169 {
 170         struct rockchip_gem_object *rk_obj;
 171
 172         rk_obj = to_rockchip_obj(obj);
 173
 174         if (obj->import_attach) {
 175                 drm_prime_gem_destroy(obj, rk_obj->sgt);
 176         } else {
 177                 drm_gem_free_mmap_offset(obj);
 178                 rockchip_gem_free_buf(rk_obj);
 179         }
 180
 181 #ifdef CONFIG_DRM_DMA_SYNC
 182         drm_fence_signal_and_put(&rk_obj->acquire_fence);
 183 #endif
 184
 185         kfree(rk_obj);
 186 }
 187
 188 /*
 189  * rockchip_gem_create_with_handle - allocate an object with the given
 190  * size and create a gem handle on it
 191  *
 192  * returns a struct rockchip_gem_object* on success or ERR_PTR values
 193  * on failure.
 194  */
 195 static struct rockchip_gem_object *
 196 rockchip_gem_create_with_handle(struct drm_file *file_priv,
 197                                 struct drm_device *drm, unsigned int size,
 198                                 unsigned int *handle)
 199 {
 200         struct rockchip_gem_object *rk_obj;
 201         struct drm_gem_object *obj;
 202         int ret;
 203
 204         rk_obj = rockchip_gem_create_object(drm, size, false);
 205         if (IS_ERR(rk_obj))
 206                 return ERR_CAST(rk_obj);
 207
 208         obj = &rk_obj->base;
 209
 210         /*
 211          * allocate a id of idr table where the obj is registered
 212          * and handle has the id what user can see.
 213          */
 214         ret = drm_gem_handle_create(file_priv, obj, handle);
 215         if (ret)
 216                 goto err_handle_create;
 217
 218         /* drop reference from allocate - handle holds it now. */
 219         drm_gem_object_unreference_unlocked(obj);
 220
 221         return rk_obj;
 222
 223 err_handle_create:
 224         rockchip_gem_free_object(obj);
 225
 226         return ERR_PTR(ret);
 227 }
 228
 229 int rockchip_gem_dumb_map_offset(struct drm_file *file_priv,
 230                                  struct drm_device *dev, uint32_t handle,
 231                                  uint64_t *offset)
 232 {
 233         struct drm_gem_object *obj;
 234         int ret;
 235
 236         obj = drm_gem_object_lookup(dev, file_priv, handle);
 237         if (!obj) {
 238                 DRM_ERROR("failed to lookup gem object.\n");
 239                 return -EINVAL;
 240         }
 241
 242         ret = drm_gem_create_mmap_offset(obj);
 243         if (ret)
 244                 goto out;
 245
 246         *offset = drm_vma_node_offset_addr(&obj->vma_node);
 247         DRM_DEBUG_KMS("offset = 0x%llx\n", *offset);
 248
 249 out:
 250         drm_gem_object_unreference_unlocked(obj);
 251
 252         return 0;
 253 }
 254
 255 /*
 256  * rockchip_gem_dumb_create - (struct drm_driver)->dumb_create callback
 257  * function
 258  *
 259  * This aligns the pitch and size arguments to the minimum required. wrap
 260  * this into your own function if you need bigger alignment.
 261  */
 262 int rockchip_gem_dumb_create(struct drm_file *file_priv,
 263                              struct drm_device *dev,
 264                              struct drm_mode_create_dumb *args)
 265 {
 266         struct rockchip_gem_object *rk_obj;
 267         int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
 268
 269         /*
 270          * align to 64 bytes since Mali requires it.
 271          */
 272         args->pitch = ALIGN(min_pitch, 64);
 273         args->size = args->pitch * args->height;
 274
 275         rk_obj = rockchip_gem_create_with_handle(file_priv, dev, args->size,
 276                                                  &args->handle);
 277
 278         return PTR_ERR_OR_ZERO(rk_obj);
 279 }
 280
 281 int rockchip_gem_map_offset_ioctl(struct drm_device *drm, void *data,
 282                                   struct drm_file *file_priv)
 283 {
 284         struct drm_rockchip_gem_map_off *args = data;
 285
 286         return rockchip_gem_dumb_map_offset(file_priv, drm, args->handle,
 287                                             &args->offset);
 288 }
 289
 290 int rockchip_gem_create_ioctl(struct drm_device *dev, void *data,
 291                               struct drm_file *file_priv)
 292 {
 293         struct drm_rockchip_gem_create *args = data;
 294         struct rockchip_gem_object *rk_obj;
 295
 296         rk_obj = rockchip_gem_create_with_handle(file_priv, dev, args->size,
 297                                                  &args->handle);
 298         return PTR_ERR_OR_ZERO(rk_obj);
 299 }
 300
 301 static struct reservation_object *drm_gem_get_resv(struct drm_gem_object *gem)
 302 {
 303         struct dma_buf *dma_buf = gem->dma_buf;
 304         return dma_buf ? dma_buf->resv : NULL;
 305 }
 306
 307 #ifdef CONFIG_DRM_DMA_SYNC
 308 static void rockchip_gem_acquire_complete(struct drm_reservation_cb *rcb,
 309                                         void *context)
 310 {
 311         struct completion *compl = context;
 312         complete(compl);
 313 }
 314
 315 static int rockchip_gem_acquire(struct drm_device *dev,
 316                                 struct rockchip_gem_object *rockchip_gem_obj,
 317                                 bool exclusive)
 318 {
 319         struct fence *fence;
 320         struct rockchip_drm_private *dev_priv = dev->dev_private;
 321         struct reservation_object *resv =
 322                 drm_gem_get_resv(&rockchip_gem_obj->base);
 323         int ret = 0;
 324         struct drm_reservation_cb rcb;
 325         DECLARE_COMPLETION_ONSTACK(compl);
 326
 327         if (!resv)
 328                 return ret;
 329
 330         if (!exclusive &&
 331             !rockchip_gem_obj->acquire_exclusive &&
 332             rockchip_gem_obj->acquire_fence) {
 333                 atomic_inc(&rockchip_gem_obj->acquire_shared_count);
 334                 return ret;
 335         }
 336
 337         fence = drm_sw_fence_new(dev_priv->cpu_fence_context,
 338                         atomic_add_return(1, &dev_priv->cpu_fence_seqno));
 339         if (IS_ERR(fence)) {
 340                 ret = PTR_ERR(fence);
 341                 DRM_ERROR("Failed to create acquire fence %d.\n", ret);
 342                 return ret;
 343         }
 344         ww_mutex_lock(&resv->lock, NULL);
 345         if (!exclusive) {
 346                 ret = reservation_object_reserve_shared(resv);
 347                 if (ret < 0) {
 348                         DRM_ERROR("Failed to reserve space for shared fence %d.\n",
 349                                   ret);
 350                         goto resv_unlock;
 351                 }
 352         }
 353         drm_reservation_cb_init(&rcb, rockchip_gem_acquire_complete, &compl);
 354         ret = drm_reservation_cb_add(&rcb, resv, exclusive);
 355         if (ret < 0) {
 356                 DRM_ERROR("Failed to add reservation to callback %d.\n", ret);
 357                 goto resv_unlock;
 358         }
 359         drm_reservation_cb_done(&rcb);
 360         if (exclusive)
 361                 reservation_object_add_excl_fence(resv, fence);
 362         else
 363                 reservation_object_add_shared_fence(resv, fence);
 364
 365         ww_mutex_unlock(&resv->lock);
 366         mutex_unlock(&dev->struct_mutex);
 367         ret = wait_for_completion_interruptible(&compl);
 368         mutex_lock(&dev->struct_mutex);
 369         if (ret < 0) {
 370                 DRM_ERROR("Failed wait for reservation callback %d.\n", ret);
 371                 drm_reservation_cb_fini(&rcb);
 372                 /* somebody else may be already waiting on it */
 373                 drm_fence_signal_and_put(&fence);
 374                 return ret;
 375         }
 376         rockchip_gem_obj->acquire_fence = fence;
 377         rockchip_gem_obj->acquire_exclusive = exclusive;
 378         atomic_set(&rockchip_gem_obj->acquire_shared_count, 1);
 379         return ret;
 380
 381 resv_unlock:
 382         ww_mutex_unlock(&resv->lock);
 383         fence_put(fence);
 384         return ret;
 385 }
 386
 387 static void rockchip_gem_release(struct rockchip_gem_object *rockchip_gem_obj)
 388 {
 389         BUG_ON(!rockchip_gem_obj->acquire_fence);
 390         if (atomic_sub_and_test(1,
 391                         &rockchip_gem_obj->acquire_shared_count))
 392                 drm_fence_signal_and_put(&rockchip_gem_obj->acquire_fence);
 393 }
 394 #endif
 395
 396 int rockchip_gem_cpu_acquire_ioctl(struct drm_device *dev, void *data,
 397                                    struct drm_file *file)
 398 {
 399         struct drm_rockchip_gem_cpu_acquire *args = data;
 400         struct rockchip_drm_file_private *file_priv = file->driver_priv;
 401         struct drm_gem_object *obj;
 402         struct rockchip_gem_object *rockchip_gem_obj;
 403         struct rockchip_gem_object_node *gem_node;
 404         int ret = 0;
 405
 406         DRM_DEBUG_KMS("[BO:%u] flags: 0x%x\n", args->handle, args->flags);
 407
 408         mutex_lock(&dev->struct_mutex);
 409
 410         obj = drm_gem_object_lookup(dev, file, args->handle);
 411         if (!obj) {
 412                 DRM_ERROR("failed to lookup gem object.\n");
 413                 ret = -EINVAL;
 414                 goto unlock;
 415         }
 416
 417         rockchip_gem_obj = to_rockchip_obj(obj);
 418
 419         if (!drm_gem_get_resv(&rockchip_gem_obj->base)) {
 420                 /* If there is no reservation object present, there is no
 421                  * cross-process/cross-device sharing and sync is unnecessary.
 422                  */
 423                 ret = 0;
 424                 goto unref_obj;
 425         }
 426
 427 #ifdef CONFIG_DRM_DMA_SYNC
 428         ret = rockchip_gem_acquire(dev, rockchip_gem_obj,
 429                         args->flags & DRM_ROCKCHIP_GEM_CPU_ACQUIRE_EXCLUSIVE);
 430         if (ret < 0)
 431                 goto unref_obj;
 432 #endif
 433
 434         gem_node = kzalloc(sizeof(*gem_node), GFP_KERNEL);
 435         if (!gem_node) {
 436                 DRM_ERROR("Failed to allocate rockchip_drm_gem_obj_node.\n");
 437                 ret = -ENOMEM;
 438                 goto release_sync;
 439         }
 440
 441         gem_node->rockchip_gem_obj = rockchip_gem_obj;
 442         list_add(&gem_node->list, &file_priv->gem_cpu_acquire_list);
 443         mutex_unlock(&dev->struct_mutex);
 444         return 0;
 445
 446 release_sync:
 447 #ifdef CONFIG_DRM_DMA_SYNC
 448         rockchip_gem_release(rockchip_gem_obj);
 449 #endif
 450 unref_obj:
 451         drm_gem_object_unreference(obj);
 452
 453 unlock:
 454         mutex_unlock(&dev->struct_mutex);
 455         return ret;
 456 }
 457
 458 int rockchip_gem_cpu_release_ioctl(struct drm_device *dev, void *data,
 459                                    struct drm_file *file)
 460 {
 461         struct drm_rockchip_gem_cpu_release *args = data;
 462         struct rockchip_drm_file_private *file_priv = file->driver_priv;
 463         struct drm_gem_object *obj;
 464         struct rockchip_gem_object *rockchip_gem_obj;
 465         struct list_head *cur;
 466         int ret = 0;
 467
 468         DRM_DEBUG_KMS("[BO:%u]\n", args->handle);
 469
 470         mutex_lock(&dev->struct_mutex);
 471
 472         obj = drm_gem_object_lookup(dev, file, args->handle);
 473         if (!obj) {
 474                 DRM_ERROR("failed to lookup gem object.\n");
 475                 ret = -EINVAL;
 476                 goto unlock;
 477         }
 478
 479         rockchip_gem_obj = to_rockchip_obj(obj);
 480
 481         if (!drm_gem_get_resv(&rockchip_gem_obj->base)) {
 482                 /* If there is no reservation object present, there is no
 483                  * cross-process/cross-device sharing and sync is unnecessary.
 484                  */
 485                 ret = 0;
 486                 goto unref_obj;
 487         }
 488
 489         list_for_each(cur, &file_priv->gem_cpu_acquire_list) {
 490                 struct rockchip_gem_object_node *node = list_entry(
 491                                 cur, struct rockchip_gem_object_node, list);
 492                 if (node->rockchip_gem_obj == rockchip_gem_obj)
 493                         break;
 494         }
 495         if (cur == &file_priv->gem_cpu_acquire_list) {
 496                 DRM_ERROR("gem object not acquired for current process.\n");
 497                 ret = -EINVAL;
 498                 goto unref_obj;
 499         }
 500
 501 #ifdef CONFIG_DRM_DMA_SYNC
 502         rockchip_gem_release(rockchip_gem_obj);
 503 #endif
 504
 505         list_del(cur);
 506         kfree(list_entry(cur, struct rockchip_gem_object_node, list));
 507         /* unreference for the reference held since cpu_acquire_ioctl */
 508         drm_gem_object_unreference(obj);
 509         ret = 0;
 510
 511 unref_obj:
 512         /* unreference for the reference from drm_gem_object_lookup() */
 513         drm_gem_object_unreference(obj);
 514
 515 unlock:
 516         mutex_unlock(&dev->struct_mutex);
 517         return ret;
 518 }
 519
 520 /*
 521  * Allocate a sg_table for this GEM object.
 522  * Note: Both the table's contents, and the sg_table itself must be freed by
 523  *       the caller.
 524  * Returns a pointer to the newly allocated sg_table, or an ERR_PTR() error.
 525  */
 526 struct sg_table *rockchip_gem_prime_get_sg_table(struct drm_gem_object *obj)
 527 {
 528         struct rockchip_gem_object *rk_obj = to_rockchip_obj(obj);
 529         struct drm_device *drm = obj->dev;
 530         struct sg_table *sgt;
 531         int ret;
 532
 533         sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
 534         if (!sgt)
 535                 return ERR_PTR(-ENOMEM);
 536
 537         ret = dma_get_sgtable_attrs(drm->dev, sgt, rk_obj->kvaddr,
 538                                     rk_obj->dma_addr, obj->size,
 539                                     &rk_obj->dma_attrs);
 540         if (ret) {
 541                 DRM_ERROR("failed to allocate sgt, %d\n", ret);
 542                 kfree(sgt);
 543                 return ERR_PTR(ret);
 544         }
 545
 546         return sgt;
 547 }
 548
 549 void *rockchip_gem_prime_vmap(struct drm_gem_object *obj)
 550 {
 551         struct rockchip_gem_object *rk_obj = to_rockchip_obj(obj);
 552
 553         if (dma_get_attr(DMA_ATTR_NO_KERNEL_MAPPING, &rk_obj->dma_attrs))
 554                 return NULL;
 555
 556         return rk_obj->kvaddr;
 557 }
 558
 559 void rockchip_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr)
 560 {
 561         /* Nothing to do */
 562 }