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                 struct fence *fence;
 259
 260                 if (!p->relocs[i].robj)
 261                         continue;
 262
 263                 resv = p->relocs[i].robj->tbo.resv;
 264                 fence = reservation_object_get_excl(resv);
 265
 266                 radeon_semaphore_sync_to(p->ib.semaphore,
 267                                          (struct radeon_fence *)fence);
 268         }
 269 }
 270
 271 /* XXX: note that this is called from the legacy UMS CS ioctl as well */
 272 int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data)
 273 {
 274         struct drm_radeon_cs *cs = data;
 275         uint64_t *chunk_array_ptr;
 276         unsigned size, i;
 277         u32 ring = RADEON_CS_RING_GFX;
 278         s32 priority = 0;
 279
 280         if (!cs->num_chunks) {
 281                 return 0;
 282         }
 283         /* get chunks */
 284         INIT_LIST_HEAD(&p->validated);
 285         p->idx = 0;
 286         p->ib.sa_bo = NULL;
 287         p->ib.semaphore = NULL;
 288         p->const_ib.sa_bo = NULL;
 289         p->const_ib.semaphore = NULL;
 290         p->chunk_ib_idx = -1;
 291         p->chunk_relocs_idx = -1;
 292         p->chunk_flags_idx = -1;
 293         p->chunk_const_ib_idx = -1;
 294         p->chunks_array = kcalloc(cs->num_chunks, sizeof(uint64_t), GFP_KERNEL);
 295         if (p->chunks_array == NULL) {
 296                 return -ENOMEM;
 297         }
 298         chunk_array_ptr = (uint64_t *)(unsigned long)(cs->chunks);
 299         if (copy_from_user(p->chunks_array, chunk_array_ptr,
 300                                sizeof(uint64_t)*cs->num_chunks)) {
 301                 return -EFAULT;
 302         }
 303         p->cs_flags = 0;
 304         p->nchunks = cs->num_chunks;
 305         p->chunks = kcalloc(p->nchunks, sizeof(struct radeon_cs_chunk), GFP_KERNEL);
 306         if (p->chunks == NULL) {
 307                 return -ENOMEM;
 308         }
 309         for (i = 0; i < p->nchunks; i++) {
 310                 struct drm_radeon_cs_chunk __user **chunk_ptr = NULL;
 311                 struct drm_radeon_cs_chunk user_chunk;
 312                 uint32_t __user *cdata;
 313
 314                 chunk_ptr = (void __user*)(unsigned long)p->chunks_array[i];
 315                 if (copy_from_user(&user_chunk, chunk_ptr,
 316                                        sizeof(struct drm_radeon_cs_chunk))) {
 317                         return -EFAULT;
 318                 }
 319                 p->chunks[i].length_dw = user_chunk.length_dw;
 320                 p->chunks[i].chunk_id = user_chunk.chunk_id;
 321                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_RELOCS) {
 322                         p->chunk_relocs_idx = i;
 323                 }
 324                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_IB) {
 325                         p->chunk_ib_idx = i;
 326                         /* zero length IB isn't useful */
 327                         if (p->chunks[i].length_dw == 0)
 328                                 return -EINVAL;
 329                 }
 330                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_CONST_IB) {
 331                         p->chunk_const_ib_idx = i;
 332                         /* zero length CONST IB isn't useful */
 333                         if (p->chunks[i].length_dw == 0)
 334                                 return -EINVAL;
 335                 }
 336                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_FLAGS) {
 337                         p->chunk_flags_idx = i;
 338                         /* zero length flags aren't useful */
 339                         if (p->chunks[i].length_dw == 0)
 340                                 return -EINVAL;
 341                 }
 342
 343                 size = p->chunks[i].length_dw;
 344                 cdata = (void __user *)(unsigned long)user_chunk.chunk_data;
 345                 p->chunks[i].user_ptr = cdata;
 346                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_CONST_IB)
 347                         continue;
 348
 349                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_IB) {
 350                         if (!p->rdev || !(p->rdev->flags & RADEON_IS_AGP))
 351                                 continue;
 352                 }
 353
 354                 p->chunks[i].kdata = drm_malloc_ab(size, sizeof(uint32_t));
 355                 size *= sizeof(uint32_t);
 356                 if (p->chunks[i].kdata == NULL) {
 357                         return -ENOMEM;
 358                 }
 359                 if (copy_from_user(p->chunks[i].kdata, cdata, size)) {
 360                         return -EFAULT;
 361                 }
 362                 if (p->chunks[i].chunk_id == RADEON_CHUNK_ID_FLAGS) {
 363                         p->cs_flags = p->chunks[i].kdata[0];
 364                         if (p->chunks[i].length_dw > 1)
 365                                 ring = p->chunks[i].kdata[1];
 366                         if (p->chunks[i].length_dw > 2)
 367                                 priority = (s32)p->chunks[i].kdata[2];
 368                 }
 369         }
 370
 371         /* these are KMS only */
 372         if (p->rdev) {
 373                 if ((p->cs_flags & RADEON_CS_USE_VM) &&
 374                     !p->rdev->vm_manager.enabled) {
 375                         DRM_ERROR("VM not active on asic!\n");
 376                         return -EINVAL;
 377                 }
 378
 379                 if (radeon_cs_get_ring(p, ring, priority))
 380                         return -EINVAL;
 381
 382                 /* we only support VM on some SI+ rings */
 383                 if ((p->cs_flags & RADEON_CS_USE_VM) == 0) {
 384                         if (p->rdev->asic->ring[p->ring]->cs_parse == NULL) {
 385                                 DRM_ERROR("Ring %d requires VM!\n", p->ring);
 386                                 return -EINVAL;
 387                         }
 388                 } else {
 389                         if (p->rdev->asic->ring[p->ring]->ib_parse == NULL) {
 390                                 DRM_ERROR("VM not supported on ring %d!\n",
 391                                           p->ring);
 392                                 return -EINVAL;
 393                         }
 394                 }
 395         }
 396
 397         return 0;
 398 }
 399
 400 static int cmp_size_smaller_first(void *priv, struct list_head *a,
 401                                   struct list_head *b)
 402 {
 403         struct radeon_cs_reloc *la = list_entry(a, struct radeon_cs_reloc, tv.head);
 404         struct radeon_cs_reloc *lb = list_entry(b, struct radeon_cs_reloc, tv.head);
 405
 406         /* Sort A before B if A is smaller. */
 407         return (int)la->robj->tbo.num_pages - (int)lb->robj->tbo.num_pages;
 408 }
 409
 410 /**
 411  * cs_parser_fini() - clean parser states
 412  * @parser:     parser structure holding parsing context.
 413  * @error:      error number
 414  *
 415  * If error is set than unvalidate buffer, otherwise just free memory
 416  * used by parsing context.
 417  **/
 418 static void radeon_cs_parser_fini(struct radeon_cs_parser *parser, int error, bool backoff)
 419 {
 420         unsigned i;
 421
 422         if (!error) {
 423                 /* Sort the buffer list from the smallest to largest buffer,
 424                  * which affects the order of buffers in the LRU list.
 425                  * This assures that the smallest buffers are added first
 426                  * to the LRU list, so they are likely to be later evicted
 427                  * first, instead of large buffers whose eviction is more
 428                  * expensive.
 429                  *
 430                  * This slightly lowers the number of bytes moved by TTM
 431                  * per frame under memory pressure.
 432                  */
 433                 list_sort(NULL, &parser->validated, cmp_size_smaller_first);
 434
 435                 ttm_eu_fence_buffer_objects(&parser->ticket,
 436                                             &parser->validated,
 437                                             &parser->ib.fence->base);
 438         } else if (backoff) {
 439                 ttm_eu_backoff_reservation(&parser->ticket,
 440                                            &parser->validated);
 441         }
 442
 443         if (parser->relocs != NULL) {
 444                 for (i = 0; i < parser->nrelocs; i++) {
 445                         if (parser->relocs[i].gobj)
 446                                 drm_gem_object_unreference_unlocked(parser->relocs[i].gobj);
 447                 }
 448         }
 449         kfree(parser->track);
 450         kfree(parser->relocs);
 451         kfree(parser->relocs_ptr);
 452         kfree(parser->vm_bos);
 453         for (i = 0; i < parser->nchunks; i++)
 454                 drm_free_large(parser->chunks[i].kdata);
 455         kfree(parser->chunks);
 456         kfree(parser->chunks_array);
 457         radeon_ib_free(parser->rdev, &parser->ib);
 458         radeon_ib_free(parser->rdev, &parser->const_ib);
 459 }
 460
 461 static int radeon_cs_ib_chunk(struct radeon_device *rdev,
 462                               struct radeon_cs_parser *parser)
 463 {
 464         int r;
 465
 466         if (parser->chunk_ib_idx == -1)
 467                 return 0;
 468
 469         if (parser->cs_flags & RADEON_CS_USE_VM)
 470                 return 0;
 471
 472         r = radeon_cs_parse(rdev, parser->ring, parser);
 473         if (r || parser->parser_error) {
 474                 DRM_ERROR("Invalid command stream !\n");
 475                 return r;
 476         }
 477
 478         if (parser->ring == R600_RING_TYPE_UVD_INDEX)
 479                 radeon_uvd_note_usage(rdev);
 480         else if ((parser->ring == TN_RING_TYPE_VCE1_INDEX) ||
 481                  (parser->ring == TN_RING_TYPE_VCE2_INDEX))
 482                 radeon_vce_note_usage(rdev);
 483
 484         radeon_cs_sync_rings(parser);
 485         r = radeon_ib_schedule(rdev, &parser->ib, NULL, true);
 486         if (r) {
 487                 DRM_ERROR("Failed to schedule IB !\n");
 488         }
 489         return r;
 490 }
 491
 492 static int radeon_bo_vm_update_pte(struct radeon_cs_parser *p,
 493                                    struct radeon_vm *vm)
 494 {
 495         struct radeon_device *rdev = p->rdev;
 496         struct radeon_bo_va *bo_va;
 497         int i, r;
 498
 499         r = radeon_vm_update_page_directory(rdev, vm);
 500         if (r)
 501                 return r;
 502
 503         r = radeon_vm_clear_freed(rdev, vm);
 504         if (r)
 505                 return r;
 506
 507         if (vm->ib_bo_va == NULL) {
 508                 DRM_ERROR("Tmp BO not in VM!\n");
 509                 return -EINVAL;
 510         }
 511
 512         r = radeon_vm_bo_update(rdev, vm->ib_bo_va,
 513                                 &rdev->ring_tmp_bo.bo->tbo.mem);
 514         if (r)
 515                 return r;
 516
 517         for (i = 0; i < p->nrelocs; i++) {
 518                 struct radeon_bo *bo;
 519
 520                 /* ignore duplicates */
 521                 if (p->relocs_ptr[i] != &p->relocs[i])
 522                         continue;
 523
 524                 bo = p->relocs[i].robj;
 525                 bo_va = radeon_vm_bo_find(vm, bo);
 526                 if (bo_va == NULL) {
 527                         dev_err(rdev->dev, "bo %p not in vm %p\n", bo, vm);
 528                         return -EINVAL;
 529                 }
 530
 531                 r = radeon_vm_bo_update(rdev, bo_va, &bo->tbo.mem);
 532                 if (r)
 533                         return r;
 534         }
 535
 536         return radeon_vm_clear_invalids(rdev, vm);
 537 }
 538
 539 static int radeon_cs_ib_vm_chunk(struct radeon_device *rdev,
 540                                  struct radeon_cs_parser *parser)
 541 {
 542         struct radeon_fpriv *fpriv = parser->filp->driver_priv;
 543         struct radeon_vm *vm = &fpriv->vm;
 544         int r;
 545
 546         if (parser->chunk_ib_idx == -1)
 547                 return 0;
 548         if ((parser->cs_flags & RADEON_CS_USE_VM) == 0)
 549                 return 0;
 550
 551         if (parser->const_ib.length_dw) {
 552                 r = radeon_ring_ib_parse(rdev, parser->ring, &parser->const_ib);
 553                 if (r) {
 554                         return r;
 555                 }
 556         }
 557
 558         r = radeon_ring_ib_parse(rdev, parser->ring, &parser->ib);
 559         if (r) {
 560                 return r;
 561         }
 562
 563         if (parser->ring == R600_RING_TYPE_UVD_INDEX)
 564                 radeon_uvd_note_usage(rdev);
 565
 566         mutex_lock(&vm->mutex);
 567         r = radeon_bo_vm_update_pte(parser, vm);
 568         if (r) {
 569                 goto out;
 570         }
 571         radeon_cs_sync_rings(parser);
 572         radeon_semaphore_sync_to(parser->ib.semaphore, vm->fence);
 573
 574         if ((rdev->family >= CHIP_TAHITI) &&
 575             (parser->chunk_const_ib_idx != -1)) {
 576                 r = radeon_ib_schedule(rdev, &parser->ib, &parser->const_ib, true);
 577         } else {
 578                 r = radeon_ib_schedule(rdev, &parser->ib, NULL, true);
 579         }
 580
 581 out:
 582         mutex_unlock(&vm->mutex);
 583         return r;
 584 }
 585
 586 static int radeon_cs_handle_lockup(struct radeon_device *rdev, int r)
 587 {
 588         if (r == -EDEADLK) {
 589                 r = radeon_gpu_reset(rdev);
 590                 if (!r)
 591                         r = -EAGAIN;
 592         }
 593         return r;
 594 }
 595
 596 static int radeon_cs_ib_fill(struct radeon_device *rdev, struct radeon_cs_parser *parser)
 597 {
 598         struct radeon_cs_chunk *ib_chunk;
 599         struct radeon_vm *vm = NULL;
 600         int r;
 601
 602         if (parser->chunk_ib_idx == -1)
 603                 return 0;
 604
 605         if (parser->cs_flags & RADEON_CS_USE_VM) {
 606                 struct radeon_fpriv *fpriv = parser->filp->driver_priv;
 607                 vm = &fpriv->vm;
 608
 609                 if ((rdev->family >= CHIP_TAHITI) &&
 610                     (parser->chunk_const_ib_idx != -1)) {
 611                         ib_chunk = &parser->chunks[parser->chunk_const_ib_idx];
 612                         if (ib_chunk->length_dw > RADEON_IB_VM_MAX_SIZE) {
 613                                 DRM_ERROR("cs IB CONST too big: %d\n", ib_chunk->length_dw);
 614                                 return -EINVAL;
 615                         }
 616                         r =  radeon_ib_get(rdev, parser->ring, &parser->const_ib,
 617                                            vm, ib_chunk->length_dw * 4);
 618                         if (r) {
 619                                 DRM_ERROR("Failed to get const ib !\n");
 620                                 return r;
 621                         }
 622                         parser->const_ib.is_const_ib = true;
 623                         parser->const_ib.length_dw = ib_chunk->length_dw;
 624                         if (copy_from_user(parser->const_ib.ptr,
 625                                                ib_chunk->user_ptr,
 626                                                ib_chunk->length_dw * 4))
 627                                 return -EFAULT;
 628                 }
 629
 630                 ib_chunk = &parser->chunks[parser->chunk_ib_idx];
 631                 if (ib_chunk->length_dw > RADEON_IB_VM_MAX_SIZE) {
 632                         DRM_ERROR("cs IB too big: %d\n", ib_chunk->length_dw);
 633                         return -EINVAL;
 634                 }
 635         }
 636         ib_chunk = &parser->chunks[parser->chunk_ib_idx];
 637
 638         r =  radeon_ib_get(rdev, parser->ring, &parser->ib,
 639                            vm, ib_chunk->length_dw * 4);
 640         if (r) {
 641                 DRM_ERROR("Failed to get ib !\n");
 642                 return r;
 643         }
 644         parser->ib.length_dw = ib_chunk->length_dw;
 645         if (ib_chunk->kdata)
 646                 memcpy(parser->ib.ptr, ib_chunk->kdata, ib_chunk->length_dw * 4);
 647         else if (copy_from_user(parser->ib.ptr, ib_chunk->user_ptr, ib_chunk->length_dw * 4))
 648                 return -EFAULT;
 649         return 0;
 650 }
 651
 652 int radeon_cs_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
 653 {
 654         struct radeon_device *rdev = dev->dev_private;
 655         struct radeon_cs_parser parser;
 656         int r;
 657
 658         down_read(&rdev->exclusive_lock);
 659         if (!rdev->accel_working) {
 660                 up_read(&rdev->exclusive_lock);
 661                 return -EBUSY;
 662         }
 663         if (rdev->in_reset) {
 664                 up_read(&rdev->exclusive_lock);
 665                 r = radeon_gpu_reset(rdev);
 666                 if (!r)
 667                         r = -EAGAIN;
 668                 return r;
 669         }
 670         /* initialize parser */
 671         memset(&parser, 0, sizeof(struct radeon_cs_parser));
 672         parser.filp = filp;
 673         parser.rdev = rdev;
 674         parser.dev = rdev->dev;
 675         parser.family = rdev->family;
 676         r = radeon_cs_parser_init(&parser, data);
 677         if (r) {
 678                 DRM_ERROR("Failed to initialize parser !\n");
 679                 radeon_cs_parser_fini(&parser, r, false);
 680                 up_read(&rdev->exclusive_lock);
 681                 r = radeon_cs_handle_lockup(rdev, r);
 682                 return r;
 683         }
 684
 685         r = radeon_cs_ib_fill(rdev, &parser);
 686         if (!r) {
 687                 r = radeon_cs_parser_relocs(&parser);
 688                 if (r && r != -ERESTARTSYS)
 689                         DRM_ERROR("Failed to parse relocation %d!\n", r);
 690         }
 691
 692         if (r) {
 693                 radeon_cs_parser_fini(&parser, r, false);
 694                 up_read(&rdev->exclusive_lock);
 695                 r = radeon_cs_handle_lockup(rdev, r);
 696                 return r;
 697         }
 698
 699         trace_radeon_cs(&parser);
 700
 701         r = radeon_cs_ib_chunk(rdev, &parser);
 702         if (r) {
 703                 goto out;
 704         }
 705         r = radeon_cs_ib_vm_chunk(rdev, &parser);
 706         if (r) {
 707                 goto out;
 708         }
 709 out:
 710         radeon_cs_parser_fini(&parser, r, true);
 711         up_read(&rdev->exclusive_lock);
 712         r = radeon_cs_handle_lockup(rdev, r);
 713         return r;
 714 }
 715
 716 /**
 717  * radeon_cs_packet_parse() - parse cp packet and point ib index to next packet
 718  * @parser:     parser structure holding parsing context.
 719  * @pkt:        where to store packet information
 720  *
 721  * Assume that chunk_ib_index is properly set. Will return -EINVAL
 722  * if packet is bigger than remaining ib size. or if packets is unknown.
 723  **/
 724 int radeon_cs_packet_parse(struct radeon_cs_parser *p,
 725                            struct radeon_cs_packet *pkt,
 726                            unsigned idx)
 727 {
 728         struct radeon_cs_chunk *ib_chunk = &p->chunks[p->chunk_ib_idx];
 729         struct radeon_device *rdev = p->rdev;
 730         uint32_t header;
 731
 732         if (idx >= ib_chunk->length_dw) {
 733                 DRM_ERROR("Can not parse packet at %d after CS end %d !\n",
 734                           idx, ib_chunk->length_dw);
 735                 return -EINVAL;
 736         }
 737         header = radeon_get_ib_value(p, idx);
 738         pkt->idx = idx;
 739         pkt->type = RADEON_CP_PACKET_GET_TYPE(header);
 740         pkt->count = RADEON_CP_PACKET_GET_COUNT(header);
 741         pkt->one_reg_wr = 0;
 742         switch (pkt->type) {
 743         case RADEON_PACKET_TYPE0:
 744                 if (rdev->family < CHIP_R600) {
 745                         pkt->reg = R100_CP_PACKET0_GET_REG(header);
 746                         pkt->one_reg_wr =
 747                                 RADEON_CP_PACKET0_GET_ONE_REG_WR(header);
 748                 } else
 749                         pkt->reg = R600_CP_PACKET0_GET_REG(header);
 750                 break;
 751         case RADEON_PACKET_TYPE3:
 752                 pkt->opcode = RADEON_CP_PACKET3_GET_OPCODE(header);
 753                 break;
 754         case RADEON_PACKET_TYPE2:
 755                 pkt->count = -1;
 756                 break;
 757         default:
 758                 DRM_ERROR("Unknown packet type %d at %d !\n", pkt->type, idx);
 759                 return -EINVAL;
 760         }
 761         if ((pkt->count + 1 + pkt->idx) >= ib_chunk->length_dw) {
 762                 DRM_ERROR("Packet (%d:%d:%d) end after CS buffer (%d) !\n",
 763                           pkt->idx, pkt->type, pkt->count, ib_chunk->length_dw);
 764                 return -EINVAL;
 765         }
 766         return 0;
 767 }
 768
 769 /**
 770  * radeon_cs_packet_next_is_pkt3_nop() - test if the next packet is P3 NOP
 771  * @p:          structure holding the parser context.
 772  *
 773  * Check if the next packet is NOP relocation packet3.
 774  **/
 775 bool radeon_cs_packet_next_is_pkt3_nop(struct radeon_cs_parser *p)
 776 {
 777         struct radeon_cs_packet p3reloc;
 778         int r;
 779
 780         r = radeon_cs_packet_parse(p, &p3reloc, p->idx);
 781         if (r)
 782                 return false;
 783         if (p3reloc.type != RADEON_PACKET_TYPE3)
 784                 return false;
 785         if (p3reloc.opcode != RADEON_PACKET3_NOP)
 786                 return false;
 787         return true;
 788 }
 789
 790 /**
 791  * radeon_cs_dump_packet() - dump raw packet context
 792  * @p:          structure holding the parser context.
 793  * @pkt:        structure holding the packet.
 794  *
 795  * Used mostly for debugging and error reporting.
 796  **/
 797 void radeon_cs_dump_packet(struct radeon_cs_parser *p,
 798                            struct radeon_cs_packet *pkt)
 799 {
 800         volatile uint32_t *ib;
 801         unsigned i;
 802         unsigned idx;
 803
 804         ib = p->ib.ptr;
 805         idx = pkt->idx;
 806         for (i = 0; i <= (pkt->count + 1); i++, idx++)
 807                 DRM_INFO("ib[%d]=0x%08X\n", idx, ib[idx]);
 808 }
 809
 810 /**
 811  * radeon_cs_packet_next_reloc() - parse next (should be reloc) packet
 812  * @parser:             parser structure holding parsing context.
 813  * @data:               pointer to relocation data
 814  * @offset_start:       starting offset
 815  * @offset_mask:        offset mask (to align start offset on)
 816  * @reloc:              reloc informations
 817  *
 818  * Check if next packet is relocation packet3, do bo validation and compute
 819  * GPU offset using the provided start.
 820  **/
 821 int radeon_cs_packet_next_reloc(struct radeon_cs_parser *p,
 822                                 struct radeon_cs_reloc **cs_reloc,
 823                                 int nomm)
 824 {
 825         struct radeon_cs_chunk *relocs_chunk;
 826         struct radeon_cs_packet p3reloc;
 827         unsigned idx;
 828         int r;
 829
 830         if (p->chunk_relocs_idx == -1) {
 831                 DRM_ERROR("No relocation chunk !\n");
 832                 return -EINVAL;
 833         }
 834         *cs_reloc = NULL;
 835         relocs_chunk = &p->chunks[p->chunk_relocs_idx];
 836         r = radeon_cs_packet_parse(p, &p3reloc, p->idx);
 837         if (r)
 838                 return r;
 839         p->idx += p3reloc.count + 2;
 840         if (p3reloc.type != RADEON_PACKET_TYPE3 ||
 841             p3reloc.opcode != RADEON_PACKET3_NOP) {
 842                 DRM_ERROR("No packet3 for relocation for packet at %d.\n",
 843                           p3reloc.idx);
 844                 radeon_cs_dump_packet(p, &p3reloc);
 845                 return -EINVAL;
 846         }
 847         idx = radeon_get_ib_value(p, p3reloc.idx + 1);
 848         if (idx >= relocs_chunk->length_dw) {
 849                 DRM_ERROR("Relocs at %d after relocations chunk end %d !\n",
 850                           idx, relocs_chunk->length_dw);
 851                 radeon_cs_dump_packet(p, &p3reloc);
 852                 return -EINVAL;
 853         }
 854         /* FIXME: we assume reloc size is 4 dwords */
 855         if (nomm) {
 856                 *cs_reloc = p->relocs;
 857                 (*cs_reloc)->gpu_offset =
 858                         (u64)relocs_chunk->kdata[idx + 3] << 32;
 859                 (*cs_reloc)->gpu_offset |= relocs_chunk->kdata[idx + 0];
 860         } else
 861                 *cs_reloc = p->relocs_ptr[(idx / 4)];
 862         return 0;
 863 }