[mirror_ubuntu-artful-kernel.git] / drivers / gpu / drm / i915 / i915_trace.h

#if !defined(_I915_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ)
#define _I915_TRACE_H_

#include <linux/stringify.h>
#include <linux/types.h>
#include <linux/tracepoint.h>

#include <drm/drmP.h>
#include "i915_drv.h"
#include "intel_drv.h"
#include "intel_ringbuffer.h"

#undef TRACE_SYSTEM
#define TRACE_SYSTEM i915
#define TRACE_SYSTEM_STRING __stringify(TRACE_SYSTEM)
#define TRACE_INCLUDE_FILE i915_trace

/* pipe updates */

TRACE_EVENT(i915_pipe_update_start,
	    TP_PROTO(struct intel_crtc *crtc, u32 min, u32 max),
	    TP_ARGS(crtc, min, max),

	    TP_STRUCT__entry(
			     __field(enum pipe, pipe)
			     __field(u32, frame)
			     __field(u32, scanline)
			     __field(u32, min)
			     __field(u32, max)
			     ),

	    TP_fast_assign(
			   __entry->pipe = crtc->pipe;
			   __entry->frame = crtc->base.dev->driver->get_vblank_counter(crtc->base.dev,
										       crtc->pipe);
			   __entry->scanline = intel_get_crtc_scanline(crtc);
			   __entry->min = min;
			   __entry->max = max;
			   ),

	    TP_printk("pipe %c, frame=%u, scanline=%u, min=%u, max=%u",
		      pipe_name(__entry->pipe), __entry->frame,
		       __entry->scanline, __entry->min, __entry->max)
);

TRACE_EVENT(i915_pipe_update_vblank_evaded,
	    TP_PROTO(struct intel_crtc *crtc, u32 min, u32 max, u32 frame),
	    TP_ARGS(crtc, min, max, frame),

	    TP_STRUCT__entry(
			     __field(enum pipe, pipe)
			     __field(u32, frame)
			     __field(u32, scanline)
			     __field(u32, min)
			     __field(u32, max)
			     ),

	    TP_fast_assign(
			   __entry->pipe = crtc->pipe;
			   __entry->frame = frame;
			   __entry->scanline = intel_get_crtc_scanline(crtc);
			   __entry->min = min;
			   __entry->max = max;
			   ),

	    TP_printk("pipe %c, frame=%u, scanline=%u, min=%u, max=%u",
		      pipe_name(__entry->pipe), __entry->frame,
		       __entry->scanline, __entry->min, __entry->max)
);

TRACE_EVENT(i915_pipe_update_end,
	    TP_PROTO(struct intel_crtc *crtc, u32 frame),
	    TP_ARGS(crtc, frame),

	    TP_STRUCT__entry(
			     __field(enum pipe, pipe)
			     __field(u32, frame)
			     __field(u32, scanline)
			     ),

	    TP_fast_assign(
			   __entry->pipe = crtc->pipe;
			   __entry->frame = frame;
			   __entry->scanline = intel_get_crtc_scanline(crtc);
			   ),

	    TP_printk("pipe %c, frame=%u, scanline=%u",
		      pipe_name(__entry->pipe), __entry->frame,
		      __entry->scanline)
);

/* object tracking */

TRACE_EVENT(i915_gem_object_create,
	    TP_PROTO(struct drm_i915_gem_object *obj),
	    TP_ARGS(obj),

	    TP_STRUCT__entry(
			     __field(struct drm_i915_gem_object *, obj)
			     __field(u32, size)
			     ),

	    TP_fast_assign(
			   __entry->obj = obj;
			   __entry->size = obj->base.size;
			   ),

	    TP_printk("obj=%p, size=%u", __entry->obj, __entry->size)
);

TRACE_EVENT(i915_vma_bind,
	    TP_PROTO(struct i915_vma *vma, unsigned flags),
	    TP_ARGS(vma, flags),

	    TP_STRUCT__entry(
			     __field(struct drm_i915_gem_object *, obj)
			     __field(struct i915_address_space *, vm)
			     __field(u64, offset)
			     __field(u32, size)
			     __field(unsigned, flags)
			     ),

	    TP_fast_assign(
			   __entry->obj = vma->obj;
			   __entry->vm = vma->vm;
			   __entry->offset = vma->node.start;
			   __entry->size = vma->node.size;
			   __entry->flags = flags;
			   ),

	    TP_printk("obj=%p, offset=%016llx size=%x%s vm=%p",
		      __entry->obj, __entry->offset, __entry->size,
		      __entry->flags & PIN_MAPPABLE ? ", mappable" : "",
		      __entry->vm)
);

TRACE_EVENT(i915_vma_unbind,
	    TP_PROTO(struct i915_vma *vma),
	    TP_ARGS(vma),

	    TP_STRUCT__entry(
			     __field(struct drm_i915_gem_object *, obj)
			     __field(struct i915_address_space *, vm)
			     __field(u64, offset)
			     __field(u32, size)
			     ),

	    TP_fast_assign(
			   __entry->obj = vma->obj;
			   __entry->vm = vma->vm;
			   __entry->offset = vma->node.start;
			   __entry->size = vma->node.size;
			   ),

	    TP_printk("obj=%p, offset=%016llx size=%x vm=%p",
		      __entry->obj, __entry->offset, __entry->size, __entry->vm)
);

TRACE_EVENT(i915_gem_object_change_domain,
	    TP_PROTO(struct drm_i915_gem_object *obj, u32 old_read, u32 old_write),
	    TP_ARGS(obj, old_read, old_write),

	    TP_STRUCT__entry(
			     __field(struct drm_i915_gem_object *, obj)
			     __field(u32, read_domains)
			     __field(u32, write_domain)
			     ),

	    TP_fast_assign(
			   __entry->obj = obj;
			   __entry->read_domains = obj->base.read_domains | (old_read << 16);
			   __entry->write_domain = obj->base.write_domain | (old_write << 16);
			   ),

	    TP_printk("obj=%p, read=%02x=>%02x, write=%02x=>%02x",
		      __entry->obj,
		      __entry->read_domains >> 16,
		      __entry->read_domains & 0xffff,
		      __entry->write_domain >> 16,
		      __entry->write_domain & 0xffff)
);

