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