drivers/gpu/drm/radeon/radeon_cs.c

   1 /*
   2  * Copyright 2008 Jerome Glisse.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Jerome Glisse <glisse@freedesktop.org>
  26  */
  27 #include <linux/list_sort.h>
  28 #include <drm/drmP.h>
  29 #include <drm/radeon_drm.h>
  30 #include "radeon_reg.h"
  31 #include "radeon.h"
  32 #include "radeon_trace.h"
  33
  34 #define RADEON_CS_MAX_PRIORITY          32u
  35 #define RADEON_CS_NUM_BUCKETS           (RADEON_CS_MAX_PRIORITY + 1)
  36
  37 /* This is based on the bucket sort with O(n) time complexity.
  38  * An item with priority "i" is added to bucket[i]. The lists are then
  39  * concatenated in descending order.
  40  */
  41 struct radeon_cs_buckets {
  42         struct list_head bucket[RADEON_CS_NUM_BUCKETS];
  43 };
  44
  45 static void radeon_cs_buckets_init(struct radeon_cs_buckets *b)
  46 {
  47         unsigned i;
  48
  49         for (i = 0; i < RADEON_CS_NUM_BUCKETS; i++)
  50                 INIT_LIST_HEAD(&b->bucket[i]);
  51 }
  52
  53 static void radeon_cs_buckets_add(struct radeon_cs_buckets *b,
  54                                   struct list_head *item, unsigned priority)
  55 {
  56         /* Since buffers which appear sooner in the relocation list are
  57          * likely to be used more often than buffers which appear later
  58          * in the list, the sort mustn't change the ordering of buffers
  59          * with the same priority, i.e. it must be stable.
  60          */
  61         list_add_tail(item, &b->bucket[min(priority, RADEON_CS_MAX_PRIORITY)]);
  62 }
  63
  64 static void radeon_cs_buckets_get_list(struct radeon_cs_buckets *b,
  65                                        struct list_head *out_list)
  66 {
  67         unsigned i;
  68
  69         /* Connect the sorted buckets in the output list. */
  70         for (i = 0; i < RADEON_CS_NUM_BUCKETS; i++) {
  71                 list_splice(&b->bucket[i], out_list);
  72         }
  73 }
  74
  75 static int radeon_cs_parser_relocs(struct radeon_cs_parser *p)
  76 {
  77         struct drm_device *ddev = p->rdev->ddev;
  78         struct radeon_cs_chunk *chunk;
  79         struct radeon_cs_buckets buckets;
  80         unsigned i, j;
  81         bool duplicate, need_mmap_lock = false;
  82         int r;
  83
  84         if (p->chunk_relocs_idx == -1) {
  85                 return 0;
  86         }
  87         chunk = &p->chunks[p->chunk_relocs_idx];
  88         p->dma_reloc_idx = 0;
  89         /* FIXME: we assume that each relocs use 4 dwords */
  90         p->nrelocs = chunk->length_dw / 4;
  91         p->relocs_ptr = kcalloc(p->nrelocs, sizeof(void *), GFP_KERNEL);
  92         if (p->relocs_ptr == NULL) {
  93                 return -ENOMEM;
  94         }
  95         p->relocs = kcalloc(p->nrelocs, sizeof(struct radeon_cs_reloc), GFP_KERNEL);
  96         if (p->relocs == NULL) {
  97                 return -ENOMEM;
  98         }
  99
 100         radeon_cs_buckets_init(&buckets);
 101
 102         for (i = 0; i < p->nrelocs; i++) {
 103                 struct drm_radeon_cs_reloc *r;
 104                 unsigned priority;
 105
 106                 duplicate = false;
 107                 r = (struct drm_radeon_cs_reloc *)&chunk->kdata[i*4];
 108                 for (j = 0; j < i; j++) {
 109                         if (r->handle == p->relocs[j].handle) {
 110                                 p->relocs_ptr[i] = &p->relocs[j];
 111                                 duplicate = true;
 112                                 break;
 113                         }
 114                 }
 115                 if (duplicate) {
 116                         p->relocs[i].handle = 0;
 117                         continue;
 118                 }
 119
 120                 p->relocs[i].gobj = drm_gem_object_lookup(ddev, p->filp,
 121                                                           r->handle);
 122                 if (p->relocs[i].gobj == NULL) {
 123                         DRM_ERROR("gem object lookup failed 0x%x\n",
 124                                   r->handle);
 125                         return -ENOENT;
 126                 }
 127                 p->relocs_ptr[i] = &p->relocs[i];
 128                 p->relocs[i].robj = gem_to_radeon_bo(p->relocs[i].gobj);
 129
 130                 /* The userspace buffer priorities are from 0 to 15. A higher
 131                  * number means the buffer is more important.
 132                  * Also, the buffers used for write have a higher priority than
 133                  * the buffers used for read only, which doubles the range
 134                  * to 0 to 31. 32 is reserved for the kernel driver.
 135                  */
 136                 priority = (r->flags & RADEON_RELOC_PRIO_MASK) * 2
 137                            + !!r->write_domain;
 138
 139                 /* the first reloc of an UVD job is the msg and that must be in
 140                    VRAM, also but everything into VRAM on AGP cards and older
 141                    IGP chips to avoid image corruptions */
 142                 if (p->ring == R600_RING_TYPE_UVD_INDEX &&
 143                     (i == 0 || drm_pci_device_is_agp(p->rdev->ddev) ||
 144                      p->rdev->family == CHIP_RS780 ||
 145                      p->rdev->family == CHIP_RS880)) {
 146
 147                         /* TODO: is this still needed for NI+ ? */
 148                         p->relocs[i].prefered_domains =
 149                                 RADEON_GEM_DOMAIN_VRAM;
 150
 151                         p->relocs[i].allowed_domains =
 152                                 RADEON_GEM_DOMAIN_VRAM;
 153
 154                         /* prioritize this over any other relocation */
 155                         priority = RADEON_CS_MAX_PRIORITY;
 156                 } else {
 157                         uint32_t domain = r->write_domain ?
 158                                 r->write_domain : r->read_domains;
 159
 160                         if (domain & RADEON_GEM_DOMAIN_CPU) {
 161                                 DRM_ERROR("RADEON_GEM_DOMAIN_CPU is not valid "
 162                                           "for command submission\n");
 163                                 return -EINVAL;
 164                         }
 165
 166                         p->relocs[i].prefered_domains = domain;
 167                         if (domain == RADEON_GEM_DOMAIN_VRAM)
 168                                 domain |= RADEON_GEM_DOMAIN_GTT;
 169                         p->relocs[i].allowed_domains = domain;
 170                 }
 171
 172                 if (radeon_ttm_tt_has_userptr(p->relocs[i].robj->tbo.ttm)) {
 173                         uint32_t domain = p->relocs[i].prefered_domains;
 174                         if (!(domain & RADEON_GEM_DOMAIN_GTT)) {
 175                                 DRM_ERROR("Only RADEON_GEM_DOMAIN_GTT is "
 176                                           "allowed for userptr BOs\n");
 177                                 return -EINVAL;
 178                         }
 179                         need_mmap_lock = true;
 180                         domain = RADEON_GEM_DOMAIN_GTT;
 181                         p->relocs[i].prefered_domains = domain;
 182                         p->relocs[i].allowed_domains = domain;
 183                 }
 184
 185                 p->relocs[i].tv.bo = &p->relocs[i].robj->tbo;
 186                 p->relocs[i].tv.shared = false;
 187                 p->relocs[i].handle = r->handle;
 188
 189                 radeon_cs_buckets_add(&buckets, &p->relocs[i].tv.head,
 190                                       priority);
 191         }
 192
 193         radeon_cs_buckets_get_list(&buckets, &p->validated);
 194
 195         if (p->cs_flags & RADEON_CS_USE_VM)
 196                 p->vm_bos = radeon_vm_get_bos(p->rdev, p->ib.vm,
 197                                               &p->validated);
 198         if (need_mmap_lock)
 199                 down_read(&current->mm->mmap_sem);
 200
 201         r = radeon_bo_list_validate(p->rdev, &p->ticket, &p->validated, p->ring);
 202
 203         if (need_mmap_lock)
 204                 up_read(&current->mm->mmap_sem);
 205
 206         return r;
 207 }
 208
 209 static int radeon_cs_get_ring(struct radeon_cs_parser *p, u32 ring, s32 priority)
 210 {
 211         p->priority = priority;
 212
 213         switch (ring) {
 214         default:
 215                 DRM_ERROR("unknown ring id: %d\n", ring);
 216                 return -EINVAL;
 217         case RADEON_CS_RING_GFX:
 218                 p->ring = RADEON_RING_TYPE_GFX_INDEX;
 219                 break;
 220         case RADEON_CS_RING_COMPUTE:
 221                 if (p->rdev->family >= CHIP_TAHITI) {
 222                         if (p->priority > 0)
 223                                 p->ring = CAYMAN_RING_TYPE_CP1_INDEX;
 224                         else
 225                                 p->ring = CAYMAN_RING_TYPE_CP2_INDEX;
 226                 } else
 227                         p->ring = RADEON_RING_TYPE_GFX_INDEX;
 228                 break;
 229         case RADEON_CS_RING_DMA:
 230                 if (p->rdev->family >= CHIP_CAYMAN) {
 231                         if (p->priority > 0)
 232                                 p->ring = R600_RING_TYPE_DMA_INDEX;
 233                         else
 234                                 p->ring = CAYMAN_RING_TYPE_DMA1_INDEX;
 235                 } else if (p->rdev->family >= CHIP_RV770) {
 236                         p->ring = R600_RING_TYPE_DMA_INDEX;
 237                 } else {
 238                         return -EINVAL;
 239                 }
 240                 break;
 241         case RADEON_CS_RING_UVD:
 242                 p->ring = R600_RING_TYPE_UVD_INDEX;
 243                 break;
 244         case RADEON_CS_RING_VCE:
 245                 /* TODO: only use the low priority ring for now */
 246                 p->ring = TN_RING_TYPE_VCE1_INDEX;
 247                 break;
 248         }
 249         return 0;
 250 }
 251
 252 static void radeon_cs_sync_rings(struct radeon_cs_parser *p)
 253 {
 254         int i;
 255
 256         for (i = 0; i < p->nrelocs; i++) {
 257                 struct reservation_object *resv;
 258
 259                 if (!p->relocs[i].robj)
 260                         continue;
 261
 262                 resv = p->relocs[i].robj->tbo.resv;
 263                 radeon_semaphore_sync_resv(p->ib.semaphore, resv, false);
 264         }
 265 }
 266
 267 /* XXX: note that this is called from the legacy UMS CS ioctl as well */
 268 int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data)
 269 {
 270         struct drm_radeon_cs *cs = data;
 271         uint64_t *chunk_array_ptr;
 272         unsigned size, i;
 273         u32 ring = RADEON_CS_RING_GFX;
 274         s32 priority = 0;
 275
 276         if (!cs->num_chunks) {
 277                 return 0;
 278         }
 279         /* get chunks */
 280         INIT_LIST_HEAD(&p->validated);
 281         p->idx = 0;
 282         p->ib.sa_bo = NULL;
 283         p->ib.semaphore = NULL;
 284         p->const_ib.sa_bo = NULL;
 285         p->const_ib.semaphore = NULL;
 286         p->chunk_ib_idx = -1;
 287         p->chunk_relocs_idx = -1;
 288         p->chunk_flags_idx = -1;
 289         p->chunk_const_ib_idx = -1;
 290         p->chunks_array = kcalloc(cs->num_chunks, sizeof(uint64_t), GFP_KERNEL);
 291         if (p->chunks_array == NULL) {
 292                 return -ENOMEM;
 293         }
 294         chunk_array_ptr = (uint64_t *)(unsigned long)(cs->chunks);
 295         if (copy_from_user(p->chunks_array, chunk_array_ptr,
 296                                sizeof(uint64_t)*cs->num_chunks)) {
 297                 return -EFAULT;
 298         }
 299         p->cs_flags = 0;
 300         p->nchunks = cs->num_chunks;
 301         p->chunks = kcalloc(p->nchunks, sizeof(struct radeon_cs_chunk), GFP_KERNEL);
 302         if (p->chunks == NULL) {
 303                 return -ENOMEM;
 304         }
 305         for (i = 0; i < p->nchunks; i++) {
 306                 struct drm_radeon_cs_chunk __user **chunk_ptr = NULL;
 307                 struct drm_radeon_cs_chunk user_chunk;
 308                 uint32_t __user *cdata;
 309
 310                 chunk_ptr = (void __user*)(unsigned long)p->chunks_array[i];
 311                 if (copy_from_user(&user_chunk, chunk_ptr,
 312                                        sizeof(struct drm_radeon_cs_chunk))) {
 313                         return -EFAULT;
 314                 }
 315                 p->chunks[i].length_dw = user_chunk.length_dw;
 316                 p->chunks[i].chunk_id = user_chunk.chunk_id;
 317                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_RELOCS) {
 318                         p->chunk_relocs_idx = i;
 319                 }
 320                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_IB) {
 321                         p->chunk_ib_idx = i;
 322                         /* zero length IB isn't useful */
 323                         if (p->chunks[i].length_dw == 0)
 324                                 return -EINVAL;
 325                 }
 326                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_CONST_IB) {
 327                         p->chunk_const_ib_idx = i;
 328                         /* zero length CONST IB isn't useful */
 329                         if (p->chunks[i].length_dw == 0)
 330                                 return -EINVAL;
 331                 }
 332                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_FLAGS) {
 333                         p->chunk_flags_idx = i;
 334                         /* zero length flags aren't useful */
 335                         if (p->chunks[i].length_dw == 0)
 336                                 return -EINVAL;
 337                 }
 338
 339                 size = p->chunks[i].length_dw;
 340                 cdata = (void __user *)(unsigned long)user_chunk.chunk_data;
 341                 p->chunks[i].user_ptr = cdata;
 342                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_CONST_IB)
 343                         continue;
 344
 345                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_IB) {
 346                         if (!p->rdev || !(p->rdev->flags & RADEON_IS_AGP))
 347                                 continue;
 348                 }
 349
 350                 p->chunks[i].kdata = drm_malloc_ab(size, sizeof(uint32_t));
 351                 size *= sizeof(uint32_t);
 352                 if (p->chunks[i].kdata == NULL) {
 353                         return -ENOMEM;
 354                 }
 355                 if (copy_from_user(p->chunks[i].kdata, cdata, size)) {
 356                         return -EFAULT;
 357                 }
 358                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_FLAGS) {
 359                         p->cs_flags = p->chunks[i].kdata[0];
 360                         if (p->chunks[i].length_dw > 1)
 361                                 ring = p->chunks[i].kdata[1];
 362                         if (p->chunks[i].length_dw > 2)
 363                                 priority = (s32)p->chunks[i].kdata[2];
 364                 }
 365         }
 366
 367         /* these are KMS only */
 368         if (p->rdev) {
 369                 if ((p->cs_flags & RADEON_CS_USE_VM) &&
 370                     !p->rdev->vm_manager.enabled) {
 371                         DRM_ERROR("VM not active on asic!\n");
 372                         return -EINVAL;
 373                 }
 374
 375                 if (radeon_cs_get_ring(p, ring, priority))
 376                         return -EINVAL;
 377
 378                 /* we only support VM on some SI+ rings */
 379                 if ((p->cs_flags & RADEON_CS_USE_VM) == 0) {
 380                         if (p->rdev->asic->ring[p->ring]->cs_parse == NULL) {
 381                                 DRM_ERROR("Ring %d requires VM!\n", p->ring);
 382                                 return -EINVAL;
 383                         }
 384                 } else {
 385                         if (p->rdev->asic->ring[p->ring]->ib_parse == NULL) {
 386                                 DRM_ERROR("VM not supported on ring %d!\n",
 387                                           p->ring);
 388                                 return -EINVAL;
 389                         }
 390                 }
 391         }
 392
 393         return 0;
 394 }
 395
 396 static int cmp_size_smaller_first(void *priv, struct list_head *a,
 397                                   struct list_head *b)
 398 {
 399         struct radeon_cs_reloc *la = list_entry(a, struct radeon_cs_reloc, tv.head);
 400         struct radeon_cs_reloc *lb = list_entry(b, struct radeon_cs_reloc, tv.head);
 401
 402         /* Sort A before B if A is smaller. */
 403         return (int)la->robj->tbo.num_pages - (int)lb->robj->tbo.num_pages;
 404 }
 405
 406 /**
 407  * cs_parser_fini() - clean parser states
 408  * @parser:     parser structure holding parsing context.
 409  * @error:      error number
 410  *
 411  * If error is set than unvalidate buffer, otherwise just free memory
 412  * used by parsing context.
 413  **/
 414 static void radeon_cs_parser_fini(struct radeon_cs_parser *parser, int error, bool backoff)
 415 {
 416         unsigned i;
 417
 418         if (!error) {
 419                 /* Sort the buffer list from the smallest to largest buffer,
 420                  * which affects the order of buffers in the LRU list.
 421                  * This assures that the smallest buffers are added first
 422                  * to the LRU list, so they are likely to be later evicted
 423                  * first, instead of large buffers whose eviction is more
 424                  * expensive.
 425                  *
 426                  * This slightly lowers the number of bytes moved by TTM
 427                  * per frame under memory pressure.
 428                  */
 429                 list_sort(NULL, &parser->validated, cmp_size_smaller_first);
 430
 431                 ttm_eu_fence_buffer_objects(&parser->ticket,
 432                                             &parser->validated,
 433                                             &parser->ib.fence->base);
 434         } else if (backoff) {
 435                 ttm_eu_backoff_reservation(&parser->ticket,
 436                                            &parser->validated);
 437         }
 438
 439         if (parser->relocs != NULL) {
 440                 for (i = 0; i < parser->nrelocs; i++) {
 441                         if (parser->relocs[i].gobj)
 442                                 drm_gem_object_unreference_unlocked(parser->relocs[i].gobj);
 443                 }
 444         }
 445         kfree(parser->track);
 446         kfree(parser->relocs);
 447         kfree(parser->relocs_ptr);
 448         kfree(parser->vm_bos);
 449         for (i = 0; i < parser->nchunks; i++)
 450                 drm_free_large(parser->chunks[i].kdata);
 451         kfree(parser->chunks);
 452         kfree(parser->chunks_array);
 453         radeon_ib_free(parser->rdev, &parser->ib);
 454         radeon_ib_free(parser->rdev, &parser->const_ib);
 455 }
 456
 457 static int radeon_cs_ib_chunk(struct radeon_device *rdev,
 458                               struct radeon_cs_parser *parser)
 459 {
 460         int r;
 461
 462         if (parser->chunk_ib_idx == -1)
 463                 return 0;
 464
 465         if (parser->cs_flags & RADEON_CS_USE_VM)
 466                 return 0;
 467
 468         r = radeon_cs_parse(rdev, parser->ring, parser);
 469         if (r || parser->parser_error) {
 470                 DRM_ERROR("Invalid command stream !\n");
 471                 return r;
 472         }
 473
 474         if (parser->ring == R600_RING_TYPE_UVD_INDEX)
 475                 radeon_uvd_note_usage(rdev);
 476         else if ((parser->ring == TN_RING_TYPE_VCE1_INDEX) ||
 477                  (parser->ring == TN_RING_TYPE_VCE2_INDEX))
 478                 radeon_vce_note_usage(rdev);
 479
 480         radeon_cs_sync_rings(parser);
 481         r = radeon_ib_schedule(rdev, &parser->ib, NULL, true);
 482         if (r) {
 483                 DRM_ERROR("Failed to schedule IB !\n");
 484         }
 485         return r;
 486 }
 487
 488 static int radeon_bo_vm_update_pte(struct radeon_cs_parser *p,
 489                                    struct radeon_vm *vm)
 490 {
 491         struct radeon_device *rdev = p->rdev;
 492         struct radeon_bo_va *bo_va;
 493         int i, r;
 494
 495         r = radeon_vm_update_page_directory(rdev, vm);
 496         if (r)
 497                 return r;
 498
 499         r = radeon_vm_clear_freed(rdev, vm);
 500         if (r)
 501                 return r;
 502
 503         if (vm->ib_bo_va == NULL) {
 504                 DRM_ERROR("Tmp BO not in VM!\n");
 505                 return -EINVAL;
 506         }
 507
 508         r = radeon_vm_bo_update(rdev, vm->ib_bo_va,
 509                                 &rdev->ring_tmp_bo.bo->tbo.mem);
 510         if (r)
 511                 return r;
 512
 513         for (i = 0; i < p->nrelocs; i++) {
 514                 struct radeon_bo *bo;
 515
 516                 /* ignore duplicates */
 517                 if (p->relocs_ptr[i] != &p->relocs[i])
 518                         continue;
 519
 520                 bo = p->relocs[i].robj;
 521                 bo_va = radeon_vm_bo_find(vm, bo);
 522                 if (bo_va == NULL) {
 523                         dev_err(rdev->dev, "bo %p not in vm %p\n", bo, vm);
 524                         return -EINVAL;
 525                 }
 526
 527                 r = radeon_vm_bo_update(rdev, bo_va, &bo->tbo.mem);
 528                 if (r)
 529                         return r;
 530         }
 531
 532         return radeon_vm_clear_invalids(rdev, vm);
 533 }
 534
 535 static int radeon_cs_ib_vm_chunk(struct radeon_device *rdev,
 536                                  struct radeon_cs_parser *parser)
 537 {
 538         struct radeon_fpriv *fpriv = parser->filp->driver_priv;
 539         struct radeon_vm *vm = &fpriv->vm;
 540         int r;
 541
 542         if (parser->chunk_ib_idx == -1)
 543                 return 0;
 544         if ((parser->cs_flags & RADEON_CS_USE_VM) == 0)
 545                 return 0;
 546
 547         if (parser->const_ib.length_dw) {
 548                 r = radeon_ring_ib_parse(rdev, parser->ring, &parser->const_ib);
 549                 if (r) {
 550                         return r;
 551                 }
 552         }
 553
 554         r = radeon_ring_ib_parse(rdev, parser->ring, &parser->ib);
 555         if (r) {
 556                 return r;
 557         }
 558
 559         if (parser->ring == R600_RING_TYPE_UVD_INDEX)
 560                 radeon_uvd_note_usage(rdev);
 561
 562         mutex_lock(&vm->mutex);
 563         r = radeon_bo_vm_update_pte(parser, vm);
 564         if (r) {
 565                 goto out;
 566         }
 567         radeon_cs_sync_rings(parser);
 568         radeon_semaphore_sync_fence(parser->ib.semaphore, vm->fence);
 569
 570         if ((rdev->family >= CHIP_TAHITI) &&
 571             (parser->chunk_const_ib_idx != -1)) {
 572                 r = radeon_ib_schedule(rdev, &parser->ib, &parser->const_ib, true);
 573         } else {
 574                 r = radeon_ib_schedule(rdev, &parser->ib, NULL, true);
 575         }
 576
 577 out:
 578         mutex_unlock(&vm->mutex);
 579         return r;
 580 }
 581
 582 static int radeon_cs_handle_lockup(struct radeon_device *rdev, int r)
 583 {
 584         if (r == -EDEADLK) {
 585                 r = radeon_gpu_reset(rdev);
 586                 if (!r)
 587                         r = -EAGAIN;
 588         }
 589         return r;
 590 }
 591
 592 static int radeon_cs_ib_fill(struct radeon_device *rdev, struct radeon_cs_parser *parser)
 593 {
 594         struct radeon_cs_chunk *ib_chunk;
 595         struct radeon_vm *vm = NULL;
 596         int r;
 597
 598         if (parser->chunk_ib_idx == -1)
 599                 return 0;
 600
 601         if (parser->cs_flags & RADEON_CS_USE_VM) {
 602                 struct radeon_fpriv *fpriv = parser->filp->driver_priv;
 603                 vm = &fpriv->vm;
 604
 605                 if ((rdev->family >= CHIP_TAHITI) &&
 606                     (parser->chunk_const_ib_idx != -1)) {
 607                         ib_chunk = &parser->chunks[parser->chunk_const_ib_idx];
 608                         if (ib_chunk->length_dw > RADEON_IB_VM_MAX_SIZE) {
 609                                 DRM_ERROR("cs IB CONST too big: %d\n", ib_chunk->length_dw);
 610                                 return -EINVAL;
 611                         }
 612                         r =  radeon_ib_get(rdev, parser->ring, &parser->const_ib,
 613                                            vm, ib_chunk->length_dw * 4);
 614                         if (r) {
 615                                 DRM_ERROR("Failed to get const ib !\n");
 616                                 return r;
 617                         }
 618                         parser->const_ib.is_const_ib = true;
 619                         parser->const_ib.length_dw = ib_chunk->length_dw;
 620                         if (copy_from_user(parser->const_ib.ptr,
 621                                                ib_chunk->user_ptr,
 622                                                ib_chunk->length_dw * 4))
 623                                 return -EFAULT;
 624                 }
 625
 626                 ib_chunk = &parser->chunks[parser->chunk_ib_idx];
 627                 if (ib_chunk->length_dw > RADEON_IB_VM_MAX_SIZE) {
 628                         DRM_ERROR("cs IB too big: %d\n", ib_chunk->length_dw);
 629                         return -EINVAL;
 630                 }
 631         }
 632         ib_chunk = &parser->chunks[parser->chunk_ib_idx];
 633
 634         r =  radeon_ib_get(rdev, parser->ring, &parser->ib,
 635                            vm, ib_chunk->length_dw * 4);
 636         if (r) {
 637                 DRM_ERROR("Failed to get ib !\n");
 638                 return r;
 639         }
 640         parser->ib.length_dw = ib_chunk->length_dw;
 641         if (ib_chunk->kdata)
 642                 memcpy(parser->ib.ptr, ib_chunk->kdata, ib_chunk->length_dw * 4);
 643         else if (copy_from_user(parser->ib.ptr, ib_chunk->user_ptr, ib_chunk->length_dw * 4))
 644                 return -EFAULT;
 645         return 0;
 646 }
 647
 648 int radeon_cs_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
 649 {
 650         struct radeon_device *rdev = dev->dev_private;
 651         struct radeon_cs_parser parser;
 652         int r;
 653
 654         down_read(&rdev->exclusive_lock);
 655         if (!rdev->accel_working) {
 656                 up_read(&rdev->exclusive_lock);
 657                 return -EBUSY;
 658         }
 659         if (rdev->in_reset) {
 660                 up_read(&rdev->exclusive_lock);
 661                 r = radeon_gpu_reset(rdev);
 662                 if (!r)
 663                         r = -EAGAIN;
 664                 return r;
 665         }
 666         /* initialize parser */
 667         memset(&parser, 0, sizeof(struct radeon_cs_parser));
 668         parser.filp = filp;
 669         parser.rdev = rdev;
 670         parser.dev = rdev->dev;
 671         parser.family = rdev->family;
 672         r = radeon_cs_parser_init(&parser, data);
 673         if (r) {
 674                 DRM_ERROR("Failed to initialize parser !\n");
 675                 radeon_cs_parser_fini(&parser, r, false);
 676                 up_read(&rdev->exclusive_lock);
 677                 r = radeon_cs_handle_lockup(rdev, r);
 678                 return r;
 679         }
 680
 681         r = radeon_cs_ib_fill(rdev, &parser);
 682         if (!r) {
 683                 r = radeon_cs_parser_relocs(&parser);
 684                 if (r && r != -ERESTARTSYS)
 685                         DRM_ERROR("Failed to parse relocation %d!\n", r);
 686         }
 687
 688         if (r) {
 689                 radeon_cs_parser_fini(&parser, r, false);
 690                 up_read(&rdev->exclusive_lock);
 691                 r = radeon_cs_handle_lockup(rdev, r);
 692                 return r;
 693         }
 694
 695         trace_radeon_cs(&parser);
 696
 697         r = radeon_cs_ib_chunk(rdev, &parser);
 698         if (r) {
 699                 goto out;
 700         }
 701         r = radeon_cs_ib_vm_chunk(rdev, &parser);
 702         if (r) {
 703                 goto out;
 704         }
 705 out:
 706         radeon_cs_parser_fini(&parser, r, true);
 707         up_read(&rdev->exclusive_lock);
 708         r = radeon_cs_handle_lockup(rdev, r);
 709         return r;
 710 }
 711
 712 /**
 713  * radeon_cs_packet_parse() - parse cp packet and point ib index to next packet
 714  * @parser:     parser structure holding parsing context.
 715  * @pkt:        where to store packet information
 716  *
 717  * Assume that chunk_ib_index is properly set. Will return -EINVAL
 718  * if packet is bigger than remaining ib size. or if packets is unknown.
 719  **/
 720 int radeon_cs_packet_parse(struct radeon_cs_parser *p,
 721                            struct radeon_cs_packet *pkt,
 722                            unsigned idx)
 723 {
 724         struct radeon_cs_chunk *ib_chunk = &p->chunks[p->chunk_ib_idx];
 725         struct radeon_device *rdev = p->rdev;
 726         uint32_t header;
 727
 728         if (idx >= ib_chunk->length_dw) {
 729                 DRM_ERROR("Can not parse packet at %d after CS end %d !\n",
 730                           idx, ib_chunk->length_dw);
 731                 return -EINVAL;
 732         }
 733         header = radeon_get_ib_value(p, idx);
 734         pkt->idx = idx;
 735         pkt->type = RADEON_CP_PACKET_GET_TYPE(header);
 736         pkt->count = RADEON_CP_PACKET_GET_COUNT(header);
 737         pkt->one_reg_wr = 0;
 738         switch (pkt->type) {
 739         case RADEON_PACKET_TYPE0:
 740                 if (rdev->family < CHIP_R600) {
 741                         pkt->reg = R100_CP_PACKET0_GET_REG(header);
 742                         pkt->one_reg_wr =
 743                                 RADEON_CP_PACKET0_GET_ONE_REG_WR(header);
 744                 } else
 745                         pkt->reg = R600_CP_PACKET0_GET_REG(header);
 746                 break;
 747         case RADEON_PACKET_TYPE3:
 748                 pkt->opcode = RADEON_CP_PACKET3_GET_OPCODE(header);
 749                 break;
 750         case RADEON_PACKET_TYPE2:
 751                 pkt->count = -1;
 752                 break;
 753         default:
 754                 DRM_ERROR("Unknown packet type %d at %d !\n", pkt->type, idx);
 755                 return -EINVAL;
 756         }
 757         if ((pkt->count + 1 + pkt->idx) >= ib_chunk->length_dw) {
 758                 DRM_ERROR("Packet (%d:%d:%d) end after CS buffer (%d) !\n",
 759                           pkt->idx, pkt->type, pkt->count, ib_chunk->length_dw);
 760                 return -EINVAL;
 761         }
 762         return 0;
 763 }
 764
 765 /**
 766  * radeon_cs_packet_next_is_pkt3_nop() - test if the next packet is P3 NOP
 767  * @p:          structure holding the parser context.
 768  *
 769  * Check if the next packet is NOP relocation packet3.
 770  **/
 771 bool radeon_cs_packet_next_is_pkt3_nop(struct radeon_cs_parser *p)
 772 {
 773         struct radeon_cs_packet p3reloc;
 774         int r;
 775
 776         r = radeon_cs_packet_parse(p, &p3reloc, p->idx);
 777         if (r)
 778                 return false;
 779         if (p3reloc.type != RADEON_PACKET_TYPE3)
 780                 return false;
 781         if (p3reloc.opcode != RADEON_PACKET3_NOP)
 782                 return false;
 783         return true;
 784 }
 785
 786 /**
 787  * radeon_cs_dump_packet() - dump raw packet context
 788  * @p:          structure holding the parser context.
 789  * @pkt:        structure holding the packet.
 790  *
 791  * Used mostly for debugging and error reporting.
 792  **/
 793 void radeon_cs_dump_packet(struct radeon_cs_parser *p,
 794                            struct radeon_cs_packet *pkt)
 795 {
 796         volatile uint32_t *ib;
 797         unsigned i;
 798         unsigned idx;
 799
 800         ib = p->ib.ptr;
 801         idx = pkt->idx;
 802         for (i = 0; i <= (pkt->count + 1); i++, idx++)
 803                 DRM_INFO("ib[%d]=0x%08X\n", idx, ib[idx]);
 804 }
 805
 806 /**
 807  * radeon_cs_packet_next_reloc() - parse next (should be reloc) packet
 808  * @parser:             parser structure holding parsing context.
 809  * @data:               pointer to relocation data
 810  * @offset_start:       starting offset
 811  * @offset_mask:        offset mask (to align start offset on)
 812  * @reloc:              reloc informations
 813  *
 814  * Check if next packet is relocation packet3, do bo validation and compute
 815  * GPU offset using the provided start.
 816  **/
 817 int radeon_cs_packet_next_reloc(struct radeon_cs_parser *p,
 818                                 struct radeon_cs_reloc **cs_reloc,
 819                                 int nomm)
 820 {
 821         struct radeon_cs_chunk *relocs_chunk;
 822         struct radeon_cs_packet p3reloc;
 823         unsigned idx;
 824         int r;
 825
 826         if (p->chunk_relocs_idx == -1) {
 827                 DRM_ERROR("No relocation chunk !\n");
 828                 return -EINVAL;
 829         }
 830         *cs_reloc = NULL;
 831         relocs_chunk = &p->chunks[p->chunk_relocs_idx];
 832         r = radeon_cs_packet_parse(p, &p3reloc, p->idx);
 833         if (r)
 834                 return r;
 835         p->idx += p3reloc.count + 2;
 836         if (p3reloc.type != RADEON_PACKET_TYPE3 ||
 837             p3reloc.opcode != RADEON_PACKET3_NOP) {
 838                 DRM_ERROR("No packet3 for relocation for packet at %d.\n",
 839                           p3reloc.idx);
 840                 radeon_cs_dump_packet(p, &p3reloc);
 841                 return -EINVAL;
 842         }
 843         idx = radeon_get_ib_value(p, p3reloc.idx + 1);
 844         if (idx >= relocs_chunk->length_dw) {
 845                 DRM_ERROR("Relocs at %d after relocations chunk end %d !\n",
 846                           idx, relocs_chunk->length_dw);
 847                 radeon_cs_dump_packet(p, &p3reloc);
 848                 return -EINVAL;
 849         }
 850         /* FIXME: we assume reloc size is 4 dwords */
 851         if (nomm) {
 852                 *cs_reloc = p->relocs;
 853                 (*cs_reloc)->gpu_offset =
 854                         (u64)relocs_chunk->kdata[idx + 3] << 32;
 855                 (*cs_reloc)->gpu_offset |= relocs_chunk->kdata[idx + 0];
 856         } else
 857                 *cs_reloc = p->relocs_ptr[(idx / 4)];
 858         return 0;
 859 }