TRACE_EVENT(i915_gem_object_pwrite,
	    TP_PROTO(struct drm_i915_gem_object *obj, u32 offset, u32 len),
	    TP_ARGS(obj, offset, len),

	    TP_STRUCT__entry(
			     __field(struct drm_i915_gem_object *, obj)
			     __field(u32, offset)
			     __field(u32, len)
			     ),

	    TP_fast_assign(
			   __entry->obj = obj;
			   __entry->offset = offset;
			   __entry->len = len;
			   ),

	    TP_printk("obj=%p, offset=%u, len=%u",
		      __entry->obj, __entry->offset, __entry->len)
);

TRACE_EVENT(i915_gem_object_pread,
	    TP_PROTO(struct drm_i915_gem_object *obj, u32 offset, u32 len),
	    TP_ARGS(obj, offset, len),

	    TP_STRUCT__entry(
			     __field(struct drm_i915_gem_object *, obj)
			     __field(u32, offset)
			     __field(u32, len)
			     ),

	    TP_fast_assign(
			   __entry->obj = obj;
			   __entry->offset = offset;
			   __entry->len = len;
			   ),

	    TP_printk("obj=%p, offset=%u, len=%u",
		      __entry->obj, __entry->offset, __entry->len)
);

TRACE_EVENT(i915_gem_object_fault,
	    TP_PROTO(struct drm_i915_gem_object *obj, u32 index, bool gtt, bool write),
	    TP_ARGS(obj, index, gtt, write),

	    TP_STRUCT__entry(
			     __field(struct drm_i915_gem_object *, obj)
			     __field(u32, index)
			     __field(bool, gtt)
			     __field(bool, write)
			     ),

	    TP_fast_assign(
			   __entry->obj = obj;
			   __entry->index = index;
			   __entry->gtt = gtt;
			   __entry->write = write;
			   ),

	    TP_printk("obj=%p, %s index=%u %s",
		      __entry->obj,
		      __entry->gtt ? "GTT" : "CPU",
		      __entry->index,
		      __entry->write ? ", writable" : "")
);

DECLARE_EVENT_CLASS(i915_gem_object,
	    TP_PROTO(struct drm_i915_gem_object *obj),
	    TP_ARGS(obj),

	    TP_STRUCT__entry(
			     __field(struct drm_i915_gem_object *, obj)
			     ),

	    TP_fast_assign(
			   __entry->obj = obj;
			   ),

	    TP_printk("obj=%p", __entry->obj)
);

DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush,
	     TP_PROTO(struct drm_i915_gem_object *obj),
	     TP_ARGS(obj)
);

DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy,
	    TP_PROTO(struct drm_i915_gem_object *obj),
	    TP_ARGS(obj)
);

TRACE_EVENT(i915_gem_evict,
	    TP_PROTO(struct drm_device *dev, u32 size, u32 align, unsigned flags),
	    TP_ARGS(dev, size, align, flags),

	    TP_STRUCT__entry(
			     __field(u32, dev)
			     __field(u32, size)
			     __field(u32, align)
			     __field(unsigned, flags)
			    ),

	    TP_fast_assign(
			   __entry->dev = dev->primary->index;
			   __entry->size = size;
			   __entry->align = align;
			   __entry->flags = flags;
			  ),

	    TP_printk("dev=%d, size=%d, align=%d %s",
		      __entry->dev, __entry->size, __entry->align,
		      __entry->flags & PIN_MAPPABLE ? ", mappable" : "")
);

TRACE_EVENT(i915_gem_evict_everything,
	    TP_PROTO(struct drm_device *dev),
	    TP_ARGS(dev),

	    TP_STRUCT__entry(
			     __field(u32, dev)
			    ),

	    TP_fast_assign(
			   __entry->dev = dev->primary->index;
			  ),

	    TP_printk("dev=%d", __entry->dev)
);

TRACE_EVENT(i915_gem_evict_vm,
	    TP_PROTO(struct i915_address_space *vm),
	    TP_ARGS(vm),

	    TP_STRUCT__entry(
			     __field(u32, dev)
			     __field(struct i915_address_space *, vm)
			    ),

	    TP_fast_assign(
			   __entry->dev = vm->dev->primary->index;
			   __entry->vm = vm;
			  ),

	    TP_printk("dev=%d, vm=%p", __entry->dev, __entry->vm)
);

TRACE_EVENT(i915_gem_ring_sync_to,
	    TP_PROTO(struct intel_engine_cs *from,
		     struct intel_engine_cs *to,
		     struct drm_i915_gem_request *req),
	    TP_ARGS(from, to, req),

	    TP_STRUCT__entry(
			     __field(u32, dev)
			     __field(u32, sync_from)
			     __field(u32, sync_to)
			     __field(u32, seqno)
			     ),

	    TP_fast_assign(
			   __entry->dev = from->dev->primary->index;
			   __entry->sync_from = from->id;
			   __entry->sync_to = to->id;
			   __entry->seqno = i915_gem_request_get_seqno(req);
			   ),

	    TP_printk("dev=%u, sync-from=%u, sync-to=%u, seqno=%u",
		      __entry->dev,
		      __entry->sync_from, __entry->sync_to,
		      __entry->seqno)
);

TRACE_EVENT(i915_gem_ring_dispatch,
	    TP_PROTO(struct drm_i915_gem_request *req, u32 flags),
	    TP_ARGS(req, flags),

	    TP_STRUCT__entry(
			     __field(u32, dev)
			     __field(u32, ring)
			     __field(u32, seqno)
			     __field(u32, flags)
			     ),

	    TP_fast_assign(
			   struct intel_engine_cs *ring =
						i915_gem_request_get_ring(req);
			   __entry->dev = ring->dev->primary->index;
			   __entry->ring = ring->id;
			   __entry->seqno = i915_gem_request_get_seqno(req);
			   __entry->flags = flags;
			   i915_trace_irq_get(ring, req);
			   ),

	    TP_printk("dev=%u, ring=%u, seqno=%u, flags=%x",
		      __entry->dev, __entry->ring, __entry->seqno, __entry->flags)
);

TRACE_EVENT(i915_gem_ring_flush,
	    TP_PROTO(struct intel_engine_cs *ring, u32 invalidate, u32 flush),
	    TP_ARGS(ring, invalidate, flush),

	    TP_STRUCT__entry(
			     __field(u32, dev)
			     __field(u32, ring)
			     __field(u32, invalidate)
			     __field(u32, flush)
			     ),

	    TP_fast_assign(
			   __entry->dev = ring->dev->primary->index;
			   __entry->ring = ring->id;
			   __entry->invalidate = invalidate;
			   __entry->flush = flush;
			   ),

	    TP_printk("dev=%u, ring=%x, invalidate=%04x, flush=%04x",
		      __entry->dev, __entry->ring,
		      __entry->invalidate, __entry->flush)
);

