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].handle = r->handle;
 187
 188                 radeon_cs_buckets_add(&buckets, &p->relocs[i].tv.head,
 189                                       priority);
 190         }
 191
 192         radeon_cs_buckets_get_list(&buckets, &p->validated);
 193
 194         if (p->cs_flags & RADEON_CS_USE_VM)
 195                 p->vm_bos = radeon_vm_get_bos(p->rdev, p->ib.vm,
 196                                               &p->validated);
 197         if (need_mmap_lock)
 198                 down_read(&current->mm->mmap_sem);
 199
 200         r = radeon_bo_list_validate(p->rdev, &p->ticket, &p->validated, p->ring);
 201
 202         if (need_mmap_lock)
 203                 up_read(&current->mm->mmap_sem);
 204
 205         return r;
 206 }
 207
 208 static int radeon_cs_get_ring(struct radeon_cs_parser *p, u32 ring, s32 priority)
 209 {
 210         p->priority = priority;
 211
 212         switch (ring) {
 213         default:
 214                 DRM_ERROR("unknown ring id: %d\n", ring);
 215                 return -EINVAL;
 216         case RADEON_CS_RING_GFX:
 217                 p->ring = RADEON_RING_TYPE_GFX_INDEX;
 218                 break;
 219         case RADEON_CS_RING_COMPUTE:
 220                 if (p->rdev->family >= CHIP_TAHITI) {
 221                         if (p->priority > 0)
 222                                 p->ring = CAYMAN_RING_TYPE_CP1_INDEX;
 223                         else
 224                                 p->ring = CAYMAN_RING_TYPE_CP2_INDEX;
 225                 } else
 226                         p->ring = RADEON_RING_TYPE_GFX_INDEX;
 227                 break;
 228         case RADEON_CS_RING_DMA:
 229                 if (p->rdev->family >= CHIP_CAYMAN) {
 230                         if (p->priority > 0)
 231                                 p->ring = R600_RING_TYPE_DMA_INDEX;
 232                         else
 233                                 p->ring = CAYMAN_RING_TYPE_DMA1_INDEX;
 234                 } else if (p->rdev->family >= CHIP_RV770) {
 235                         p->ring = R600_RING_TYPE_DMA_INDEX;
 236                 } else {
 237                         return -EINVAL;
 238                 }
 239                 break;
 240         case RADEON_CS_RING_UVD:
 241                 p->ring = R600_RING_TYPE_UVD_INDEX;
 242                 break;
 243         case RADEON_CS_RING_VCE:
 244                 /* TODO: only use the low priority ring for now */
 245                 p->ring = TN_RING_TYPE_VCE1_INDEX;
 246                 break;
 247         }
 248         return 0;
 249 }
 250
 251 static void radeon_cs_sync_rings(struct radeon_cs_parser *p)
 252 {
 253         int i;
 254
 255         for (i = 0; i < p->nrelocs; i++) {
 256                 struct reservation_object *resv;
 257                 struct fence *fence;
 258
 259                 if (!p->relocs[i].robj)
 260                         continue;
 261
 262                 resv = p->relocs[i].robj->tbo.resv;
 263                 fence = reservation_object_get_excl(resv);
 264
 265                 radeon_semaphore_sync_to(p->ib.semaphore,
 266                                          (struct radeon_fence *)fence);
 267         }
 268 }
 269
 270 /* XXX: note that this is called from the legacy UMS CS ioctl as well */
 271 int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data)
 272 {
 273         struct drm_radeon_cs *cs = data;
 274         uint64_t *chunk_array_ptr;
 275         unsigned size, i;
 276         u32 ring = RADEON_CS_RING_GFX;
 277         s32 priority = 0;
 278
 279         if (!cs->num_chunks) {
 280                 return 0;
 281         }
 282         /* get chunks */
 283         INIT_LIST_HEAD(&p->validated);
 284         p->idx = 0;
 285         p->ib.sa_bo = NULL;
 286         p->ib.semaphore = NULL;
 287         p->const_ib.sa_bo = NULL;
 288         p->const_ib.semaphore = 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         kfree(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         if (parser->ring == R600_RING_TYPE_UVD_INDEX)
 478                 radeon_uvd_note_usage(rdev);
 479         else if ((parser->ring == TN_RING_TYPE_VCE1_INDEX) ||
 480                  (parser->ring == TN_RING_TYPE_VCE2_INDEX))
 481                 radeon_vce_note_usage(rdev);
 482
 483         radeon_cs_sync_rings(parser);
 484         r = radeon_ib_schedule(rdev, &parser->ib, NULL, true);
 485         if (r) {
 486                 DRM_ERROR("Failed to schedule IB !\n");
 487         }
 488         return r;
 489 }
 490
 491 static int radeon_bo_vm_update_pte(struct radeon_cs_parser *p,
 492                                    struct radeon_vm *vm)
 493 {
 494         struct radeon_device *rdev = p->rdev;
 495         struct radeon_bo_va *bo_va;
 496         int i, r;
 497
 498         r = radeon_vm_update_page_directory(rdev, vm);
 499         if (r)
 500                 return r;
 501
 502         r = radeon_vm_clear_freed(rdev, vm);
 503         if (r)
 504                 return r;
 505
 506         if (vm->ib_bo_va == NULL) {
 507                 DRM_ERROR("Tmp BO not in VM!\n");
 508                 return -EINVAL;
 509         }
 510
 511         r = radeon_vm_bo_update(rdev, vm->ib_bo_va,
 512                                 &rdev->ring_tmp_bo.bo->tbo.mem);
 513         if (r)
 514                 return r;
 515
 516         for (i = 0; i < p->nrelocs; i++) {
 517                 struct radeon_bo *bo;
 518
 519                 /* ignore duplicates */
 520                 if (p->relocs_ptr[i] != &p->relocs[i])
 521                         continue;
 522
 523                 bo = p->relocs[i].robj;
 524                 bo_va = radeon_vm_bo_find(vm, bo);
 525                 if (bo_va == NULL) {
 526                         dev_err(rdev->dev, "bo %p not in vm %p\n", bo, vm);
 527                         return -EINVAL;
 528                 }
 529
 530                 r = radeon_vm_bo_update(rdev, bo_va, &bo->tbo.mem);
 531                 if (r)
 532                         return r;
 533         }
 534
 535         return radeon_vm_clear_invalids(rdev, vm);
 536 }
 537
 538 static int radeon_cs_ib_vm_chunk(struct radeon_device *rdev,
 539                                  struct radeon_cs_parser *parser)
 540 {
 541         struct radeon_fpriv *fpriv = parser->filp->driver_priv;
 542         struct radeon_vm *vm = &fpriv->vm;
 543         int r;
 544
 545         if (parser->chunk_ib_idx == -1)
 546                 return 0;
 547         if ((parser->cs_flags & RADEON_CS_USE_VM) == 0)
 548                 return 0;
 549
 550         if (parser->const_ib.length_dw) {
 551                 r = radeon_ring_ib_parse(rdev, parser->ring, &parser->const_ib);
 552                 if (r) {
 553                         return r;
 554                 }
 555         }
 556
 557         r = radeon_ring_ib_parse(rdev, parser->ring, &parser->ib);
 558         if (r) {
 559                 return r;
 560         }
 561
 562         if (parser->ring == R600_RING_TYPE_UVD_INDEX)
 563                 radeon_uvd_note_usage(rdev);
 564
 565         mutex_lock(&vm->mutex);
 566         r = radeon_bo_vm_update_pte(parser, vm);
 567         if (r) {
 568                 goto out;
 569         }
 570         radeon_cs_sync_rings(parser);
 571         radeon_semaphore_sync_to(parser->ib.semaphore, vm->fence);
 572
 573         if ((rdev->family >= CHIP_TAHITI) &&
 574             (parser->chunk_const_ib_idx != -1)) {
 575                 r = radeon_ib_schedule(rdev, &parser->ib, &parser->const_ib, true);
 576         } else {
 577                 r = radeon_ib_schedule(rdev, &parser->ib, NULL, true);
 578         }
 579
 580 out:
 581         mutex_unlock(&vm->mutex);
 582         return r;
 583 }
 584
 585 static int radeon_cs_handle_lockup(struct radeon_device *rdev, int r)
 586 {
 587         if (r == -EDEADLK) {
 588                 r = radeon_gpu_reset(rdev);
 589                 if (!r)
 590                         r = -EAGAIN;
 591         }
 592         return r;
 593 }
 594
 595 static int radeon_cs_ib_fill(struct radeon_device *rdev, struct radeon_cs_parser *parser)
 596 {
 597         struct radeon_cs_chunk *ib_chunk;
 598         struct radeon_vm *vm = NULL;
 599         int r;
 600
 601         if (parser->chunk_ib_idx == -1)
 602                 return 0;
 603
 604         if (parser->cs_flags & RADEON_CS_USE_VM) {
 605                 struct radeon_fpriv *fpriv = parser->filp->driver_priv;
 606                 vm = &fpriv->vm;
 607
 608                 if ((rdev->family >= CHIP_TAHITI) &&
 609                     (parser->chunk_const_ib_idx != -1)) {
 610                         ib_chunk = &parser->chunks[parser->chunk_const_ib_idx];
 611                         if (ib_chunk->length_dw > RADEON_IB_VM_MAX_SIZE) {
 612                                 DRM_ERROR("cs IB CONST too big: %d\n", ib_chunk->length_dw);
 613                                 return -EINVAL;
 614                         }
 615                         r =  radeon_ib_get(rdev, parser->ring, &parser->const_ib,
 616                                            vm, ib_chunk->length_dw * 4);
 617                         if (r) {
 618                                 DRM_ERROR("Failed to get const ib !\n");
 619                                 return r;
 620                         }
 621                         parser->const_ib.is_const_ib = true;
 622                         parser->const_ib.length_dw = ib_chunk->length_dw;
 623                         if (copy_from_user(parser->const_ib.ptr,
 624                                                ib_chunk->user_ptr,
 625                                                ib_chunk->length_dw * 4))
 626                                 return -EFAULT;
 627                 }
 628
 629                 ib_chunk = &parser->chunks[parser->chunk_ib_idx];
 630                 if (ib_chunk->length_dw > RADEON_IB_VM_MAX_SIZE) {
 631                         DRM_ERROR("cs IB too big: %d\n", ib_chunk->length_dw);
 632                         return -EINVAL;
 633                 }
 634         }
 635         ib_chunk = &parser->chunks[parser->chunk_ib_idx];
 636
 637         r =  radeon_ib_get(rdev, parser->ring, &parser->ib,
 638                            vm, ib_chunk->length_dw * 4);
 639         if (r) {
 640                 DRM_ERROR("Failed to get ib !\n");
 641                 return r;
 642         }
 643         parser->ib.length_dw = ib_chunk->length_dw;
 644         if (ib_chunk->kdata)
 645                 memcpy(parser->ib.ptr, ib_chunk->kdata, ib_chunk->length_dw * 4);
 646         else if (copy_from_user(parser->ib.ptr, ib_chunk->user_ptr, ib_chunk->length_dw * 4))
 647                 return -EFAULT;
 648         return 0;
 649 }
 650
 651 int radeon_cs_ioctl(struct drm_device *dev, void *data, struct drm_file *filp)
 652 {
 653         struct radeon_device *rdev = dev->dev_private;
 654         struct radeon_cs_parser parser;
 655         int r;
 656
 657         down_read(&rdev->exclusive_lock);
 658         if (!rdev->accel_working) {
 659                 up_read(&rdev->exclusive_lock);
 660                 return -EBUSY;
 661         }
 662         if (rdev->in_reset) {
 663                 up_read(&rdev->exclusive_lock);
 664                 r = radeon_gpu_reset(rdev);
 665                 if (!r)
 666                         r = -EAGAIN;
 667                 return r;
 668         }
 669         /* initialize parser */
 670         memset(&parser, 0, sizeof(struct radeon_cs_parser));
 671         parser.filp = filp;
 672         parser.rdev = rdev;
 673         parser.dev = rdev->dev;
 674         parser.family = rdev->family;
 675         r = radeon_cs_parser_init(&parser, data);
 676         if (r) {
 677                 DRM_ERROR("Failed to initialize parser !\n");
 678                 radeon_cs_parser_fini(&parser, r, false);
 679                 up_read(&rdev->exclusive_lock);
 680                 r = radeon_cs_handle_lockup(rdev, r);
 681                 return r;
 682         }
 683
 684         r = radeon_cs_ib_fill(rdev, &parser);
 685         if (!r) {
 686                 r = radeon_cs_parser_relocs(&parser);
 687                 if (r && r != -ERESTARTSYS)
 688                         DRM_ERROR("Failed to parse relocation %d!\n", r);
 689         }
 690
 691         if (r) {
 692                 radeon_cs_parser_fini(&parser, r, false);
 693                 up_read(&rdev->exclusive_lock);
 694                 r = radeon_cs_handle_lockup(rdev, r);
 695                 return r;
 696         }
 697
 698         trace_radeon_cs(&parser);
 699
 700         r = radeon_cs_ib_chunk(rdev, &parser);
 701         if (r) {
 702                 goto out;
 703         }
 704         r = radeon_cs_ib_vm_chunk(rdev, &parser);
 705         if (r) {
 706                 goto out;
 707         }
 708 out:
 709         radeon_cs_parser_fini(&parser, r, true);
 710         up_read(&rdev->exclusive_lock);
 711         r = radeon_cs_handle_lockup(rdev, r);
 712         return r;
 713 }
 714
 715 /**
 716  * radeon_cs_packet_parse() - parse cp packet and point ib index to next packet
 717  * @parser:     parser structure holding parsing context.
 718  * @pkt:        where to store packet information
 719  *
 720  * Assume that chunk_ib_index is properly set. Will return -EINVAL
 721  * if packet is bigger than remaining ib size. or if packets is unknown.
 722  **/
 723 int radeon_cs_packet_parse(struct radeon_cs_parser *p,
 724                            struct radeon_cs_packet *pkt,
 725                            unsigned idx)
 726 {
 727         struct radeon_cs_chunk *ib_chunk = &p->chunks[p->chunk_ib_idx];
 728         struct radeon_device *rdev = p->rdev;
 729         uint32_t header;
 730
 731         if (idx >= ib_chunk->length_dw) {
 732                 DRM_ERROR("Can not parse packet at %d after CS end %d !\n",
 733                           idx, ib_chunk->length_dw);
 734                 return -EINVAL;
 735         }
 736         header = radeon_get_ib_value(p, idx);
 737         pkt->idx = idx;
 738         pkt->type = RADEON_CP_PACKET_GET_TYPE(header);
 739         pkt->count = RADEON_CP_PACKET_GET_COUNT(header);
 740         pkt->one_reg_wr = 0;
 741         switch (pkt->type) {
 742         case RADEON_PACKET_TYPE0:
 743                 if (rdev->family < CHIP_R600) {
 744                         pkt->reg = R100_CP_PACKET0_GET_REG(header);
 745                         pkt->one_reg_wr =
 746                                 RADEON_CP_PACKET0_GET_ONE_REG_WR(header);
 747                 } else
 748                         pkt->reg = R600_CP_PACKET0_GET_REG(header);
 749                 break;
 750         case RADEON_PACKET_TYPE3:
 751                 pkt->opcode = RADEON_CP_PACKET3_GET_OPCODE(header);
 752                 break;
 753         case RADEON_PACKET_TYPE2:
 754                 pkt->count = -1;
 755                 break;
 756         default:
 757                 DRM_ERROR("Unknown packet type %d at %d !\n", pkt->type, idx);
 758                 return -EINVAL;
 759         }
 760         if ((pkt->count + 1 + pkt->idx) >= ib_chunk->length_dw) {
 761                 DRM_ERROR("Packet (%d:%d:%d) end after CS buffer (%d) !\n",
 762                           pkt->idx, pkt->type, pkt->count, ib_chunk->length_dw);
 763                 return -EINVAL;
 764         }
 765         return 0;
 766 }
 767
 768 /**
 769  * radeon_cs_packet_next_is_pkt3_nop() - test if the next packet is P3 NOP
 770  * @p:          structure holding the parser context.
 771  *
 772  * Check if the next packet is NOP relocation packet3.
 773  **/
 774 bool radeon_cs_packet_next_is_pkt3_nop(struct radeon_cs_parser *p)
 775 {
 776         struct radeon_cs_packet p3reloc;
 777         int r;
 778
 779         r = radeon_cs_packet_parse(p, &p3reloc, p->idx);
 780         if (r)
 781                 return false;
 782         if (p3reloc.type != RADEON_PACKET_TYPE3)
 783                 return false;
 784         if (p3reloc.opcode != RADEON_PACKET3_NOP)
 785                 return false;
 786         return true;
 787 }
 788
 789 /**
 790  * radeon_cs_dump_packet() - dump raw packet context
 791  * @p:          structure holding the parser context.
 792  * @pkt:        structure holding the packet.
 793  *
 794  * Used mostly for debugging and error reporting.
 795  **/
 796 void radeon_cs_dump_packet(struct radeon_cs_parser *p,
 797                            struct radeon_cs_packet *pkt)
 798 {
 799         volatile uint32_t *ib;
 800         unsigned i;
 801         unsigned idx;
 802
 803         ib = p->ib.ptr;
 804         idx = pkt->idx;
 805         for (i = 0; i <= (pkt->count + 1); i++, idx++)
 806                 DRM_INFO("ib[%d]=0x%08X\n", idx, ib[idx]);
 807 }
 808
 809 /**
 810  * radeon_cs_packet_next_reloc() - parse next (should be reloc) packet
 811  * @parser:             parser structure holding parsing context.
 812  * @data:               pointer to relocation data
 813  * @offset_start:       starting offset
 814  * @offset_mask:        offset mask (to align start offset on)
 815  * @reloc:              reloc informations
 816  *
 817  * Check if next packet is relocation packet3, do bo validation and compute
 818  * GPU offset using the provided start.
 819  **/
 820 int radeon_cs_packet_next_reloc(struct radeon_cs_parser *p,
 821                                 struct radeon_cs_reloc **cs_reloc,
 822                                 int nomm)
 823 {
 824         struct radeon_cs_chunk *relocs_chunk;
 825         struct radeon_cs_packet p3reloc;
 826         unsigned idx;
 827         int r;
 828
 829         if (p->chunk_relocs_idx == -1) {
 830                 DRM_ERROR("No relocation chunk !\n");
 831                 return -EINVAL;
 832         }
 833         *cs_reloc = NULL;
 834         relocs_chunk = &p->chunks[p->chunk_relocs_idx];
 835         r = radeon_cs_packet_parse(p, &p3reloc, p->idx);
 836         if (r)
 837                 return r;
 838         p->idx += p3reloc.count + 2;
 839         if (p3reloc.type != RADEON_PACKET_TYPE3 ||
 840             p3reloc.opcode != RADEON_PACKET3_NOP) {
 841                 DRM_ERROR("No packet3 for relocation for packet at %d.\n",
 842                           p3reloc.idx);
 843                 radeon_cs_dump_packet(p, &p3reloc);
 844                 return -EINVAL;
 845         }
 846         idx = radeon_get_ib_value(p, p3reloc.idx + 1);
 847         if (idx >= relocs_chunk->length_dw) {
 848                 DRM_ERROR("Relocs at %d after relocations chunk end %d !\n",
 849                           idx, relocs_chunk->length_dw);
 850                 radeon_cs_dump_packet(p, &p3reloc);
 851                 return -EINVAL;
 852         }
 853         /* FIXME: we assume reloc size is 4 dwords */
 854         if (nomm) {
 855                 *cs_reloc = p->relocs;
 856                 (*cs_reloc)->gpu_offset =
 857                         (u64)relocs_chunk->kdata[idx + 3] << 32;
 858                 (*cs_reloc)->gpu_offset |= relocs_chunk->kdata[idx + 0];
 859         } else
 860                 *cs_reloc = p->relocs_ptr[(idx / 4)];
 861         return 0;
 862 }