drivers/gpu/drm/i915/i915_trace.h

   1 #if !defined(_I915_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ)
   2 #define _I915_TRACE_H_
   3
   4 #include <linux/stringify.h>
   5 #include <linux/types.h>
   6 #include <linux/tracepoint.h>
   7
   8 #include <drm/drmP.h>
   9 #include "i915_drv.h"
  10 #include "intel_drv.h"
  11 #include "intel_ringbuffer.h"
  12
  13 #undef TRACE_SYSTEM
  14 #define TRACE_SYSTEM i915
  15 #define TRACE_SYSTEM_STRING __stringify(TRACE_SYSTEM)
  16 #define TRACE_INCLUDE_FILE i915_trace
  17
  18 /* pipe updates */
  19
  20 TRACE_EVENT(i915_pipe_update_start,
  21             TP_PROTO(struct intel_crtc *crtc, u32 min, u32 max),
  22             TP_ARGS(crtc, min, max),
  23
  24             TP_STRUCT__entry(
  25                              __field(enum pipe, pipe)
  26                              __field(u32, frame)
  27                              __field(u32, scanline)
  28                              __field(u32, min)
  29                              __field(u32, max)
  30                              ),
  31
  32             TP_fast_assign(
  33                            __entry->pipe = crtc->pipe;
  34                            __entry->frame = crtc->base.dev->driver->get_vblank_counter(crtc->base.dev,
  35                                                                                        crtc->pipe);
  36                            __entry->scanline = intel_get_crtc_scanline(crtc);
  37                            __entry->min = min;
  38                            __entry->max = max;
  39                            ),
  40
  41             TP_printk("pipe %c, frame=%u, scanline=%u, min=%u, max=%u",
  42                       pipe_name(__entry->pipe), __entry->frame,
  43                        __entry->scanline, __entry->min, __entry->max)
  44 );
  45
  46 TRACE_EVENT(i915_pipe_update_vblank_evaded,
  47             TP_PROTO(struct intel_crtc *crtc, u32 min, u32 max, u32 frame),
  48             TP_ARGS(crtc, min, max, frame),
  49
  50             TP_STRUCT__entry(
  51                              __field(enum pipe, pipe)
  52                              __field(u32, frame)
  53                              __field(u32, scanline)
  54                              __field(u32, min)
  55                              __field(u32, max)
  56                              ),
  57
  58             TP_fast_assign(
  59                            __entry->pipe = crtc->pipe;
  60                            __entry->frame = frame;
  61                            __entry->scanline = intel_get_crtc_scanline(crtc);
  62                            __entry->min = min;
  63                            __entry->max = max;
  64                            ),
  65
  66             TP_printk("pipe %c, frame=%u, scanline=%u, min=%u, max=%u",
  67                       pipe_name(__entry->pipe), __entry->frame,
  68                        __entry->scanline, __entry->min, __entry->max)
  69 );
  70
  71 TRACE_EVENT(i915_pipe_update_end,
  72             TP_PROTO(struct intel_crtc *crtc, u32 frame),
  73             TP_ARGS(crtc, frame),
  74
  75             TP_STRUCT__entry(
  76                              __field(enum pipe, pipe)
  77                              __field(u32, frame)
  78                              __field(u32, scanline)
  79                              ),
  80
  81             TP_fast_assign(
  82                            __entry->pipe = crtc->pipe;
  83                            __entry->frame = frame;
  84                            __entry->scanline = intel_get_crtc_scanline(crtc);
  85                            ),
  86
  87             TP_printk("pipe %c, frame=%u, scanline=%u",
  88                       pipe_name(__entry->pipe), __entry->frame,
  89                       __entry->scanline)
  90 );
  91
  92 /* object tracking */
  93
  94 TRACE_EVENT(i915_gem_object_create,
  95             TP_PROTO(struct drm_i915_gem_object *obj),
  96             TP_ARGS(obj),
  97
  98             TP_STRUCT__entry(
  99                              __field(struct drm_i915_gem_object *, obj)
 100                              __field(u32, size)
 101                              ),
 102
 103             TP_fast_assign(
 104                            __entry->obj = obj;
 105                            __entry->size = obj->base.size;
 106                            ),
 107
 108             TP_printk("obj=%p, size=%u", __entry->obj, __entry->size)
 109 );
 110
 111 TRACE_EVENT(i915_vma_bind,
 112             TP_PROTO(struct i915_vma *vma, unsigned flags),
 113             TP_ARGS(vma, flags),
 114
 115             TP_STRUCT__entry(
 116                              __field(struct drm_i915_gem_object *, obj)
 117                              __field(struct i915_address_space *, vm)
 118                              __field(u64, offset)
 119                              __field(u32, size)
 120                              __field(unsigned, flags)
 121                              ),
 122
 123             TP_fast_assign(
 124                            __entry->obj = vma->obj;
 125                            __entry->vm = vma->vm;
 126                            __entry->offset = vma->node.start;
 127                            __entry->size = vma->node.size;
 128                            __entry->flags = flags;
 129                            ),
 130
 131             TP_printk("obj=%p, offset=%016llx size=%x%s vm=%p",
 132                       __entry->obj, __entry->offset, __entry->size,
 133                       __entry->flags & PIN_MAPPABLE ? ", mappable" : "",
 134                       __entry->vm)
 135 );
 136
 137 TRACE_EVENT(i915_vma_unbind,
 138             TP_PROTO(struct i915_vma *vma),
 139             TP_ARGS(vma),
 140
 141             TP_STRUCT__entry(
 142                              __field(struct drm_i915_gem_object *, obj)
 143                              __field(struct i915_address_space *, vm)
 144                              __field(u64, offset)
 145                              __field(u32, size)
 146                              ),
 147
 148             TP_fast_assign(
 149                            __entry->obj = vma->obj;
 150                            __entry->vm = vma->vm;
 151                            __entry->offset = vma->node.start;
 152                            __entry->size = vma->node.size;
 153                            ),
 154
 155             TP_printk("obj=%p, offset=%016llx size=%x vm=%p",
 156                       __entry->obj, __entry->offset, __entry->size, __entry->vm)
 157 );
 158
 159 #define VM_TO_TRACE_NAME(vm) \
 160         (i915_is_ggtt(vm) ? "G" : \
 161                       "P")
 162
 163 DECLARE_EVENT_CLASS(i915_va,
 164         TP_PROTO(struct i915_address_space *vm, u64 start, u64 length, const char *name),
 165         TP_ARGS(vm, start, length, name),
 166
 167         TP_STRUCT__entry(
 168                 __field(struct i915_address_space *, vm)
 169                 __field(u64, start)
 170                 __field(u64, end)
 171                 __string(name, name)
 172         ),
 173
 174         TP_fast_assign(
 175                 __entry->vm = vm;
 176                 __entry->start = start;
 177                 __entry->end = start + length - 1;
 178                 __assign_str(name, name);
 179         ),
 180
 181         TP_printk("vm=%p (%s), 0x%llx-0x%llx",
 182                   __entry->vm, __get_str(name),  __entry->start, __entry->end)
 183 );
 184
 185 DEFINE_EVENT(i915_va, i915_va_alloc,
 186              TP_PROTO(struct i915_address_space *vm, u64 start, u64 length, const char *name),
 187              TP_ARGS(vm, start, length, name)
 188 );
 189
 190 DECLARE_EVENT_CLASS(i915_page_table_entry,
 191         TP_PROTO(struct i915_address_space *vm, u32 pde, u64 start, u64 pde_shift),
 192         TP_ARGS(vm, pde, start, pde_shift),
 193
 194         TP_STRUCT__entry(
 195                 __field(struct i915_address_space *, vm)
 196                 __field(u32, pde)
 197                 __field(u64, start)
 198                 __field(u64, end)
 199         ),
 200
 201         TP_fast_assign(
 202                 __entry->vm = vm;
 203                 __entry->pde = pde;
 204                 __entry->start = start;
 205                 __entry->end = ((start + (1ULL << pde_shift)) & ~((1ULL << pde_shift)-1)) - 1;
 206         ),
 207
 208         TP_printk("vm=%p, pde=%d (0x%llx-0x%llx)",
 209                   __entry->vm, __entry->pde, __entry->start, __entry->end)
 210 );
 211
 212 DEFINE_EVENT(i915_page_table_entry, i915_page_table_entry_alloc,
 213              TP_PROTO(struct i915_address_space *vm, u32 pde, u64 start, u64 pde_shift),
 214              TP_ARGS(vm, pde, start, pde_shift)
 215 );
 216
 217 /* Avoid extra math because we only support two sizes. The format is defined by
 218  * bitmap_scnprintf. Each 32 bits is 8 HEX digits followed by comma */
 219 #define TRACE_PT_SIZE(bits) \
 220         ((((bits) == 1024) ? 288 : 144) + 1)
 221
 222 DECLARE_EVENT_CLASS(i915_page_table_entry_update,
 223         TP_PROTO(struct i915_address_space *vm, u32 pde,
 224                  struct i915_page_table_entry *pt, u32 first, u32 count, u32 bits),
 225         TP_ARGS(vm, pde, pt, first, count, bits),
 226
 227         TP_STRUCT__entry(
 228                 __field(struct i915_address_space *, vm)
 229                 __field(u32, pde)
 230                 __field(u32, first)
 231                 __field(u32, last)
 232                 __dynamic_array(char, cur_ptes, TRACE_PT_SIZE(bits))
 233         ),
 234
 235         TP_fast_assign(
 236                 __entry->vm = vm;
 237                 __entry->pde = pde;
 238                 __entry->first = first;
 239                 __entry->last = first + count - 1;
 240                 scnprintf(__get_str(cur_ptes),
 241                           TRACE_PT_SIZE(bits),
 242                           "%*pb",
 243                           bits,
 244                           pt->used_ptes);
 245         ),
 246
 247         TP_printk("vm=%p, pde=%d, updating %u:%u\t%s",
 248                   __entry->vm, __entry->pde, __entry->last, __entry->first,
 249                   __get_str(cur_ptes))
 250 );
 251
 252 DEFINE_EVENT(i915_page_table_entry_update, i915_page_table_entry_map,
 253         TP_PROTO(struct i915_address_space *vm, u32 pde,
 254                  struct i915_page_table_entry *pt, u32 first, u32 count, u32 bits),
 255         TP_ARGS(vm, pde, pt, first, count, bits)
 256 );
 257
 258 TRACE_EVENT(i915_gem_object_change_domain,
 259             TP_PROTO(struct drm_i915_gem_object *obj, u32 old_read, u32 old_write),
 260             TP_ARGS(obj, old_read, old_write),
 261
 262             TP_STRUCT__entry(
 263                              __field(struct drm_i915_gem_object *, obj)
 264                              __field(u32, read_domains)
 265                              __field(u32, write_domain)
 266                              ),
 267
 268             TP_fast_assign(
 269                            __entry->obj = obj;
 270                            __entry->read_domains = obj->base.read_domains | (old_read << 16);
 271                            __entry->write_domain = obj->base.write_domain | (old_write << 16);
 272                            ),
 273
 274             TP_printk("obj=%p, read=%02x=>%02x, write=%02x=>%02x",
 275                       __entry->obj,
 276                       __entry->read_domains >> 16,
 277                       __entry->read_domains & 0xffff,
 278                       __entry->write_domain >> 16,
 279                       __entry->write_domain & 0xffff)
 280 );
 281
 282 TRACE_EVENT(i915_gem_object_pwrite,
 283             TP_PROTO(struct drm_i915_gem_object *obj, u32 offset, u32 len),
 284             TP_ARGS(obj, offset, len),
 285
 286             TP_STRUCT__entry(
 287                              __field(struct drm_i915_gem_object *, obj)
 288                              __field(u32, offset)
 289                              __field(u32, len)
 290                              ),
 291
 292             TP_fast_assign(
 293                            __entry->obj = obj;
 294                            __entry->offset = offset;
 295                            __entry->len = len;
 296                            ),
 297
 298             TP_printk("obj=%p, offset=%u, len=%u",
 299                       __entry->obj, __entry->offset, __entry->len)
 300 );
 301
 302 TRACE_EVENT(i915_gem_object_pread,
 303             TP_PROTO(struct drm_i915_gem_object *obj, u32 offset, u32 len),
 304             TP_ARGS(obj, offset, len),
 305
 306             TP_STRUCT__entry(
 307                              __field(struct drm_i915_gem_object *, obj)
 308                              __field(u32, offset)
 309                              __field(u32, len)
 310                              ),
 311
 312             TP_fast_assign(
 313                            __entry->obj = obj;
 314                            __entry->offset = offset;
 315                            __entry->len = len;
 316                            ),
 317
 318             TP_printk("obj=%p, offset=%u, len=%u",
 319                       __entry->obj, __entry->offset, __entry->len)
 320 );
 321
 322 TRACE_EVENT(i915_gem_object_fault,
 323             TP_PROTO(struct drm_i915_gem_object *obj, u32 index, bool gtt, bool write),
 324             TP_ARGS(obj, index, gtt, write),
 325
 326             TP_STRUCT__entry(
 327                              __field(struct drm_i915_gem_object *, obj)
 328                              __field(u32, index)
 329                              __field(bool, gtt)
 330                              __field(bool, write)
 331                              ),
 332
 333             TP_fast_assign(
 334                            __entry->obj = obj;
 335                            __entry->index = index;
 336                            __entry->gtt = gtt;
 337                            __entry->write = write;
 338                            ),
 339
 340             TP_printk("obj=%p, %s index=%u %s",
 341                       __entry->obj,
 342                       __entry->gtt ? "GTT" : "CPU",
 343                       __entry->index,
 344                       __entry->write ? ", writable" : "")
 345 );
 346
 347 DECLARE_EVENT_CLASS(i915_gem_object,
 348             TP_PROTO(struct drm_i915_gem_object *obj),
 349             TP_ARGS(obj),
 350
 351             TP_STRUCT__entry(
 352                              __field(struct drm_i915_gem_object *, obj)
 353                              ),
 354
 355             TP_fast_assign(
 356                            __entry->obj = obj;
 357                            ),
 358
 359             TP_printk("obj=%p", __entry->obj)
 360 );
 361
 362 DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush,
 363              TP_PROTO(struct drm_i915_gem_object *obj),
 364              TP_ARGS(obj)
 365 );
 366
 367 DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy,
 368             TP_PROTO(struct drm_i915_gem_object *obj),
 369             TP_ARGS(obj)
 370 );
 371
 372 TRACE_EVENT(i915_gem_evict,
 373             TP_PROTO(struct drm_device *dev, u32 size, u32 align, unsigned flags),
 374             TP_ARGS(dev, size, align, flags),
 375
 376             TP_STRUCT__entry(
 377                              __field(u32, dev)
 378                              __field(u32, size)
 379                              __field(u32, align)
 380                              __field(unsigned, flags)
 381                             ),
 382
 383             TP_fast_assign(
 384                            __entry->dev = dev->primary->index;
 385                            __entry->size = size;
 386                            __entry->align = align;
 387                            __entry->flags = flags;
 388                           ),
 389
 390             TP_printk("dev=%d, size=%d, align=%d %s",
 391                       __entry->dev, __entry->size, __entry->align,
 392                       __entry->flags & PIN_MAPPABLE ? ", mappable" : "")
 393 );
 394
 395 TRACE_EVENT(i915_gem_evict_everything,
 396             TP_PROTO(struct drm_device *dev),
 397             TP_ARGS(dev),
 398
 399             TP_STRUCT__entry(
 400                              __field(u32, dev)
 401                             ),
 402
 403             TP_fast_assign(
 404                            __entry->dev = dev->primary->index;
 405                           ),
 406
 407             TP_printk("dev=%d", __entry->dev)
 408 );
 409
 410 TRACE_EVENT(i915_gem_evict_vm,
 411             TP_PROTO(struct i915_address_space *vm),
 412             TP_ARGS(vm),
 413
 414             TP_STRUCT__entry(
 415                              __field(u32, dev)
 416                              __field(struct i915_address_space *, vm)
 417                             ),
 418
 419             TP_fast_assign(
 420                            __entry->dev = vm->dev->primary->index;
 421                            __entry->vm = vm;
 422                           ),
 423
 424             TP_printk("dev=%d, vm=%p", __entry->dev, __entry->vm)
 425 );
 426
 427 TRACE_EVENT(i915_gem_ring_sync_to,
 428             TP_PROTO(struct intel_engine_cs *from,
 429                      struct intel_engine_cs *to,
 430                      struct drm_i915_gem_request *req),
 431             TP_ARGS(from, to, req),
 432
 433             TP_STRUCT__entry(
 434                              __field(u32, dev)
 435                              __field(u32, sync_from)
 436                              __field(u32, sync_to)
 437                              __field(u32, seqno)
 438                              ),
 439
 440             TP_fast_assign(
 441                            __entry->dev = from->dev->primary->index;
 442                            __entry->sync_from = from->id;
 443                            __entry->sync_to = to->id;
 444                            __entry->seqno = i915_gem_request_get_seqno(req);
 445                            ),
 446
 447             TP_printk("dev=%u, sync-from=%u, sync-to=%u, seqno=%u",
 448                       __entry->dev,
 449                       __entry->sync_from, __entry->sync_to,
 450                       __entry->seqno)
 451 );
 452
 453 TRACE_EVENT(i915_gem_ring_dispatch,
 454             TP_PROTO(struct drm_i915_gem_request *req, u32 flags),
 455             TP_ARGS(req, flags),
 456
 457             TP_STRUCT__entry(
 458                              __field(u32, dev)
 459                              __field(u32, ring)
 460                              __field(u32, seqno)
 461                              __field(u32, flags)
 462                              ),
 463
 464             TP_fast_assign(
 465                            struct intel_engine_cs *ring =
 466                                                 i915_gem_request_get_ring(req);
 467                            __entry->dev = ring->dev->primary->index;
 468                            __entry->ring = ring->id;
 469                            __entry->seqno = i915_gem_request_get_seqno(req);
 470                            __entry->flags = flags;
 471                            i915_trace_irq_get(ring, req);
 472                            ),
 473
 474             TP_printk("dev=%u, ring=%u, seqno=%u, flags=%x",
 475                       __entry->dev, __entry->ring, __entry->seqno, __entry->flags)
 476 );
 477
 478 TRACE_EVENT(i915_gem_ring_flush,
 479             TP_PROTO(struct intel_engine_cs *ring, u32 invalidate, u32 flush),
 480             TP_ARGS(ring, invalidate, flush),
 481
 482             TP_STRUCT__entry(
 483                              __field(u32, dev)
 484                              __field(u32, ring)
 485                              __field(u32, invalidate)
 486                              __field(u32, flush)
 487                              ),
 488
 489             TP_fast_assign(
 490                            __entry->dev = ring->dev->primary->index;
 491                            __entry->ring = ring->id;
 492                            __entry->invalidate = invalidate;
 493                            __entry->flush = flush;
 494                            ),
 495
 496             TP_printk("dev=%u, ring=%x, invalidate=%04x, flush=%04x",
 497                       __entry->dev, __entry->ring,
 498                       __entry->invalidate, __entry->flush)
 499 );
 500
 501 DECLARE_EVENT_CLASS(i915_gem_request,
 502             TP_PROTO(struct drm_i915_gem_request *req),
 503             TP_ARGS(req),
 504
 505             TP_STRUCT__entry(
 506                              __field(u32, dev)
 507                              __field(u32, ring)
 508                              __field(u32, uniq)
 509                              __field(u32, seqno)
 510                              ),
 511
 512             TP_fast_assign(
 513                            struct intel_engine_cs *ring =
 514                                                 i915_gem_request_get_ring(req);
 515                            __entry->dev = ring->dev->primary->index;
 516                            __entry->ring = ring->id;
 517                            __entry->uniq = req ? req->uniq : 0;
 518                            __entry->seqno = i915_gem_request_get_seqno(req);
 519                            ),
 520
 521             TP_printk("dev=%u, ring=%u, uniq=%u, seqno=%u",
 522                       __entry->dev, __entry->ring, __entry->uniq,
 523                       __entry->seqno)
 524 );
 525
 526 DEFINE_EVENT(i915_gem_request, i915_gem_request_add,
 527             TP_PROTO(struct drm_i915_gem_request *req),
 528             TP_ARGS(req)
 529 );
 530
 531 TRACE_EVENT(i915_gem_request_notify,
 532             TP_PROTO(struct intel_engine_cs *ring),
 533             TP_ARGS(ring),
 534
 535             TP_STRUCT__entry(
 536                              __field(u32, dev)
 537                              __field(u32, ring)
 538                              __field(u32, seqno)
 539                              ),
 540
 541             TP_fast_assign(
 542                            __entry->dev = ring->dev->primary->index;
 543                            __entry->ring = ring->id;
 544                            __entry->seqno = ring->get_seqno(ring, false);
 545                            ),
 546
 547             TP_printk("dev=%u, ring=%u, seqno=%u",
 548                       __entry->dev, __entry->ring, __entry->seqno)
 549 );
 550
 551 DEFINE_EVENT(i915_gem_request, i915_gem_request_retire,
 552             TP_PROTO(struct drm_i915_gem_request *req),
 553             TP_ARGS(req)
 554 );
 555
 556 DEFINE_EVENT(i915_gem_request, i915_gem_request_complete,
 557             TP_PROTO(struct drm_i915_gem_request *req),
 558             TP_ARGS(req)
 559 );
 560
 561 TRACE_EVENT(i915_gem_request_wait_begin,
 562             TP_PROTO(struct drm_i915_gem_request *req),
 563             TP_ARGS(req),
 564
 565             TP_STRUCT__entry(
 566                              __field(u32, dev)
 567                              __field(u32, ring)
 568                              __field(u32, uniq)
 569                              __field(u32, seqno)
 570                              __field(bool, blocking)
 571                              ),
 572
 573             /* NB: the blocking information is racy since mutex_is_locked
 574              * doesn't check that the current thread holds the lock. The only
 575              * other option would be to pass the boolean information of whether
 576              * or not the class was blocking down through the stack which is
 577              * less desirable.
 578              */
 579             TP_fast_assign(
 580                            struct intel_engine_cs *ring =
 581                                                 i915_gem_request_get_ring(req);
 582                            __entry->dev = ring->dev->primary->index;
 583                            __entry->ring = ring->id;
 584                            __entry->uniq = req ? req->uniq : 0;
 585                            __entry->seqno = i915_gem_request_get_seqno(req);
 586                            __entry->blocking =
 587                                      mutex_is_locked(&ring->dev->struct_mutex);
 588                            ),
 589
 590             TP_printk("dev=%u, ring=%u, uniq=%u, seqno=%u, blocking=%s",
 591                       __entry->dev, __entry->ring, __entry->uniq,
 592                       __entry->seqno, __entry->blocking ?  "yes (NB)" : "no")
 593 );
 594
 595 DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end,
 596             TP_PROTO(struct drm_i915_gem_request *req),
 597             TP_ARGS(req)
 598 );
 599
 600 DECLARE_EVENT_CLASS(i915_ring,
 601             TP_PROTO(struct intel_engine_cs *ring),
 602             TP_ARGS(ring),
 603
 604             TP_STRUCT__entry(
 605                              __field(u32, dev)
 606                              __field(u32, ring)
 607                              ),
 608
 609             TP_fast_assign(
 610                            __entry->dev = ring->dev->primary->index;
 611                            __entry->ring = ring->id;
 612                            ),
 613
 614             TP_printk("dev=%u, ring=%u", __entry->dev, __entry->ring)
 615 );
 616
 617 DEFINE_EVENT(i915_ring, i915_ring_wait_begin,
 618             TP_PROTO(struct intel_engine_cs *ring),
 619             TP_ARGS(ring)
 620 );
 621
 622 DEFINE_EVENT(i915_ring, i915_ring_wait_end,
 623             TP_PROTO(struct intel_engine_cs *ring),
 624             TP_ARGS(ring)
 625 );
 626
 627 TRACE_EVENT(i915_flip_request,
 628             TP_PROTO(int plane, struct drm_i915_gem_object *obj),
 629
 630             TP_ARGS(plane, obj),
 631
 632             TP_STRUCT__entry(
 633                     __field(int, plane)
 634                     __field(struct drm_i915_gem_object *, obj)
 635                     ),
 636
 637             TP_fast_assign(
 638                     __entry->plane = plane;
 639                     __entry->obj = obj;
 640                     ),
 641
 642             TP_printk("plane=%d, obj=%p", __entry->plane, __entry->obj)
 643 );
 644
 645 TRACE_EVENT(i915_flip_complete,
 646             TP_PROTO(int plane, struct drm_i915_gem_object *obj),
 647
 648             TP_ARGS(plane, obj),
 649
 650             TP_STRUCT__entry(
 651                     __field(int, plane)
 652                     __field(struct drm_i915_gem_object *, obj)
 653                     ),
 654
 655             TP_fast_assign(
 656                     __entry->plane = plane;
 657                     __entry->obj = obj;
 658                     ),
 659
 660             TP_printk("plane=%d, obj=%p", __entry->plane, __entry->obj)
 661 );
 662
 663 TRACE_EVENT_CONDITION(i915_reg_rw,
 664         TP_PROTO(bool write, u32 reg, u64 val, int len, bool trace),
 665
 666         TP_ARGS(write, reg, val, len, trace),
 667
 668         TP_CONDITION(trace),
 669
 670         TP_STRUCT__entry(
 671                 __field(u64, val)
 672                 __field(u32, reg)
 673                 __field(u16, write)
 674                 __field(u16, len)
 675                 ),
 676
 677         TP_fast_assign(
 678                 __entry->val = (u64)val;
 679                 __entry->reg = reg;
 680                 __entry->write = write;
 681                 __entry->len = len;
 682                 ),
 683
 684         TP_printk("%s reg=0x%x, len=%d, val=(0x%x, 0x%x)",
 685                 __entry->write ? "write" : "read",
 686                 __entry->reg, __entry->len,
 687                 (u32)(__entry->val & 0xffffffff),
 688                 (u32)(__entry->val >> 32))
 689 );
 690
 691 TRACE_EVENT(intel_gpu_freq_change,
 692             TP_PROTO(u32 freq),
 693             TP_ARGS(freq),
 694
 695             TP_STRUCT__entry(
 696                              __field(u32, freq)
 697                              ),
 698
 699             TP_fast_assign(
 700                            __entry->freq = freq;
 701                            ),
 702
 703             TP_printk("new_freq=%u", __entry->freq)
 704 );
 705
 706 /**
 707  * DOC: i915_ppgtt_create and i915_ppgtt_release tracepoints
 708  *
 709  * With full ppgtt enabled each process using drm will allocate at least one
 710  * translation table. With these traces it is possible to keep track of the
 711  * allocation and of the lifetime of the tables; this can be used during
 712  * testing/debug to verify that we are not leaking ppgtts.
 713  * These traces identify the ppgtt through the vm pointer, which is also printed
 714  * by the i915_vma_bind and i915_vma_unbind tracepoints.
 715  */
 716 DECLARE_EVENT_CLASS(i915_ppgtt,
 717         TP_PROTO(struct i915_address_space *vm),
 718         TP_ARGS(vm),
 719
 720         TP_STRUCT__entry(
 721                         __field(struct i915_address_space *, vm)
 722                         __field(u32, dev)
 723         ),
 724
 725         TP_fast_assign(
 726                         __entry->vm = vm;
 727                         __entry->dev = vm->dev->primary->index;
 728         ),
 729
 730         TP_printk("dev=%u, vm=%p", __entry->dev, __entry->vm)
 731 )
 732
 733 DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create,
 734         TP_PROTO(struct i915_address_space *vm),
 735         TP_ARGS(vm)
 736 );
 737
 738 DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release,
 739         TP_PROTO(struct i915_address_space *vm),
 740         TP_ARGS(vm)
 741 );
 742
 743 /**
 744  * DOC: i915_context_create and i915_context_free tracepoints
 745  *
 746  * These tracepoints are used to track creation and deletion of contexts.
 747  * If full ppgtt is enabled, they also print the address of the vm assigned to
 748  * the context.
 749  */
 750 DECLARE_EVENT_CLASS(i915_context,
 751         TP_PROTO(struct intel_context *ctx),
 752         TP_ARGS(ctx),
 753
 754         TP_STRUCT__entry(
 755                         __field(u32, dev)
 756                         __field(struct intel_context *, ctx)
 757                         __field(struct i915_address_space *, vm)
 758         ),
 759
 760         TP_fast_assign(
 761                         __entry->ctx = ctx;
 762                         __entry->vm = ctx->ppgtt ? &ctx->ppgtt->base : NULL;
 763                         __entry->dev = ctx->file_priv->dev_priv->dev->primary->index;
 764         ),
 765
 766         TP_printk("dev=%u, ctx=%p, ctx_vm=%p",
 767                   __entry->dev, __entry->ctx, __entry->vm)
 768 )
 769
 770 DEFINE_EVENT(i915_context, i915_context_create,
 771         TP_PROTO(struct intel_context *ctx),
 772         TP_ARGS(ctx)
 773 );
 774
 775 DEFINE_EVENT(i915_context, i915_context_free,
 776         TP_PROTO(struct intel_context *ctx),
 777         TP_ARGS(ctx)
 778 );
 779
 780 /**
 781  * DOC: switch_mm tracepoint
 782  *
 783  * This tracepoint allows tracking of the mm switch, which is an important point
 784  * in the lifetime of the vm in the legacy submission path. This tracepoint is
 785  * called only if full ppgtt is enabled.
 786  */
 787 TRACE_EVENT(switch_mm,
 788         TP_PROTO(struct intel_engine_cs *ring, struct intel_context *to),
 789
 790         TP_ARGS(ring, to),
 791
 792         TP_STRUCT__entry(
 793                         __field(u32, ring)
 794                         __field(struct intel_context *, to)
 795                         __field(struct i915_address_space *, vm)
 796                         __field(u32, dev)
 797         ),
 798
 799         TP_fast_assign(
 800                         __entry->ring = ring->id;
 801                         __entry->to = to;
 802                         __entry->vm = to->ppgtt? &to->ppgtt->base : NULL;
 803                         __entry->dev = ring->dev->primary->index;
 804         ),
 805
 806         TP_printk("dev=%u, ring=%u, ctx=%p, ctx_vm=%p",
 807                   __entry->dev, __entry->ring, __entry->to, __entry->vm)
 808 );
 809
 810 #endif /* _I915_TRACE_H_ */
 811
 812 /* This part must be outside protection */
 813 #undef TRACE_INCLUDE_PATH
 814 #define TRACE_INCLUDE_PATH .
 815 #include <trace/define_trace.h>