DECLARE_EVENT_CLASS(i915_gem_request,
	    TP_PROTO(struct drm_i915_gem_request *req),
	    TP_ARGS(req),

	    TP_STRUCT__entry(
			     __field(u32, dev)
			     __field(u32, ring)
			     __field(u32, uniq)
			     __field(u32, seqno)
			     ),

	    TP_fast_assign(
			   struct intel_engine_cs *ring =
						i915_gem_request_get_ring(req);
			   __entry->dev = ring->dev->primary->index;
			   __entry->ring = ring->id;
			   __entry->uniq = req ? req->uniq : 0;
			   __entry->seqno = i915_gem_request_get_seqno(req);
			   ),

	    TP_printk("dev=%u, ring=%u, uniq=%u, seqno=%u",
		      __entry->dev, __entry->ring, __entry->uniq,
		      __entry->seqno)
);

DEFINE_EVENT(i915_gem_request, i915_gem_request_add,
	    TP_PROTO(struct drm_i915_gem_request *req),
	    TP_ARGS(req)
);

TRACE_EVENT(i915_gem_request_notify,
	    TP_PROTO(struct intel_engine_cs *ring),
	    TP_ARGS(ring),

	    TP_STRUCT__entry(
			     __field(u32, dev)
			     __field(u32, ring)
			     __field(u32, seqno)
			     ),

	    TP_fast_assign(
			   __entry->dev = ring->dev->primary->index;
			   __entry->ring = ring->id;
			   __entry->seqno = ring->get_seqno(ring, false);
			   ),

	    TP_printk("dev=%u, ring=%u, seqno=%u",
		      __entry->dev, __entry->ring, __entry->seqno)
);

DEFINE_EVENT(i915_gem_request, i915_gem_request_retire,
	    TP_PROTO(struct drm_i915_gem_request *req),
	    TP_ARGS(req)
);

DEFINE_EVENT(i915_gem_request, i915_gem_request_complete,
	    TP_PROTO(struct drm_i915_gem_request *req),
	    TP_ARGS(req)
);

TRACE_EVENT(i915_gem_request_wait_begin,
	    TP_PROTO(struct drm_i915_gem_request *req),
	    TP_ARGS(req),

	    TP_STRUCT__entry(
			     __field(u32, dev)
			     __field(u32, ring)
			     __field(u32, uniq)
			     __field(u32, seqno)
			     __field(bool, blocking)
			     ),

	    /* NB: the blocking information is racy since mutex_is_locked
	     * doesn't check that the current thread holds the lock. The only
	     * other option would be to pass the boolean information of whether
	     * or not the class was blocking down through the stack which is
	     * less desirable.
	     */
	    TP_fast_assign(
			   struct intel_engine_cs *ring =
						i915_gem_request_get_ring(req);
			   __entry->dev = ring->dev->primary->index;
			   __entry->ring = ring->id;
			   __entry->uniq = req ? req->uniq : 0;
			   __entry->seqno = i915_gem_request_get_seqno(req);
			   __entry->blocking =
				     mutex_is_locked(&ring->dev->struct_mutex);
			   ),

	    TP_printk("dev=%u, ring=%u, uniq=%u, seqno=%u, blocking=%s",
		      __entry->dev, __entry->ring, __entry->uniq,
		      __entry->seqno, __entry->blocking ?  "yes (NB)" : "no")
);

DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end,
	    TP_PROTO(struct drm_i915_gem_request *req),
	    TP_ARGS(req)
);

DECLARE_EVENT_CLASS(i915_ring,
	    TP_PROTO(struct intel_engine_cs *ring),
	    TP_ARGS(ring),

	    TP_STRUCT__entry(
			     __field(u32, dev)
			     __field(u32, ring)
			     ),

	    TP_fast_assign(
			   __entry->dev = ring->dev->primary->index;
			   __entry->ring = ring->id;
			   ),

	    TP_printk("dev=%u, ring=%u", __entry->dev, __entry->ring)
);

DEFINE_EVENT(i915_ring, i915_ring_wait_begin,
	    TP_PROTO(struct intel_engine_cs *ring),
	    TP_ARGS(ring)
);

DEFINE_EVENT(i915_ring, i915_ring_wait_end,
	    TP_PROTO(struct intel_engine_cs *ring),
	    TP_ARGS(ring)
);

TRACE_EVENT(i915_flip_request,
	    TP_PROTO(int plane, struct drm_i915_gem_object *obj),

	    TP_ARGS(plane, obj),

	    TP_STRUCT__entry(
		    __field(int, plane)
		    __field(struct drm_i915_gem_object *, obj)
		    ),

	    TP_fast_assign(
		    __entry->plane = plane;
		    __entry->obj = obj;
		    ),

	    TP_printk("plane=%d, obj=%p", __entry->plane, __entry->obj)
);

TRACE_EVENT(i915_flip_complete,
	    TP_PROTO(int plane, struct drm_i915_gem_object *obj),

	    TP_ARGS(plane, obj),

	    TP_STRUCT__entry(
		    __field(int, plane)
		    __field(struct drm_i915_gem_object *, obj)
		    ),

	    TP_fast_assign(
		    __entry->plane = plane;
		    __entry->obj = obj;
		    ),

	    TP_printk("plane=%d, obj=%p", __entry->plane, __entry->obj)
);

TRACE_EVENT_CONDITION(i915_reg_rw,
	TP_PROTO(bool write, u32 reg, u64 val, int len, bool trace),

	TP_ARGS(write, reg, val, len, trace),

	TP_CONDITION(trace),

	TP_STRUCT__entry(
		__field(u64, val)
		__field(u32, reg)
		__field(u16, write)
		__field(u16, len)
		),

	TP_fast_assign(
		__entry->val = (u64)val;
		__entry->reg = reg;
		__entry->write = write;
		__entry->len = len;
		),

	TP_printk("%s reg=0x%x, len=%d, val=(0x%x, 0x%x)",
		__entry->write ? "write" : "read",
		__entry->reg, __entry->len,
		(u32)(__entry->val & 0xffffffff),
		(u32)(__entry->val >> 32))
);

TRACE_EVENT(intel_gpu_freq_change,
	    TP_PROTO(u32 freq),
	    TP_ARGS(freq),

	    TP_STRUCT__entry(
			     __field(u32, freq)
			     ),

	    TP_fast_assign(
			   __entry->freq = freq;
			   ),

	    TP_printk("new_freq=%u", __entry->freq)
);

/**
 * DOC: i915_ppgtt_create and i915_ppgtt_release tracepoints
 *
 * With full ppgtt enabled each process using drm will allocate at least one
 * translation table. With these traces it is possible to keep track of the
 * allocation and of the lifetime of the tables; this can be used during
 * testing/debug to verify that we are not leaking ppgtts.
 * These traces identify the ppgtt through the vm pointer, which is also printed
 * by the i915_vma_bind and i915_vma_unbind tracepoints.
 */
DECLARE_EVENT_CLASS(i915_ppgtt,
	TP_PROTO(struct i915_address_space *vm),
	TP_ARGS(vm),

	TP_STRUCT__entry(
			__field(struct i915_address_space *, vm)
			__field(u32, dev)
	),

	TP_fast_assign(
			__entry->vm = vm;
			__entry->dev = vm->dev->primary->index;
	),

	TP_printk("dev=%u, vm=%p", __entry->dev, __entry->vm)
)

DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create,
	TP_PROTO(struct i915_address_space *vm),
	TP_ARGS(vm)
);

DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release,
	TP_PROTO(struct i915_address_space *vm),
	TP_ARGS(vm)
);

/**
 * DOC: i915_context_create and i915_context_free tracepoints
 *
 * These tracepoints are used to track creation and deletion of contexts.
 * If full ppgtt is enabled, they also print the address of the vm assigned to
 * the context.
 */
DECLARE_EVENT_CLASS(i915_context,
	TP_PROTO(struct intel_context *ctx),
	TP_ARGS(ctx),

	TP_STRUCT__entry(
			__field(u32, dev)
			__field(struct intel_context *, ctx)
			__field(struct i915_address_space *, vm)
	),

	TP_fast_assign(
			__entry->ctx = ctx;
			__entry->vm = ctx->ppgtt ? &ctx->ppgtt->base : NULL;
			__entry->dev = ctx->file_priv->dev_priv->dev->primary->index;
	),

	TP_printk("dev=%u, ctx=%p, ctx_vm=%p",
		  __entry->dev, __entry->ctx, __entry->vm)
)

DEFINE_EVENT(i915_context, i915_context_create,
	TP_PROTO(struct intel_context *ctx),
	TP_ARGS(ctx)
);

DEFINE_EVENT(i915_context, i915_context_free,
	TP_PROTO(struct intel_context *ctx),
	TP_ARGS(ctx)
);

/**
 * DOC: switch_mm tracepoint
 *
 * This tracepoint allows tracking of the mm switch, which is an important point
 * in the lifetime of the vm in the legacy submission path. This tracepoint is
 * called only if full ppgtt is enabled.
 */
TRACE_EVENT(switch_mm,
	TP_PROTO(struct intel_engine_cs *ring, struct intel_context *to),

	TP_ARGS(ring, to),

	TP_STRUCT__entry(
			__field(u32, ring)
			__field(struct intel_context *, to)
			__field(struct i915_address_space *, vm)
			__field(u32, dev)
	),

	TP_fast_assign(
			__entry->ring = ring->id;
			__entry->to = to;
			__entry->vm = to->ppgtt? &to->ppgtt->base : NULL;
			__entry->dev = ring->dev->primary->index;
	),

	TP_printk("dev=%u, ring=%u, ctx=%p, ctx_vm=%p",
		  __entry->dev, __entry->ring, __entry->to, __entry->vm)
);

#endif /* _I915_TRACE_H_ */

/* This part must be outside protection */
#undef TRACE_INCLUDE_PATH
#define TRACE_INCLUDE_PATH .
#include <trace/define_trace.h>
Commit	Line	Data
1c5d22f7 CW	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>
05394f39	9	#include "i915_drv.h"
25ef284a	10	#include "intel_drv.h"
db53a302	11	#include "intel_ringbuffer.h"
1c5d22f7 CW	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
25ef284a VS	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
1c5d22f7 CW	92	/* object tracking */
	93
	94	TRACE_EVENT(i915_gem_object_create,
05394f39	95	TP_PROTO(struct drm_i915_gem_object *obj),
1c5d22f7 CW	96	TP_ARGS(obj),
	97
	98	TP_STRUCT__entry(
05394f39	99	__field(struct drm_i915_gem_object *, obj)
1c5d22f7 CW	100	__field(u32, size)
	101	),
	102
	103	TP_fast_assign(
	104	__entry->obj = obj;
05394f39	105	__entry->size = obj->base.size;
1c5d22f7 CW	106	),
	107
	108	TP_printk("obj=%p, size=%u", __entry->obj, __entry->size)
	109	);
	110
07fe0b12	111	TRACE_EVENT(i915_vma_bind,
1ec9e26d DV	112	TP_PROTO(struct i915_vma *vma, unsigned flags),
1ec9e26d DV	113	TP_ARGS(vma, flags),
1c5d22f7 CW	114
1c5d22f7 CW	115	TP_STRUCT__entry(
05394f39	116	__field(struct drm_i915_gem_object *, obj)
07fe0b12	117	__field(struct i915_address_space *, vm)
33938714	118	__field(u64, offset)
db53a302	119	__field(u32, size)
1ec9e26d	120	__field(unsigned, flags)
1c5d22f7 CW	121	),
	122
	123	TP_fast_assign(
07fe0b12 BW	124	__entry->obj = vma->obj;
	125	__entry->vm = vma->vm;
	126	__entry->offset = vma->node.start;
	127	__entry->size = vma->node.size;
1ec9e26d	128	__entry->flags = flags;
1c5d22f7 CW	129	),
1c5d22f7 CW	130
33938714	131	TP_printk("obj=%p, offset=%016llx size=%x%s vm=%p",
db53a302	132	__entry->obj, __entry->offset, __entry->size,
1ec9e26d	133	__entry->flags & PIN_MAPPABLE ? ", mappable" : "",
07fe0b12	134	__entry->vm)
1c5d22f7 CW	135	);
1c5d22f7 CW	136
07fe0b12 BW	137	TRACE_EVENT(i915_vma_unbind,
	138	TP_PROTO(struct i915_vma *vma),
	139	TP_ARGS(vma),
db53a302 CW	140
	141	TP_STRUCT__entry(
	142	__field(struct drm_i915_gem_object *, obj)
07fe0b12	143	__field(struct i915_address_space *, vm)
33938714	144	__field(u64, offset)
db53a302 CW	145	__field(u32, size)
db53a302 CW	146	),
1c5d22f7	147
db53a302	148	TP_fast_assign(
07fe0b12 BW	149	__entry->obj = vma->obj;
	150	__entry->vm = vma->vm;
	151	__entry->offset = vma->node.start;
	152	__entry->size = vma->node.size;
db53a302	153	),
1c5d22f7	154
33938714	155	TP_printk("obj=%p, offset=%016llx size=%x vm=%p",
07fe0b12	156	__entry->obj, __entry->offset, __entry->size, __entry->vm)
db53a302 CW	157	);
	158
	159	TRACE_EVENT(i915_gem_object_change_domain,
	160	TP_PROTO(struct drm_i915_gem_object *obj, u32 old_read, u32 old_write),
	161	TP_ARGS(obj, old_read, old_write),
1c5d22f7 CW	162
1c5d22f7 CW	163	TP_STRUCT__entry(
05394f39	164	__field(struct drm_i915_gem_object *, obj)
1c5d22f7 CW	165	__field(u32, read_domains)
	166	__field(u32, write_domain)
	167	),
	168
	169	TP_fast_assign(
	170	__entry->obj = obj;
db53a302 CW	171	__entry->read_domains = obj->base.read_domains \| (old_read << 16);
db53a302 CW	172	__entry->write_domain = obj->base.write_domain \| (old_write << 16);
1c5d22f7 CW	173	),
1c5d22f7 CW	174
db53a302	175	TP_printk("obj=%p, read=%02x=>%02x, write=%02x=>%02x",
1c5d22f7	176	__entry->obj,
db53a302 CW	177	__entry->read_domains >> 16,
	178	__entry->read_domains & 0xffff,
	179	__entry->write_domain >> 16,
	180	__entry->write_domain & 0xffff)
1c5d22f7 CW	181	);
1c5d22f7 CW	182
db53a302 CW	183	TRACE_EVENT(i915_gem_object_pwrite,
	184	TP_PROTO(struct drm_i915_gem_object *obj, u32 offset, u32 len),
	185	TP_ARGS(obj, offset, len),
1c5d22f7	186
db53a302 CW	187	TP_STRUCT__entry(
	188	__field(struct drm_i915_gem_object *, obj)
	189	__field(u32, offset)
	190	__field(u32, len)
	191	),
1c5d22f7	192
db53a302 CW	193	TP_fast_assign(
	194	__entry->obj = obj;
	195	__entry->offset = offset;
	196	__entry->len = len;
	197	),
	198
	199	TP_printk("obj=%p, offset=%u, len=%u",
	200	__entry->obj, __entry->offset, __entry->len)
	201	);
	202
	203	TRACE_EVENT(i915_gem_object_pread,
	204	TP_PROTO(struct drm_i915_gem_object *obj, u32 offset, u32 len),
	205	TP_ARGS(obj, offset, len),
1c5d22f7 CW	206
1c5d22f7 CW	207	TP_STRUCT__entry(
05394f39	208	__field(struct drm_i915_gem_object *, obj)
db53a302 CW	209	__field(u32, offset)
db53a302 CW	210	__field(u32, len)
1c5d22f7 CW	211	),
	212
	213	TP_fast_assign(
	214	__entry->obj = obj;
db53a302 CW	215	__entry->offset = offset;
db53a302 CW	216	__entry->len = len;
1c5d22f7 CW	217	),
1c5d22f7 CW	218
db53a302 CW	219	TP_printk("obj=%p, offset=%u, len=%u",
db53a302 CW	220	__entry->obj, __entry->offset, __entry->len)
1c5d22f7 CW	221	);
1c5d22f7 CW	222
db53a302 CW	223	TRACE_EVENT(i915_gem_object_fault,
	224	TP_PROTO(struct drm_i915_gem_object *obj, u32 index, bool gtt, bool write),
	225	TP_ARGS(obj, index, gtt, write),
	226
	227	TP_STRUCT__entry(
	228	__field(struct drm_i915_gem_object *, obj)
	229	__field(u32, index)
	230	__field(bool, gtt)
	231	__field(bool, write)
	232	),
	233
	234	TP_fast_assign(
	235	__entry->obj = obj;
	236	__entry->index = index;
	237	__entry->gtt = gtt;
	238	__entry->write = write;
	239	),
f41275e8	240
db53a302 CW	241	TP_printk("obj=%p, %s index=%u %s",
	242	__entry->obj,
	243	__entry->gtt ? "GTT" : "CPU",
	244	__entry->index,
	245	__entry->write ? ", writable" : "")
	246	);
	247
	248	DECLARE_EVENT_CLASS(i915_gem_object,
05394f39	249	TP_PROTO(struct drm_i915_gem_object *obj),
db53a302	250	TP_ARGS(obj),
f41275e8	251
db53a302 CW	252	TP_STRUCT__entry(
	253	__field(struct drm_i915_gem_object *, obj)
	254	),
	255
	256	TP_fast_assign(
	257	__entry->obj = obj;
	258	),
	259
	260	TP_printk("obj=%p", __entry->obj)
f41275e8 LZ	261	);
f41275e8 LZ	262
db53a302 CW	263	DEFINE_EVENT(i915_gem_object, i915_gem_object_clflush,
	264	TP_PROTO(struct drm_i915_gem_object *obj),
	265	TP_ARGS(obj)
	266	);
1c5d22f7	267
db53a302	268	DEFINE_EVENT(i915_gem_object, i915_gem_object_destroy,
05394f39	269	TP_PROTO(struct drm_i915_gem_object *obj),
903cf20c LZ	270	TP_ARGS(obj)
903cf20c LZ	271	);
1c5d22f7	272
db53a302	273	TRACE_EVENT(i915_gem_evict,
1ec9e26d DV	274	TP_PROTO(struct drm_device *dev, u32 size, u32 align, unsigned flags),
1ec9e26d DV	275	TP_ARGS(dev, size, align, flags),
1c5d22f7	276
db53a302 CW	277	TP_STRUCT__entry(
	278	__field(u32, dev)
	279	__field(u32, size)
	280	__field(u32, align)
1ec9e26d	281	__field(unsigned, flags)
db53a302	282	),
1c5d22f7	283
db53a302 CW	284	TP_fast_assign(
	285	__entry->dev = dev->primary->index;
	286	__entry->size = size;
	287	__entry->align = align;
1ec9e26d	288	__entry->flags = flags;
db53a302 CW	289	),
	290
	291	TP_printk("dev=%d, size=%d, align=%d %s",
	292	__entry->dev, __entry->size, __entry->align,
1ec9e26d	293	__entry->flags & PIN_MAPPABLE ? ", mappable" : "")
1c5d22f7 CW	294	);
1c5d22f7 CW	295
db53a302	296	TRACE_EVENT(i915_gem_evict_everything,
6c085a72 CW	297	TP_PROTO(struct drm_device *dev),
6c085a72 CW	298	TP_ARGS(dev),
1c5d22f7	299
db53a302 CW	300	TP_STRUCT__entry(
db53a302 CW	301	__field(u32, dev)
db53a302 CW	302	),
	303
	304	TP_fast_assign(
	305	__entry->dev = dev->primary->index;
db53a302	306	),
1c5d22f7	307
6c085a72	308	TP_printk("dev=%d", __entry->dev)
db53a302	309	);
1c5d22f7	310
bcccff84 BW	311	TRACE_EVENT(i915_gem_evict_vm,
	312	TP_PROTO(struct i915_address_space *vm),
	313	TP_ARGS(vm),
	314
	315	TP_STRUCT__entry(
9297ebf2	316	__field(u32, dev)
bcccff84 BW	317	__field(struct i915_address_space *, vm)
	318	),
	319
	320	TP_fast_assign(
9297ebf2	321	__entry->dev = vm->dev->primary->index;
bcccff84 BW	322	__entry->vm = vm;
	323	),
	324
9297ebf2	325	TP_printk("dev=%d, vm=%p", __entry->dev, __entry->vm)
bcccff84 BW	326	);
bcccff84 BW	327
b52b89da	328	TRACE_EVENT(i915_gem_ring_sync_to,
a4872ba6 OM	329	TP_PROTO(struct intel_engine_cs *from,
a4872ba6 OM	330	struct intel_engine_cs *to,
74328ee5 JH	331	struct drm_i915_gem_request *req),
74328ee5 JH	332	TP_ARGS(from, to, req),
b52b89da CW	333
	334	TP_STRUCT__entry(
	335	__field(u32, dev)
	336	__field(u32, sync_from)
	337	__field(u32, sync_to)
	338	__field(u32, seqno)
	339	),
	340
	341	TP_fast_assign(
	342	__entry->dev = from->dev->primary->index;
	343	__entry->sync_from = from->id;
	344	__entry->sync_to = to->id;
74328ee5	345	__entry->seqno = i915_gem_request_get_seqno(req);
b52b89da CW	346	),
	347
	348	TP_printk("dev=%u, sync-from=%u, sync-to=%u, seqno=%u",
	349	__entry->dev,
	350	__entry->sync_from, __entry->sync_to,
	351	__entry->seqno)
	352	);
	353
db53a302	354	TRACE_EVENT(i915_gem_ring_dispatch,
74328ee5 JH	355	TP_PROTO(struct drm_i915_gem_request *req, u32 flags),
74328ee5 JH	356	TP_ARGS(req, flags),
1c5d22f7 CW	357
1c5d22f7 CW	358	TP_STRUCT__entry(
4f49be54	359	__field(u32, dev)
db53a302	360	__field(u32, ring)
1c5d22f7	361	__field(u32, seqno)
d7d4eedd	362	__field(u32, flags)
1c5d22f7 CW	363	),
	364
	365	TP_fast_assign(
74328ee5 JH	366	struct intel_engine_cs *ring =
74328ee5 JH	367	i915_gem_request_get_ring(req);
db53a302 CW	368	__entry->dev = ring->dev->primary->index;
db53a302 CW	369	__entry->ring = ring->id;
74328ee5	370	__entry->seqno = i915_gem_request_get_seqno(req);
d7d4eedd	371	__entry->flags = flags;
581c26e8	372	i915_trace_irq_get(ring, req);
1c5d22f7 CW	373	),
1c5d22f7 CW	374
d7d4eedd CW	375	TP_printk("dev=%u, ring=%u, seqno=%u, flags=%x",
d7d4eedd CW	376	__entry->dev, __entry->ring, __entry->seqno, __entry->flags)
1c5d22f7 CW	377	);
1c5d22f7 CW	378
db53a302	379	TRACE_EVENT(i915_gem_ring_flush,
a4872ba6	380	TP_PROTO(struct intel_engine_cs *ring, u32 invalidate, u32 flush),
db53a302	381	TP_ARGS(ring, invalidate, flush),
1c5d22f7 CW	382
1c5d22f7 CW	383	TP_STRUCT__entry(
4f49be54	384	__field(u32, dev)
db53a302 CW	385	__field(u32, ring)
	386	__field(u32, invalidate)
	387	__field(u32, flush)
1c5d22f7 CW	388	),
	389
	390	TP_fast_assign(
db53a302 CW	391	__entry->dev = ring->dev->primary->index;
	392	__entry->ring = ring->id;
	393	__entry->invalidate = invalidate;
	394	__entry->flush = flush;
1c5d22f7 CW	395	),
1c5d22f7 CW	396
db53a302 CW	397	TP_printk("dev=%u, ring=%x, invalidate=%04x, flush=%04x",
	398	__entry->dev, __entry->ring,
	399	__entry->invalidate, __entry->flush)
1c5d22f7 CW	400	);
1c5d22f7 CW	401
903cf20c	402	DECLARE_EVENT_CLASS(i915_gem_request,
74328ee5 JH	403	TP_PROTO(struct drm_i915_gem_request *req),
74328ee5 JH	404	TP_ARGS(req),
1c5d22f7 CW	405
1c5d22f7 CW	406	TP_STRUCT__entry(
4f49be54	407	__field(u32, dev)
db53a302	408	__field(u32, ring)
bcfcc8ba	409	__field(u32, uniq)
1c5d22f7 CW	410	__field(u32, seqno)
	411	),
	412
	413	TP_fast_assign(
74328ee5 JH	414	struct intel_engine_cs *ring =
74328ee5 JH	415	i915_gem_request_get_ring(req);
db53a302 CW	416	__entry->dev = ring->dev->primary->index;
db53a302 CW	417	__entry->ring = ring->id;
bcfcc8ba	418	__entry->uniq = req ? req->uniq : 0;
74328ee5	419	__entry->seqno = i915_gem_request_get_seqno(req);
1c5d22f7 CW	420	),
1c5d22f7 CW	421
bcfcc8ba JH	422	TP_printk("dev=%u, ring=%u, uniq=%u, seqno=%u",
	423	__entry->dev, __entry->ring, __entry->uniq,
	424	__entry->seqno)
1c5d22f7 CW	425	);
1c5d22f7 CW	426
db53a302	427	DEFINE_EVENT(i915_gem_request, i915_gem_request_add,
74328ee5 JH	428	TP_PROTO(struct drm_i915_gem_request *req),
74328ee5 JH	429	TP_ARGS(req)
db53a302	430	);
1c5d22f7	431
bcfcc8ba	432	TRACE_EVENT(i915_gem_request_notify,
a4872ba6	433	TP_PROTO(struct intel_engine_cs *ring),
814e9b57 CW	434	TP_ARGS(ring),
	435
	436	TP_STRUCT__entry(
	437	__field(u32, dev)
	438	__field(u32, ring)
	439	__field(u32, seqno)
	440	),
	441
	442	TP_fast_assign(
	443	__entry->dev = ring->dev->primary->index;
	444	__entry->ring = ring->id;
	445	__entry->seqno = ring->get_seqno(ring, false);
	446	),
	447
	448	TP_printk("dev=%u, ring=%u, seqno=%u",
	449	__entry->dev, __entry->ring, __entry->seqno)
1c5d22f7 CW	450	);
1c5d22f7 CW	451
903cf20c	452	DEFINE_EVENT(i915_gem_request, i915_gem_request_retire,
74328ee5 JH	453	TP_PROTO(struct drm_i915_gem_request *req),
74328ee5 JH	454	TP_ARGS(req)
1c5d22f7 CW	455	);
1c5d22f7 CW	456
bcfcc8ba JH	457	DEFINE_EVENT(i915_gem_request, i915_gem_request_complete,
	458	TP_PROTO(struct drm_i915_gem_request *req),
	459	TP_ARGS(req)
	460	);
	461
f3fd3768	462	TRACE_EVENT(i915_gem_request_wait_begin,
74328ee5 JH	463	TP_PROTO(struct drm_i915_gem_request *req),
74328ee5 JH	464	TP_ARGS(req),
f3fd3768 BW	465
	466	TP_STRUCT__entry(
	467	__field(u32, dev)
	468	__field(u32, ring)
bcfcc8ba	469	__field(u32, uniq)
f3fd3768 BW	470	__field(u32, seqno)
	471	__field(bool, blocking)
	472	),
	473
	474	/* NB: the blocking information is racy since mutex_is_locked
	475	* doesn't check that the current thread holds the lock. The only
	476	* other option would be to pass the boolean information of whether
	477	* or not the class was blocking down through the stack which is
	478	* less desirable.
	479	*/
	480	TP_fast_assign(
74328ee5 JH	481	struct intel_engine_cs *ring =
74328ee5 JH	482	i915_gem_request_get_ring(req);
f3fd3768 BW	483	__entry->dev = ring->dev->primary->index;
f3fd3768 BW	484	__entry->ring = ring->id;
bcfcc8ba	485	__entry->uniq = req ? req->uniq : 0;
74328ee5 JH	486	__entry->seqno = i915_gem_request_get_seqno(req);
	487	__entry->blocking =
	488	mutex_is_locked(&ring->dev->struct_mutex);
f3fd3768 BW	489	),
f3fd3768 BW	490
bcfcc8ba JH	491	TP_printk("dev=%u, ring=%u, uniq=%u, seqno=%u, blocking=%s",
	492	__entry->dev, __entry->ring, __entry->uniq,
	493	__entry->seqno, __entry->blocking ? "yes (NB)" : "no")
903cf20c	494	);
1c5d22f7	495
903cf20c	496	DEFINE_EVENT(i915_gem_request, i915_gem_request_wait_end,
74328ee5 JH	497	TP_PROTO(struct drm_i915_gem_request *req),
74328ee5 JH	498	TP_ARGS(req)
1c5d22f7 CW	499	);
1c5d22f7 CW	500
903cf20c	501	DECLARE_EVENT_CLASS(i915_ring,
a4872ba6	502	TP_PROTO(struct intel_engine_cs *ring),
db53a302	503	TP_ARGS(ring),
1c5d22f7 CW	504
1c5d22f7 CW	505	TP_STRUCT__entry(
4f49be54	506	__field(u32, dev)
db53a302	507	__field(u32, ring)
1c5d22f7 CW	508	),
	509
	510	TP_fast_assign(
db53a302 CW	511	__entry->dev = ring->dev->primary->index;
db53a302 CW	512	__entry->ring = ring->id;
1c5d22f7 CW	513	),
1c5d22f7 CW	514
db53a302	515	TP_printk("dev=%u, ring=%u", __entry->dev, __entry->ring)
1c5d22f7 CW	516	);
1c5d22f7 CW	517
903cf20c	518	DEFINE_EVENT(i915_ring, i915_ring_wait_begin,
a4872ba6	519	TP_PROTO(struct intel_engine_cs *ring),
db53a302	520	TP_ARGS(ring)
903cf20c	521	);
1c5d22f7	522
903cf20c	523	DEFINE_EVENT(i915_ring, i915_ring_wait_end,
a4872ba6	524	TP_PROTO(struct intel_engine_cs *ring),
db53a302	525	TP_ARGS(ring)
1c5d22f7 CW	526	);
1c5d22f7 CW	527
e5510fac	528	TRACE_EVENT(i915_flip_request,
05394f39	529	TP_PROTO(int plane, struct drm_i915_gem_object *obj),
e5510fac JB	530
	531	TP_ARGS(plane, obj),
	532
	533	TP_STRUCT__entry(
	534	__field(int, plane)
05394f39	535	__field(struct drm_i915_gem_object *, obj)
e5510fac JB	536	),
	537
	538	TP_fast_assign(
	539	__entry->plane = plane;
	540	__entry->obj = obj;
	541	),
	542
	543	TP_printk("plane=%d, obj=%p", __entry->plane, __entry->obj)
	544	);
	545
	546	TRACE_EVENT(i915_flip_complete,
05394f39	547	TP_PROTO(int plane, struct drm_i915_gem_object *obj),
e5510fac JB	548
	549	TP_ARGS(plane, obj),
	550
	551	TP_STRUCT__entry(
	552	__field(int, plane)
05394f39	553	__field(struct drm_i915_gem_object *, obj)
e5510fac JB	554	),
	555
	556	TP_fast_assign(
	557	__entry->plane = plane;
	558	__entry->obj = obj;
	559	),
	560
	561	TP_printk("plane=%d, obj=%p", __entry->plane, __entry->obj)
	562	);
	563
ed71f1b4 CW	564	TRACE_EVENT_CONDITION(i915_reg_rw,
ed71f1b4 CW	565	TP_PROTO(bool write, u32 reg, u64 val, int len, bool trace),
0206e353	566
ed71f1b4 CW	567	TP_ARGS(write, reg, val, len, trace),
	568
	569	TP_CONDITION(trace),
0206e353 AJ	570
	571	TP_STRUCT__entry(
	572	__field(u64, val)
	573	__field(u32, reg)
	574	__field(u16, write)
	575	__field(u16, len)
	576	),
	577
	578	TP_fast_assign(
	579	__entry->val = (u64)val;
	580	__entry->reg = reg;
	581	__entry->write = write;
	582	__entry->len = len;
	583	),
	584
	585	TP_printk("%s reg=0x%x, len=%d, val=(0x%x, 0x%x)",
	586	__entry->write ? "write" : "read",
	587	__entry->reg, __entry->len,
	588	(u32)(__entry->val & 0xffffffff),
	589	(u32)(__entry->val >> 32))
ba4f01a3 YL	590	);
ba4f01a3 YL	591
be2cde9a DV	592	TRACE_EVENT(intel_gpu_freq_change,
	593	TP_PROTO(u32 freq),
	594	TP_ARGS(freq),
	595
	596	TP_STRUCT__entry(
	597	__field(u32, freq)
	598	),
	599
	600	TP_fast_assign(
	601	__entry->freq = freq;
	602	),
	603
	604	TP_printk("new_freq=%u", __entry->freq)
	605	);
	606
198c974d DCS	607	/**
	608	* DOC: i915_ppgtt_create and i915_ppgtt_release tracepoints
	609	*
	610	* With full ppgtt enabled each process using drm will allocate at least one
	611	* translation table. With these traces it is possible to keep track of the
	612	* allocation and of the lifetime of the tables; this can be used during
	613	* testing/debug to verify that we are not leaking ppgtts.
	614	* These traces identify the ppgtt through the vm pointer, which is also printed
	615	* by the i915_vma_bind and i915_vma_unbind tracepoints.
	616	*/
	617	DECLARE_EVENT_CLASS(i915_ppgtt,
	618	TP_PROTO(struct i915_address_space *vm),
	619	TP_ARGS(vm),
	620
	621	TP_STRUCT__entry(
	622	__field(struct i915_address_space *, vm)
	623	__field(u32, dev)
	624	),
	625
	626	TP_fast_assign(
	627	__entry->vm = vm;
	628	__entry->dev = vm->dev->primary->index;
	629	),
	630
	631	TP_printk("dev=%u, vm=%p", __entry->dev, __entry->vm)
	632	)
	633
	634	DEFINE_EVENT(i915_ppgtt, i915_ppgtt_create,
	635	TP_PROTO(struct i915_address_space *vm),
	636	TP_ARGS(vm)
	637	);
	638
	639	DEFINE_EVENT(i915_ppgtt, i915_ppgtt_release,
	640	TP_PROTO(struct i915_address_space *vm),
	641	TP_ARGS(vm)
	642	);
	643
	644	/**
	645	* DOC: i915_context_create and i915_context_free tracepoints
	646	*
	647	* These tracepoints are used to track creation and deletion of contexts.
	648	* If full ppgtt is enabled, they also print the address of the vm assigned to
	649	* the context.
	650	*/
	651	DECLARE_EVENT_CLASS(i915_context,
	652	TP_PROTO(struct intel_context *ctx),
	653	TP_ARGS(ctx),
	654
	655	TP_STRUCT__entry(
	656	__field(u32, dev)
	657	__field(struct intel_context *, ctx)
	658	__field(struct i915_address_space *, vm)
	659	),
	660
	661	TP_fast_assign(
	662	__entry->ctx = ctx;
	663	__entry->vm = ctx->ppgtt ? &ctx->ppgtt->base : NULL;
	664	__entry->dev = ctx->file_priv->dev_priv->dev->primary->index;
	665	),
	666
	667	TP_printk("dev=%u, ctx=%p, ctx_vm=%p",
	668	__entry->dev, __entry->ctx, __entry->vm)
	669	)
	670
671	DEFINE_EVENT(i915_context, i915_context_create,
672	TP_PROTO(struct intel_context *ctx),
673	TP_ARGS(ctx)
674	);
675
676	DEFINE_EVENT(i915_context, i915_context_free,
677	TP_PROTO(struct intel_context *ctx),
678	TP_ARGS(ctx)
679	);
680
681	/**
682	* DOC: switch_mm tracepoint
683	*
684	* This tracepoint allows tracking of the mm switch, which is an important point
685	* in the lifetime of the vm in the legacy submission path. This tracepoint is
686	* called only if full ppgtt is enabled.
687	*/
688	TRACE_EVENT(switch_mm,
689	TP_PROTO(struct intel_engine_cs ring, struct intel_context to),
690
691	TP_ARGS(ring, to),
692
693	TP_STRUCT__entry(
694	__field(u32, ring)
695	__field(struct intel_context *, to)
696	__field(struct i915_address_space *, vm)
697	__field(u32, dev)
698	),
699
700	TP_fast_assign(
701	__entry->ring = ring->id;
702	__entry->to = to;
703	__entry->vm = to->ppgtt? &to->ppgtt->base : NULL;
704	__entry->dev = ring->dev->primary->index;
705	),
706
707	TP_printk("dev=%u, ring=%u, ctx=%p, ctx_vm=%p",
708	__entry->dev, __entry->ring, __entry->to, __entry->vm)
709	);
710
1c5d22f7 CW	711	#endif /* _I915_TRACE_H_ */
	712
	713	/* This part must be outside protection */
	714	#undef TRACE_INCLUDE_PATH
a7c54278	715	#define TRACE_INCLUDE_PATH .
1c5d22f7	716	#include <trace/define_trace.h>