Branch data Line data Source code
1 : : /*
2 : : * Copyright © 2008 Intel Corporation
3 : : *
4 : : * Permission is hereby granted, free of charge, to any person obtaining a
5 : : * copy of this software and associated documentation files (the "Software"),
6 : : * to deal in the Software without restriction, including without limitation
7 : : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 : : * and/or sell copies of the Software, and to permit persons to whom the
9 : : * Software is furnished to do so, subject to the following conditions:
10 : : *
11 : : * The above copyright notice and this permission notice (including the next
12 : : * paragraph) shall be included in all copies or substantial portions of the
13 : : * Software.
14 : : *
15 : : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 : : * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 : : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 : : * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 : : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 : : * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
21 : : * IN THE SOFTWARE.
22 : : *
23 : : * Authors:
24 : : * Eric Anholt <eric@anholt.net>
25 : : * Keith Packard <keithp@keithp.com>
26 : : *
27 : : */
28 : :
29 : : #include <linux/sched/mm.h>
30 : : #include <linux/sort.h>
31 : :
32 : : #include <drm/drm_debugfs.h>
33 : : #include <drm/drm_fourcc.h>
34 : :
35 : : #include "display/intel_display_types.h"
36 : : #include "display/intel_dp.h"
37 : : #include "display/intel_fbc.h"
38 : : #include "display/intel_hdcp.h"
39 : : #include "display/intel_hdmi.h"
40 : : #include "display/intel_psr.h"
41 : :
42 : : #include "gem/i915_gem_context.h"
43 : : #include "gt/intel_gt_pm.h"
44 : : #include "gt/intel_gt_requests.h"
45 : : #include "gt/intel_reset.h"
46 : : #include "gt/intel_rc6.h"
47 : : #include "gt/intel_rps.h"
48 : : #include "gt/uc/intel_guc_submission.h"
49 : :
50 : : #include "i915_debugfs.h"
51 : : #include "i915_irq.h"
52 : : #include "i915_trace.h"
53 : : #include "intel_csr.h"
54 : : #include "intel_pm.h"
55 : : #include "intel_sideband.h"
56 : :
57 : 0 : static inline struct drm_i915_private *node_to_i915(struct drm_info_node *node)
58 : : {
59 : 0 : return to_i915(node->minor->dev);
60 : : }
61 : :
62 : 0 : static int i915_capabilities(struct seq_file *m, void *data)
63 : : {
64 : 0 : struct drm_i915_private *i915 = node_to_i915(m->private);
65 : 0 : struct drm_printer p = drm_seq_file_printer(m);
66 : :
67 : 0 : seq_printf(m, "pch: %d\n", INTEL_PCH_TYPE(i915));
68 : :
69 : 0 : intel_device_info_print_static(INTEL_INFO(i915), &p);
70 : 0 : intel_device_info_print_runtime(RUNTIME_INFO(i915), &p);
71 : 0 : intel_driver_caps_print(&i915->caps, &p);
72 : :
73 : 0 : kernel_param_lock(THIS_MODULE);
74 : 0 : i915_params_dump(&i915_modparams, &p);
75 : 0 : kernel_param_unlock(THIS_MODULE);
76 : :
77 : 0 : return 0;
78 : : }
79 : :
80 : 0 : static char get_tiling_flag(struct drm_i915_gem_object *obj)
81 : : {
82 : 0 : switch (i915_gem_object_get_tiling(obj)) {
83 : : default:
84 : : case I915_TILING_NONE: return ' ';
85 : 0 : case I915_TILING_X: return 'X';
86 : 0 : case I915_TILING_Y: return 'Y';
87 : : }
88 : : }
89 : :
90 : 0 : static char get_global_flag(struct drm_i915_gem_object *obj)
91 : : {
92 : 0 : return READ_ONCE(obj->userfault_count) ? 'g' : ' ';
93 : : }
94 : :
95 : 0 : static char get_pin_mapped_flag(struct drm_i915_gem_object *obj)
96 : : {
97 : 0 : return obj->mm.mapping ? 'M' : ' ';
98 : : }
99 : :
100 : : static const char *
101 : 0 : stringify_page_sizes(unsigned int page_sizes, char *buf, size_t len)
102 : : {
103 : 0 : size_t x = 0;
104 : :
105 [ # # # # : 0 : switch (page_sizes) {
# ]
106 : : case 0:
107 : : return "";
108 : 0 : case I915_GTT_PAGE_SIZE_4K:
109 : 0 : return "4K";
110 : 0 : case I915_GTT_PAGE_SIZE_64K:
111 : 0 : return "64K";
112 : 0 : case I915_GTT_PAGE_SIZE_2M:
113 : 0 : return "2M";
114 : 0 : default:
115 [ # # ]: 0 : if (!buf)
116 : : return "M";
117 : :
118 [ # # ]: 0 : if (page_sizes & I915_GTT_PAGE_SIZE_2M)
119 : 0 : x += snprintf(buf + x, len - x, "2M, ");
120 [ # # ]: 0 : if (page_sizes & I915_GTT_PAGE_SIZE_64K)
121 : 0 : x += snprintf(buf + x, len - x, "64K, ");
122 [ # # ]: 0 : if (page_sizes & I915_GTT_PAGE_SIZE_4K)
123 : 0 : x += snprintf(buf + x, len - x, "4K, ");
124 : 0 : buf[x-2] = '\0';
125 : :
126 : 0 : return buf;
127 : : }
128 : : }
129 : :
130 : : static void
131 : 0 : describe_obj(struct seq_file *m, struct drm_i915_gem_object *obj)
132 : : {
133 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(obj->base.dev);
134 : 0 : struct intel_engine_cs *engine;
135 : 0 : struct i915_vma *vma;
136 : 0 : int pin_count = 0;
137 : :
138 [ # # # # : 0 : seq_printf(m, "%pK: %c%c%c %8zdKiB %02x %02x %s%s%s",
# ]
139 : : &obj->base,
140 : : get_tiling_flag(obj),
141 : : get_global_flag(obj),
142 : 0 : get_pin_mapped_flag(obj),
143 : 0 : obj->base.size / 1024,
144 : 0 : obj->read_domains,
145 [ # # ]: 0 : obj->write_domain,
146 : 0 : i915_cache_level_str(dev_priv, obj->cache_level),
147 [ # # ]: 0 : obj->mm.dirty ? " dirty" : "",
148 [ # # ]: 0 : obj->mm.madv == I915_MADV_DONTNEED ? " purgeable" : "");
149 [ # # ]: 0 : if (obj->base.name)
150 : 0 : seq_printf(m, " (name: %d)", obj->base.name);
151 : :
152 : 0 : spin_lock(&obj->vma.lock);
153 [ # # ]: 0 : list_for_each_entry(vma, &obj->vma.list, obj_link) {
154 [ # # ]: 0 : if (!drm_mm_node_allocated(&vma->node))
155 : 0 : continue;
156 : :
157 : 0 : spin_unlock(&obj->vma.lock);
158 : :
159 [ # # ]: 0 : if (i915_vma_is_pinned(vma))
160 : 0 : pin_count++;
161 : :
162 [ # # ]: 0 : seq_printf(m, " (%sgtt offset: %08llx, size: %08llx, pages: %s",
163 : : i915_vma_is_ggtt(vma) ? "g" : "pp",
164 : : vma->node.start, vma->node.size,
165 : : stringify_page_sizes(vma->page_sizes.gtt, NULL, 0));
166 [ # # ]: 0 : if (i915_vma_is_ggtt(vma)) {
167 [ # # # # : 0 : switch (vma->ggtt_view.type) {
# ]
168 : 0 : case I915_GGTT_VIEW_NORMAL:
169 : 0 : seq_puts(m, ", normal");
170 : 0 : break;
171 : :
172 : 0 : case I915_GGTT_VIEW_PARTIAL:
173 : 0 : seq_printf(m, ", partial [%08llx+%x]",
174 : 0 : vma->ggtt_view.partial.offset << PAGE_SHIFT,
175 : 0 : vma->ggtt_view.partial.size << PAGE_SHIFT);
176 : 0 : break;
177 : :
178 : 0 : case I915_GGTT_VIEW_ROTATED:
179 : 0 : seq_printf(m, ", rotated [(%ux%u, stride=%u, offset=%u), (%ux%u, stride=%u, offset=%u)]",
180 : : vma->ggtt_view.rotated.plane[0].width,
181 : : vma->ggtt_view.rotated.plane[0].height,
182 : : vma->ggtt_view.rotated.plane[0].stride,
183 : : vma->ggtt_view.rotated.plane[0].offset,
184 : : vma->ggtt_view.rotated.plane[1].width,
185 : : vma->ggtt_view.rotated.plane[1].height,
186 : : vma->ggtt_view.rotated.plane[1].stride,
187 : : vma->ggtt_view.rotated.plane[1].offset);
188 : 0 : break;
189 : :
190 : 0 : case I915_GGTT_VIEW_REMAPPED:
191 : 0 : seq_printf(m, ", remapped [(%ux%u, stride=%u, offset=%u), (%ux%u, stride=%u, offset=%u)]",
192 : : vma->ggtt_view.remapped.plane[0].width,
193 : : vma->ggtt_view.remapped.plane[0].height,
194 : : vma->ggtt_view.remapped.plane[0].stride,
195 : : vma->ggtt_view.remapped.plane[0].offset,
196 : : vma->ggtt_view.remapped.plane[1].width,
197 : : vma->ggtt_view.remapped.plane[1].height,
198 : : vma->ggtt_view.remapped.plane[1].stride,
199 : : vma->ggtt_view.remapped.plane[1].offset);
200 : 0 : break;
201 : :
202 : : default:
203 : 0 : MISSING_CASE(vma->ggtt_view.type);
204 : 0 : break;
205 : : }
206 : 0 : }
207 [ # # ]: 0 : if (vma->fence)
208 : 0 : seq_printf(m, " , fence: %d", vma->fence->id);
209 : 0 : seq_puts(m, ")");
210 : :
211 : 0 : spin_lock(&obj->vma.lock);
212 : : }
213 : 0 : spin_unlock(&obj->vma.lock);
214 : :
215 : 0 : seq_printf(m, " (pinned x %d)", pin_count);
216 [ # # ]: 0 : if (obj->stolen)
217 : 0 : seq_printf(m, " (stolen: %08llx)", obj->stolen->start);
218 [ # # ]: 0 : if (i915_gem_object_is_framebuffer(obj))
219 : 0 : seq_printf(m, " (fb)");
220 : :
221 : 0 : engine = i915_gem_object_last_write_engine(obj);
222 [ # # ]: 0 : if (engine)
223 : 0 : seq_printf(m, " (%s)", engine->name);
224 : 0 : }
225 : :
226 : : struct file_stats {
227 : : struct i915_address_space *vm;
228 : : unsigned long count;
229 : : u64 total, unbound;
230 : : u64 active, inactive;
231 : : u64 closed;
232 : : };
233 : :
234 : 0 : static int per_file_stats(int id, void *ptr, void *data)
235 : : {
236 : 0 : struct drm_i915_gem_object *obj = ptr;
237 : 0 : struct file_stats *stats = data;
238 : 0 : struct i915_vma *vma;
239 : :
240 [ # # ]: 0 : if (!kref_get_unless_zero(&obj->base.refcount))
241 : : return 0;
242 : :
243 : 0 : stats->count++;
244 : 0 : stats->total += obj->base.size;
245 [ # # ]: 0 : if (!atomic_read(&obj->bind_count))
246 : 0 : stats->unbound += obj->base.size;
247 : :
248 : 0 : spin_lock(&obj->vma.lock);
249 [ # # ]: 0 : if (!stats->vm) {
250 [ # # # # ]: 0 : for_each_ggtt_vma(vma, obj) {
251 [ # # ]: 0 : if (!drm_mm_node_allocated(&vma->node))
252 : 0 : continue;
253 : :
254 [ # # ]: 0 : if (i915_vma_is_active(vma))
255 : 0 : stats->active += vma->node.size;
256 : : else
257 : 0 : stats->inactive += vma->node.size;
258 : :
259 [ # # ]: 0 : if (i915_vma_is_closed(vma))
260 : 0 : stats->closed += vma->node.size;
261 : : }
262 : : } else {
263 : 0 : struct rb_node *p = obj->vma.tree.rb_node;
264 : :
265 [ # # ]: 0 : while (p) {
266 : 0 : long cmp;
267 : :
268 : 0 : vma = rb_entry(p, typeof(*vma), obj_node);
269 [ # # ]: 0 : cmp = i915_vma_compare(vma, stats->vm, NULL);
270 [ # # ]: 0 : if (cmp == 0) {
271 [ # # ]: 0 : if (drm_mm_node_allocated(&vma->node)) {
272 [ # # ]: 0 : if (i915_vma_is_active(vma))
273 : 0 : stats->active += vma->node.size;
274 : : else
275 : 0 : stats->inactive += vma->node.size;
276 : :
277 [ # # ]: 0 : if (i915_vma_is_closed(vma))
278 : 0 : stats->closed += vma->node.size;
279 : : }
280 : : break;
281 : : }
282 [ # # ]: 0 : if (cmp < 0)
283 : 0 : p = p->rb_right;
284 : : else
285 : 0 : p = p->rb_left;
286 : : }
287 : : }
288 : 0 : spin_unlock(&obj->vma.lock);
289 : :
290 : 0 : i915_gem_object_put(obj);
291 : 0 : return 0;
292 : : }
293 : :
294 : : #define print_file_stats(m, name, stats) do { \
295 : : if (stats.count) \
296 : : seq_printf(m, "%s: %lu objects, %llu bytes (%llu active, %llu inactive, %llu unbound, %llu closed)\n", \
297 : : name, \
298 : : stats.count, \
299 : : stats.total, \
300 : : stats.active, \
301 : : stats.inactive, \
302 : : stats.unbound, \
303 : : stats.closed); \
304 : : } while (0)
305 : :
306 : 0 : static void print_context_stats(struct seq_file *m,
307 : : struct drm_i915_private *i915)
308 : : {
309 : 0 : struct file_stats kstats = {};
310 : 0 : struct i915_gem_context *ctx, *cn;
311 : :
312 : 0 : spin_lock(&i915->gem.contexts.lock);
313 [ # # ]: 0 : list_for_each_entry_safe(ctx, cn, &i915->gem.contexts.list, link) {
314 : 0 : struct i915_gem_engines_iter it;
315 : 0 : struct intel_context *ce;
316 : :
317 [ # # ]: 0 : if (!kref_get_unless_zero(&ctx->ref))
318 : 0 : continue;
319 : :
320 : 0 : spin_unlock(&i915->gem.contexts.lock);
321 : :
322 [ # # ]: 0 : for_each_gem_engine(ce,
323 : : i915_gem_context_lock_engines(ctx), it) {
324 [ # # ]: 0 : if (intel_context_pin_if_active(ce)) {
325 : 0 : rcu_read_lock();
326 [ # # ]: 0 : if (ce->state)
327 : 0 : per_file_stats(0,
328 : 0 : ce->state->obj, &kstats);
329 : 0 : per_file_stats(0, ce->ring->vma->obj, &kstats);
330 : 0 : rcu_read_unlock();
331 : 0 : intel_context_unpin(ce);
332 : : }
333 : : }
334 : 0 : i915_gem_context_unlock_engines(ctx);
335 : :
336 [ # # # # ]: 0 : if (!IS_ERR_OR_NULL(ctx->file_priv)) {
337 : 0 : struct file_stats stats = {
338 : 0 : .vm = rcu_access_pointer(ctx->vm),
339 : : };
340 : 0 : struct drm_file *file = ctx->file_priv->file;
341 : 0 : struct task_struct *task;
342 : 0 : char name[80];
343 : :
344 : 0 : rcu_read_lock();
345 : 0 : idr_for_each(&file->object_idr, per_file_stats, &stats);
346 : 0 : rcu_read_unlock();
347 : :
348 : 0 : rcu_read_lock();
349 [ # # ]: 0 : task = pid_task(ctx->pid ?: file->pid, PIDTYPE_PID);
350 [ # # ]: 0 : snprintf(name, sizeof(name), "%s",
351 : : task ? task->comm : "<unknown>");
352 : 0 : rcu_read_unlock();
353 : :
354 [ # # ]: 0 : print_file_stats(m, name, stats);
355 : : }
356 : :
357 : 0 : spin_lock(&i915->gem.contexts.lock);
358 : 0 : list_safe_reset_next(ctx, cn, link);
359 : 0 : i915_gem_context_put(ctx);
360 : : }
361 : 0 : spin_unlock(&i915->gem.contexts.lock);
362 : :
363 [ # # ]: 0 : print_file_stats(m, "[k]contexts", kstats);
364 : 0 : }
365 : :
366 : 0 : static int i915_gem_object_info(struct seq_file *m, void *data)
367 : : {
368 : 0 : struct drm_i915_private *i915 = node_to_i915(m->private);
369 : 0 : struct intel_memory_region *mr;
370 : 0 : enum intel_region_id id;
371 : :
372 : 0 : seq_printf(m, "%u shrinkable [%u free] objects, %llu bytes\n",
373 : : i915->mm.shrink_count,
374 : 0 : atomic_read(&i915->mm.free_count),
375 : : i915->mm.shrink_memory);
376 [ # # # # ]: 0 : for_each_memory_region(mr, i915, id)
377 : 0 : seq_printf(m, "%s: total:%pa, available:%pa bytes\n",
378 : 0 : mr->name, &mr->total, &mr->avail);
379 : 0 : seq_putc(m, '\n');
380 : :
381 : 0 : print_context_stats(m, i915);
382 : :
383 : 0 : return 0;
384 : : }
385 : :
386 : 0 : static void gen8_display_interrupt_info(struct seq_file *m)
387 : : {
388 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
389 : 0 : enum pipe pipe;
390 : :
391 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
392 : 0 : enum intel_display_power_domain power_domain;
393 : 0 : intel_wakeref_t wakeref;
394 : :
395 : 0 : power_domain = POWER_DOMAIN_PIPE(pipe);
396 : 0 : wakeref = intel_display_power_get_if_enabled(dev_priv,
397 : : power_domain);
398 [ # # ]: 0 : if (!wakeref) {
399 : 0 : seq_printf(m, "Pipe %c power disabled\n",
400 : : pipe_name(pipe));
401 : 0 : continue;
402 : : }
403 : 0 : seq_printf(m, "Pipe %c IMR:\t%08x\n",
404 : : pipe_name(pipe),
405 : 0 : I915_READ(GEN8_DE_PIPE_IMR(pipe)));
406 : 0 : seq_printf(m, "Pipe %c IIR:\t%08x\n",
407 : : pipe_name(pipe),
408 : 0 : I915_READ(GEN8_DE_PIPE_IIR(pipe)));
409 : 0 : seq_printf(m, "Pipe %c IER:\t%08x\n",
410 : : pipe_name(pipe),
411 : 0 : I915_READ(GEN8_DE_PIPE_IER(pipe)));
412 : :
413 : 0 : intel_display_power_put(dev_priv, power_domain, wakeref);
414 : : }
415 : :
416 : 0 : seq_printf(m, "Display Engine port interrupt mask:\t%08x\n",
417 : : I915_READ(GEN8_DE_PORT_IMR));
418 : 0 : seq_printf(m, "Display Engine port interrupt identity:\t%08x\n",
419 : : I915_READ(GEN8_DE_PORT_IIR));
420 : 0 : seq_printf(m, "Display Engine port interrupt enable:\t%08x\n",
421 : : I915_READ(GEN8_DE_PORT_IER));
422 : :
423 : 0 : seq_printf(m, "Display Engine misc interrupt mask:\t%08x\n",
424 : : I915_READ(GEN8_DE_MISC_IMR));
425 : 0 : seq_printf(m, "Display Engine misc interrupt identity:\t%08x\n",
426 : : I915_READ(GEN8_DE_MISC_IIR));
427 : 0 : seq_printf(m, "Display Engine misc interrupt enable:\t%08x\n",
428 : : I915_READ(GEN8_DE_MISC_IER));
429 : :
430 : 0 : seq_printf(m, "PCU interrupt mask:\t%08x\n",
431 : : I915_READ(GEN8_PCU_IMR));
432 : 0 : seq_printf(m, "PCU interrupt identity:\t%08x\n",
433 : : I915_READ(GEN8_PCU_IIR));
434 : 0 : seq_printf(m, "PCU interrupt enable:\t%08x\n",
435 : : I915_READ(GEN8_PCU_IER));
436 : 0 : }
437 : :
438 : 0 : static int i915_interrupt_info(struct seq_file *m, void *data)
439 : : {
440 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
441 : 0 : struct intel_engine_cs *engine;
442 : 0 : intel_wakeref_t wakeref;
443 : 0 : int i, pipe;
444 : :
445 : 0 : wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);
446 : :
447 [ # # ]: 0 : if (IS_CHERRYVIEW(dev_priv)) {
448 : 0 : intel_wakeref_t pref;
449 : :
450 : 0 : seq_printf(m, "Master Interrupt Control:\t%08x\n",
451 : : I915_READ(GEN8_MASTER_IRQ));
452 : :
453 : 0 : seq_printf(m, "Display IER:\t%08x\n",
454 : : I915_READ(VLV_IER));
455 : 0 : seq_printf(m, "Display IIR:\t%08x\n",
456 : : I915_READ(VLV_IIR));
457 : 0 : seq_printf(m, "Display IIR_RW:\t%08x\n",
458 : : I915_READ(VLV_IIR_RW));
459 : 0 : seq_printf(m, "Display IMR:\t%08x\n",
460 : : I915_READ(VLV_IMR));
461 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
462 : 0 : enum intel_display_power_domain power_domain;
463 : :
464 : 0 : power_domain = POWER_DOMAIN_PIPE(pipe);
465 : 0 : pref = intel_display_power_get_if_enabled(dev_priv,
466 : : power_domain);
467 [ # # ]: 0 : if (!pref) {
468 : 0 : seq_printf(m, "Pipe %c power disabled\n",
469 : : pipe_name(pipe));
470 : 0 : continue;
471 : : }
472 : :
473 : 0 : seq_printf(m, "Pipe %c stat:\t%08x\n",
474 : : pipe_name(pipe),
475 : 0 : I915_READ(PIPESTAT(pipe)));
476 : :
477 : 0 : intel_display_power_put(dev_priv, power_domain, pref);
478 : : }
479 : :
480 : 0 : pref = intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
481 : 0 : seq_printf(m, "Port hotplug:\t%08x\n",
482 : 0 : I915_READ(PORT_HOTPLUG_EN));
483 : 0 : seq_printf(m, "DPFLIPSTAT:\t%08x\n",
484 : : I915_READ(VLV_DPFLIPSTAT));
485 : 0 : seq_printf(m, "DPINVGTT:\t%08x\n",
486 : : I915_READ(DPINVGTT));
487 : 0 : intel_display_power_put(dev_priv, POWER_DOMAIN_INIT, pref);
488 : :
489 [ # # ]: 0 : for (i = 0; i < 4; i++) {
490 : 0 : seq_printf(m, "GT Interrupt IMR %d:\t%08x\n",
491 : 0 : i, I915_READ(GEN8_GT_IMR(i)));
492 : 0 : seq_printf(m, "GT Interrupt IIR %d:\t%08x\n",
493 : 0 : i, I915_READ(GEN8_GT_IIR(i)));
494 : 0 : seq_printf(m, "GT Interrupt IER %d:\t%08x\n",
495 : 0 : i, I915_READ(GEN8_GT_IER(i)));
496 : : }
497 : :
498 : 0 : seq_printf(m, "PCU interrupt mask:\t%08x\n",
499 : : I915_READ(GEN8_PCU_IMR));
500 : 0 : seq_printf(m, "PCU interrupt identity:\t%08x\n",
501 : : I915_READ(GEN8_PCU_IIR));
502 : 0 : seq_printf(m, "PCU interrupt enable:\t%08x\n",
503 : : I915_READ(GEN8_PCU_IER));
504 [ # # ]: 0 : } else if (INTEL_GEN(dev_priv) >= 11) {
505 : 0 : seq_printf(m, "Master Interrupt Control: %08x\n",
506 : : I915_READ(GEN11_GFX_MSTR_IRQ));
507 : :
508 : 0 : seq_printf(m, "Render/Copy Intr Enable: %08x\n",
509 : : I915_READ(GEN11_RENDER_COPY_INTR_ENABLE));
510 : 0 : seq_printf(m, "VCS/VECS Intr Enable: %08x\n",
511 : : I915_READ(GEN11_VCS_VECS_INTR_ENABLE));
512 : 0 : seq_printf(m, "GUC/SG Intr Enable:\t %08x\n",
513 : : I915_READ(GEN11_GUC_SG_INTR_ENABLE));
514 : 0 : seq_printf(m, "GPM/WGBOXPERF Intr Enable: %08x\n",
515 : : I915_READ(GEN11_GPM_WGBOXPERF_INTR_ENABLE));
516 : 0 : seq_printf(m, "Crypto Intr Enable:\t %08x\n",
517 : : I915_READ(GEN11_CRYPTO_RSVD_INTR_ENABLE));
518 : 0 : seq_printf(m, "GUnit/CSME Intr Enable:\t %08x\n",
519 : : I915_READ(GEN11_GUNIT_CSME_INTR_ENABLE));
520 : :
521 : 0 : seq_printf(m, "Display Interrupt Control:\t%08x\n",
522 : : I915_READ(GEN11_DISPLAY_INT_CTL));
523 : :
524 : 0 : gen8_display_interrupt_info(m);
525 [ # # ]: 0 : } else if (INTEL_GEN(dev_priv) >= 8) {
526 : 0 : seq_printf(m, "Master Interrupt Control:\t%08x\n",
527 : : I915_READ(GEN8_MASTER_IRQ));
528 : :
529 [ # # ]: 0 : for (i = 0; i < 4; i++) {
530 : 0 : seq_printf(m, "GT Interrupt IMR %d:\t%08x\n",
531 : 0 : i, I915_READ(GEN8_GT_IMR(i)));
532 : 0 : seq_printf(m, "GT Interrupt IIR %d:\t%08x\n",
533 : 0 : i, I915_READ(GEN8_GT_IIR(i)));
534 : 0 : seq_printf(m, "GT Interrupt IER %d:\t%08x\n",
535 : 0 : i, I915_READ(GEN8_GT_IER(i)));
536 : : }
537 : :
538 : 0 : gen8_display_interrupt_info(m);
539 [ # # ]: 0 : } else if (IS_VALLEYVIEW(dev_priv)) {
540 : 0 : intel_wakeref_t pref;
541 : :
542 : 0 : seq_printf(m, "Display IER:\t%08x\n",
543 : : I915_READ(VLV_IER));
544 : 0 : seq_printf(m, "Display IIR:\t%08x\n",
545 : : I915_READ(VLV_IIR));
546 : 0 : seq_printf(m, "Display IIR_RW:\t%08x\n",
547 : : I915_READ(VLV_IIR_RW));
548 : 0 : seq_printf(m, "Display IMR:\t%08x\n",
549 : : I915_READ(VLV_IMR));
550 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe) {
551 : 0 : enum intel_display_power_domain power_domain;
552 : :
553 : 0 : power_domain = POWER_DOMAIN_PIPE(pipe);
554 : 0 : pref = intel_display_power_get_if_enabled(dev_priv,
555 : : power_domain);
556 [ # # ]: 0 : if (!pref) {
557 : 0 : seq_printf(m, "Pipe %c power disabled\n",
558 : : pipe_name(pipe));
559 : 0 : continue;
560 : : }
561 : :
562 : 0 : seq_printf(m, "Pipe %c stat:\t%08x\n",
563 : : pipe_name(pipe),
564 : 0 : I915_READ(PIPESTAT(pipe)));
565 : 0 : intel_display_power_put(dev_priv, power_domain, pref);
566 : : }
567 : :
568 : 0 : seq_printf(m, "Master IER:\t%08x\n",
569 : : I915_READ(VLV_MASTER_IER));
570 : :
571 : 0 : seq_printf(m, "Render IER:\t%08x\n",
572 : : I915_READ(GTIER));
573 : 0 : seq_printf(m, "Render IIR:\t%08x\n",
574 : : I915_READ(GTIIR));
575 : 0 : seq_printf(m, "Render IMR:\t%08x\n",
576 : : I915_READ(GTIMR));
577 : :
578 : 0 : seq_printf(m, "PM IER:\t\t%08x\n",
579 : : I915_READ(GEN6_PMIER));
580 : 0 : seq_printf(m, "PM IIR:\t\t%08x\n",
581 : : I915_READ(GEN6_PMIIR));
582 : 0 : seq_printf(m, "PM IMR:\t\t%08x\n",
583 : : I915_READ(GEN6_PMIMR));
584 : :
585 : 0 : pref = intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
586 : 0 : seq_printf(m, "Port hotplug:\t%08x\n",
587 : 0 : I915_READ(PORT_HOTPLUG_EN));
588 : 0 : seq_printf(m, "DPFLIPSTAT:\t%08x\n",
589 : : I915_READ(VLV_DPFLIPSTAT));
590 : 0 : seq_printf(m, "DPINVGTT:\t%08x\n",
591 : : I915_READ(DPINVGTT));
592 : 0 : intel_display_power_put(dev_priv, POWER_DOMAIN_INIT, pref);
593 : :
594 [ # # ]: 0 : } else if (!HAS_PCH_SPLIT(dev_priv)) {
595 : 0 : seq_printf(m, "Interrupt enable: %08x\n",
596 : : I915_READ(GEN2_IER));
597 : 0 : seq_printf(m, "Interrupt identity: %08x\n",
598 : : I915_READ(GEN2_IIR));
599 : 0 : seq_printf(m, "Interrupt mask: %08x\n",
600 : : I915_READ(GEN2_IMR));
601 [ # # # # ]: 0 : for_each_pipe(dev_priv, pipe)
602 : 0 : seq_printf(m, "Pipe %c stat: %08x\n",
603 : : pipe_name(pipe),
604 : 0 : I915_READ(PIPESTAT(pipe)));
605 : : } else {
606 : 0 : seq_printf(m, "North Display Interrupt enable: %08x\n",
607 : : I915_READ(DEIER));
608 : 0 : seq_printf(m, "North Display Interrupt identity: %08x\n",
609 : : I915_READ(DEIIR));
610 : 0 : seq_printf(m, "North Display Interrupt mask: %08x\n",
611 : : I915_READ(DEIMR));
612 : 0 : seq_printf(m, "South Display Interrupt enable: %08x\n",
613 : : I915_READ(SDEIER));
614 : 0 : seq_printf(m, "South Display Interrupt identity: %08x\n",
615 : : I915_READ(SDEIIR));
616 : 0 : seq_printf(m, "South Display Interrupt mask: %08x\n",
617 : : I915_READ(SDEIMR));
618 : 0 : seq_printf(m, "Graphics Interrupt enable: %08x\n",
619 : : I915_READ(GTIER));
620 : 0 : seq_printf(m, "Graphics Interrupt identity: %08x\n",
621 : : I915_READ(GTIIR));
622 : 0 : seq_printf(m, "Graphics Interrupt mask: %08x\n",
623 : : I915_READ(GTIMR));
624 : : }
625 : :
626 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 11) {
627 : 0 : seq_printf(m, "RCS Intr Mask:\t %08x\n",
628 : : I915_READ(GEN11_RCS0_RSVD_INTR_MASK));
629 : 0 : seq_printf(m, "BCS Intr Mask:\t %08x\n",
630 : : I915_READ(GEN11_BCS_RSVD_INTR_MASK));
631 : 0 : seq_printf(m, "VCS0/VCS1 Intr Mask:\t %08x\n",
632 : : I915_READ(GEN11_VCS0_VCS1_INTR_MASK));
633 : 0 : seq_printf(m, "VCS2/VCS3 Intr Mask:\t %08x\n",
634 : : I915_READ(GEN11_VCS2_VCS3_INTR_MASK));
635 : 0 : seq_printf(m, "VECS0/VECS1 Intr Mask:\t %08x\n",
636 : : I915_READ(GEN11_VECS0_VECS1_INTR_MASK));
637 : 0 : seq_printf(m, "GUC/SG Intr Mask:\t %08x\n",
638 : : I915_READ(GEN11_GUC_SG_INTR_MASK));
639 : 0 : seq_printf(m, "GPM/WGBOXPERF Intr Mask: %08x\n",
640 : : I915_READ(GEN11_GPM_WGBOXPERF_INTR_MASK));
641 : 0 : seq_printf(m, "Crypto Intr Mask:\t %08x\n",
642 : : I915_READ(GEN11_CRYPTO_RSVD_INTR_MASK));
643 : 0 : seq_printf(m, "Gunit/CSME Intr Mask:\t %08x\n",
644 : : I915_READ(GEN11_GUNIT_CSME_INTR_MASK));
645 : :
646 [ # # ]: 0 : } else if (INTEL_GEN(dev_priv) >= 6) {
647 [ # # # # : 0 : for_each_uabi_engine(engine, dev_priv) {
# # ]
648 : 0 : seq_printf(m,
649 : : "Graphics Interrupt mask (%s): %08x\n",
650 : 0 : engine->name, ENGINE_READ(engine, RING_IMR));
651 : : }
652 : : }
653 : :
654 : 0 : intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);
655 : :
656 : 0 : return 0;
657 : : }
658 : :
659 : 0 : static int i915_gem_fence_regs_info(struct seq_file *m, void *data)
660 : : {
661 : 0 : struct drm_i915_private *i915 = node_to_i915(m->private);
662 : 0 : unsigned int i;
663 : :
664 : 0 : seq_printf(m, "Total fences = %d\n", i915->ggtt.num_fences);
665 : :
666 : 0 : rcu_read_lock();
667 [ # # ]: 0 : for (i = 0; i < i915->ggtt.num_fences; i++) {
668 : 0 : struct i915_fence_reg *reg = &i915->ggtt.fence_regs[i];
669 : 0 : struct i915_vma *vma = reg->vma;
670 : :
671 : 0 : seq_printf(m, "Fence %d, pin count = %d, object = ",
672 : 0 : i, atomic_read(®->pin_count));
673 [ # # ]: 0 : if (!vma)
674 : 0 : seq_puts(m, "unused");
675 : : else
676 : 0 : describe_obj(m, vma->obj);
677 : 0 : seq_putc(m, '\n');
678 : : }
679 : 0 : rcu_read_unlock();
680 : :
681 : 0 : return 0;
682 : : }
683 : :
684 : : #if IS_ENABLED(CONFIG_DRM_I915_CAPTURE_ERROR)
685 : 0 : static ssize_t gpu_state_read(struct file *file, char __user *ubuf,
686 : : size_t count, loff_t *pos)
687 : : {
688 : 0 : struct i915_gpu_coredump *error;
689 : 0 : ssize_t ret;
690 : 0 : void *buf;
691 : :
692 : 0 : error = file->private_data;
693 [ # # ]: 0 : if (!error)
694 : : return 0;
695 : :
696 : : /* Bounce buffer required because of kernfs __user API convenience. */
697 [ # # ]: 0 : buf = kmalloc(count, GFP_KERNEL);
698 [ # # ]: 0 : if (!buf)
699 : : return -ENOMEM;
700 : :
701 : 0 : ret = i915_gpu_coredump_copy_to_buffer(error, buf, *pos, count);
702 [ # # ]: 0 : if (ret <= 0)
703 : 0 : goto out;
704 : :
705 [ # # # # ]: 0 : if (!copy_to_user(ubuf, buf, ret))
706 : 0 : *pos += ret;
707 : : else
708 : : ret = -EFAULT;
709 : :
710 : 0 : out:
711 : 0 : kfree(buf);
712 : 0 : return ret;
713 : : }
714 : :
715 : 0 : static int gpu_state_release(struct inode *inode, struct file *file)
716 : : {
717 : 0 : i915_gpu_coredump_put(file->private_data);
718 : 0 : return 0;
719 : : }
720 : :
721 : 0 : static int i915_gpu_info_open(struct inode *inode, struct file *file)
722 : : {
723 : 0 : struct drm_i915_private *i915 = inode->i_private;
724 : 0 : struct i915_gpu_coredump *gpu;
725 : 0 : intel_wakeref_t wakeref;
726 : :
727 : 0 : gpu = NULL;
728 [ # # ]: 0 : with_intel_runtime_pm(&i915->runtime_pm, wakeref)
729 : 0 : gpu = i915_gpu_coredump(i915);
730 [ # # ]: 0 : if (IS_ERR(gpu))
731 : 0 : return PTR_ERR(gpu);
732 : :
733 : 0 : file->private_data = gpu;
734 : 0 : return 0;
735 : : }
736 : :
737 : : static const struct file_operations i915_gpu_info_fops = {
738 : : .owner = THIS_MODULE,
739 : : .open = i915_gpu_info_open,
740 : : .read = gpu_state_read,
741 : : .llseek = default_llseek,
742 : : .release = gpu_state_release,
743 : : };
744 : :
745 : : static ssize_t
746 : 0 : i915_error_state_write(struct file *filp,
747 : : const char __user *ubuf,
748 : : size_t cnt,
749 : : loff_t *ppos)
750 : : {
751 : 0 : struct i915_gpu_coredump *error = filp->private_data;
752 : :
753 [ # # ]: 0 : if (!error)
754 : : return 0;
755 : :
756 : 0 : DRM_DEBUG_DRIVER("Resetting error state\n");
757 : 0 : i915_reset_error_state(error->i915);
758 : :
759 : 0 : return cnt;
760 : : }
761 : :
762 : 0 : static int i915_error_state_open(struct inode *inode, struct file *file)
763 : : {
764 : 0 : struct i915_gpu_coredump *error;
765 : :
766 : 0 : error = i915_first_error_state(inode->i_private);
767 [ # # ]: 0 : if (IS_ERR(error))
768 : 0 : return PTR_ERR(error);
769 : :
770 : 0 : file->private_data = error;
771 : 0 : return 0;
772 : : }
773 : :
774 : : static const struct file_operations i915_error_state_fops = {
775 : : .owner = THIS_MODULE,
776 : : .open = i915_error_state_open,
777 : : .read = gpu_state_read,
778 : : .write = i915_error_state_write,
779 : : .llseek = default_llseek,
780 : : .release = gpu_state_release,
781 : : };
782 : : #endif
783 : :
784 : 0 : static int i915_frequency_info(struct seq_file *m, void *unused)
785 : : {
786 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
787 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
788 : 0 : struct intel_rps *rps = &dev_priv->gt.rps;
789 : 0 : intel_wakeref_t wakeref;
790 : 0 : int ret = 0;
791 : :
792 : 0 : wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);
793 : :
794 [ # # ]: 0 : if (IS_GEN(dev_priv, 5)) {
795 : 0 : u16 rgvswctl = intel_uncore_read16(uncore, MEMSWCTL);
796 : 0 : u16 rgvstat = intel_uncore_read16(uncore, MEMSTAT_ILK);
797 : :
798 : 0 : seq_printf(m, "Requested P-state: %d\n", (rgvswctl >> 8) & 0xf);
799 : 0 : seq_printf(m, "Requested VID: %d\n", rgvswctl & 0x3f);
800 : 0 : seq_printf(m, "Current VID: %d\n", (rgvstat & MEMSTAT_VID_MASK) >>
801 : : MEMSTAT_VID_SHIFT);
802 : 0 : seq_printf(m, "Current P-state: %d\n",
803 : 0 : (rgvstat & MEMSTAT_PSTATE_MASK) >> MEMSTAT_PSTATE_SHIFT);
804 [ # # # # ]: 0 : } else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv)) {
805 : 0 : u32 rpmodectl, freq_sts;
806 : :
807 : 0 : rpmodectl = I915_READ(GEN6_RP_CONTROL);
808 : 0 : seq_printf(m, "Video Turbo Mode: %s\n",
809 [ # # ]: 0 : yesno(rpmodectl & GEN6_RP_MEDIA_TURBO));
810 : 0 : seq_printf(m, "HW control enabled: %s\n",
811 [ # # ]: 0 : yesno(rpmodectl & GEN6_RP_ENABLE));
812 : 0 : seq_printf(m, "SW control enabled: %s\n",
813 [ # # ]: 0 : yesno((rpmodectl & GEN6_RP_MEDIA_MODE_MASK) ==
814 : : GEN6_RP_MEDIA_SW_MODE));
815 : :
816 : 0 : vlv_punit_get(dev_priv);
817 : 0 : freq_sts = vlv_punit_read(dev_priv, PUNIT_REG_GPU_FREQ_STS);
818 : 0 : vlv_punit_put(dev_priv);
819 : :
820 : 0 : seq_printf(m, "PUNIT_REG_GPU_FREQ_STS: 0x%08x\n", freq_sts);
821 : 0 : seq_printf(m, "DDR freq: %d MHz\n", dev_priv->mem_freq);
822 : :
823 : 0 : seq_printf(m, "actual GPU freq: %d MHz\n",
824 : 0 : intel_gpu_freq(rps, (freq_sts >> 8) & 0xff));
825 : :
826 : 0 : seq_printf(m, "current GPU freq: %d MHz\n",
827 : 0 : intel_gpu_freq(rps, rps->cur_freq));
828 : :
829 : 0 : seq_printf(m, "max GPU freq: %d MHz\n",
830 : 0 : intel_gpu_freq(rps, rps->max_freq));
831 : :
832 : 0 : seq_printf(m, "min GPU freq: %d MHz\n",
833 : 0 : intel_gpu_freq(rps, rps->min_freq));
834 : :
835 : 0 : seq_printf(m, "idle GPU freq: %d MHz\n",
836 : 0 : intel_gpu_freq(rps, rps->idle_freq));
837 : :
838 : 0 : seq_printf(m,
839 : : "efficient (RPe) frequency: %d MHz\n",
840 : 0 : intel_gpu_freq(rps, rps->efficient_freq));
841 [ # # ]: 0 : } else if (INTEL_GEN(dev_priv) >= 6) {
842 : 0 : u32 rp_state_limits;
843 : 0 : u32 gt_perf_status;
844 : 0 : u32 rp_state_cap;
845 : 0 : u32 rpmodectl, rpinclimit, rpdeclimit;
846 : 0 : u32 rpstat, cagf, reqf;
847 : 0 : u32 rpupei, rpcurup, rpprevup;
848 : 0 : u32 rpdownei, rpcurdown, rpprevdown;
849 : 0 : u32 pm_ier, pm_imr, pm_isr, pm_iir, pm_mask;
850 : 0 : int max_freq;
851 : :
852 : 0 : rp_state_limits = I915_READ(GEN6_RP_STATE_LIMITS);
853 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv)) {
854 : 0 : rp_state_cap = I915_READ(BXT_RP_STATE_CAP);
855 : 0 : gt_perf_status = I915_READ(BXT_GT_PERF_STATUS);
856 : : } else {
857 : 0 : rp_state_cap = I915_READ(GEN6_RP_STATE_CAP);
858 : 0 : gt_perf_status = I915_READ(GEN6_GT_PERF_STATUS);
859 : : }
860 : :
861 : : /* RPSTAT1 is in the GT power well */
862 : 0 : intel_uncore_forcewake_get(&dev_priv->uncore, FORCEWAKE_ALL);
863 : :
864 : 0 : reqf = I915_READ(GEN6_RPNSWREQ);
865 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9)
866 : 0 : reqf >>= 23;
867 : : else {
868 : 0 : reqf &= ~GEN6_TURBO_DISABLE;
869 [ # # # # ]: 0 : if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv))
870 : 0 : reqf >>= 24;
871 : : else
872 : 0 : reqf >>= 25;
873 : : }
874 : 0 : reqf = intel_gpu_freq(rps, reqf);
875 : :
876 : 0 : rpmodectl = I915_READ(GEN6_RP_CONTROL);
877 : 0 : rpinclimit = I915_READ(GEN6_RP_UP_THRESHOLD);
878 : 0 : rpdeclimit = I915_READ(GEN6_RP_DOWN_THRESHOLD);
879 : :
880 : 0 : rpstat = I915_READ(GEN6_RPSTAT1);
881 : 0 : rpupei = I915_READ(GEN6_RP_CUR_UP_EI) & GEN6_CURICONT_MASK;
882 : 0 : rpcurup = I915_READ(GEN6_RP_CUR_UP) & GEN6_CURBSYTAVG_MASK;
883 : 0 : rpprevup = I915_READ(GEN6_RP_PREV_UP) & GEN6_CURBSYTAVG_MASK;
884 : 0 : rpdownei = I915_READ(GEN6_RP_CUR_DOWN_EI) & GEN6_CURIAVG_MASK;
885 : 0 : rpcurdown = I915_READ(GEN6_RP_CUR_DOWN) & GEN6_CURBSYTAVG_MASK;
886 : 0 : rpprevdown = I915_READ(GEN6_RP_PREV_DOWN) & GEN6_CURBSYTAVG_MASK;
887 : 0 : cagf = intel_rps_read_actual_frequency(rps);
888 : :
889 : 0 : intel_uncore_forcewake_put(&dev_priv->uncore, FORCEWAKE_ALL);
890 : :
891 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 11) {
892 : 0 : pm_ier = I915_READ(GEN11_GPM_WGBOXPERF_INTR_ENABLE);
893 : 0 : pm_imr = I915_READ(GEN11_GPM_WGBOXPERF_INTR_MASK);
894 : : /*
895 : : * The equivalent to the PM ISR & IIR cannot be read
896 : : * without affecting the current state of the system
897 : : */
898 : 0 : pm_isr = 0;
899 : 0 : pm_iir = 0;
900 [ # # ]: 0 : } else if (INTEL_GEN(dev_priv) >= 8) {
901 : 0 : pm_ier = I915_READ(GEN8_GT_IER(2));
902 : 0 : pm_imr = I915_READ(GEN8_GT_IMR(2));
903 : 0 : pm_isr = I915_READ(GEN8_GT_ISR(2));
904 : 0 : pm_iir = I915_READ(GEN8_GT_IIR(2));
905 : : } else {
906 : 0 : pm_ier = I915_READ(GEN6_PMIER);
907 : 0 : pm_imr = I915_READ(GEN6_PMIMR);
908 : 0 : pm_isr = I915_READ(GEN6_PMISR);
909 : 0 : pm_iir = I915_READ(GEN6_PMIIR);
910 : : }
911 : 0 : pm_mask = I915_READ(GEN6_PMINTRMSK);
912 : :
913 : 0 : seq_printf(m, "Video Turbo Mode: %s\n",
914 [ # # ]: 0 : yesno(rpmodectl & GEN6_RP_MEDIA_TURBO));
915 : 0 : seq_printf(m, "HW control enabled: %s\n",
916 [ # # ]: 0 : yesno(rpmodectl & GEN6_RP_ENABLE));
917 : 0 : seq_printf(m, "SW control enabled: %s\n",
918 [ # # ]: 0 : yesno((rpmodectl & GEN6_RP_MEDIA_MODE_MASK) ==
919 : : GEN6_RP_MEDIA_SW_MODE));
920 : :
921 : 0 : seq_printf(m, "PM IER=0x%08x IMR=0x%08x, MASK=0x%08x\n",
922 : : pm_ier, pm_imr, pm_mask);
923 [ # # ]: 0 : if (INTEL_GEN(dev_priv) <= 10)
924 : 0 : seq_printf(m, "PM ISR=0x%08x IIR=0x%08x\n",
925 : : pm_isr, pm_iir);
926 : 0 : seq_printf(m, "pm_intrmsk_mbz: 0x%08x\n",
927 : : rps->pm_intrmsk_mbz);
928 : 0 : seq_printf(m, "GT_PERF_STATUS: 0x%08x\n", gt_perf_status);
929 : 0 : seq_printf(m, "Render p-state ratio: %d\n",
930 [ # # ]: 0 : (gt_perf_status & (INTEL_GEN(dev_priv) >= 9 ? 0x1ff00 : 0xff00)) >> 8);
931 : 0 : seq_printf(m, "Render p-state VID: %d\n",
932 : : gt_perf_status & 0xff);
933 : 0 : seq_printf(m, "Render p-state limit: %d\n",
934 : : rp_state_limits & 0xff);
935 : 0 : seq_printf(m, "RPSTAT1: 0x%08x\n", rpstat);
936 : 0 : seq_printf(m, "RPMODECTL: 0x%08x\n", rpmodectl);
937 : 0 : seq_printf(m, "RPINCLIMIT: 0x%08x\n", rpinclimit);
938 : 0 : seq_printf(m, "RPDECLIMIT: 0x%08x\n", rpdeclimit);
939 : 0 : seq_printf(m, "RPNSWREQ: %dMHz\n", reqf);
940 : 0 : seq_printf(m, "CAGF: %dMHz\n", cagf);
941 : 0 : seq_printf(m, "RP CUR UP EI: %d (%dus)\n",
942 [ # # # # : 0 : rpupei, GT_PM_INTERVAL_TO_US(dev_priv, rpupei));
# # ]
943 : 0 : seq_printf(m, "RP CUR UP: %d (%dus)\n",
944 [ # # # # : 0 : rpcurup, GT_PM_INTERVAL_TO_US(dev_priv, rpcurup));
# # ]
945 : 0 : seq_printf(m, "RP PREV UP: %d (%dus)\n",
946 [ # # # # : 0 : rpprevup, GT_PM_INTERVAL_TO_US(dev_priv, rpprevup));
# # ]
947 : 0 : seq_printf(m, "Up threshold: %d%%\n",
948 : 0 : rps->power.up_threshold);
949 : :
950 : 0 : seq_printf(m, "RP CUR DOWN EI: %d (%dus)\n",
951 [ # # # # : 0 : rpdownei, GT_PM_INTERVAL_TO_US(dev_priv, rpdownei));
# # ]
952 : 0 : seq_printf(m, "RP CUR DOWN: %d (%dus)\n",
953 [ # # # # : 0 : rpcurdown, GT_PM_INTERVAL_TO_US(dev_priv, rpcurdown));
# # ]
954 : 0 : seq_printf(m, "RP PREV DOWN: %d (%dus)\n",
955 [ # # # # : 0 : rpprevdown, GT_PM_INTERVAL_TO_US(dev_priv, rpprevdown));
# # ]
956 : 0 : seq_printf(m, "Down threshold: %d%%\n",
957 : 0 : rps->power.down_threshold);
958 : :
959 [ # # ]: 0 : max_freq = (IS_GEN9_LP(dev_priv) ? rp_state_cap >> 0 :
960 [ # # ]: 0 : rp_state_cap >> 16) & 0xff;
961 [ # # # # ]: 0 : max_freq *= (IS_GEN9_BC(dev_priv) ||
962 [ # # ]: 0 : INTEL_GEN(dev_priv) >= 10 ? GEN9_FREQ_SCALER : 1);
963 : 0 : seq_printf(m, "Lowest (RPN) frequency: %dMHz\n",
964 : : intel_gpu_freq(rps, max_freq));
965 : :
966 : 0 : max_freq = (rp_state_cap & 0xff00) >> 8;
967 [ # # # # ]: 0 : max_freq *= (IS_GEN9_BC(dev_priv) ||
968 [ # # ]: 0 : INTEL_GEN(dev_priv) >= 10 ? GEN9_FREQ_SCALER : 1);
969 : 0 : seq_printf(m, "Nominal (RP1) frequency: %dMHz\n",
970 : : intel_gpu_freq(rps, max_freq));
971 : :
972 [ # # ]: 0 : max_freq = (IS_GEN9_LP(dev_priv) ? rp_state_cap >> 16 :
973 [ # # ]: 0 : rp_state_cap >> 0) & 0xff;
974 [ # # # # ]: 0 : max_freq *= (IS_GEN9_BC(dev_priv) ||
975 [ # # ]: 0 : INTEL_GEN(dev_priv) >= 10 ? GEN9_FREQ_SCALER : 1);
976 : 0 : seq_printf(m, "Max non-overclocked (RP0) frequency: %dMHz\n",
977 : : intel_gpu_freq(rps, max_freq));
978 : 0 : seq_printf(m, "Max overclocked frequency: %dMHz\n",
979 : 0 : intel_gpu_freq(rps, rps->max_freq));
980 : :
981 : 0 : seq_printf(m, "Current freq: %d MHz\n",
982 : 0 : intel_gpu_freq(rps, rps->cur_freq));
983 : 0 : seq_printf(m, "Actual freq: %d MHz\n", cagf);
984 : 0 : seq_printf(m, "Idle freq: %d MHz\n",
985 : 0 : intel_gpu_freq(rps, rps->idle_freq));
986 : 0 : seq_printf(m, "Min freq: %d MHz\n",
987 : 0 : intel_gpu_freq(rps, rps->min_freq));
988 : 0 : seq_printf(m, "Boost freq: %d MHz\n",
989 : 0 : intel_gpu_freq(rps, rps->boost_freq));
990 : 0 : seq_printf(m, "Max freq: %d MHz\n",
991 : 0 : intel_gpu_freq(rps, rps->max_freq));
992 : 0 : seq_printf(m,
993 : : "efficient (RPe) frequency: %d MHz\n",
994 : 0 : intel_gpu_freq(rps, rps->efficient_freq));
995 : : } else {
996 : 0 : seq_puts(m, "no P-state info available\n");
997 : : }
998 : :
999 : 0 : seq_printf(m, "Current CD clock frequency: %d kHz\n", dev_priv->cdclk.hw.cdclk);
1000 : 0 : seq_printf(m, "Max CD clock frequency: %d kHz\n", dev_priv->max_cdclk_freq);
1001 : 0 : seq_printf(m, "Max pixel clock frequency: %d kHz\n", dev_priv->max_dotclk_freq);
1002 : :
1003 : 0 : intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);
1004 : 0 : return ret;
1005 : : }
1006 : :
1007 : 0 : static int ilk_drpc_info(struct seq_file *m)
1008 : : {
1009 : 0 : struct drm_i915_private *i915 = node_to_i915(m->private);
1010 : 0 : struct intel_uncore *uncore = &i915->uncore;
1011 : 0 : u32 rgvmodectl, rstdbyctl;
1012 : 0 : u16 crstandvid;
1013 : :
1014 : 0 : rgvmodectl = intel_uncore_read(uncore, MEMMODECTL);
1015 : 0 : rstdbyctl = intel_uncore_read(uncore, RSTDBYCTL);
1016 : 0 : crstandvid = intel_uncore_read16(uncore, CRSTANDVID);
1017 : :
1018 [ # # ]: 0 : seq_printf(m, "HD boost: %s\n", yesno(rgvmodectl & MEMMODE_BOOST_EN));
1019 : 0 : seq_printf(m, "Boost freq: %d\n",
1020 : 0 : (rgvmodectl & MEMMODE_BOOST_FREQ_MASK) >>
1021 : : MEMMODE_BOOST_FREQ_SHIFT);
1022 : 0 : seq_printf(m, "HW control enabled: %s\n",
1023 [ # # ]: 0 : yesno(rgvmodectl & MEMMODE_HWIDLE_EN));
1024 : 0 : seq_printf(m, "SW control enabled: %s\n",
1025 [ # # ]: 0 : yesno(rgvmodectl & MEMMODE_SWMODE_EN));
1026 : 0 : seq_printf(m, "Gated voltage change: %s\n",
1027 [ # # ]: 0 : yesno(rgvmodectl & MEMMODE_RCLK_GATE));
1028 : 0 : seq_printf(m, "Starting frequency: P%d\n",
1029 : 0 : (rgvmodectl & MEMMODE_FSTART_MASK) >> MEMMODE_FSTART_SHIFT);
1030 : 0 : seq_printf(m, "Max P-state: P%d\n",
1031 : 0 : (rgvmodectl & MEMMODE_FMAX_MASK) >> MEMMODE_FMAX_SHIFT);
1032 : 0 : seq_printf(m, "Min P-state: P%d\n", (rgvmodectl & MEMMODE_FMIN_MASK));
1033 : 0 : seq_printf(m, "RS1 VID: %d\n", (crstandvid & 0x3f));
1034 : 0 : seq_printf(m, "RS2 VID: %d\n", ((crstandvid >> 8) & 0x3f));
1035 : 0 : seq_printf(m, "Render standby enabled: %s\n",
1036 [ # # ]: 0 : yesno(!(rstdbyctl & RCX_SW_EXIT)));
1037 : 0 : seq_puts(m, "Current RS state: ");
1038 [ # # # # : 0 : switch (rstdbyctl & RSX_STATUS_MASK) {
# # # ]
1039 : 0 : case RSX_STATUS_ON:
1040 : 0 : seq_puts(m, "on\n");
1041 : 0 : break;
1042 : 0 : case RSX_STATUS_RC1:
1043 : 0 : seq_puts(m, "RC1\n");
1044 : 0 : break;
1045 : 0 : case RSX_STATUS_RC1E:
1046 : 0 : seq_puts(m, "RC1E\n");
1047 : 0 : break;
1048 : 0 : case RSX_STATUS_RS1:
1049 : 0 : seq_puts(m, "RS1\n");
1050 : 0 : break;
1051 : 0 : case RSX_STATUS_RS2:
1052 : 0 : seq_puts(m, "RS2 (RC6)\n");
1053 : 0 : break;
1054 : 0 : case RSX_STATUS_RS3:
1055 : 0 : seq_puts(m, "RC3 (RC6+)\n");
1056 : 0 : break;
1057 : 0 : default:
1058 : 0 : seq_puts(m, "unknown\n");
1059 : 0 : break;
1060 : : }
1061 : :
1062 : 0 : return 0;
1063 : : }
1064 : :
1065 : 0 : static int i915_forcewake_domains(struct seq_file *m, void *data)
1066 : : {
1067 : 0 : struct drm_i915_private *i915 = node_to_i915(m->private);
1068 : 0 : struct intel_uncore *uncore = &i915->uncore;
1069 : 0 : struct intel_uncore_forcewake_domain *fw_domain;
1070 : 0 : unsigned int tmp;
1071 : :
1072 : 0 : seq_printf(m, "user.bypass_count = %u\n",
1073 : : uncore->user_forcewake_count);
1074 : :
1075 [ # # # # ]: 0 : for_each_fw_domain(fw_domain, uncore, tmp)
1076 : 0 : seq_printf(m, "%s.wake_count = %u\n",
1077 : : intel_uncore_forcewake_domain_to_str(fw_domain->id),
1078 : 0 : READ_ONCE(fw_domain->wake_count));
1079 : :
1080 : 0 : return 0;
1081 : : }
1082 : :
1083 : 0 : static void print_rc6_res(struct seq_file *m,
1084 : : const char *title,
1085 : : const i915_reg_t reg)
1086 : : {
1087 : 0 : struct drm_i915_private *i915 = node_to_i915(m->private);
1088 : 0 : intel_wakeref_t wakeref;
1089 : :
1090 [ # # ]: 0 : with_intel_runtime_pm(&i915->runtime_pm, wakeref)
1091 : 0 : seq_printf(m, "%s %u (%llu us)\n", title,
1092 : : intel_uncore_read(&i915->uncore, reg),
1093 : : intel_rc6_residency_us(&i915->gt.rc6, reg));
1094 : 0 : }
1095 : :
1096 : 0 : static int vlv_drpc_info(struct seq_file *m)
1097 : : {
1098 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1099 : 0 : u32 rcctl1, pw_status;
1100 : :
1101 : 0 : pw_status = I915_READ(VLV_GTLC_PW_STATUS);
1102 : 0 : rcctl1 = I915_READ(GEN6_RC_CONTROL);
1103 : :
1104 : 0 : seq_printf(m, "RC6 Enabled: %s\n",
1105 [ # # ]: 0 : yesno(rcctl1 & (GEN7_RC_CTL_TO_MODE |
1106 : : GEN6_RC_CTL_EI_MODE(1))));
1107 : 0 : seq_printf(m, "Render Power Well: %s\n",
1108 [ # # ]: 0 : (pw_status & VLV_GTLC_PW_RENDER_STATUS_MASK) ? "Up" : "Down");
1109 : 0 : seq_printf(m, "Media Power Well: %s\n",
1110 [ # # ]: 0 : (pw_status & VLV_GTLC_PW_MEDIA_STATUS_MASK) ? "Up" : "Down");
1111 : :
1112 : 0 : print_rc6_res(m, "Render RC6 residency since boot:", VLV_GT_RENDER_RC6);
1113 : 0 : print_rc6_res(m, "Media RC6 residency since boot:", VLV_GT_MEDIA_RC6);
1114 : :
1115 : 0 : return i915_forcewake_domains(m, NULL);
1116 : : }
1117 : :
1118 : 0 : static int gen6_drpc_info(struct seq_file *m)
1119 : : {
1120 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1121 : 0 : u32 gt_core_status, rcctl1, rc6vids = 0;
1122 : 0 : u32 gen9_powergate_enable = 0, gen9_powergate_status = 0;
1123 : :
1124 : 0 : gt_core_status = I915_READ_FW(GEN6_GT_CORE_STATUS);
1125 : 0 : trace_i915_reg_rw(false, GEN6_GT_CORE_STATUS, gt_core_status, 4, true);
1126 : :
1127 : 0 : rcctl1 = I915_READ(GEN6_RC_CONTROL);
1128 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9) {
1129 : 0 : gen9_powergate_enable = I915_READ(GEN9_PG_ENABLE);
1130 : 0 : gen9_powergate_status = I915_READ(GEN9_PWRGT_DOMAIN_STATUS);
1131 : : }
1132 : :
1133 [ # # ]: 0 : if (INTEL_GEN(dev_priv) <= 7)
1134 : 0 : sandybridge_pcode_read(dev_priv, GEN6_PCODE_READ_RC6VIDS,
1135 : : &rc6vids, NULL);
1136 : :
1137 : 0 : seq_printf(m, "RC1e Enabled: %s\n",
1138 [ # # ]: 0 : yesno(rcctl1 & GEN6_RC_CTL_RC1e_ENABLE));
1139 : 0 : seq_printf(m, "RC6 Enabled: %s\n",
1140 [ # # ]: 0 : yesno(rcctl1 & GEN6_RC_CTL_RC6_ENABLE));
1141 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9) {
1142 : 0 : seq_printf(m, "Render Well Gating Enabled: %s\n",
1143 [ # # ]: 0 : yesno(gen9_powergate_enable & GEN9_RENDER_PG_ENABLE));
1144 : 0 : seq_printf(m, "Media Well Gating Enabled: %s\n",
1145 [ # # ]: 0 : yesno(gen9_powergate_enable & GEN9_MEDIA_PG_ENABLE));
1146 : : }
1147 : 0 : seq_printf(m, "Deep RC6 Enabled: %s\n",
1148 [ # # ]: 0 : yesno(rcctl1 & GEN6_RC_CTL_RC6p_ENABLE));
1149 : 0 : seq_printf(m, "Deepest RC6 Enabled: %s\n",
1150 [ # # ]: 0 : yesno(rcctl1 & GEN6_RC_CTL_RC6pp_ENABLE));
1151 : 0 : seq_puts(m, "Current RC state: ");
1152 [ # # # # : 0 : switch (gt_core_status & GEN6_RCn_MASK) {
# ]
1153 : 0 : case GEN6_RC0:
1154 [ # # ]: 0 : if (gt_core_status & GEN6_CORE_CPD_STATE_MASK)
1155 : 0 : seq_puts(m, "Core Power Down\n");
1156 : : else
1157 : 0 : seq_puts(m, "on\n");
1158 : : break;
1159 : 0 : case GEN6_RC3:
1160 : 0 : seq_puts(m, "RC3\n");
1161 : 0 : break;
1162 : 0 : case GEN6_RC6:
1163 : 0 : seq_puts(m, "RC6\n");
1164 : 0 : break;
1165 : 0 : case GEN6_RC7:
1166 : 0 : seq_puts(m, "RC7\n");
1167 : 0 : break;
1168 : 0 : default:
1169 : 0 : seq_puts(m, "Unknown\n");
1170 : 0 : break;
1171 : : }
1172 : :
1173 : 0 : seq_printf(m, "Core Power Down: %s\n",
1174 [ # # ]: 0 : yesno(gt_core_status & GEN6_CORE_CPD_STATE_MASK));
1175 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9) {
1176 : 0 : seq_printf(m, "Render Power Well: %s\n",
1177 [ # # ]: 0 : (gen9_powergate_status &
1178 : : GEN9_PWRGT_RENDER_STATUS_MASK) ? "Up" : "Down");
1179 : 0 : seq_printf(m, "Media Power Well: %s\n",
1180 [ # # ]: 0 : (gen9_powergate_status &
1181 : : GEN9_PWRGT_MEDIA_STATUS_MASK) ? "Up" : "Down");
1182 : : }
1183 : :
1184 : : /* Not exactly sure what this is */
1185 : 0 : print_rc6_res(m, "RC6 \"Locked to RPn\" residency since boot:",
1186 : 0 : GEN6_GT_GFX_RC6_LOCKED);
1187 : 0 : print_rc6_res(m, "RC6 residency since boot:", GEN6_GT_GFX_RC6);
1188 : 0 : print_rc6_res(m, "RC6+ residency since boot:", GEN6_GT_GFX_RC6p);
1189 : 0 : print_rc6_res(m, "RC6++ residency since boot:", GEN6_GT_GFX_RC6pp);
1190 : :
1191 [ # # ]: 0 : if (INTEL_GEN(dev_priv) <= 7) {
1192 : 0 : seq_printf(m, "RC6 voltage: %dmV\n",
1193 : 0 : GEN6_DECODE_RC6_VID(((rc6vids >> 0) & 0xff)));
1194 : 0 : seq_printf(m, "RC6+ voltage: %dmV\n",
1195 : 0 : GEN6_DECODE_RC6_VID(((rc6vids >> 8) & 0xff)));
1196 : 0 : seq_printf(m, "RC6++ voltage: %dmV\n",
1197 : 0 : GEN6_DECODE_RC6_VID(((rc6vids >> 16) & 0xff)));
1198 : : }
1199 : :
1200 : 0 : return i915_forcewake_domains(m, NULL);
1201 : : }
1202 : :
1203 : 0 : static int i915_drpc_info(struct seq_file *m, void *unused)
1204 : : {
1205 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1206 : 0 : intel_wakeref_t wakeref;
1207 : 0 : int err = -ENODEV;
1208 : :
1209 [ # # ]: 0 : with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref) {
1210 [ # # # # ]: 0 : if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
1211 : 0 : err = vlv_drpc_info(m);
1212 [ # # ]: 0 : else if (INTEL_GEN(dev_priv) >= 6)
1213 : 0 : err = gen6_drpc_info(m);
1214 : : else
1215 : 0 : err = ilk_drpc_info(m);
1216 : : }
1217 : :
1218 : 0 : return err;
1219 : : }
1220 : :
1221 : 0 : static int i915_frontbuffer_tracking(struct seq_file *m, void *unused)
1222 : : {
1223 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1224 : :
1225 : 0 : seq_printf(m, "FB tracking busy bits: 0x%08x\n",
1226 : : dev_priv->fb_tracking.busy_bits);
1227 : :
1228 : 0 : seq_printf(m, "FB tracking flip bits: 0x%08x\n",
1229 : : dev_priv->fb_tracking.flip_bits);
1230 : :
1231 : 0 : return 0;
1232 : : }
1233 : :
1234 : 0 : static int i915_fbc_status(struct seq_file *m, void *unused)
1235 : : {
1236 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1237 : 0 : struct intel_fbc *fbc = &dev_priv->fbc;
1238 : 0 : intel_wakeref_t wakeref;
1239 : :
1240 [ # # ]: 0 : if (!HAS_FBC(dev_priv))
1241 : : return -ENODEV;
1242 : :
1243 : 0 : wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);
1244 : 0 : mutex_lock(&fbc->lock);
1245 : :
1246 [ # # ]: 0 : if (intel_fbc_is_active(dev_priv))
1247 : 0 : seq_puts(m, "FBC enabled\n");
1248 : : else
1249 : 0 : seq_printf(m, "FBC disabled: %s\n", fbc->no_fbc_reason);
1250 : :
1251 [ # # ]: 0 : if (intel_fbc_is_active(dev_priv)) {
1252 : 0 : u32 mask;
1253 : :
1254 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 8)
1255 : 0 : mask = I915_READ(IVB_FBC_STATUS2) & BDW_FBC_COMP_SEG_MASK;
1256 [ # # ]: 0 : else if (INTEL_GEN(dev_priv) >= 7)
1257 : 0 : mask = I915_READ(IVB_FBC_STATUS2) & IVB_FBC_COMP_SEG_MASK;
1258 [ # # ]: 0 : else if (INTEL_GEN(dev_priv) >= 5)
1259 : 0 : mask = I915_READ(ILK_DPFC_STATUS) & ILK_DPFC_COMP_SEG_MASK;
1260 [ # # # # ]: 0 : else if (IS_G4X(dev_priv))
1261 : 0 : mask = I915_READ(DPFC_STATUS) & DPFC_COMP_SEG_MASK;
1262 : : else
1263 : 0 : mask = I915_READ(FBC_STATUS) & (FBC_STAT_COMPRESSING |
1264 : : FBC_STAT_COMPRESSED);
1265 : :
1266 [ # # ]: 0 : seq_printf(m, "Compressing: %s\n", yesno(mask));
1267 : : }
1268 : :
1269 : 0 : mutex_unlock(&fbc->lock);
1270 : 0 : intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);
1271 : :
1272 : 0 : return 0;
1273 : : }
1274 : :
1275 : 0 : static int i915_fbc_false_color_get(void *data, u64 *val)
1276 : : {
1277 : 0 : struct drm_i915_private *dev_priv = data;
1278 : :
1279 [ # # # # ]: 0 : if (INTEL_GEN(dev_priv) < 7 || !HAS_FBC(dev_priv))
1280 : : return -ENODEV;
1281 : :
1282 : 0 : *val = dev_priv->fbc.false_color;
1283 : :
1284 : 0 : return 0;
1285 : : }
1286 : :
1287 : 0 : static int i915_fbc_false_color_set(void *data, u64 val)
1288 : : {
1289 : 0 : struct drm_i915_private *dev_priv = data;
1290 : 0 : u32 reg;
1291 : :
1292 [ # # # # ]: 0 : if (INTEL_GEN(dev_priv) < 7 || !HAS_FBC(dev_priv))
1293 : : return -ENODEV;
1294 : :
1295 : 0 : mutex_lock(&dev_priv->fbc.lock);
1296 : :
1297 : 0 : reg = I915_READ(ILK_DPFC_CONTROL);
1298 : 0 : dev_priv->fbc.false_color = val;
1299 : :
1300 [ # # ]: 0 : I915_WRITE(ILK_DPFC_CONTROL, val ?
1301 : : (reg | FBC_CTL_FALSE_COLOR) :
1302 : : (reg & ~FBC_CTL_FALSE_COLOR));
1303 : :
1304 : 0 : mutex_unlock(&dev_priv->fbc.lock);
1305 : 0 : return 0;
1306 : : }
1307 : :
1308 : 0 : DEFINE_SIMPLE_ATTRIBUTE(i915_fbc_false_color_fops,
1309 : : i915_fbc_false_color_get, i915_fbc_false_color_set,
1310 : : "%llu\n");
1311 : :
1312 : 0 : static int i915_ips_status(struct seq_file *m, void *unused)
1313 : : {
1314 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1315 : : intel_wakeref_t wakeref;
1316 : :
1317 [ # # # # ]: 0 : if (!HAS_IPS(dev_priv))
1318 : : return -ENODEV;
1319 : :
1320 : 0 : wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);
1321 : :
1322 : 0 : seq_printf(m, "Enabled by kernel parameter: %s\n",
1323 [ # # ]: 0 : yesno(i915_modparams.enable_ips));
1324 : :
1325 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 8) {
1326 : 0 : seq_puts(m, "Currently: unknown\n");
1327 : : } else {
1328 [ # # ]: 0 : if (I915_READ(IPS_CTL) & IPS_ENABLE)
1329 : 0 : seq_puts(m, "Currently: enabled\n");
1330 : : else
1331 : 0 : seq_puts(m, "Currently: disabled\n");
1332 : : }
1333 : :
1334 : 0 : intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);
1335 : :
1336 : 0 : return 0;
1337 : : }
1338 : :
1339 : 0 : static int i915_sr_status(struct seq_file *m, void *unused)
1340 : : {
1341 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1342 : 0 : intel_wakeref_t wakeref;
1343 : 0 : bool sr_enabled = false;
1344 : :
1345 : 0 : wakeref = intel_display_power_get(dev_priv, POWER_DOMAIN_INIT);
1346 : :
1347 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9)
1348 : : /* no global SR status; inspect per-plane WM */;
1349 [ # # ]: 0 : else if (HAS_PCH_SPLIT(dev_priv))
1350 : 0 : sr_enabled = I915_READ(WM1_LP_ILK) & WM1_LP_SR_EN;
1351 [ # # # # : 0 : else if (IS_I965GM(dev_priv) || IS_G4X(dev_priv) ||
# # # # ]
1352 [ # # ]: 0 : IS_I945G(dev_priv) || IS_I945GM(dev_priv))
1353 : 0 : sr_enabled = I915_READ(FW_BLC_SELF) & FW_BLC_SELF_EN;
1354 [ # # ]: 0 : else if (IS_I915GM(dev_priv))
1355 : 0 : sr_enabled = I915_READ(INSTPM) & INSTPM_SELF_EN;
1356 [ # # ]: 0 : else if (IS_PINEVIEW(dev_priv))
1357 : 0 : sr_enabled = I915_READ(DSPFW3) & PINEVIEW_SELF_REFRESH_EN;
1358 [ # # # # ]: 0 : else if (IS_VALLEYVIEW(dev_priv) || IS_CHERRYVIEW(dev_priv))
1359 : 0 : sr_enabled = I915_READ(FW_BLC_SELF_VLV) & FW_CSPWRDWNEN;
1360 : :
1361 : 0 : intel_display_power_put(dev_priv, POWER_DOMAIN_INIT, wakeref);
1362 : :
1363 [ # # ]: 0 : seq_printf(m, "self-refresh: %s\n", enableddisabled(sr_enabled));
1364 : :
1365 : 0 : return 0;
1366 : : }
1367 : :
1368 : 0 : static int i915_ring_freq_table(struct seq_file *m, void *unused)
1369 : : {
1370 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1371 : 0 : struct intel_rps *rps = &dev_priv->gt.rps;
1372 : 0 : unsigned int max_gpu_freq, min_gpu_freq;
1373 : 0 : intel_wakeref_t wakeref;
1374 : 0 : int gpu_freq, ia_freq;
1375 : :
1376 [ # # ]: 0 : if (!HAS_LLC(dev_priv))
1377 : : return -ENODEV;
1378 : :
1379 : 0 : min_gpu_freq = rps->min_freq;
1380 : 0 : max_gpu_freq = rps->max_freq;
1381 [ # # # # : 0 : if (IS_GEN9_BC(dev_priv) || INTEL_GEN(dev_priv) >= 10) {
# # ]
1382 : : /* Convert GT frequency to 50 HZ units */
1383 : 0 : min_gpu_freq /= GEN9_FREQ_SCALER;
1384 : 0 : max_gpu_freq /= GEN9_FREQ_SCALER;
1385 : : }
1386 : :
1387 : 0 : seq_puts(m, "GPU freq (MHz)\tEffective CPU freq (MHz)\tEffective Ring freq (MHz)\n");
1388 : :
1389 : 0 : wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);
1390 [ # # ]: 0 : for (gpu_freq = min_gpu_freq; gpu_freq <= max_gpu_freq; gpu_freq++) {
1391 : 0 : ia_freq = gpu_freq;
1392 : 0 : sandybridge_pcode_read(dev_priv,
1393 : : GEN6_PCODE_READ_MIN_FREQ_TABLE,
1394 : : &ia_freq, NULL);
1395 : 0 : seq_printf(m, "%d\t\t%d\t\t\t\t%d\n",
1396 : : intel_gpu_freq(rps,
1397 : : (gpu_freq *
1398 [ # # # # ]: 0 : (IS_GEN9_BC(dev_priv) ||
1399 : : INTEL_GEN(dev_priv) >= 10 ?
1400 : 0 : GEN9_FREQ_SCALER : 1))),
1401 : 0 : ((ia_freq >> 0) & 0xff) * 100,
1402 [ # # ]: 0 : ((ia_freq >> 8) & 0xff) * 100);
1403 : : }
1404 : 0 : intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);
1405 : :
1406 : 0 : return 0;
1407 : : }
1408 : :
1409 : 0 : static int i915_opregion(struct seq_file *m, void *unused)
1410 : : {
1411 [ # # ]: 0 : struct intel_opregion *opregion = &node_to_i915(m->private)->opregion;
1412 : :
1413 [ # # ]: 0 : if (opregion->header)
1414 : 0 : seq_write(m, opregion->header, OPREGION_SIZE);
1415 : :
1416 : 0 : return 0;
1417 : : }
1418 : :
1419 : 0 : static int i915_vbt(struct seq_file *m, void *unused)
1420 : : {
1421 [ # # ]: 0 : struct intel_opregion *opregion = &node_to_i915(m->private)->opregion;
1422 : :
1423 [ # # ]: 0 : if (opregion->vbt)
1424 : 0 : seq_write(m, opregion->vbt, opregion->vbt_size);
1425 : :
1426 : 0 : return 0;
1427 : : }
1428 : :
1429 : 0 : static int i915_gem_framebuffer_info(struct seq_file *m, void *data)
1430 : : {
1431 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1432 : 0 : struct drm_device *dev = &dev_priv->drm;
1433 : 0 : struct intel_framebuffer *fbdev_fb = NULL;
1434 : 0 : struct drm_framebuffer *drm_fb;
1435 : :
1436 : : #ifdef CONFIG_DRM_FBDEV_EMULATION
1437 [ # # # # ]: 0 : if (dev_priv->fbdev && dev_priv->fbdev->helper.fb) {
1438 : 0 : fbdev_fb = to_intel_framebuffer(dev_priv->fbdev->helper.fb);
1439 : :
1440 : 0 : seq_printf(m, "fbcon size: %d x %d, depth %d, %d bpp, modifier 0x%llx, refcount %d, obj ",
1441 : : fbdev_fb->base.width,
1442 : : fbdev_fb->base.height,
1443 : 0 : fbdev_fb->base.format->depth,
1444 : 0 : fbdev_fb->base.format->cpp[0] * 8,
1445 : : fbdev_fb->base.modifier,
1446 : : drm_framebuffer_read_refcount(&fbdev_fb->base));
1447 : 0 : describe_obj(m, intel_fb_obj(&fbdev_fb->base));
1448 : 0 : seq_putc(m, '\n');
1449 : : }
1450 : : #endif
1451 : :
1452 : 0 : mutex_lock(&dev->mode_config.fb_lock);
1453 [ # # # # ]: 0 : drm_for_each_fb(drm_fb, dev) {
1454 : 0 : struct intel_framebuffer *fb = to_intel_framebuffer(drm_fb);
1455 [ # # ]: 0 : if (fb == fbdev_fb)
1456 : 0 : continue;
1457 : :
1458 : 0 : seq_printf(m, "user size: %d x %d, depth %d, %d bpp, modifier 0x%llx, refcount %d, obj ",
1459 : : fb->base.width,
1460 : : fb->base.height,
1461 : 0 : fb->base.format->depth,
1462 : 0 : fb->base.format->cpp[0] * 8,
1463 : : fb->base.modifier,
1464 : : drm_framebuffer_read_refcount(&fb->base));
1465 [ # # ]: 0 : describe_obj(m, intel_fb_obj(&fb->base));
1466 : 0 : seq_putc(m, '\n');
1467 : : }
1468 : 0 : mutex_unlock(&dev->mode_config.fb_lock);
1469 : :
1470 : 0 : return 0;
1471 : : }
1472 : :
1473 : 0 : static void describe_ctx_ring(struct seq_file *m, struct intel_ring *ring)
1474 : : {
1475 : 0 : seq_printf(m, " (ringbuffer, space: %d, head: %u, tail: %u, emit: %u)",
1476 : : ring->space, ring->head, ring->tail, ring->emit);
1477 : : }
1478 : :
1479 : 0 : static int i915_context_status(struct seq_file *m, void *unused)
1480 : : {
1481 : 0 : struct drm_i915_private *i915 = node_to_i915(m->private);
1482 : 0 : struct i915_gem_context *ctx, *cn;
1483 : :
1484 : 0 : spin_lock(&i915->gem.contexts.lock);
1485 [ # # ]: 0 : list_for_each_entry_safe(ctx, cn, &i915->gem.contexts.list, link) {
1486 : 0 : struct i915_gem_engines_iter it;
1487 : 0 : struct intel_context *ce;
1488 : :
1489 [ # # ]: 0 : if (!kref_get_unless_zero(&ctx->ref))
1490 : 0 : continue;
1491 : :
1492 : 0 : spin_unlock(&i915->gem.contexts.lock);
1493 : :
1494 : 0 : seq_puts(m, "HW context ");
1495 [ # # ]: 0 : if (ctx->pid) {
1496 : 0 : struct task_struct *task;
1497 : :
1498 : 0 : task = get_pid_task(ctx->pid, PIDTYPE_PID);
1499 [ # # ]: 0 : if (task) {
1500 : 0 : seq_printf(m, "(%s [%d]) ",
1501 : 0 : task->comm, task->pid);
1502 : 0 : put_task_struct(task);
1503 : : }
1504 [ # # ]: 0 : } else if (IS_ERR(ctx->file_priv)) {
1505 : 0 : seq_puts(m, "(deleted) ");
1506 : : } else {
1507 : 0 : seq_puts(m, "(kernel) ");
1508 : : }
1509 : :
1510 [ # # ]: 0 : seq_putc(m, ctx->remap_slice ? 'R' : 'r');
1511 : 0 : seq_putc(m, '\n');
1512 : :
1513 [ # # ]: 0 : for_each_gem_engine(ce,
1514 : : i915_gem_context_lock_engines(ctx), it) {
1515 [ # # ]: 0 : if (intel_context_pin_if_active(ce)) {
1516 : 0 : seq_printf(m, "%s: ", ce->engine->name);
1517 [ # # ]: 0 : if (ce->state)
1518 : 0 : describe_obj(m, ce->state->obj);
1519 : 0 : describe_ctx_ring(m, ce->ring);
1520 : 0 : seq_putc(m, '\n');
1521 : 0 : intel_context_unpin(ce);
1522 : : }
1523 : : }
1524 : 0 : i915_gem_context_unlock_engines(ctx);
1525 : :
1526 : 0 : seq_putc(m, '\n');
1527 : :
1528 : 0 : spin_lock(&i915->gem.contexts.lock);
1529 : 0 : list_safe_reset_next(ctx, cn, link);
1530 : 0 : i915_gem_context_put(ctx);
1531 : : }
1532 : 0 : spin_unlock(&i915->gem.contexts.lock);
1533 : :
1534 : 0 : return 0;
1535 : : }
1536 : :
1537 : 0 : static const char *swizzle_string(unsigned swizzle)
1538 : : {
1539 : 0 : switch (swizzle) {
1540 : : case I915_BIT_6_SWIZZLE_NONE:
1541 : : return "none";
1542 : : case I915_BIT_6_SWIZZLE_9:
1543 : : return "bit9";
1544 : : case I915_BIT_6_SWIZZLE_9_10:
1545 : : return "bit9/bit10";
1546 : : case I915_BIT_6_SWIZZLE_9_11:
1547 : : return "bit9/bit11";
1548 : : case I915_BIT_6_SWIZZLE_9_10_11:
1549 : : return "bit9/bit10/bit11";
1550 : : case I915_BIT_6_SWIZZLE_9_17:
1551 : : return "bit9/bit17";
1552 : : case I915_BIT_6_SWIZZLE_9_10_17:
1553 : : return "bit9/bit10/bit17";
1554 : : case I915_BIT_6_SWIZZLE_UNKNOWN:
1555 : : return "unknown";
1556 : : }
1557 : :
1558 : : return "bug";
1559 : : }
1560 : :
1561 : 0 : static int i915_swizzle_info(struct seq_file *m, void *data)
1562 : : {
1563 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1564 : 0 : struct intel_uncore *uncore = &dev_priv->uncore;
1565 : 0 : intel_wakeref_t wakeref;
1566 : :
1567 : 0 : wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);
1568 : :
1569 [ # # ]: 0 : seq_printf(m, "bit6 swizzle for X-tiling = %s\n",
1570 : : swizzle_string(dev_priv->ggtt.bit_6_swizzle_x));
1571 [ # # ]: 0 : seq_printf(m, "bit6 swizzle for Y-tiling = %s\n",
1572 : : swizzle_string(dev_priv->ggtt.bit_6_swizzle_y));
1573 : :
1574 [ # # ]: 0 : if (IS_GEN_RANGE(dev_priv, 3, 4)) {
1575 : 0 : seq_printf(m, "DDC = 0x%08x\n",
1576 : : intel_uncore_read(uncore, DCC));
1577 : 0 : seq_printf(m, "DDC2 = 0x%08x\n",
1578 : : intel_uncore_read(uncore, DCC2));
1579 : 0 : seq_printf(m, "C0DRB3 = 0x%04x\n",
1580 : 0 : intel_uncore_read16(uncore, C0DRB3));
1581 : 0 : seq_printf(m, "C1DRB3 = 0x%04x\n",
1582 : 0 : intel_uncore_read16(uncore, C1DRB3));
1583 [ # # ]: 0 : } else if (INTEL_GEN(dev_priv) >= 6) {
1584 : 0 : seq_printf(m, "MAD_DIMM_C0 = 0x%08x\n",
1585 : : intel_uncore_read(uncore, MAD_DIMM_C0));
1586 : 0 : seq_printf(m, "MAD_DIMM_C1 = 0x%08x\n",
1587 : : intel_uncore_read(uncore, MAD_DIMM_C1));
1588 : 0 : seq_printf(m, "MAD_DIMM_C2 = 0x%08x\n",
1589 : : intel_uncore_read(uncore, MAD_DIMM_C2));
1590 : 0 : seq_printf(m, "TILECTL = 0x%08x\n",
1591 : : intel_uncore_read(uncore, TILECTL));
1592 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 8)
1593 : 0 : seq_printf(m, "GAMTARBMODE = 0x%08x\n",
1594 : : intel_uncore_read(uncore, GAMTARBMODE));
1595 : : else
1596 : 0 : seq_printf(m, "ARB_MODE = 0x%08x\n",
1597 : : intel_uncore_read(uncore, ARB_MODE));
1598 : 0 : seq_printf(m, "DISP_ARB_CTL = 0x%08x\n",
1599 : : intel_uncore_read(uncore, DISP_ARB_CTL));
1600 : : }
1601 : :
1602 [ # # ]: 0 : if (dev_priv->quirks & QUIRK_PIN_SWIZZLED_PAGES)
1603 : 0 : seq_puts(m, "L-shaped memory detected\n");
1604 : :
1605 : 0 : intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);
1606 : :
1607 : 0 : return 0;
1608 : : }
1609 : :
1610 : 0 : static const char *rps_power_to_str(unsigned int power)
1611 : : {
1612 : 0 : static const char * const strings[] = {
1613 : : [LOW_POWER] = "low power",
1614 : : [BETWEEN] = "mixed",
1615 : : [HIGH_POWER] = "high power",
1616 : : };
1617 : :
1618 [ # # ]: 0 : if (power >= ARRAY_SIZE(strings) || !strings[power])
1619 : 0 : return "unknown";
1620 : :
1621 : : return strings[power];
1622 : : }
1623 : :
1624 : 0 : static int i915_rps_boost_info(struct seq_file *m, void *data)
1625 : : {
1626 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1627 : 0 : struct intel_rps *rps = &dev_priv->gt.rps;
1628 : :
1629 : 0 : seq_printf(m, "RPS enabled? %d\n", rps->enabled);
1630 [ # # ]: 0 : seq_printf(m, "GPU busy? %s\n", yesno(dev_priv->gt.awake));
1631 : 0 : seq_printf(m, "Boosts outstanding? %d\n",
1632 : 0 : atomic_read(&rps->num_waiters));
1633 : 0 : seq_printf(m, "Interactive? %d\n", READ_ONCE(rps->power.interactive));
1634 : 0 : seq_printf(m, "Frequency requested %d, actual %d\n",
1635 : 0 : intel_gpu_freq(rps, rps->cur_freq),
1636 : : intel_rps_read_actual_frequency(rps));
1637 : 0 : seq_printf(m, " min hard:%d, soft:%d; max soft:%d, hard:%d\n",
1638 : 0 : intel_gpu_freq(rps, rps->min_freq),
1639 : 0 : intel_gpu_freq(rps, rps->min_freq_softlimit),
1640 : 0 : intel_gpu_freq(rps, rps->max_freq_softlimit),
1641 : 0 : intel_gpu_freq(rps, rps->max_freq));
1642 : 0 : seq_printf(m, " idle:%d, efficient:%d, boost:%d\n",
1643 : 0 : intel_gpu_freq(rps, rps->idle_freq),
1644 : 0 : intel_gpu_freq(rps, rps->efficient_freq),
1645 : 0 : intel_gpu_freq(rps, rps->boost_freq));
1646 : :
1647 : 0 : seq_printf(m, "Wait boosts: %d\n", atomic_read(&rps->boosts));
1648 : :
1649 [ # # # # : 0 : if (INTEL_GEN(dev_priv) >= 6 && rps->enabled && dev_priv->gt.awake) {
# # ]
1650 : 0 : u32 rpup, rpupei;
1651 : 0 : u32 rpdown, rpdownei;
1652 : :
1653 : 0 : intel_uncore_forcewake_get(&dev_priv->uncore, FORCEWAKE_ALL);
1654 : 0 : rpup = I915_READ_FW(GEN6_RP_CUR_UP) & GEN6_RP_EI_MASK;
1655 : 0 : rpupei = I915_READ_FW(GEN6_RP_CUR_UP_EI) & GEN6_RP_EI_MASK;
1656 : 0 : rpdown = I915_READ_FW(GEN6_RP_CUR_DOWN) & GEN6_RP_EI_MASK;
1657 : 0 : rpdownei = I915_READ_FW(GEN6_RP_CUR_DOWN_EI) & GEN6_RP_EI_MASK;
1658 : 0 : intel_uncore_forcewake_put(&dev_priv->uncore, FORCEWAKE_ALL);
1659 : :
1660 : 0 : seq_printf(m, "\nRPS Autotuning (current \"%s\" window):\n",
1661 [ # # ]: 0 : rps_power_to_str(rps->power.mode));
1662 : 0 : seq_printf(m, " Avg. up: %d%% [above threshold? %d%%]\n",
1663 : 0 : rpup && rpupei ? 100 * rpup / rpupei : 0,
1664 [ # # ]: 0 : rps->power.up_threshold);
1665 : 0 : seq_printf(m, " Avg. down: %d%% [below threshold? %d%%]\n",
1666 : 0 : rpdown && rpdownei ? 100 * rpdown / rpdownei : 0,
1667 [ # # ]: 0 : rps->power.down_threshold);
1668 : : } else {
1669 : 0 : seq_puts(m, "\nRPS Autotuning inactive\n");
1670 : : }
1671 : :
1672 : 0 : return 0;
1673 : : }
1674 : :
1675 : 0 : static int i915_llc(struct seq_file *m, void *data)
1676 : : {
1677 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1678 : 0 : const bool edram = INTEL_GEN(dev_priv) > 8;
1679 : :
1680 [ # # ]: 0 : seq_printf(m, "LLC: %s\n", yesno(HAS_LLC(dev_priv)));
1681 [ # # ]: 0 : seq_printf(m, "%s: %uMB\n", edram ? "eDRAM" : "eLLC",
1682 : : dev_priv->edram_size_mb);
1683 : :
1684 : 0 : return 0;
1685 : : }
1686 : :
1687 : 0 : static int i915_huc_load_status_info(struct seq_file *m, void *data)
1688 : : {
1689 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1690 : 0 : intel_wakeref_t wakeref;
1691 : 0 : struct drm_printer p;
1692 : :
1693 [ # # ]: 0 : if (!HAS_GT_UC(dev_priv))
1694 : : return -ENODEV;
1695 : :
1696 : 0 : p = drm_seq_file_printer(m);
1697 : 0 : intel_uc_fw_dump(&dev_priv->gt.uc.huc.fw, &p);
1698 : :
1699 [ # # ]: 0 : with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref)
1700 : 0 : seq_printf(m, "\nHuC status 0x%08x:\n", I915_READ(HUC_STATUS2));
1701 : :
1702 : : return 0;
1703 : : }
1704 : :
1705 : 0 : static int i915_guc_load_status_info(struct seq_file *m, void *data)
1706 : : {
1707 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1708 : 0 : intel_wakeref_t wakeref;
1709 : 0 : struct drm_printer p;
1710 : :
1711 [ # # ]: 0 : if (!HAS_GT_UC(dev_priv))
1712 : : return -ENODEV;
1713 : :
1714 : 0 : p = drm_seq_file_printer(m);
1715 : 0 : intel_uc_fw_dump(&dev_priv->gt.uc.guc.fw, &p);
1716 : :
1717 [ # # ]: 0 : with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref) {
1718 : 0 : u32 tmp = I915_READ(GUC_STATUS);
1719 : 0 : u32 i;
1720 : :
1721 : 0 : seq_printf(m, "\nGuC status 0x%08x:\n", tmp);
1722 : 0 : seq_printf(m, "\tBootrom status = 0x%x\n",
1723 : 0 : (tmp & GS_BOOTROM_MASK) >> GS_BOOTROM_SHIFT);
1724 : 0 : seq_printf(m, "\tuKernel status = 0x%x\n",
1725 : 0 : (tmp & GS_UKERNEL_MASK) >> GS_UKERNEL_SHIFT);
1726 : 0 : seq_printf(m, "\tMIA Core status = 0x%x\n",
1727 : 0 : (tmp & GS_MIA_MASK) >> GS_MIA_SHIFT);
1728 : 0 : seq_puts(m, "\nScratch registers:\n");
1729 [ # # ]: 0 : for (i = 0; i < 16; i++) {
1730 : 0 : seq_printf(m, "\t%2d: \t0x%x\n",
1731 : 0 : i, I915_READ(SOFT_SCRATCH(i)));
1732 : : }
1733 : : }
1734 : :
1735 : : return 0;
1736 : : }
1737 : :
1738 : : static const char *
1739 : 0 : stringify_guc_log_type(enum guc_log_buffer_type type)
1740 : : {
1741 [ # # ]: 0 : switch (type) {
1742 : : case GUC_ISR_LOG_BUFFER:
1743 : : return "ISR";
1744 : : case GUC_DPC_LOG_BUFFER:
1745 : : return "DPC";
1746 : : case GUC_CRASH_DUMP_LOG_BUFFER:
1747 : : return "CRASH";
1748 : : default:
1749 : 0 : MISSING_CASE(type);
1750 : : }
1751 : :
1752 : 0 : return "";
1753 : : }
1754 : :
1755 : 0 : static void i915_guc_log_info(struct seq_file *m,
1756 : : struct drm_i915_private *dev_priv)
1757 : : {
1758 : 0 : struct intel_guc_log *log = &dev_priv->gt.uc.guc.log;
1759 : 0 : enum guc_log_buffer_type type;
1760 : :
1761 [ # # ]: 0 : if (!intel_guc_log_relay_created(log)) {
1762 : 0 : seq_puts(m, "GuC log relay not created\n");
1763 : 0 : return;
1764 : : }
1765 : :
1766 : 0 : seq_puts(m, "GuC logging stats:\n");
1767 : :
1768 : 0 : seq_printf(m, "\tRelay full count: %u\n",
1769 : : log->relay.full_count);
1770 : :
1771 [ # # ]: 0 : for (type = GUC_ISR_LOG_BUFFER; type < GUC_MAX_LOG_BUFFER; type++) {
1772 : 0 : seq_printf(m, "\t%s:\tflush count %10u, overflow count %10u\n",
1773 : : stringify_guc_log_type(type),
1774 : : log->stats[type].flush,
1775 : : log->stats[type].sampled_overflow);
1776 : : }
1777 : : }
1778 : :
1779 : 0 : static int i915_guc_info(struct seq_file *m, void *data)
1780 : : {
1781 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1782 : :
1783 [ # # ]: 0 : if (!USES_GUC(dev_priv))
1784 : : return -ENODEV;
1785 : :
1786 : 0 : i915_guc_log_info(m, dev_priv);
1787 : :
1788 : : /* Add more as required ... */
1789 : :
1790 : 0 : return 0;
1791 : : }
1792 : :
1793 : 0 : static int i915_guc_stage_pool(struct seq_file *m, void *data)
1794 : : {
1795 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
1796 : 0 : const struct intel_guc *guc = &dev_priv->gt.uc.guc;
1797 : 0 : struct guc_stage_desc *desc = guc->stage_desc_pool_vaddr;
1798 : 0 : int index;
1799 : :
1800 [ # # ]: 0 : if (!USES_GUC_SUBMISSION(dev_priv))
1801 : : return -ENODEV;
1802 : :
1803 [ # # ]: 0 : for (index = 0; index < GUC_MAX_STAGE_DESCRIPTORS; index++, desc++) {
1804 : 0 : struct intel_engine_cs *engine;
1805 : :
1806 [ # # ]: 0 : if (!(desc->attribute & GUC_STAGE_DESC_ATTR_ACTIVE))
1807 : 0 : continue;
1808 : :
1809 : 0 : seq_printf(m, "GuC stage descriptor %u:\n", index);
1810 : 0 : seq_printf(m, "\tIndex: %u\n", desc->stage_id);
1811 : 0 : seq_printf(m, "\tAttribute: 0x%x\n", desc->attribute);
1812 : 0 : seq_printf(m, "\tPriority: %d\n", desc->priority);
1813 : 0 : seq_printf(m, "\tDoorbell id: %d\n", desc->db_id);
1814 : 0 : seq_printf(m, "\tEngines used: 0x%x\n",
1815 : 0 : desc->engines_used);
1816 : 0 : seq_printf(m, "\tDoorbell trigger phy: 0x%llx, cpu: 0x%llx, uK: 0x%x\n",
1817 : : desc->db_trigger_phy,
1818 : : desc->db_trigger_cpu,
1819 : : desc->db_trigger_uk);
1820 : 0 : seq_printf(m, "\tProcess descriptor: 0x%x\n",
1821 : : desc->process_desc);
1822 : 0 : seq_printf(m, "\tWorkqueue address: 0x%x, size: 0x%x\n",
1823 : : desc->wq_addr, desc->wq_size);
1824 : 0 : seq_putc(m, '\n');
1825 : :
1826 [ # # # # : 0 : for_each_uabi_engine(engine, dev_priv) {
# # ]
1827 : 0 : u32 guc_engine_id = engine->guc_id;
1828 : 0 : struct guc_execlist_context *lrc =
1829 : : &desc->lrc[guc_engine_id];
1830 : :
1831 : 0 : seq_printf(m, "\t%s LRC:\n", engine->name);
1832 : 0 : seq_printf(m, "\t\tContext desc: 0x%x\n",
1833 : : lrc->context_desc);
1834 : 0 : seq_printf(m, "\t\tContext id: 0x%x\n", lrc->context_id);
1835 : 0 : seq_printf(m, "\t\tLRCA: 0x%x\n", lrc->ring_lrca);
1836 : 0 : seq_printf(m, "\t\tRing begin: 0x%x\n", lrc->ring_begin);
1837 : 0 : seq_printf(m, "\t\tRing end: 0x%x\n", lrc->ring_end);
1838 : 0 : seq_putc(m, '\n');
1839 : : }
1840 : : }
1841 : :
1842 : : return 0;
1843 : : }
1844 : :
1845 : 0 : static int i915_guc_log_dump(struct seq_file *m, void *data)
1846 : : {
1847 : 0 : struct drm_info_node *node = m->private;
1848 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(node);
1849 : 0 : bool dump_load_err = !!node->info_ent->data;
1850 : 0 : struct drm_i915_gem_object *obj = NULL;
1851 : 0 : u32 *log;
1852 : 0 : int i = 0;
1853 : :
1854 [ # # ]: 0 : if (!HAS_GT_UC(dev_priv))
1855 : : return -ENODEV;
1856 : :
1857 [ # # ]: 0 : if (dump_load_err)
1858 : 0 : obj = dev_priv->gt.uc.load_err_log;
1859 [ # # ]: 0 : else if (dev_priv->gt.uc.guc.log.vma)
1860 : 0 : obj = dev_priv->gt.uc.guc.log.vma->obj;
1861 : :
1862 [ # # ]: 0 : if (!obj)
1863 : : return 0;
1864 : :
1865 : 0 : log = i915_gem_object_pin_map(obj, I915_MAP_WC);
1866 [ # # ]: 0 : if (IS_ERR(log)) {
1867 : 0 : DRM_DEBUG("Failed to pin object\n");
1868 : 0 : seq_puts(m, "(log data unaccessible)\n");
1869 : 0 : return PTR_ERR(log);
1870 : : }
1871 : :
1872 [ # # ]: 0 : for (i = 0; i < obj->base.size / sizeof(u32); i += 4)
1873 : 0 : seq_printf(m, "0x%08x 0x%08x 0x%08x 0x%08x\n",
1874 : 0 : *(log + i), *(log + i + 1),
1875 : 0 : *(log + i + 2), *(log + i + 3));
1876 : :
1877 : 0 : seq_putc(m, '\n');
1878 : :
1879 : 0 : i915_gem_object_unpin_map(obj);
1880 : :
1881 : 0 : return 0;
1882 : : }
1883 : :
1884 : 0 : static int i915_guc_log_level_get(void *data, u64 *val)
1885 : : {
1886 : 0 : struct drm_i915_private *dev_priv = data;
1887 : :
1888 [ # # ]: 0 : if (!USES_GUC(dev_priv))
1889 : : return -ENODEV;
1890 : :
1891 : 0 : *val = intel_guc_log_get_level(&dev_priv->gt.uc.guc.log);
1892 : :
1893 : 0 : return 0;
1894 : : }
1895 : :
1896 : 0 : static int i915_guc_log_level_set(void *data, u64 val)
1897 : : {
1898 : 0 : struct drm_i915_private *dev_priv = data;
1899 : :
1900 [ # # ]: 0 : if (!USES_GUC(dev_priv))
1901 : : return -ENODEV;
1902 : :
1903 : 0 : return intel_guc_log_set_level(&dev_priv->gt.uc.guc.log, val);
1904 : : }
1905 : :
1906 : 0 : DEFINE_SIMPLE_ATTRIBUTE(i915_guc_log_level_fops,
1907 : : i915_guc_log_level_get, i915_guc_log_level_set,
1908 : : "%lld\n");
1909 : :
1910 : 0 : static int i915_guc_log_relay_open(struct inode *inode, struct file *file)
1911 : : {
1912 : 0 : struct drm_i915_private *i915 = inode->i_private;
1913 : 0 : struct intel_guc *guc = &i915->gt.uc.guc;
1914 : 0 : struct intel_guc_log *log = &guc->log;
1915 : :
1916 [ # # ]: 0 : if (!intel_guc_is_running(guc))
1917 : : return -ENODEV;
1918 : :
1919 : 0 : file->private_data = log;
1920 : :
1921 : 0 : return intel_guc_log_relay_open(log);
1922 : : }
1923 : :
1924 : : static ssize_t
1925 : 0 : i915_guc_log_relay_write(struct file *filp,
1926 : : const char __user *ubuf,
1927 : : size_t cnt,
1928 : : loff_t *ppos)
1929 : : {
1930 : 0 : struct intel_guc_log *log = filp->private_data;
1931 : 0 : int val;
1932 : 0 : int ret;
1933 : :
1934 : 0 : ret = kstrtoint_from_user(ubuf, cnt, 0, &val);
1935 [ # # ]: 0 : if (ret < 0)
1936 : 0 : return ret;
1937 : :
1938 : : /*
1939 : : * Enable and start the guc log relay on value of 1.
1940 : : * Flush log relay for any other value.
1941 : : */
1942 [ # # ]: 0 : if (val == 1)
1943 : 0 : ret = intel_guc_log_relay_start(log);
1944 : : else
1945 : 0 : intel_guc_log_relay_flush(log);
1946 : :
1947 [ # # ]: 0 : return ret ?: cnt;
1948 : : }
1949 : :
1950 : 0 : static int i915_guc_log_relay_release(struct inode *inode, struct file *file)
1951 : : {
1952 : 0 : struct drm_i915_private *i915 = inode->i_private;
1953 : 0 : struct intel_guc *guc = &i915->gt.uc.guc;
1954 : :
1955 : 0 : intel_guc_log_relay_close(&guc->log);
1956 : 0 : return 0;
1957 : : }
1958 : :
1959 : : static const struct file_operations i915_guc_log_relay_fops = {
1960 : : .owner = THIS_MODULE,
1961 : : .open = i915_guc_log_relay_open,
1962 : : .write = i915_guc_log_relay_write,
1963 : : .release = i915_guc_log_relay_release,
1964 : : };
1965 : :
1966 : 0 : static int i915_psr_sink_status_show(struct seq_file *m, void *data)
1967 : : {
1968 : 0 : u8 val;
1969 : 0 : static const char * const sink_status[] = {
1970 : : "inactive",
1971 : : "transition to active, capture and display",
1972 : : "active, display from RFB",
1973 : : "active, capture and display on sink device timings",
1974 : : "transition to inactive, capture and display, timing re-sync",
1975 : : "reserved",
1976 : : "reserved",
1977 : : "sink internal error",
1978 : : };
1979 : 0 : struct drm_connector *connector = m->private;
1980 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(connector->dev);
1981 : 0 : struct intel_dp *intel_dp =
1982 [ # # ]: 0 : enc_to_intel_dp(intel_attached_encoder(to_intel_connector(connector)));
1983 : 0 : int ret;
1984 : :
1985 [ # # # # ]: 0 : if (!CAN_PSR(dev_priv)) {
1986 : 0 : seq_puts(m, "PSR Unsupported\n");
1987 : 0 : return -ENODEV;
1988 : : }
1989 : :
1990 [ # # ]: 0 : if (connector->status != connector_status_connected)
1991 : : return -ENODEV;
1992 : :
1993 : 0 : ret = drm_dp_dpcd_readb(&intel_dp->aux, DP_PSR_STATUS, &val);
1994 : :
1995 [ # # ]: 0 : if (ret == 1) {
1996 : 0 : const char *str = "unknown";
1997 : :
1998 : 0 : val &= DP_PSR_SINK_STATE_MASK;
1999 : 0 : if (val < ARRAY_SIZE(sink_status))
2000 : 0 : str = sink_status[val];
2001 : 0 : seq_printf(m, "Sink PSR status: 0x%x [%s]\n", val, str);
2002 : : } else {
2003 : : return ret;
2004 : : }
2005 : :
2006 : 0 : return 0;
2007 : : }
2008 : 0 : DEFINE_SHOW_ATTRIBUTE(i915_psr_sink_status);
2009 : :
2010 : : static void
2011 : 0 : psr_source_status(struct drm_i915_private *dev_priv, struct seq_file *m)
2012 : : {
2013 : 0 : u32 val, status_val;
2014 : 0 : const char *status = "unknown";
2015 : :
2016 [ # # ]: 0 : if (dev_priv->psr.psr2_enabled) {
2017 : 0 : static const char * const live_status[] = {
2018 : : "IDLE",
2019 : : "CAPTURE",
2020 : : "CAPTURE_FS",
2021 : : "SLEEP",
2022 : : "BUFON_FW",
2023 : : "ML_UP",
2024 : : "SU_STANDBY",
2025 : : "FAST_SLEEP",
2026 : : "DEEP_SLEEP",
2027 : : "BUF_ON",
2028 : : "TG_ON"
2029 : : };
2030 : 0 : val = I915_READ(EDP_PSR2_STATUS(dev_priv->psr.transcoder));
2031 : 0 : status_val = (val & EDP_PSR2_STATUS_STATE_MASK) >>
2032 : : EDP_PSR2_STATUS_STATE_SHIFT;
2033 [ # # ]: 0 : if (status_val < ARRAY_SIZE(live_status))
2034 : 0 : status = live_status[status_val];
2035 : : } else {
2036 : 0 : static const char * const live_status[] = {
2037 : : "IDLE",
2038 : : "SRDONACK",
2039 : : "SRDENT",
2040 : : "BUFOFF",
2041 : : "BUFON",
2042 : : "AUXACK",
2043 : : "SRDOFFACK",
2044 : : "SRDENT_ON",
2045 : : };
2046 : 0 : val = I915_READ(EDP_PSR_STATUS(dev_priv->psr.transcoder));
2047 : 0 : status_val = (val & EDP_PSR_STATUS_STATE_MASK) >>
2048 : : EDP_PSR_STATUS_STATE_SHIFT;
2049 : 0 : if (status_val < ARRAY_SIZE(live_status))
2050 : 0 : status = live_status[status_val];
2051 : : }
2052 : :
2053 : 0 : seq_printf(m, "Source PSR status: %s [0x%08x]\n", status, val);
2054 : 0 : }
2055 : :
2056 : 0 : static int i915_edp_psr_status(struct seq_file *m, void *data)
2057 : : {
2058 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2059 : 0 : struct i915_psr *psr = &dev_priv->psr;
2060 : 0 : intel_wakeref_t wakeref;
2061 : 0 : const char *status;
2062 : 0 : bool enabled;
2063 : 0 : u32 val;
2064 : :
2065 [ # # ]: 0 : if (!HAS_PSR(dev_priv))
2066 : : return -ENODEV;
2067 : :
2068 [ # # ]: 0 : seq_printf(m, "Sink support: %s", yesno(psr->sink_support));
2069 [ # # ]: 0 : if (psr->dp)
2070 : 0 : seq_printf(m, " [0x%02x]", psr->dp->psr_dpcd[0]);
2071 : 0 : seq_puts(m, "\n");
2072 : :
2073 [ # # ]: 0 : if (!psr->sink_support)
2074 : : return 0;
2075 : :
2076 : 0 : wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);
2077 : 0 : mutex_lock(&psr->lock);
2078 : :
2079 [ # # ]: 0 : if (psr->enabled)
2080 [ # # ]: 0 : status = psr->psr2_enabled ? "PSR2 enabled" : "PSR1 enabled";
2081 : : else
2082 : : status = "disabled";
2083 : 0 : seq_printf(m, "PSR mode: %s\n", status);
2084 : :
2085 [ # # ]: 0 : if (!psr->enabled) {
2086 : 0 : seq_printf(m, "PSR sink not reliable: %s\n",
2087 [ # # ]: 0 : yesno(psr->sink_not_reliable));
2088 : :
2089 : 0 : goto unlock;
2090 : : }
2091 : :
2092 [ # # ]: 0 : if (psr->psr2_enabled) {
2093 : 0 : val = I915_READ(EDP_PSR2_CTL(dev_priv->psr.transcoder));
2094 : 0 : enabled = val & EDP_PSR2_ENABLE;
2095 : : } else {
2096 : 0 : val = I915_READ(EDP_PSR_CTL(dev_priv->psr.transcoder));
2097 : 0 : enabled = val & EDP_PSR_ENABLE;
2098 : : }
2099 [ # # ]: 0 : seq_printf(m, "Source PSR ctl: %s [0x%08x]\n",
2100 : : enableddisabled(enabled), val);
2101 : 0 : psr_source_status(dev_priv, m);
2102 : 0 : seq_printf(m, "Busy frontbuffer bits: 0x%08x\n",
2103 : : psr->busy_frontbuffer_bits);
2104 : :
2105 : : /*
2106 : : * SKL+ Perf counter is reset to 0 everytime DC state is entered
2107 : : */
2108 [ # # # # ]: 0 : if (IS_HASWELL(dev_priv) || IS_BROADWELL(dev_priv)) {
2109 : 0 : val = I915_READ(EDP_PSR_PERF_CNT(dev_priv->psr.transcoder));
2110 : 0 : val &= EDP_PSR_PERF_CNT_MASK;
2111 : 0 : seq_printf(m, "Performance counter: %u\n", val);
2112 : : }
2113 : :
2114 [ # # ]: 0 : if (psr->debug & I915_PSR_DEBUG_IRQ) {
2115 : 0 : seq_printf(m, "Last attempted entry at: %lld\n",
2116 : : psr->last_entry_attempt);
2117 : 0 : seq_printf(m, "Last exit at: %lld\n", psr->last_exit);
2118 : : }
2119 : :
2120 [ # # ]: 0 : if (psr->psr2_enabled) {
2121 : : u32 su_frames_val[3];
2122 : : int frame;
2123 : :
2124 : : /*
2125 : : * Reading all 3 registers before hand to minimize crossing a
2126 : : * frame boundary between register reads
2127 : : */
2128 [ # # ]: 0 : for (frame = 0; frame < PSR2_SU_STATUS_FRAMES; frame += 3) {
2129 : 0 : val = I915_READ(PSR2_SU_STATUS(dev_priv->psr.transcoder,
2130 : : frame));
2131 : 0 : su_frames_val[frame / 3] = val;
2132 : : }
2133 : :
2134 : 0 : seq_puts(m, "Frame:\tPSR2 SU blocks:\n");
2135 : :
2136 [ # # ]: 0 : for (frame = 0; frame < PSR2_SU_STATUS_FRAMES; frame++) {
2137 : 0 : u32 su_blocks;
2138 : :
2139 : 0 : su_blocks = su_frames_val[frame / 3] &
2140 : 0 : PSR2_SU_STATUS_MASK(frame);
2141 : 0 : su_blocks = su_blocks >> PSR2_SU_STATUS_SHIFT(frame);
2142 : 0 : seq_printf(m, "%d\t%d\n", frame, su_blocks);
2143 : : }
2144 : : }
2145 : :
2146 : 0 : unlock:
2147 : 0 : mutex_unlock(&psr->lock);
2148 : 0 : intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);
2149 : :
2150 : 0 : return 0;
2151 : : }
2152 : :
2153 : : static int
2154 : 0 : i915_edp_psr_debug_set(void *data, u64 val)
2155 : : {
2156 : 0 : struct drm_i915_private *dev_priv = data;
2157 : 0 : intel_wakeref_t wakeref;
2158 : 0 : int ret;
2159 : :
2160 [ # # # # ]: 0 : if (!CAN_PSR(dev_priv))
2161 : : return -ENODEV;
2162 : :
2163 : 0 : DRM_DEBUG_KMS("Setting PSR debug to %llx\n", val);
2164 : :
2165 : 0 : wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);
2166 : :
2167 : 0 : ret = intel_psr_debug_set(dev_priv, val);
2168 : :
2169 : 0 : intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);
2170 : :
2171 : 0 : return ret;
2172 : : }
2173 : :
2174 : : static int
2175 : 0 : i915_edp_psr_debug_get(void *data, u64 *val)
2176 : : {
2177 : 0 : struct drm_i915_private *dev_priv = data;
2178 : :
2179 [ # # # # ]: 0 : if (!CAN_PSR(dev_priv))
2180 : : return -ENODEV;
2181 : :
2182 : 0 : *val = READ_ONCE(dev_priv->psr.debug);
2183 : 0 : return 0;
2184 : : }
2185 : :
2186 : 0 : DEFINE_SIMPLE_ATTRIBUTE(i915_edp_psr_debug_fops,
2187 : : i915_edp_psr_debug_get, i915_edp_psr_debug_set,
2188 : : "%llu\n");
2189 : :
2190 : 0 : static int i915_energy_uJ(struct seq_file *m, void *data)
2191 : : {
2192 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2193 : 0 : unsigned long long power;
2194 : 0 : intel_wakeref_t wakeref;
2195 : 0 : u32 units;
2196 : :
2197 [ # # ]: 0 : if (INTEL_GEN(dev_priv) < 6)
2198 : : return -ENODEV;
2199 : :
2200 [ # # ]: 0 : if (rdmsrl_safe(MSR_RAPL_POWER_UNIT, &power))
2201 : : return -ENODEV;
2202 : :
2203 : 0 : units = (power & 0x1f00) >> 8;
2204 [ # # ]: 0 : with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref)
2205 : 0 : power = I915_READ(MCH_SECP_NRG_STTS);
2206 : :
2207 : 0 : power = (1000000 * power) >> units; /* convert to uJ */
2208 : 0 : seq_printf(m, "%llu", power);
2209 : :
2210 : 0 : return 0;
2211 : : }
2212 : :
2213 : 0 : static int i915_runtime_pm_status(struct seq_file *m, void *unused)
2214 : : {
2215 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2216 : 0 : struct pci_dev *pdev = dev_priv->drm.pdev;
2217 : :
2218 [ # # ]: 0 : if (!HAS_RUNTIME_PM(dev_priv))
2219 : 0 : seq_puts(m, "Runtime power management not supported\n");
2220 : :
2221 : 0 : seq_printf(m, "Runtime power status: %s\n",
2222 [ # # ]: 0 : enableddisabled(!dev_priv->power_domains.wakeref));
2223 : :
2224 [ # # ]: 0 : seq_printf(m, "GPU idle: %s\n", yesno(!dev_priv->gt.awake));
2225 : 0 : seq_printf(m, "IRQs disabled: %s\n",
2226 [ # # ]: 0 : yesno(!intel_irqs_enabled(dev_priv)));
2227 : : #ifdef CONFIG_PM
2228 : 0 : seq_printf(m, "Usage count: %d\n",
2229 : 0 : atomic_read(&dev_priv->drm.dev->power.usage_count));
2230 : : #else
2231 : : seq_printf(m, "Device Power Management (CONFIG_PM) disabled\n");
2232 : : #endif
2233 : 0 : seq_printf(m, "PCI device power state: %s [%d]\n",
2234 : : pci_power_name(pdev->current_state),
2235 : : pdev->current_state);
2236 : :
2237 : 0 : if (IS_ENABLED(CONFIG_DRM_I915_DEBUG_RUNTIME_PM)) {
2238 : : struct drm_printer p = drm_seq_file_printer(m);
2239 : :
2240 : : print_intel_runtime_pm_wakeref(&dev_priv->runtime_pm, &p);
2241 : : }
2242 : :
2243 : 0 : return 0;
2244 : : }
2245 : :
2246 : 0 : static int i915_power_domain_info(struct seq_file *m, void *unused)
2247 : : {
2248 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2249 : 0 : struct i915_power_domains *power_domains = &dev_priv->power_domains;
2250 : 0 : int i;
2251 : :
2252 : 0 : mutex_lock(&power_domains->lock);
2253 : :
2254 : 0 : seq_printf(m, "%-25s %s\n", "Power well/domain", "Use count");
2255 [ # # ]: 0 : for (i = 0; i < power_domains->power_well_count; i++) {
2256 : 0 : struct i915_power_well *power_well;
2257 : 0 : enum intel_display_power_domain power_domain;
2258 : :
2259 : 0 : power_well = &power_domains->power_wells[i];
2260 : 0 : seq_printf(m, "%-25s %d\n", power_well->desc->name,
2261 : : power_well->count);
2262 : :
2263 [ # # # # ]: 0 : for_each_power_domain(power_domain, power_well->desc->domains)
2264 : 0 : seq_printf(m, " %-23s %d\n",
2265 : : intel_display_power_domain_str(power_domain),
2266 : : power_domains->domain_use_count[power_domain]);
2267 : : }
2268 : :
2269 : 0 : mutex_unlock(&power_domains->lock);
2270 : :
2271 : 0 : return 0;
2272 : : }
2273 : :
2274 : 0 : static int i915_dmc_info(struct seq_file *m, void *unused)
2275 : : {
2276 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2277 : 0 : intel_wakeref_t wakeref;
2278 : 0 : struct intel_csr *csr;
2279 : 0 : i915_reg_t dc5_reg, dc6_reg = {};
2280 : :
2281 [ # # ]: 0 : if (!HAS_CSR(dev_priv))
2282 : : return -ENODEV;
2283 : :
2284 : 0 : csr = &dev_priv->csr;
2285 : :
2286 : 0 : wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);
2287 : :
2288 [ # # ]: 0 : seq_printf(m, "fw loaded: %s\n", yesno(csr->dmc_payload != NULL));
2289 : 0 : seq_printf(m, "path: %s\n", csr->fw_path);
2290 : :
2291 [ # # ]: 0 : if (!csr->dmc_payload)
2292 : 0 : goto out;
2293 : :
2294 : 0 : seq_printf(m, "version: %d.%d\n", CSR_VERSION_MAJOR(csr->version),
2295 : 0 : CSR_VERSION_MINOR(csr->version));
2296 : :
2297 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 12) {
2298 : 0 : dc5_reg = TGL_DMC_DEBUG_DC5_COUNT;
2299 : 0 : dc6_reg = TGL_DMC_DEBUG_DC6_COUNT;
2300 : : /*
2301 : : * NOTE: DMC_DEBUG3 is a general purpose reg.
2302 : : * According to B.Specs:49196 DMC f/w reuses DC5/6 counter
2303 : : * reg for DC3CO debugging and validation,
2304 : : * but TGL DMC f/w is using DMC_DEBUG3 reg for DC3CO counter.
2305 : : */
2306 : 0 : seq_printf(m, "DC3CO count: %d\n", I915_READ(DMC_DEBUG3));
2307 : : } else {
2308 [ # # ]: 0 : dc5_reg = IS_BROXTON(dev_priv) ? BXT_CSR_DC3_DC5_COUNT :
2309 : : SKL_CSR_DC3_DC5_COUNT;
2310 [ # # # # ]: 0 : if (!IS_GEN9_LP(dev_priv))
2311 : 0 : dc6_reg = SKL_CSR_DC5_DC6_COUNT;
2312 : : }
2313 : :
2314 : 0 : seq_printf(m, "DC3 -> DC5 count: %d\n", I915_READ(dc5_reg));
2315 [ # # ]: 0 : if (dc6_reg.reg)
2316 : 0 : seq_printf(m, "DC5 -> DC6 count: %d\n", I915_READ(dc6_reg));
2317 : :
2318 : 0 : out:
2319 : 0 : seq_printf(m, "program base: 0x%08x\n", I915_READ(CSR_PROGRAM(0)));
2320 : 0 : seq_printf(m, "ssp base: 0x%08x\n", I915_READ(CSR_SSP_BASE));
2321 : 0 : seq_printf(m, "htp: 0x%08x\n", I915_READ(CSR_HTP_SKL));
2322 : :
2323 : 0 : intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);
2324 : :
2325 : 0 : return 0;
2326 : : }
2327 : :
2328 : 0 : static void intel_seq_print_mode(struct seq_file *m, int tabs,
2329 : : const struct drm_display_mode *mode)
2330 : : {
2331 : 0 : int i;
2332 : :
2333 [ # # ]: 0 : for (i = 0; i < tabs; i++)
2334 : 0 : seq_putc(m, '\t');
2335 : :
2336 : 0 : seq_printf(m, DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));
2337 : 0 : }
2338 : :
2339 : : static void intel_encoder_info(struct seq_file *m,
2340 : : struct intel_crtc *crtc,
2341 : : struct intel_encoder *encoder)
2342 : : {
2343 : : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2344 : : struct drm_connector_list_iter conn_iter;
2345 : : struct drm_connector *connector;
2346 : :
2347 : : seq_printf(m, "\t[ENCODER:%d:%s]: connectors:\n",
2348 : : encoder->base.base.id, encoder->base.name);
2349 : :
2350 : : drm_connector_list_iter_begin(&dev_priv->drm, &conn_iter);
2351 : : drm_for_each_connector_iter(connector, &conn_iter) {
2352 : : const struct drm_connector_state *conn_state =
2353 : : connector->state;
2354 : :
2355 : : if (conn_state->best_encoder != &encoder->base)
2356 : : continue;
2357 : :
2358 : : seq_printf(m, "\t\t[CONNECTOR:%d:%s]\n",
2359 : : connector->base.id, connector->name);
2360 : : }
2361 : : drm_connector_list_iter_end(&conn_iter);
2362 : : }
2363 : :
2364 : : static void intel_panel_info(struct seq_file *m, struct intel_panel *panel)
2365 : : {
2366 : : const struct drm_display_mode *mode = panel->fixed_mode;
2367 : :
2368 : : seq_printf(m, "\tfixed mode: " DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));
2369 : : }
2370 : :
2371 : 0 : static void intel_hdcp_info(struct seq_file *m,
2372 : : struct intel_connector *intel_connector)
2373 : : {
2374 : 0 : bool hdcp_cap, hdcp2_cap;
2375 : :
2376 : 0 : hdcp_cap = intel_hdcp_capable(intel_connector);
2377 : 0 : hdcp2_cap = intel_hdcp2_capable(intel_connector);
2378 : :
2379 [ # # ]: 0 : if (hdcp_cap)
2380 : 0 : seq_puts(m, "HDCP1.4 ");
2381 [ # # ]: 0 : if (hdcp2_cap)
2382 : 0 : seq_puts(m, "HDCP2.2 ");
2383 : :
2384 [ # # ]: 0 : if (!hdcp_cap && !hdcp2_cap)
2385 : 0 : seq_puts(m, "None");
2386 : :
2387 : 0 : seq_puts(m, "\n");
2388 : 0 : }
2389 : :
2390 : 0 : static void intel_dp_info(struct seq_file *m,
2391 : : struct intel_connector *intel_connector)
2392 : : {
2393 : 0 : struct intel_encoder *intel_encoder = intel_connector->encoder;
2394 [ # # ]: 0 : struct intel_dp *intel_dp = enc_to_intel_dp(intel_encoder);
2395 : :
2396 : 0 : seq_printf(m, "\tDPCD rev: %x\n", intel_dp->dpcd[DP_DPCD_REV]);
2397 [ # # ]: 0 : seq_printf(m, "\taudio support: %s\n", yesno(intel_dp->has_audio));
2398 [ # # ]: 0 : if (intel_connector->base.connector_type == DRM_MODE_CONNECTOR_eDP)
2399 : 0 : intel_panel_info(m, &intel_connector->panel);
2400 : :
2401 : 0 : drm_dp_downstream_debug(m, intel_dp->dpcd, intel_dp->downstream_ports,
2402 : : &intel_dp->aux);
2403 [ # # ]: 0 : if (intel_connector->hdcp.shim) {
2404 : 0 : seq_puts(m, "\tHDCP version: ");
2405 : 0 : intel_hdcp_info(m, intel_connector);
2406 : : }
2407 : 0 : }
2408 : :
2409 : : static void intel_dp_mst_info(struct seq_file *m,
2410 : : struct intel_connector *intel_connector)
2411 : : {
2412 : : struct intel_encoder *intel_encoder = intel_connector->encoder;
2413 : : struct intel_dp_mst_encoder *intel_mst =
2414 : : enc_to_mst(intel_encoder);
2415 : : struct intel_digital_port *intel_dig_port = intel_mst->primary;
2416 : : struct intel_dp *intel_dp = &intel_dig_port->dp;
2417 : : bool has_audio = drm_dp_mst_port_has_audio(&intel_dp->mst_mgr,
2418 : : intel_connector->port);
2419 : :
2420 : : seq_printf(m, "\taudio support: %s\n", yesno(has_audio));
2421 : : }
2422 : :
2423 : 0 : static void intel_hdmi_info(struct seq_file *m,
2424 : : struct intel_connector *intel_connector)
2425 : : {
2426 : 0 : struct intel_encoder *intel_encoder = intel_connector->encoder;
2427 : 0 : struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(intel_encoder);
2428 : :
2429 [ # # ]: 0 : seq_printf(m, "\taudio support: %s\n", yesno(intel_hdmi->has_audio));
2430 [ # # ]: 0 : if (intel_connector->hdcp.shim) {
2431 : 0 : seq_puts(m, "\tHDCP version: ");
2432 : 0 : intel_hdcp_info(m, intel_connector);
2433 : : }
2434 : 0 : }
2435 : :
2436 : 0 : static void intel_lvds_info(struct seq_file *m,
2437 : : struct intel_connector *intel_connector)
2438 : : {
2439 : 0 : intel_panel_info(m, &intel_connector->panel);
2440 : 0 : }
2441 : :
2442 : 0 : static void intel_connector_info(struct seq_file *m,
2443 : : struct drm_connector *connector)
2444 : : {
2445 : 0 : struct intel_connector *intel_connector = to_intel_connector(connector);
2446 : 0 : const struct drm_connector_state *conn_state = connector->state;
2447 : 0 : struct intel_encoder *encoder =
2448 : 0 : to_intel_encoder(conn_state->best_encoder);
2449 : 0 : const struct drm_display_mode *mode;
2450 : :
2451 : 0 : seq_printf(m, "[CONNECTOR:%d:%s]: status: %s\n",
2452 : : connector->base.id, connector->name,
2453 : : drm_get_connector_status_name(connector->status));
2454 : :
2455 [ # # ]: 0 : if (connector->status == connector_status_disconnected)
2456 : : return;
2457 : :
2458 : 0 : seq_printf(m, "\tphysical dimensions: %dx%dmm\n",
2459 : : connector->display_info.width_mm,
2460 : : connector->display_info.height_mm);
2461 : 0 : seq_printf(m, "\tsubpixel order: %s\n",
2462 : : drm_get_subpixel_order_name(connector->display_info.subpixel_order));
2463 : 0 : seq_printf(m, "\tCEA rev: %d\n", connector->display_info.cea_rev);
2464 : :
2465 [ # # ]: 0 : if (!encoder)
2466 : : return;
2467 : :
2468 [ # # # # ]: 0 : switch (connector->connector_type) {
2469 : 0 : case DRM_MODE_CONNECTOR_DisplayPort:
2470 : : case DRM_MODE_CONNECTOR_eDP:
2471 [ # # ]: 0 : if (encoder->type == INTEL_OUTPUT_DP_MST)
2472 : 0 : intel_dp_mst_info(m, intel_connector);
2473 : : else
2474 : 0 : intel_dp_info(m, intel_connector);
2475 : : break;
2476 : 0 : case DRM_MODE_CONNECTOR_LVDS:
2477 [ # # ]: 0 : if (encoder->type == INTEL_OUTPUT_LVDS)
2478 : 0 : intel_lvds_info(m, intel_connector);
2479 : : break;
2480 : 0 : case DRM_MODE_CONNECTOR_HDMIA:
2481 [ # # ]: 0 : if (encoder->type == INTEL_OUTPUT_HDMI ||
2482 : : encoder->type == INTEL_OUTPUT_DDI)
2483 : 0 : intel_hdmi_info(m, intel_connector);
2484 : : break;
2485 : : default:
2486 : : break;
2487 : : }
2488 : :
2489 : 0 : seq_printf(m, "\tmodes:\n");
2490 [ # # ]: 0 : list_for_each_entry(mode, &connector->modes, head)
2491 : 0 : intel_seq_print_mode(m, 2, mode);
2492 : : }
2493 : :
2494 : : static const char *plane_type(enum drm_plane_type type)
2495 : : {
2496 : : switch (type) {
2497 : : case DRM_PLANE_TYPE_OVERLAY:
2498 : : return "OVL";
2499 : : case DRM_PLANE_TYPE_PRIMARY:
2500 : : return "PRI";
2501 : : case DRM_PLANE_TYPE_CURSOR:
2502 : : return "CUR";
2503 : : /*
2504 : : * Deliberately omitting default: to generate compiler warnings
2505 : : * when a new drm_plane_type gets added.
2506 : : */
2507 : : }
2508 : :
2509 : : return "unknown";
2510 : : }
2511 : :
2512 : 0 : static void plane_rotation(char *buf, size_t bufsize, unsigned int rotation)
2513 : : {
2514 : : /*
2515 : : * According to doc only one DRM_MODE_ROTATE_ is allowed but this
2516 : : * will print them all to visualize if the values are misused
2517 : : */
2518 : 0 : snprintf(buf, bufsize,
2519 : : "%s%s%s%s%s%s(0x%08x)",
2520 [ # # ]: 0 : (rotation & DRM_MODE_ROTATE_0) ? "0 " : "",
2521 [ # # ]: 0 : (rotation & DRM_MODE_ROTATE_90) ? "90 " : "",
2522 [ # # ]: 0 : (rotation & DRM_MODE_ROTATE_180) ? "180 " : "",
2523 [ # # ]: 0 : (rotation & DRM_MODE_ROTATE_270) ? "270 " : "",
2524 [ # # ]: 0 : (rotation & DRM_MODE_REFLECT_X) ? "FLIPX " : "",
2525 [ # # ]: 0 : (rotation & DRM_MODE_REFLECT_Y) ? "FLIPY " : "",
2526 : : rotation);
2527 : 0 : }
2528 : :
2529 : : static void intel_plane_uapi_info(struct seq_file *m, struct intel_plane *plane)
2530 : : {
2531 : : const struct intel_plane_state *plane_state =
2532 : : to_intel_plane_state(plane->base.state);
2533 : : const struct drm_framebuffer *fb = plane_state->uapi.fb;
2534 : : struct drm_format_name_buf format_name;
2535 : : struct drm_rect src, dst;
2536 : : char rot_str[48];
2537 : :
2538 : : src = drm_plane_state_src(&plane_state->uapi);
2539 : : dst = drm_plane_state_dest(&plane_state->uapi);
2540 : :
2541 : : if (fb)
2542 : : drm_get_format_name(fb->format->format, &format_name);
2543 : :
2544 : : plane_rotation(rot_str, sizeof(rot_str),
2545 : : plane_state->uapi.rotation);
2546 : :
2547 : : seq_printf(m, "\t\tuapi: fb=%d,%s,%dx%d, src=" DRM_RECT_FP_FMT ", dst=" DRM_RECT_FMT ", rotation=%s\n",
2548 : : fb ? fb->base.id : 0, fb ? format_name.str : "n/a",
2549 : : fb ? fb->width : 0, fb ? fb->height : 0,
2550 : : DRM_RECT_FP_ARG(&src),
2551 : : DRM_RECT_ARG(&dst),
2552 : : rot_str);
2553 : : }
2554 : :
2555 : : static void intel_plane_hw_info(struct seq_file *m, struct intel_plane *plane)
2556 : : {
2557 : : const struct intel_plane_state *plane_state =
2558 : : to_intel_plane_state(plane->base.state);
2559 : : const struct drm_framebuffer *fb = plane_state->hw.fb;
2560 : : struct drm_format_name_buf format_name;
2561 : : char rot_str[48];
2562 : :
2563 : : if (!fb)
2564 : : return;
2565 : :
2566 : : drm_get_format_name(fb->format->format, &format_name);
2567 : :
2568 : : plane_rotation(rot_str, sizeof(rot_str),
2569 : : plane_state->hw.rotation);
2570 : :
2571 : : seq_printf(m, "\t\thw: fb=%d,%s,%dx%d, visible=%s, src=" DRM_RECT_FP_FMT ", dst=" DRM_RECT_FMT ", rotation=%s\n",
2572 : : fb->base.id, format_name.str,
2573 : : fb->width, fb->height,
2574 : : yesno(plane_state->uapi.visible),
2575 : : DRM_RECT_FP_ARG(&plane_state->uapi.src),
2576 : : DRM_RECT_ARG(&plane_state->uapi.dst),
2577 : : rot_str);
2578 : : }
2579 : :
2580 : : static void intel_plane_info(struct seq_file *m, struct intel_crtc *crtc)
2581 : : {
2582 : : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2583 : : struct intel_plane *plane;
2584 : :
2585 : : for_each_intel_plane_on_crtc(&dev_priv->drm, crtc, plane) {
2586 : : seq_printf(m, "\t[PLANE:%d:%s]: type=%s\n",
2587 : : plane->base.base.id, plane->base.name,
2588 : : plane_type(plane->base.type));
2589 : : intel_plane_uapi_info(m, plane);
2590 : : intel_plane_hw_info(m, plane);
2591 : : }
2592 : : }
2593 : :
2594 : : static void intel_scaler_info(struct seq_file *m, struct intel_crtc *crtc)
2595 : : {
2596 : : const struct intel_crtc_state *crtc_state =
2597 : : to_intel_crtc_state(crtc->base.state);
2598 : : int num_scalers = crtc->num_scalers;
2599 : : int i;
2600 : :
2601 : : /* Not all platformas have a scaler */
2602 : : if (num_scalers) {
2603 : : seq_printf(m, "\tnum_scalers=%d, scaler_users=%x scaler_id=%d",
2604 : : num_scalers,
2605 : : crtc_state->scaler_state.scaler_users,
2606 : : crtc_state->scaler_state.scaler_id);
2607 : :
2608 : : for (i = 0; i < num_scalers; i++) {
2609 : : const struct intel_scaler *sc =
2610 : : &crtc_state->scaler_state.scalers[i];
2611 : :
2612 : : seq_printf(m, ", scalers[%d]: use=%s, mode=%x",
2613 : : i, yesno(sc->in_use), sc->mode);
2614 : : }
2615 : : seq_puts(m, "\n");
2616 : : } else {
2617 : : seq_puts(m, "\tNo scalers available on this platform\n");
2618 : : }
2619 : : }
2620 : :
2621 : 0 : static void intel_crtc_info(struct seq_file *m, struct intel_crtc *crtc)
2622 : : {
2623 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2624 : 0 : const struct intel_crtc_state *crtc_state =
2625 : 0 : to_intel_crtc_state(crtc->base.state);
2626 : 0 : struct intel_encoder *encoder;
2627 : :
2628 : 0 : seq_printf(m, "[CRTC:%d:%s]:\n",
2629 : : crtc->base.base.id, crtc->base.name);
2630 : :
2631 : 0 : seq_printf(m, "\tuapi: enable=%s, active=%s, mode=" DRM_MODE_FMT "\n",
2632 [ # # ]: 0 : yesno(crtc_state->uapi.enable),
2633 : 0 : yesno(crtc_state->uapi.active),
2634 [ # # ]: 0 : DRM_MODE_ARG(&crtc_state->uapi.mode));
2635 : :
2636 [ # # ]: 0 : if (crtc_state->hw.enable) {
2637 : 0 : seq_printf(m, "\thw: active=%s, adjusted_mode=" DRM_MODE_FMT "\n",
2638 : 0 : yesno(crtc_state->hw.active),
2639 [ # # ]: 0 : DRM_MODE_ARG(&crtc_state->hw.adjusted_mode));
2640 : :
2641 : 0 : seq_printf(m, "\tpipe src size=%dx%d, dither=%s, bpp=%d\n",
2642 : : crtc_state->pipe_src_w, crtc_state->pipe_src_h,
2643 [ # # ]: 0 : yesno(crtc_state->dither), crtc_state->pipe_bpp);
2644 : :
2645 : 0 : intel_scaler_info(m, crtc);
2646 : : }
2647 : :
2648 [ # # # # ]: 0 : for_each_intel_encoder_mask(&dev_priv->drm, encoder,
2649 : : crtc_state->uapi.encoder_mask)
2650 : 0 : intel_encoder_info(m, crtc, encoder);
2651 : :
2652 : 0 : intel_plane_info(m, crtc);
2653 : :
2654 : 0 : seq_printf(m, "\tunderrun reporting: cpu=%s pch=%s\n",
2655 [ # # ]: 0 : yesno(!crtc->cpu_fifo_underrun_disabled),
2656 [ # # ]: 0 : yesno(!crtc->pch_fifo_underrun_disabled));
2657 : 0 : }
2658 : :
2659 : 0 : static int i915_display_info(struct seq_file *m, void *unused)
2660 : : {
2661 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2662 : 0 : struct drm_device *dev = &dev_priv->drm;
2663 : 0 : struct intel_crtc *crtc;
2664 : 0 : struct drm_connector *connector;
2665 : 0 : struct drm_connector_list_iter conn_iter;
2666 : 0 : intel_wakeref_t wakeref;
2667 : :
2668 : 0 : wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);
2669 : :
2670 : 0 : drm_modeset_lock_all(dev);
2671 : :
2672 : 0 : seq_printf(m, "CRTC info\n");
2673 : 0 : seq_printf(m, "---------\n");
2674 [ # # ]: 0 : for_each_intel_crtc(dev, crtc)
2675 : 0 : intel_crtc_info(m, crtc);
2676 : :
2677 : 0 : seq_printf(m, "\n");
2678 : 0 : seq_printf(m, "Connector info\n");
2679 : 0 : seq_printf(m, "--------------\n");
2680 : 0 : drm_connector_list_iter_begin(dev, &conn_iter);
2681 [ # # ]: 0 : drm_for_each_connector_iter(connector, &conn_iter)
2682 : 0 : intel_connector_info(m, connector);
2683 : 0 : drm_connector_list_iter_end(&conn_iter);
2684 : :
2685 : 0 : drm_modeset_unlock_all(dev);
2686 : :
2687 : 0 : intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);
2688 : :
2689 : 0 : return 0;
2690 : : }
2691 : :
2692 : 0 : static int i915_engine_info(struct seq_file *m, void *unused)
2693 : : {
2694 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2695 : 0 : struct intel_engine_cs *engine;
2696 : 0 : intel_wakeref_t wakeref;
2697 : 0 : struct drm_printer p;
2698 : :
2699 : 0 : wakeref = intel_runtime_pm_get(&dev_priv->runtime_pm);
2700 : :
2701 : 0 : seq_printf(m, "GT awake? %s [%d]\n",
2702 [ # # ]: 0 : yesno(dev_priv->gt.awake),
2703 : 0 : atomic_read(&dev_priv->gt.wakeref.count));
2704 : 0 : seq_printf(m, "CS timestamp frequency: %u kHz\n",
2705 : : RUNTIME_INFO(dev_priv)->cs_timestamp_frequency_khz);
2706 : :
2707 : 0 : p = drm_seq_file_printer(m);
2708 [ # # # # : 0 : for_each_uabi_engine(engine, dev_priv)
# # ]
2709 : 0 : intel_engine_dump(engine, &p, "%s\n", engine->name);
2710 : :
2711 : 0 : intel_runtime_pm_put(&dev_priv->runtime_pm, wakeref);
2712 : :
2713 : 0 : return 0;
2714 : : }
2715 : :
2716 : 0 : static int i915_rcs_topology(struct seq_file *m, void *unused)
2717 : : {
2718 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2719 : 0 : struct drm_printer p = drm_seq_file_printer(m);
2720 : :
2721 : 0 : intel_device_info_print_topology(&RUNTIME_INFO(dev_priv)->sseu, &p);
2722 : :
2723 : 0 : return 0;
2724 : : }
2725 : :
2726 : 0 : static int i915_shrinker_info(struct seq_file *m, void *unused)
2727 : : {
2728 : 0 : struct drm_i915_private *i915 = node_to_i915(m->private);
2729 : :
2730 : 0 : seq_printf(m, "seeks = %d\n", i915->mm.shrinker.seeks);
2731 : 0 : seq_printf(m, "batch = %lu\n", i915->mm.shrinker.batch);
2732 : :
2733 : 0 : return 0;
2734 : : }
2735 : :
2736 : 0 : static int i915_shared_dplls_info(struct seq_file *m, void *unused)
2737 : : {
2738 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2739 : 0 : struct drm_device *dev = &dev_priv->drm;
2740 : 0 : int i;
2741 : :
2742 : 0 : drm_modeset_lock_all(dev);
2743 [ # # ]: 0 : for (i = 0; i < dev_priv->num_shared_dpll; i++) {
2744 : 0 : struct intel_shared_dpll *pll = &dev_priv->shared_dplls[i];
2745 : :
2746 : 0 : seq_printf(m, "DPLL%i: %s, id: %i\n", i, pll->info->name,
2747 : 0 : pll->info->id);
2748 : 0 : seq_printf(m, " crtc_mask: 0x%08x, active: 0x%x, on: %s\n",
2749 [ # # ]: 0 : pll->state.crtc_mask, pll->active_mask, yesno(pll->on));
2750 : 0 : seq_printf(m, " tracked hardware state:\n");
2751 : 0 : seq_printf(m, " dpll: 0x%08x\n", pll->state.hw_state.dpll);
2752 : 0 : seq_printf(m, " dpll_md: 0x%08x\n",
2753 : : pll->state.hw_state.dpll_md);
2754 : 0 : seq_printf(m, " fp0: 0x%08x\n", pll->state.hw_state.fp0);
2755 : 0 : seq_printf(m, " fp1: 0x%08x\n", pll->state.hw_state.fp1);
2756 : 0 : seq_printf(m, " wrpll: 0x%08x\n", pll->state.hw_state.wrpll);
2757 : 0 : seq_printf(m, " cfgcr0: 0x%08x\n", pll->state.hw_state.cfgcr0);
2758 : 0 : seq_printf(m, " cfgcr1: 0x%08x\n", pll->state.hw_state.cfgcr1);
2759 : 0 : seq_printf(m, " mg_refclkin_ctl: 0x%08x\n",
2760 : : pll->state.hw_state.mg_refclkin_ctl);
2761 : 0 : seq_printf(m, " mg_clktop2_coreclkctl1: 0x%08x\n",
2762 : : pll->state.hw_state.mg_clktop2_coreclkctl1);
2763 : 0 : seq_printf(m, " mg_clktop2_hsclkctl: 0x%08x\n",
2764 : : pll->state.hw_state.mg_clktop2_hsclkctl);
2765 : 0 : seq_printf(m, " mg_pll_div0: 0x%08x\n",
2766 : : pll->state.hw_state.mg_pll_div0);
2767 : 0 : seq_printf(m, " mg_pll_div1: 0x%08x\n",
2768 : : pll->state.hw_state.mg_pll_div1);
2769 : 0 : seq_printf(m, " mg_pll_lf: 0x%08x\n",
2770 : : pll->state.hw_state.mg_pll_lf);
2771 : 0 : seq_printf(m, " mg_pll_frac_lock: 0x%08x\n",
2772 : : pll->state.hw_state.mg_pll_frac_lock);
2773 : 0 : seq_printf(m, " mg_pll_ssc: 0x%08x\n",
2774 : : pll->state.hw_state.mg_pll_ssc);
2775 : 0 : seq_printf(m, " mg_pll_bias: 0x%08x\n",
2776 : : pll->state.hw_state.mg_pll_bias);
2777 : 0 : seq_printf(m, " mg_pll_tdc_coldst_bias: 0x%08x\n",
2778 : : pll->state.hw_state.mg_pll_tdc_coldst_bias);
2779 : : }
2780 : 0 : drm_modeset_unlock_all(dev);
2781 : :
2782 : 0 : return 0;
2783 : : }
2784 : :
2785 : 0 : static int i915_wa_registers(struct seq_file *m, void *unused)
2786 : : {
2787 : 0 : struct drm_i915_private *i915 = node_to_i915(m->private);
2788 : 0 : struct intel_engine_cs *engine;
2789 : :
2790 [ # # # # : 0 : for_each_uabi_engine(engine, i915) {
# # ]
2791 : 0 : const struct i915_wa_list *wal = &engine->ctx_wa_list;
2792 : 0 : const struct i915_wa *wa;
2793 : 0 : unsigned int count;
2794 : :
2795 : 0 : count = wal->count;
2796 [ # # ]: 0 : if (!count)
2797 : 0 : continue;
2798 : :
2799 : 0 : seq_printf(m, "%s: Workarounds applied: %u\n",
2800 : 0 : engine->name, count);
2801 : :
2802 [ # # ]: 0 : for (wa = wal->list; count--; wa++)
2803 : 0 : seq_printf(m, "0x%X: 0x%08X, mask: 0x%08X\n",
2804 : : i915_mmio_reg_offset(wa->reg),
2805 : : wa->val, wa->mask);
2806 : :
2807 : 0 : seq_printf(m, "\n");
2808 : : }
2809 : :
2810 : 0 : return 0;
2811 : : }
2812 : :
2813 : 0 : static int i915_ipc_status_show(struct seq_file *m, void *data)
2814 : : {
2815 : 0 : struct drm_i915_private *dev_priv = m->private;
2816 : :
2817 : 0 : seq_printf(m, "Isochronous Priority Control: %s\n",
2818 [ # # ]: 0 : yesno(dev_priv->ipc_enabled));
2819 : 0 : return 0;
2820 : : }
2821 : :
2822 : 0 : static int i915_ipc_status_open(struct inode *inode, struct file *file)
2823 : : {
2824 : 0 : struct drm_i915_private *dev_priv = inode->i_private;
2825 : :
2826 [ # # ]: 0 : if (!HAS_IPC(dev_priv))
2827 : : return -ENODEV;
2828 : :
2829 : 0 : return single_open(file, i915_ipc_status_show, dev_priv);
2830 : : }
2831 : :
2832 : 0 : static ssize_t i915_ipc_status_write(struct file *file, const char __user *ubuf,
2833 : : size_t len, loff_t *offp)
2834 : : {
2835 : 0 : struct seq_file *m = file->private_data;
2836 : 0 : struct drm_i915_private *dev_priv = m->private;
2837 : 0 : intel_wakeref_t wakeref;
2838 : 0 : bool enable;
2839 : 0 : int ret;
2840 : :
2841 : 0 : ret = kstrtobool_from_user(ubuf, len, &enable);
2842 [ # # ]: 0 : if (ret < 0)
2843 : 0 : return ret;
2844 : :
2845 [ # # ]: 0 : with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref) {
2846 [ # # # # ]: 0 : if (!dev_priv->ipc_enabled && enable)
2847 : 0 : DRM_INFO("Enabling IPC: WM will be proper only after next commit\n");
2848 : 0 : dev_priv->wm.distrust_bios_wm = true;
2849 : 0 : dev_priv->ipc_enabled = enable;
2850 : 0 : intel_enable_ipc(dev_priv);
2851 : : }
2852 : :
2853 : 0 : return len;
2854 : : }
2855 : :
2856 : : static const struct file_operations i915_ipc_status_fops = {
2857 : : .owner = THIS_MODULE,
2858 : : .open = i915_ipc_status_open,
2859 : : .read = seq_read,
2860 : : .llseek = seq_lseek,
2861 : : .release = single_release,
2862 : : .write = i915_ipc_status_write
2863 : : };
2864 : :
2865 : 0 : static int i915_ddb_info(struct seq_file *m, void *unused)
2866 : : {
2867 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2868 : 0 : struct drm_device *dev = &dev_priv->drm;
2869 : 0 : struct skl_ddb_entry *entry;
2870 : 0 : struct intel_crtc *crtc;
2871 : :
2872 [ # # ]: 0 : if (INTEL_GEN(dev_priv) < 9)
2873 : : return -ENODEV;
2874 : :
2875 : 0 : drm_modeset_lock_all(dev);
2876 : :
2877 : 0 : seq_printf(m, "%-15s%8s%8s%8s\n", "", "Start", "End", "Size");
2878 : :
2879 [ # # ]: 0 : for_each_intel_crtc(&dev_priv->drm, crtc) {
2880 : 0 : struct intel_crtc_state *crtc_state =
2881 : 0 : to_intel_crtc_state(crtc->base.state);
2882 : 0 : enum pipe pipe = crtc->pipe;
2883 : 0 : enum plane_id plane_id;
2884 : :
2885 : 0 : seq_printf(m, "Pipe %c\n", pipe_name(pipe));
2886 : :
2887 [ # # # # ]: 0 : for_each_plane_id_on_crtc(crtc, plane_id) {
2888 : 0 : entry = &crtc_state->wm.skl.plane_ddb_y[plane_id];
2889 : 0 : seq_printf(m, " Plane%-8d%8u%8u%8u\n", plane_id + 1,
2890 : 0 : entry->start, entry->end,
2891 : 0 : skl_ddb_entry_size(entry));
2892 : : }
2893 : :
2894 : 0 : entry = &crtc_state->wm.skl.plane_ddb_y[PLANE_CURSOR];
2895 : 0 : seq_printf(m, " %-13s%8u%8u%8u\n", "Cursor", entry->start,
2896 : 0 : entry->end, skl_ddb_entry_size(entry));
2897 : : }
2898 : :
2899 : 0 : drm_modeset_unlock_all(dev);
2900 : :
2901 : 0 : return 0;
2902 : : }
2903 : :
2904 : 0 : static void drrs_status_per_crtc(struct seq_file *m,
2905 : : struct drm_device *dev,
2906 : : struct intel_crtc *intel_crtc)
2907 : : {
2908 : 0 : struct drm_i915_private *dev_priv = to_i915(dev);
2909 : 0 : struct i915_drrs *drrs = &dev_priv->drrs;
2910 : 0 : int vrefresh = 0;
2911 : 0 : struct drm_connector *connector;
2912 : 0 : struct drm_connector_list_iter conn_iter;
2913 : :
2914 : 0 : drm_connector_list_iter_begin(dev, &conn_iter);
2915 [ # # ]: 0 : drm_for_each_connector_iter(connector, &conn_iter) {
2916 [ # # ]: 0 : if (connector->state->crtc != &intel_crtc->base)
2917 : 0 : continue;
2918 : :
2919 : 0 : seq_printf(m, "%s:\n", connector->name);
2920 : : }
2921 : 0 : drm_connector_list_iter_end(&conn_iter);
2922 : :
2923 [ # # ]: 0 : if (dev_priv->vbt.drrs_type == STATIC_DRRS_SUPPORT)
2924 : 0 : seq_puts(m, "\tVBT: DRRS_type: Static");
2925 [ # # ]: 0 : else if (dev_priv->vbt.drrs_type == SEAMLESS_DRRS_SUPPORT)
2926 : 0 : seq_puts(m, "\tVBT: DRRS_type: Seamless");
2927 [ # # ]: 0 : else if (dev_priv->vbt.drrs_type == DRRS_NOT_SUPPORTED)
2928 : 0 : seq_puts(m, "\tVBT: DRRS_type: None");
2929 : : else
2930 : 0 : seq_puts(m, "\tVBT: DRRS_type: FIXME: Unrecognized Value");
2931 : :
2932 : 0 : seq_puts(m, "\n\n");
2933 : :
2934 [ # # ]: 0 : if (to_intel_crtc_state(intel_crtc->base.state)->has_drrs) {
2935 : 0 : struct intel_panel *panel;
2936 : :
2937 : 0 : mutex_lock(&drrs->mutex);
2938 : : /* DRRS Supported */
2939 : 0 : seq_puts(m, "\tDRRS Supported: Yes\n");
2940 : :
2941 : : /* disable_drrs() will make drrs->dp NULL */
2942 [ # # ]: 0 : if (!drrs->dp) {
2943 : 0 : seq_puts(m, "Idleness DRRS: Disabled\n");
2944 [ # # ]: 0 : if (dev_priv->psr.enabled)
2945 : 0 : seq_puts(m,
2946 : : "\tAs PSR is enabled, DRRS is not enabled\n");
2947 : 0 : mutex_unlock(&drrs->mutex);
2948 : 0 : return;
2949 : : }
2950 : :
2951 : 0 : panel = &drrs->dp->attached_connector->panel;
2952 : 0 : seq_printf(m, "\t\tBusy_frontbuffer_bits: 0x%X",
2953 : : drrs->busy_frontbuffer_bits);
2954 : :
2955 : 0 : seq_puts(m, "\n\t\t");
2956 [ # # ]: 0 : if (drrs->refresh_rate_type == DRRS_HIGH_RR) {
2957 : 0 : seq_puts(m, "DRRS_State: DRRS_HIGH_RR\n");
2958 : 0 : vrefresh = panel->fixed_mode->vrefresh;
2959 [ # # ]: 0 : } else if (drrs->refresh_rate_type == DRRS_LOW_RR) {
2960 : 0 : seq_puts(m, "DRRS_State: DRRS_LOW_RR\n");
2961 : 0 : vrefresh = panel->downclock_mode->vrefresh;
2962 : : } else {
2963 : 0 : seq_printf(m, "DRRS_State: Unknown(%d)\n",
2964 : : drrs->refresh_rate_type);
2965 : 0 : mutex_unlock(&drrs->mutex);
2966 : 0 : return;
2967 : : }
2968 : 0 : seq_printf(m, "\t\tVrefresh: %d", vrefresh);
2969 : :
2970 : 0 : seq_puts(m, "\n\t\t");
2971 : 0 : mutex_unlock(&drrs->mutex);
2972 : : } else {
2973 : : /* DRRS not supported. Print the VBT parameter*/
2974 : 0 : seq_puts(m, "\tDRRS Supported : No");
2975 : : }
2976 : 0 : seq_puts(m, "\n");
2977 : : }
2978 : :
2979 : 0 : static int i915_drrs_status(struct seq_file *m, void *unused)
2980 : : {
2981 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
2982 : 0 : struct drm_device *dev = &dev_priv->drm;
2983 : 0 : struct intel_crtc *intel_crtc;
2984 : 0 : int active_crtc_cnt = 0;
2985 : :
2986 : 0 : drm_modeset_lock_all(dev);
2987 [ # # ]: 0 : for_each_intel_crtc(dev, intel_crtc) {
2988 [ # # ]: 0 : if (intel_crtc->base.state->active) {
2989 : 0 : active_crtc_cnt++;
2990 : 0 : seq_printf(m, "\nCRTC %d: ", active_crtc_cnt);
2991 : :
2992 : 0 : drrs_status_per_crtc(m, dev, intel_crtc);
2993 : : }
2994 : : }
2995 : 0 : drm_modeset_unlock_all(dev);
2996 : :
2997 [ # # ]: 0 : if (!active_crtc_cnt)
2998 : 0 : seq_puts(m, "No active crtc found\n");
2999 : :
3000 : 0 : return 0;
3001 : : }
3002 : :
3003 : 0 : static int i915_dp_mst_info(struct seq_file *m, void *unused)
3004 : : {
3005 : 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
3006 : 0 : struct drm_device *dev = &dev_priv->drm;
3007 : 0 : struct intel_encoder *intel_encoder;
3008 : 0 : struct intel_digital_port *intel_dig_port;
3009 : 0 : struct drm_connector *connector;
3010 : 0 : struct drm_connector_list_iter conn_iter;
3011 : :
3012 : 0 : drm_connector_list_iter_begin(dev, &conn_iter);
3013 [ # # ]: 0 : drm_for_each_connector_iter(connector, &conn_iter) {
3014 [ # # ]: 0 : if (connector->connector_type != DRM_MODE_CONNECTOR_DisplayPort)
3015 : 0 : continue;
3016 : :
3017 [ # # ]: 0 : intel_encoder = intel_attached_encoder(to_intel_connector(connector));
3018 [ # # # # ]: 0 : if (!intel_encoder || intel_encoder->type == INTEL_OUTPUT_DP_MST)
3019 : 0 : continue;
3020 : :
3021 [ # # ]: 0 : intel_dig_port = enc_to_dig_port(intel_encoder);
3022 [ # # ]: 0 : if (!intel_dig_port->dp.can_mst)
3023 : 0 : continue;
3024 : :
3025 : 0 : seq_printf(m, "MST Source Port [ENCODER:%d:%s]\n",
3026 : : intel_dig_port->base.base.base.id,
3027 : : intel_dig_port->base.base.name);
3028 : 0 : drm_dp_mst_dump_topology(m, &intel_dig_port->dp.mst_mgr);
3029 : : }
3030 : 0 : drm_connector_list_iter_end(&conn_iter);
3031 : :
3032 : 0 : return 0;
3033 : : }
3034 : :
3035 : 0 : static ssize_t i915_displayport_test_active_write(struct file *file,
3036 : : const char __user *ubuf,
3037 : : size_t len, loff_t *offp)
3038 : : {
3039 : 0 : char *input_buffer;
3040 : 0 : int status = 0;
3041 : 0 : struct drm_device *dev;
3042 : 0 : struct drm_connector *connector;
3043 : 0 : struct drm_connector_list_iter conn_iter;
3044 : 0 : struct intel_dp *intel_dp;
3045 : 0 : int val = 0;
3046 : :
3047 : 0 : dev = ((struct seq_file *)file->private_data)->private;
3048 : :
3049 [ # # ]: 0 : if (len == 0)
3050 : : return 0;
3051 : :
3052 : 0 : input_buffer = memdup_user_nul(ubuf, len);
3053 [ # # ]: 0 : if (IS_ERR(input_buffer))
3054 : 0 : return PTR_ERR(input_buffer);
3055 : :
3056 : 0 : DRM_DEBUG_DRIVER("Copied %d bytes from user\n", (unsigned int)len);
3057 : :
3058 : 0 : drm_connector_list_iter_begin(dev, &conn_iter);
3059 [ # # ]: 0 : drm_for_each_connector_iter(connector, &conn_iter) {
3060 : 0 : struct intel_encoder *encoder;
3061 : :
3062 [ # # ]: 0 : if (connector->connector_type !=
3063 : : DRM_MODE_CONNECTOR_DisplayPort)
3064 : 0 : continue;
3065 : :
3066 : 0 : encoder = to_intel_encoder(connector->encoder);
3067 [ # # # # ]: 0 : if (encoder && encoder->type == INTEL_OUTPUT_DP_MST)
3068 : 0 : continue;
3069 : :
3070 [ # # # # ]: 0 : if (encoder && connector->status == connector_status_connected) {
3071 [ # # ]: 0 : intel_dp = enc_to_intel_dp(encoder);
3072 : 0 : status = kstrtoint(input_buffer, 10, &val);
3073 [ # # ]: 0 : if (status < 0)
3074 : : break;
3075 : 0 : DRM_DEBUG_DRIVER("Got %d for test active\n", val);
3076 : : /* To prevent erroneous activation of the compliance
3077 : : * testing code, only accept an actual value of 1 here
3078 : : */
3079 [ # # ]: 0 : if (val == 1)
3080 : 0 : intel_dp->compliance.test_active = true;
3081 : : else
3082 : 0 : intel_dp->compliance.test_active = false;
3083 : : }
3084 : : }
3085 : 0 : drm_connector_list_iter_end(&conn_iter);
3086 : 0 : kfree(input_buffer);
3087 [ # # ]: 0 : if (status < 0)
3088 : 0 : return status;
3089 : :
3090 : 0 : *offp += len;
3091 : 0 : return len;
3092 : : }
3093 : :
3094 : 0 : static int i915_displayport_test_active_show(struct seq_file *m, void *data)
3095 : : {
3096 : 0 : struct drm_i915_private *dev_priv = m->private;
3097 : 0 : struct drm_device *dev = &dev_priv->drm;
3098 : 0 : struct drm_connector *connector;
3099 : 0 : struct drm_connector_list_iter conn_iter;
3100 : 0 : struct intel_dp *intel_dp;
3101 : :
3102 : 0 : drm_connector_list_iter_begin(dev, &conn_iter);
3103 [ # # ]: 0 : drm_for_each_connector_iter(connector, &conn_iter) {
3104 : 0 : struct intel_encoder *encoder;
3105 : :
3106 [ # # ]: 0 : if (connector->connector_type !=
3107 : : DRM_MODE_CONNECTOR_DisplayPort)
3108 : 0 : continue;
3109 : :
3110 : 0 : encoder = to_intel_encoder(connector->encoder);
3111 [ # # # # ]: 0 : if (encoder && encoder->type == INTEL_OUTPUT_DP_MST)
3112 : 0 : continue;
3113 : :
3114 [ # # # # ]: 0 : if (encoder && connector->status == connector_status_connected) {
3115 [ # # ]: 0 : intel_dp = enc_to_intel_dp(encoder);
3116 [ # # ]: 0 : if (intel_dp->compliance.test_active)
3117 : 0 : seq_puts(m, "1");
3118 : : else
3119 : 0 : seq_puts(m, "0");
3120 : : } else
3121 : 0 : seq_puts(m, "0");
3122 : : }
3123 : 0 : drm_connector_list_iter_end(&conn_iter);
3124 : :
3125 : 0 : return 0;
3126 : : }
3127 : :
3128 : 0 : static int i915_displayport_test_active_open(struct inode *inode,
3129 : : struct file *file)
3130 : : {
3131 : 0 : return single_open(file, i915_displayport_test_active_show,
3132 : : inode->i_private);
3133 : : }
3134 : :
3135 : : static const struct file_operations i915_displayport_test_active_fops = {
3136 : : .owner = THIS_MODULE,
3137 : : .open = i915_displayport_test_active_open,
3138 : : .read = seq_read,
3139 : : .llseek = seq_lseek,
3140 : : .release = single_release,
3141 : : .write = i915_displayport_test_active_write
3142 : : };
3143 : :
3144 : 0 : static int i915_displayport_test_data_show(struct seq_file *m, void *data)
3145 : : {
3146 : 0 : struct drm_i915_private *dev_priv = m->private;
3147 : 0 : struct drm_device *dev = &dev_priv->drm;
3148 : 0 : struct drm_connector *connector;
3149 : 0 : struct drm_connector_list_iter conn_iter;
3150 : 0 : struct intel_dp *intel_dp;
3151 : :
3152 : 0 : drm_connector_list_iter_begin(dev, &conn_iter);
3153 [ # # ]: 0 : drm_for_each_connector_iter(connector, &conn_iter) {
3154 : 0 : struct intel_encoder *encoder;
3155 : :
3156 [ # # ]: 0 : if (connector->connector_type !=
3157 : : DRM_MODE_CONNECTOR_DisplayPort)
3158 : 0 : continue;
3159 : :
3160 : 0 : encoder = to_intel_encoder(connector->encoder);
3161 [ # # # # ]: 0 : if (encoder && encoder->type == INTEL_OUTPUT_DP_MST)
3162 : 0 : continue;
3163 : :
3164 [ # # # # ]: 0 : if (encoder && connector->status == connector_status_connected) {
3165 [ # # ]: 0 : intel_dp = enc_to_intel_dp(encoder);
3166 [ # # ]: 0 : if (intel_dp->compliance.test_type ==
3167 : : DP_TEST_LINK_EDID_READ)
3168 : 0 : seq_printf(m, "%lx",
3169 : : intel_dp->compliance.test_data.edid);
3170 [ # # ]: 0 : else if (intel_dp->compliance.test_type ==
3171 : : DP_TEST_LINK_VIDEO_PATTERN) {
3172 : 0 : seq_printf(m, "hdisplay: %d\n",
3173 : 0 : intel_dp->compliance.test_data.hdisplay);
3174 : 0 : seq_printf(m, "vdisplay: %d\n",
3175 : 0 : intel_dp->compliance.test_data.vdisplay);
3176 : 0 : seq_printf(m, "bpc: %u\n",
3177 : 0 : intel_dp->compliance.test_data.bpc);
3178 : : }
3179 : : } else
3180 : 0 : seq_puts(m, "0");
3181 : : }
3182 : 0 : drm_connector_list_iter_end(&conn_iter);
3183 : :
3184 : 0 : return 0;
3185 : : }
3186 : 0 : DEFINE_SHOW_ATTRIBUTE(i915_displayport_test_data);
3187 : :
3188 : 0 : static int i915_displayport_test_type_show(struct seq_file *m, void *data)
3189 : : {
3190 : 0 : struct drm_i915_private *dev_priv = m->private;
3191 : 0 : struct drm_device *dev = &dev_priv->drm;
3192 : 0 : struct drm_connector *connector;
3193 : 0 : struct drm_connector_list_iter conn_iter;
3194 : 0 : struct intel_dp *intel_dp;
3195 : :
3196 : 0 : drm_connector_list_iter_begin(dev, &conn_iter);
3197 [ # # ]: 0 : drm_for_each_connector_iter(connector, &conn_iter) {
3198 : 0 : struct intel_encoder *encoder;
3199 : :
3200 [ # # ]: 0 : if (connector->connector_type !=
3201 : : DRM_MODE_CONNECTOR_DisplayPort)
3202 : 0 : continue;
3203 : :
3204 : 0 : encoder = to_intel_encoder(connector->encoder);
3205 [ # # # # ]: 0 : if (encoder && encoder->type == INTEL_OUTPUT_DP_MST)
3206 : 0 : continue;
3207 : :
3208 [ # # # # ]: 0 : if (encoder && connector->status == connector_status_connected) {
3209 [ # # ]: 0 : intel_dp = enc_to_intel_dp(encoder);
3210 : 0 : seq_printf(m, "%02lx", intel_dp->compliance.test_type);
3211 : : } else
3212 : 0 : seq_puts(m, "0");
3213 : : }
3214 : 0 : drm_connector_list_iter_end(&conn_iter);
3215 : :
3216 : 0 : return 0;
3217 : : }
3218 : 0 : DEFINE_SHOW_ATTRIBUTE(i915_displayport_test_type);
3219 : :
3220 : 0 : static void wm_latency_show(struct seq_file *m, const u16 wm[8])
3221 : : {
3222 : 0 : struct drm_i915_private *dev_priv = m->private;
3223 : 0 : struct drm_device *dev = &dev_priv->drm;
3224 : 0 : int level;
3225 : 0 : int num_levels;
3226 : :
3227 [ # # ]: 0 : if (IS_CHERRYVIEW(dev_priv))
3228 : : num_levels = 3;
3229 [ # # ]: 0 : else if (IS_VALLEYVIEW(dev_priv))
3230 : : num_levels = 1;
3231 [ # # # # ]: 0 : else if (IS_G4X(dev_priv))
3232 : : num_levels = 3;
3233 : : else
3234 : 0 : num_levels = ilk_wm_max_level(dev_priv) + 1;
3235 : :
3236 : 0 : drm_modeset_lock_all(dev);
3237 : :
3238 [ # # ]: 0 : for (level = 0; level < num_levels; level++) {
3239 : 0 : unsigned int latency = wm[level];
3240 : :
3241 : : /*
3242 : : * - WM1+ latency values in 0.5us units
3243 : : * - latencies are in us on gen9/vlv/chv
3244 : : */
3245 [ # # # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9 ||
3246 [ # # ]: 0 : IS_VALLEYVIEW(dev_priv) ||
3247 [ # # ]: 0 : IS_CHERRYVIEW(dev_priv) ||
3248 [ # # ]: 0 : IS_G4X(dev_priv))
3249 : 0 : latency *= 10;
3250 [ # # ]: 0 : else if (level > 0)
3251 : 0 : latency *= 5;
3252 : :
3253 : 0 : seq_printf(m, "WM%d %u (%u.%u usec)\n",
3254 : : level, wm[level], latency / 10, latency % 10);
3255 : : }
3256 : :
3257 : 0 : drm_modeset_unlock_all(dev);
3258 : 0 : }
3259 : :
3260 : 0 : static int pri_wm_latency_show(struct seq_file *m, void *data)
3261 : : {
3262 : 0 : struct drm_i915_private *dev_priv = m->private;
3263 : 0 : const u16 *latencies;
3264 : :
3265 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9)
3266 : 0 : latencies = dev_priv->wm.skl_latency;
3267 : : else
3268 : 0 : latencies = dev_priv->wm.pri_latency;
3269 : :
3270 : 0 : wm_latency_show(m, latencies);
3271 : :
3272 : 0 : return 0;
3273 : : }
3274 : :
3275 : 0 : static int spr_wm_latency_show(struct seq_file *m, void *data)
3276 : : {
3277 : 0 : struct drm_i915_private *dev_priv = m->private;
3278 : 0 : const u16 *latencies;
3279 : :
3280 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9)
3281 : 0 : latencies = dev_priv->wm.skl_latency;
3282 : : else
3283 : 0 : latencies = dev_priv->wm.spr_latency;
3284 : :
3285 : 0 : wm_latency_show(m, latencies);
3286 : :
3287 : 0 : return 0;
3288 : : }
3289 : :
3290 : 0 : static int cur_wm_latency_show(struct seq_file *m, void *data)
3291 : : {
3292 : 0 : struct drm_i915_private *dev_priv = m->private;
3293 : 0 : const u16 *latencies;
3294 : :
3295 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9)
3296 : 0 : latencies = dev_priv->wm.skl_latency;
3297 : : else
3298 : 0 : latencies = dev_priv->wm.cur_latency;
3299 : :
3300 : 0 : wm_latency_show(m, latencies);
3301 : :
3302 : 0 : return 0;
3303 : : }
3304 : :
3305 : 0 : static int pri_wm_latency_open(struct inode *inode, struct file *file)
3306 : : {
3307 : 0 : struct drm_i915_private *dev_priv = inode->i_private;
3308 : :
3309 [ # # # # : 0 : if (INTEL_GEN(dev_priv) < 5 && !IS_G4X(dev_priv))
# # ]
3310 : : return -ENODEV;
3311 : :
3312 : 0 : return single_open(file, pri_wm_latency_show, dev_priv);
3313 : : }
3314 : :
3315 : 0 : static int spr_wm_latency_open(struct inode *inode, struct file *file)
3316 : : {
3317 : 0 : struct drm_i915_private *dev_priv = inode->i_private;
3318 : :
3319 [ # # ]: 0 : if (HAS_GMCH(dev_priv))
3320 : : return -ENODEV;
3321 : :
3322 : 0 : return single_open(file, spr_wm_latency_show, dev_priv);
3323 : : }
3324 : :
3325 : 0 : static int cur_wm_latency_open(struct inode *inode, struct file *file)
3326 : : {
3327 : 0 : struct drm_i915_private *dev_priv = inode->i_private;
3328 : :
3329 [ # # ]: 0 : if (HAS_GMCH(dev_priv))
3330 : : return -ENODEV;
3331 : :
3332 : 0 : return single_open(file, cur_wm_latency_show, dev_priv);
3333 : : }
3334 : :
3335 : : static ssize_t wm_latency_write(struct file *file, const char __user *ubuf,
3336 : : size_t len, loff_t *offp, u16 wm[8])
3337 : : {
3338 : : struct seq_file *m = file->private_data;
3339 : : struct drm_i915_private *dev_priv = m->private;
3340 : : struct drm_device *dev = &dev_priv->drm;
3341 : : u16 new[8] = { 0 };
3342 : : int num_levels;
3343 : : int level;
3344 : : int ret;
3345 : : char tmp[32];
3346 : :
3347 : : if (IS_CHERRYVIEW(dev_priv))
3348 : : num_levels = 3;
3349 : : else if (IS_VALLEYVIEW(dev_priv))
3350 : : num_levels = 1;
3351 : : else if (IS_G4X(dev_priv))
3352 : : num_levels = 3;
3353 : : else
3354 : : num_levels = ilk_wm_max_level(dev_priv) + 1;
3355 : :
3356 : : if (len >= sizeof(tmp))
3357 : : return -EINVAL;
3358 : :
3359 : : if (copy_from_user(tmp, ubuf, len))
3360 : : return -EFAULT;
3361 : :
3362 : : tmp[len] = '\0';
3363 : :
3364 : : ret = sscanf(tmp, "%hu %hu %hu %hu %hu %hu %hu %hu",
3365 : : &new[0], &new[1], &new[2], &new[3],
3366 : : &new[4], &new[5], &new[6], &new[7]);
3367 : : if (ret != num_levels)
3368 : : return -EINVAL;
3369 : :
3370 : : drm_modeset_lock_all(dev);
3371 : :
3372 : : for (level = 0; level < num_levels; level++)
3373 : : wm[level] = new[level];
3374 : :
3375 : : drm_modeset_unlock_all(dev);
3376 : :
3377 : : return len;
3378 : : }
3379 : :
3380 : :
3381 : 0 : static ssize_t pri_wm_latency_write(struct file *file, const char __user *ubuf,
3382 : : size_t len, loff_t *offp)
3383 : : {
3384 : 0 : struct seq_file *m = file->private_data;
3385 : 0 : struct drm_i915_private *dev_priv = m->private;
3386 : 0 : u16 *latencies;
3387 : :
3388 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9)
3389 : 0 : latencies = dev_priv->wm.skl_latency;
3390 : : else
3391 : 0 : latencies = dev_priv->wm.pri_latency;
3392 : :
3393 : 0 : return wm_latency_write(file, ubuf, len, offp, latencies);
3394 : : }
3395 : :
3396 : 0 : static ssize_t spr_wm_latency_write(struct file *file, const char __user *ubuf,
3397 : : size_t len, loff_t *offp)
3398 : : {
3399 : 0 : struct seq_file *m = file->private_data;
3400 : 0 : struct drm_i915_private *dev_priv = m->private;
3401 : 0 : u16 *latencies;
3402 : :
3403 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9)
3404 : 0 : latencies = dev_priv->wm.skl_latency;
3405 : : else
3406 : 0 : latencies = dev_priv->wm.spr_latency;
3407 : :
3408 : 0 : return wm_latency_write(file, ubuf, len, offp, latencies);
3409 : : }
3410 : :
3411 : 0 : static ssize_t cur_wm_latency_write(struct file *file, const char __user *ubuf,
3412 : : size_t len, loff_t *offp)
3413 : : {
3414 : 0 : struct seq_file *m = file->private_data;
3415 : 0 : struct drm_i915_private *dev_priv = m->private;
3416 : 0 : u16 *latencies;
3417 : :
3418 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 9)
3419 : 0 : latencies = dev_priv->wm.skl_latency;
3420 : : else
3421 : 0 : latencies = dev_priv->wm.cur_latency;
3422 : :
3423 : 0 : return wm_latency_write(file, ubuf, len, offp, latencies);
3424 : : }
3425 : :
3426 : : static const struct file_operations i915_pri_wm_latency_fops = {
3427 : : .owner = THIS_MODULE,
3428 : : .open = pri_wm_latency_open,
3429 : : .read = seq_read,
3430 : : .llseek = seq_lseek,
3431 : : .release = single_release,
3432 : : .write = pri_wm_latency_write
3433 : : };
3434 : :
3435 : : static const struct file_operations i915_spr_wm_latency_fops = {
3436 : : .owner = THIS_MODULE,
3437 : : .open = spr_wm_latency_open,
3438 : : .read = seq_read,
3439 : : .llseek = seq_lseek,
3440 : : .release = single_release,
3441 : : .write = spr_wm_latency_write
3442 : : };
3443 : :
3444 : : static const struct file_operations i915_cur_wm_latency_fops = {
3445 : : .owner = THIS_MODULE,
3446 : : .open = cur_wm_latency_open,
3447 : : .read = seq_read,
3448 : : .llseek = seq_lseek,
3449 : : .release = single_release,
3450 : : .write = cur_wm_latency_write
3451 : : };
3452 : :
3453 : : static int
3454 : 0 : i915_wedged_get(void *data, u64 *val)
3455 : : {
3456 : 0 : struct drm_i915_private *i915 = data;
3457 : 0 : int ret = intel_gt_terminally_wedged(&i915->gt);
3458 : :
3459 [ # # # ]: 0 : switch (ret) {
3460 : 0 : case -EIO:
3461 : 0 : *val = 1;
3462 : 0 : return 0;
3463 : 0 : case 0:
3464 : 0 : *val = 0;
3465 : 0 : return 0;
3466 : : default:
3467 : : return ret;
3468 : : }
3469 : : }
3470 : :
3471 : : static int
3472 : 0 : i915_wedged_set(void *data, u64 val)
3473 : : {
3474 : 0 : struct drm_i915_private *i915 = data;
3475 : :
3476 : : /* Flush any previous reset before applying for a new one */
3477 [ # # # # ]: 0 : wait_event(i915->gt.reset.queue,
3478 : : !test_bit(I915_RESET_BACKOFF, &i915->gt.reset.flags));
3479 : :
3480 : 0 : intel_gt_handle_error(&i915->gt, val, I915_ERROR_CAPTURE,
3481 : : "Manually set wedged engine mask = %llx", val);
3482 : 0 : return 0;
3483 : : }
3484 : :
3485 : 0 : DEFINE_SIMPLE_ATTRIBUTE(i915_wedged_fops,
3486 : : i915_wedged_get, i915_wedged_set,
3487 : : "%llu\n");
3488 : :
3489 : : static int
3490 : 0 : i915_perf_noa_delay_set(void *data, u64 val)
3491 : : {
3492 : 0 : struct drm_i915_private *i915 = data;
3493 : 0 : const u32 clk = RUNTIME_INFO(i915)->cs_timestamp_frequency_khz;
3494 : :
3495 : : /*
3496 : : * This would lead to infinite waits as we're doing timestamp
3497 : : * difference on the CS with only 32bits.
3498 : : */
3499 [ # # ]: 0 : if (val > mul_u32_u32(U32_MAX, clk))
3500 : : return -EINVAL;
3501 : :
3502 : 0 : atomic64_set(&i915->perf.noa_programming_delay, val);
3503 : 0 : return 0;
3504 : : }
3505 : :
3506 : : static int
3507 : 0 : i915_perf_noa_delay_get(void *data, u64 *val)
3508 : : {
3509 : 0 : struct drm_i915_private *i915 = data;
3510 : :
3511 : 0 : *val = atomic64_read(&i915->perf.noa_programming_delay);
3512 : 0 : return 0;
3513 : : }
3514 : :
3515 : 0 : DEFINE_SIMPLE_ATTRIBUTE(i915_perf_noa_delay_fops,
3516 : : i915_perf_noa_delay_get,
3517 : : i915_perf_noa_delay_set,
3518 : : "%llu\n");
3519 : :
3520 : : #define DROP_UNBOUND BIT(0)
3521 : : #define DROP_BOUND BIT(1)
3522 : : #define DROP_RETIRE BIT(2)
3523 : : #define DROP_ACTIVE BIT(3)
3524 : : #define DROP_FREED BIT(4)
3525 : : #define DROP_SHRINK_ALL BIT(5)
3526 : : #define DROP_IDLE BIT(6)
3527 : : #define DROP_RESET_ACTIVE BIT(7)
3528 : : #define DROP_RESET_SEQNO BIT(8)
3529 : : #define DROP_RCU BIT(9)
3530 : : #define DROP_ALL (DROP_UNBOUND | \
3531 : : DROP_BOUND | \
3532 : : DROP_RETIRE | \
3533 : : DROP_ACTIVE | \
3534 : : DROP_FREED | \
3535 : : DROP_SHRINK_ALL |\
3536 : : DROP_IDLE | \
3537 : : DROP_RESET_ACTIVE | \
3538 : : DROP_RESET_SEQNO | \
3539 : : DROP_RCU)
3540 : : static int
3541 : 0 : i915_drop_caches_get(void *data, u64 *val)
3542 : : {
3543 : 0 : *val = DROP_ALL;
3544 : :
3545 : 0 : return 0;
3546 : : }
3547 : : static int
3548 : 0 : gt_drop_caches(struct intel_gt *gt, u64 val)
3549 : : {
3550 : 0 : int ret;
3551 : :
3552 [ # # ]: 0 : if (val & DROP_RESET_ACTIVE &&
3553 [ # # # # : 0 : wait_for(intel_engines_are_idle(gt), I915_IDLE_ENGINES_TIMEOUT))
# # # # ]
3554 : 0 : intel_gt_set_wedged(gt);
3555 : :
3556 [ # # ]: 0 : if (val & DROP_RETIRE)
3557 : 0 : intel_gt_retire_requests(gt);
3558 : :
3559 [ # # ]: 0 : if (val & (DROP_IDLE | DROP_ACTIVE)) {
3560 : 0 : ret = intel_gt_wait_for_idle(gt, MAX_SCHEDULE_TIMEOUT);
3561 [ # # ]: 0 : if (ret)
3562 : : return ret;
3563 : : }
3564 : :
3565 [ # # ]: 0 : if (val & DROP_IDLE) {
3566 : 0 : ret = intel_gt_pm_wait_for_idle(gt);
3567 [ # # ]: 0 : if (ret)
3568 : : return ret;
3569 : : }
3570 : :
3571 [ # # # # ]: 0 : if (val & DROP_RESET_ACTIVE && intel_gt_terminally_wedged(gt))
3572 : 0 : intel_gt_handle_error(gt, ALL_ENGINES, 0, NULL);
3573 : :
3574 : : return 0;
3575 : : }
3576 : :
3577 : : static int
3578 : 0 : i915_drop_caches_set(void *data, u64 val)
3579 : : {
3580 : 0 : struct drm_i915_private *i915 = data;
3581 : 0 : int ret;
3582 : :
3583 : 0 : DRM_DEBUG("Dropping caches: 0x%08llx [0x%08llx]\n",
3584 : : val, val & DROP_ALL);
3585 : :
3586 : 0 : ret = gt_drop_caches(&i915->gt, val);
3587 [ # # ]: 0 : if (ret)
3588 : : return ret;
3589 : :
3590 [ # # ]: 0 : fs_reclaim_acquire(GFP_KERNEL);
3591 [ # # ]: 0 : if (val & DROP_BOUND)
3592 : 0 : i915_gem_shrink(i915, LONG_MAX, NULL, I915_SHRINK_BOUND);
3593 : :
3594 [ # # ]: 0 : if (val & DROP_UNBOUND)
3595 : 0 : i915_gem_shrink(i915, LONG_MAX, NULL, I915_SHRINK_UNBOUND);
3596 : :
3597 [ # # ]: 0 : if (val & DROP_SHRINK_ALL)
3598 : 0 : i915_gem_shrink_all(i915);
3599 [ # # ]: 0 : fs_reclaim_release(GFP_KERNEL);
3600 : :
3601 [ # # ]: 0 : if (val & DROP_RCU)
3602 : 0 : rcu_barrier();
3603 : :
3604 [ # # ]: 0 : if (val & DROP_FREED)
3605 : 0 : i915_gem_drain_freed_objects(i915);
3606 : :
3607 : : return 0;
3608 : : }
3609 : :
3610 : 0 : DEFINE_SIMPLE_ATTRIBUTE(i915_drop_caches_fops,
3611 : : i915_drop_caches_get, i915_drop_caches_set,
3612 : : "0x%08llx\n");
3613 : :
3614 : : static int
3615 : 0 : i915_cache_sharing_get(void *data, u64 *val)
3616 : : {
3617 : 0 : struct drm_i915_private *dev_priv = data;
3618 : 0 : intel_wakeref_t wakeref;
3619 : 0 : u32 snpcr = 0;
3620 : :
3621 [ # # ]: 0 : if (!(IS_GEN_RANGE(dev_priv, 6, 7)))
3622 : : return -ENODEV;
3623 : :
3624 [ # # ]: 0 : with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref)
3625 : 0 : snpcr = I915_READ(GEN6_MBCUNIT_SNPCR);
3626 : :
3627 : 0 : *val = (snpcr & GEN6_MBC_SNPCR_MASK) >> GEN6_MBC_SNPCR_SHIFT;
3628 : :
3629 : 0 : return 0;
3630 : : }
3631 : :
3632 : : static int
3633 : 0 : i915_cache_sharing_set(void *data, u64 val)
3634 : : {
3635 : 0 : struct drm_i915_private *dev_priv = data;
3636 : 0 : intel_wakeref_t wakeref;
3637 : :
3638 [ # # ]: 0 : if (!(IS_GEN_RANGE(dev_priv, 6, 7)))
3639 : : return -ENODEV;
3640 : :
3641 [ # # ]: 0 : if (val > 3)
3642 : : return -EINVAL;
3643 : :
3644 : 0 : DRM_DEBUG_DRIVER("Manually setting uncore sharing to %llu\n", val);
3645 [ # # ]: 0 : with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref) {
3646 : 0 : u32 snpcr;
3647 : :
3648 : : /* Update the cache sharing policy here as well */
3649 : 0 : snpcr = I915_READ(GEN6_MBCUNIT_SNPCR);
3650 : 0 : snpcr &= ~GEN6_MBC_SNPCR_MASK;
3651 : 0 : snpcr |= val << GEN6_MBC_SNPCR_SHIFT;
3652 : 0 : I915_WRITE(GEN6_MBCUNIT_SNPCR, snpcr);
3653 : : }
3654 : :
3655 : : return 0;
3656 : : }
3657 : :
3658 : : static void
3659 : 0 : intel_sseu_copy_subslices(const struct sseu_dev_info *sseu, int slice,
3660 : : u8 *to_mask)
3661 : : {
3662 : 0 : int offset = slice * sseu->ss_stride;
3663 : :
3664 : 0 : memcpy(&to_mask[offset], &sseu->subslice_mask[offset], sseu->ss_stride);
3665 : 0 : }
3666 : :
3667 : 0 : DEFINE_SIMPLE_ATTRIBUTE(i915_cache_sharing_fops,
3668 : : i915_cache_sharing_get, i915_cache_sharing_set,
3669 : : "%llu\n");
3670 : :
3671 : 0 : static void cherryview_sseu_device_status(struct drm_i915_private *dev_priv,
3672 : : struct sseu_dev_info *sseu)
3673 : : {
3674 : : #define SS_MAX 2
3675 : 0 : const int ss_max = SS_MAX;
3676 : 0 : u32 sig1[SS_MAX], sig2[SS_MAX];
3677 : 0 : int ss;
3678 : :
3679 : 0 : sig1[0] = I915_READ(CHV_POWER_SS0_SIG1);
3680 : 0 : sig1[1] = I915_READ(CHV_POWER_SS1_SIG1);
3681 : 0 : sig2[0] = I915_READ(CHV_POWER_SS0_SIG2);
3682 : 0 : sig2[1] = I915_READ(CHV_POWER_SS1_SIG2);
3683 : :
3684 [ # # ]: 0 : for (ss = 0; ss < ss_max; ss++) {
3685 : 0 : unsigned int eu_cnt;
3686 : :
3687 [ # # ]: 0 : if (sig1[ss] & CHV_SS_PG_ENABLE)
3688 : : /* skip disabled subslice */
3689 : 0 : continue;
3690 : :
3691 : 0 : sseu->slice_mask = BIT(0);
3692 : 0 : sseu->subslice_mask[0] |= BIT(ss);
3693 [ # # ]: 0 : eu_cnt = ((sig1[ss] & CHV_EU08_PG_ENABLE) ? 0 : 2) +
3694 [ # # ]: 0 : ((sig1[ss] & CHV_EU19_PG_ENABLE) ? 0 : 2) +
3695 [ # # ]: 0 : ((sig1[ss] & CHV_EU210_PG_ENABLE) ? 0 : 2) +
3696 [ # # ]: 0 : ((sig2[ss] & CHV_EU311_PG_ENABLE) ? 0 : 2);
3697 : 0 : sseu->eu_total += eu_cnt;
3698 : 0 : sseu->eu_per_subslice = max_t(unsigned int,
3699 : : sseu->eu_per_subslice, eu_cnt);
3700 : : }
3701 : : #undef SS_MAX
3702 : 0 : }
3703 : :
3704 : 0 : static void gen10_sseu_device_status(struct drm_i915_private *dev_priv,
3705 : : struct sseu_dev_info *sseu)
3706 : : {
3707 : : #define SS_MAX 6
3708 : 0 : const struct intel_runtime_info *info = RUNTIME_INFO(dev_priv);
3709 : 0 : u32 s_reg[SS_MAX], eu_reg[2 * SS_MAX], eu_mask[2];
3710 : 0 : int s, ss;
3711 : :
3712 [ # # ]: 0 : for (s = 0; s < info->sseu.max_slices; s++) {
3713 : : /*
3714 : : * FIXME: Valid SS Mask respects the spec and read
3715 : : * only valid bits for those registers, excluding reserved
3716 : : * although this seems wrong because it would leave many
3717 : : * subslices without ACK.
3718 : : */
3719 : 0 : s_reg[s] = I915_READ(GEN10_SLICE_PGCTL_ACK(s)) &
3720 [ # # ]: 0 : GEN10_PGCTL_VALID_SS_MASK(s);
3721 : 0 : eu_reg[2 * s] = I915_READ(GEN10_SS01_EU_PGCTL_ACK(s));
3722 : 0 : eu_reg[2 * s + 1] = I915_READ(GEN10_SS23_EU_PGCTL_ACK(s));
3723 : : }
3724 : :
3725 : 0 : eu_mask[0] = GEN9_PGCTL_SSA_EU08_ACK |
3726 : : GEN9_PGCTL_SSA_EU19_ACK |
3727 : : GEN9_PGCTL_SSA_EU210_ACK |
3728 : : GEN9_PGCTL_SSA_EU311_ACK;
3729 : 0 : eu_mask[1] = GEN9_PGCTL_SSB_EU08_ACK |
3730 : : GEN9_PGCTL_SSB_EU19_ACK |
3731 : : GEN9_PGCTL_SSB_EU210_ACK |
3732 : : GEN9_PGCTL_SSB_EU311_ACK;
3733 : :
3734 [ # # ]: 0 : for (s = 0; s < info->sseu.max_slices; s++) {
3735 [ # # ]: 0 : if ((s_reg[s] & GEN9_PGCTL_SLICE_ACK) == 0)
3736 : : /* skip disabled slice */
3737 : 0 : continue;
3738 : :
3739 : 0 : sseu->slice_mask |= BIT(s);
3740 : 0 : intel_sseu_copy_subslices(&info->sseu, s, sseu->subslice_mask);
3741 : :
3742 [ # # ]: 0 : for (ss = 0; ss < info->sseu.max_subslices; ss++) {
3743 : 0 : unsigned int eu_cnt;
3744 : :
3745 [ # # ]: 0 : if (info->sseu.has_subslice_pg &&
3746 [ # # ]: 0 : !(s_reg[s] & (GEN9_PGCTL_SS_ACK(ss))))
3747 : : /* skip disabled subslice */
3748 : 0 : continue;
3749 : :
3750 [ # # ]: 0 : eu_cnt = 2 * hweight32(eu_reg[2 * s + ss / 2] &
3751 : : eu_mask[ss % 2]);
3752 : 0 : sseu->eu_total += eu_cnt;
3753 : 0 : sseu->eu_per_subslice = max_t(unsigned int,
3754 : : sseu->eu_per_subslice,
3755 : : eu_cnt);
3756 : : }
3757 : : }
3758 : : #undef SS_MAX
3759 : 0 : }
3760 : :
3761 : 0 : static void gen9_sseu_device_status(struct drm_i915_private *dev_priv,
3762 : : struct sseu_dev_info *sseu)
3763 : : {
3764 : : #define SS_MAX 3
3765 : 0 : const struct intel_runtime_info *info = RUNTIME_INFO(dev_priv);
3766 : 0 : u32 s_reg[SS_MAX], eu_reg[2 * SS_MAX], eu_mask[2];
3767 : 0 : int s, ss;
3768 : :
3769 [ # # ]: 0 : for (s = 0; s < info->sseu.max_slices; s++) {
3770 : 0 : s_reg[s] = I915_READ(GEN9_SLICE_PGCTL_ACK(s));
3771 : 0 : eu_reg[2*s] = I915_READ(GEN9_SS01_EU_PGCTL_ACK(s));
3772 : 0 : eu_reg[2*s + 1] = I915_READ(GEN9_SS23_EU_PGCTL_ACK(s));
3773 : : }
3774 : :
3775 : 0 : eu_mask[0] = GEN9_PGCTL_SSA_EU08_ACK |
3776 : : GEN9_PGCTL_SSA_EU19_ACK |
3777 : : GEN9_PGCTL_SSA_EU210_ACK |
3778 : : GEN9_PGCTL_SSA_EU311_ACK;
3779 : 0 : eu_mask[1] = GEN9_PGCTL_SSB_EU08_ACK |
3780 : : GEN9_PGCTL_SSB_EU19_ACK |
3781 : : GEN9_PGCTL_SSB_EU210_ACK |
3782 : : GEN9_PGCTL_SSB_EU311_ACK;
3783 : :
3784 [ # # ]: 0 : for (s = 0; s < info->sseu.max_slices; s++) {
3785 [ # # ]: 0 : if ((s_reg[s] & GEN9_PGCTL_SLICE_ACK) == 0)
3786 : : /* skip disabled slice */
3787 : 0 : continue;
3788 : :
3789 : 0 : sseu->slice_mask |= BIT(s);
3790 : :
3791 [ # # # # ]: 0 : if (IS_GEN9_BC(dev_priv))
3792 : 0 : intel_sseu_copy_subslices(&info->sseu, s,
3793 : 0 : sseu->subslice_mask);
3794 : :
3795 [ # # ]: 0 : for (ss = 0; ss < info->sseu.max_subslices; ss++) {
3796 : 0 : unsigned int eu_cnt;
3797 : 0 : u8 ss_idx = s * info->sseu.ss_stride +
3798 : 0 : ss / BITS_PER_BYTE;
3799 : :
3800 [ # # # # ]: 0 : if (IS_GEN9_LP(dev_priv)) {
3801 [ # # ]: 0 : if (!(s_reg[s] & (GEN9_PGCTL_SS_ACK(ss))))
3802 : : /* skip disabled subslice */
3803 : 0 : continue;
3804 : :
3805 : 0 : sseu->subslice_mask[ss_idx] |=
3806 : 0 : BIT(ss % BITS_PER_BYTE);
3807 : : }
3808 : :
3809 [ # # ]: 0 : eu_cnt = 2 * hweight32(eu_reg[2*s + ss/2] &
3810 : : eu_mask[ss%2]);
3811 : 0 : sseu->eu_total += eu_cnt;
3812 : 0 : sseu->eu_per_subslice = max_t(unsigned int,
3813 : : sseu->eu_per_subslice,
3814 : : eu_cnt);
3815 : : }
3816 : : }
3817 : : #undef SS_MAX
3818 : 0 : }
3819 : :
3820 : 0 : static void bdw_sseu_device_status(struct drm_i915_private *dev_priv,
3821 : : struct sseu_dev_info *sseu)
3822 : : {
3823 : 0 : const struct intel_runtime_info *info = RUNTIME_INFO(dev_priv);
3824 : 0 : u32 slice_info = I915_READ(GEN8_GT_SLICE_INFO);
3825 : 0 : int s;
3826 : :
3827 : 0 : sseu->slice_mask = slice_info & GEN8_LSLICESTAT_MASK;
3828 : :
3829 [ # # ]: 0 : if (sseu->slice_mask) {
3830 : 0 : sseu->eu_per_subslice = info->sseu.eu_per_subslice;
3831 [ # # ]: 0 : for (s = 0; s < fls(sseu->slice_mask); s++)
3832 : 0 : intel_sseu_copy_subslices(&info->sseu, s,
3833 : 0 : sseu->subslice_mask);
3834 : 0 : sseu->eu_total = sseu->eu_per_subslice *
3835 : 0 : intel_sseu_subslice_total(sseu);
3836 : :
3837 : : /* subtract fused off EU(s) from enabled slice(s) */
3838 [ # # ]: 0 : for (s = 0; s < fls(sseu->slice_mask); s++) {
3839 : 0 : u8 subslice_7eu = info->sseu.subslice_7eu[s];
3840 : :
3841 [ # # ]: 0 : sseu->eu_total -= hweight8(subslice_7eu);
3842 : : }
3843 : : }
3844 : 0 : }
3845 : :
3846 : 0 : static void i915_print_sseu_info(struct seq_file *m, bool is_available_info,
3847 : : const struct sseu_dev_info *sseu)
3848 : : {
3849 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
3850 [ # # ]: 0 : const char *type = is_available_info ? "Available" : "Enabled";
3851 : 0 : int s;
3852 : :
3853 : 0 : seq_printf(m, " %s Slice Mask: %04x\n", type,
3854 : 0 : sseu->slice_mask);
3855 : 0 : seq_printf(m, " %s Slice Total: %u\n", type,
3856 [ # # ]: 0 : hweight8(sseu->slice_mask));
3857 : 0 : seq_printf(m, " %s Subslice Total: %u\n", type,
3858 : : intel_sseu_subslice_total(sseu));
3859 [ # # ]: 0 : for (s = 0; s < fls(sseu->slice_mask); s++) {
3860 : 0 : seq_printf(m, " %s Slice%i subslices: %u\n", type,
3861 : : s, intel_sseu_subslices_per_slice(sseu, s));
3862 : : }
3863 : 0 : seq_printf(m, " %s EU Total: %u\n", type,
3864 : 0 : sseu->eu_total);
3865 : 0 : seq_printf(m, " %s EU Per Subslice: %u\n", type,
3866 : 0 : sseu->eu_per_subslice);
3867 : :
3868 [ # # ]: 0 : if (!is_available_info)
3869 : : return;
3870 : :
3871 [ # # ]: 0 : seq_printf(m, " Has Pooled EU: %s\n", yesno(HAS_POOLED_EU(dev_priv)));
3872 [ # # ]: 0 : if (HAS_POOLED_EU(dev_priv))
3873 : 0 : seq_printf(m, " Min EU in pool: %u\n", sseu->min_eu_in_pool);
3874 : :
3875 : 0 : seq_printf(m, " Has Slice Power Gating: %s\n",
3876 [ # # ]: 0 : yesno(sseu->has_slice_pg));
3877 : 0 : seq_printf(m, " Has Subslice Power Gating: %s\n",
3878 [ # # ]: 0 : yesno(sseu->has_subslice_pg));
3879 : 0 : seq_printf(m, " Has EU Power Gating: %s\n",
3880 [ # # ]: 0 : yesno(sseu->has_eu_pg));
3881 : : }
3882 : :
3883 : 0 : static int i915_sseu_status(struct seq_file *m, void *unused)
3884 : : {
3885 [ # # ]: 0 : struct drm_i915_private *dev_priv = node_to_i915(m->private);
3886 : 0 : const struct intel_runtime_info *info = RUNTIME_INFO(dev_priv);
3887 : 0 : struct sseu_dev_info sseu;
3888 : 0 : intel_wakeref_t wakeref;
3889 : :
3890 [ # # ]: 0 : if (INTEL_GEN(dev_priv) < 8)
3891 : : return -ENODEV;
3892 : :
3893 : 0 : seq_puts(m, "SSEU Device Info\n");
3894 : 0 : i915_print_sseu_info(m, true, &info->sseu);
3895 : :
3896 : 0 : seq_puts(m, "SSEU Device Status\n");
3897 : 0 : memset(&sseu, 0, sizeof(sseu));
3898 : 0 : intel_sseu_set_info(&sseu, info->sseu.max_slices,
3899 : 0 : info->sseu.max_subslices,
3900 : 0 : info->sseu.max_eus_per_subslice);
3901 : :
3902 [ # # ]: 0 : with_intel_runtime_pm(&dev_priv->runtime_pm, wakeref) {
3903 [ # # ]: 0 : if (IS_CHERRYVIEW(dev_priv))
3904 : 0 : cherryview_sseu_device_status(dev_priv, &sseu);
3905 [ # # ]: 0 : else if (IS_BROADWELL(dev_priv))
3906 : 0 : bdw_sseu_device_status(dev_priv, &sseu);
3907 [ # # ]: 0 : else if (IS_GEN(dev_priv, 9))
3908 : 0 : gen9_sseu_device_status(dev_priv, &sseu);
3909 [ # # ]: 0 : else if (INTEL_GEN(dev_priv) >= 10)
3910 : 0 : gen10_sseu_device_status(dev_priv, &sseu);
3911 : : }
3912 : :
3913 : 0 : i915_print_sseu_info(m, false, &sseu);
3914 : :
3915 : 0 : return 0;
3916 : : }
3917 : :
3918 : 0 : static int i915_forcewake_open(struct inode *inode, struct file *file)
3919 : : {
3920 : 0 : struct drm_i915_private *i915 = inode->i_private;
3921 : 0 : struct intel_gt *gt = &i915->gt;
3922 : :
3923 : 0 : atomic_inc(>->user_wakeref);
3924 : 0 : intel_gt_pm_get(gt);
3925 [ # # ]: 0 : if (INTEL_GEN(i915) >= 6)
3926 : 0 : intel_uncore_forcewake_user_get(gt->uncore);
3927 : :
3928 : 0 : return 0;
3929 : : }
3930 : :
3931 : 0 : static int i915_forcewake_release(struct inode *inode, struct file *file)
3932 : : {
3933 : 0 : struct drm_i915_private *i915 = inode->i_private;
3934 : 0 : struct intel_gt *gt = &i915->gt;
3935 : :
3936 [ # # ]: 0 : if (INTEL_GEN(i915) >= 6)
3937 : 0 : intel_uncore_forcewake_user_put(&i915->uncore);
3938 : 0 : intel_gt_pm_put(gt);
3939 : 0 : atomic_dec(>->user_wakeref);
3940 : :
3941 : 0 : return 0;
3942 : : }
3943 : :
3944 : : static const struct file_operations i915_forcewake_fops = {
3945 : : .owner = THIS_MODULE,
3946 : : .open = i915_forcewake_open,
3947 : : .release = i915_forcewake_release,
3948 : : };
3949 : :
3950 : 0 : static int i915_hpd_storm_ctl_show(struct seq_file *m, void *data)
3951 : : {
3952 : 0 : struct drm_i915_private *dev_priv = m->private;
3953 : 0 : struct i915_hotplug *hotplug = &dev_priv->hotplug;
3954 : :
3955 : : /* Synchronize with everything first in case there's been an HPD
3956 : : * storm, but we haven't finished handling it in the kernel yet
3957 : : */
3958 : 0 : intel_synchronize_irq(dev_priv);
3959 : 0 : flush_work(&dev_priv->hotplug.dig_port_work);
3960 : 0 : flush_delayed_work(&dev_priv->hotplug.hotplug_work);
3961 : :
3962 : 0 : seq_printf(m, "Threshold: %d\n", hotplug->hpd_storm_threshold);
3963 : 0 : seq_printf(m, "Detected: %s\n",
3964 : 0 : yesno(delayed_work_pending(&hotplug->reenable_work)));
3965 : :
3966 : 0 : return 0;
3967 : : }
3968 : :
3969 : 0 : static ssize_t i915_hpd_storm_ctl_write(struct file *file,
3970 : : const char __user *ubuf, size_t len,
3971 : : loff_t *offp)
3972 : : {
3973 : 0 : struct seq_file *m = file->private_data;
3974 : 0 : struct drm_i915_private *dev_priv = m->private;
3975 : 0 : struct i915_hotplug *hotplug = &dev_priv->hotplug;
3976 : 0 : unsigned int new_threshold;
3977 : 0 : int i;
3978 : 0 : char *newline;
3979 : 0 : char tmp[16];
3980 : :
3981 [ # # ]: 0 : if (len >= sizeof(tmp))
3982 : : return -EINVAL;
3983 : :
3984 [ # # # # ]: 0 : if (copy_from_user(tmp, ubuf, len))
3985 : : return -EFAULT;
3986 : :
3987 : 0 : tmp[len] = '\0';
3988 : :
3989 : : /* Strip newline, if any */
3990 : 0 : newline = strchr(tmp, '\n');
3991 [ # # ]: 0 : if (newline)
3992 : 0 : *newline = '\0';
3993 : :
3994 [ # # ]: 0 : if (strcmp(tmp, "reset") == 0)
3995 : 0 : new_threshold = HPD_STORM_DEFAULT_THRESHOLD;
3996 [ # # ]: 0 : else if (kstrtouint(tmp, 10, &new_threshold) != 0)
3997 : : return -EINVAL;
3998 : :
3999 [ # # ]: 0 : if (new_threshold > 0)
4000 : 0 : DRM_DEBUG_KMS("Setting HPD storm detection threshold to %d\n",
4001 : : new_threshold);
4002 : : else
4003 : 0 : DRM_DEBUG_KMS("Disabling HPD storm detection\n");
4004 : :
4005 : 0 : spin_lock_irq(&dev_priv->irq_lock);
4006 : 0 : hotplug->hpd_storm_threshold = new_threshold;
4007 : : /* Reset the HPD storm stats so we don't accidentally trigger a storm */
4008 [ # # ]: 0 : for_each_hpd_pin(i)
4009 : 0 : hotplug->stats[i].count = 0;
4010 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
4011 : :
4012 : : /* Re-enable hpd immediately if we were in an irq storm */
4013 : 0 : flush_delayed_work(&dev_priv->hotplug.reenable_work);
4014 : :
4015 : 0 : return len;
4016 : : }
4017 : :
4018 : 0 : static int i915_hpd_storm_ctl_open(struct inode *inode, struct file *file)
4019 : : {
4020 : 0 : return single_open(file, i915_hpd_storm_ctl_show, inode->i_private);
4021 : : }
4022 : :
4023 : : static const struct file_operations i915_hpd_storm_ctl_fops = {
4024 : : .owner = THIS_MODULE,
4025 : : .open = i915_hpd_storm_ctl_open,
4026 : : .read = seq_read,
4027 : : .llseek = seq_lseek,
4028 : : .release = single_release,
4029 : : .write = i915_hpd_storm_ctl_write
4030 : : };
4031 : :
4032 : 0 : static int i915_hpd_short_storm_ctl_show(struct seq_file *m, void *data)
4033 : : {
4034 : 0 : struct drm_i915_private *dev_priv = m->private;
4035 : :
4036 : 0 : seq_printf(m, "Enabled: %s\n",
4037 [ # # ]: 0 : yesno(dev_priv->hotplug.hpd_short_storm_enabled));
4038 : :
4039 : 0 : return 0;
4040 : : }
4041 : :
4042 : : static int
4043 : 0 : i915_hpd_short_storm_ctl_open(struct inode *inode, struct file *file)
4044 : : {
4045 : 0 : return single_open(file, i915_hpd_short_storm_ctl_show,
4046 : : inode->i_private);
4047 : : }
4048 : :
4049 : 0 : static ssize_t i915_hpd_short_storm_ctl_write(struct file *file,
4050 : : const char __user *ubuf,
4051 : : size_t len, loff_t *offp)
4052 : : {
4053 : 0 : struct seq_file *m = file->private_data;
4054 : 0 : struct drm_i915_private *dev_priv = m->private;
4055 : 0 : struct i915_hotplug *hotplug = &dev_priv->hotplug;
4056 : 0 : char *newline;
4057 : 0 : char tmp[16];
4058 : 0 : int i;
4059 : 0 : bool new_state;
4060 : :
4061 [ # # ]: 0 : if (len >= sizeof(tmp))
4062 : : return -EINVAL;
4063 : :
4064 [ # # # # ]: 0 : if (copy_from_user(tmp, ubuf, len))
4065 : : return -EFAULT;
4066 : :
4067 : 0 : tmp[len] = '\0';
4068 : :
4069 : : /* Strip newline, if any */
4070 : 0 : newline = strchr(tmp, '\n');
4071 [ # # ]: 0 : if (newline)
4072 : 0 : *newline = '\0';
4073 : :
4074 : : /* Reset to the "default" state for this system */
4075 [ # # ]: 0 : if (strcmp(tmp, "reset") == 0)
4076 : 0 : new_state = !HAS_DP_MST(dev_priv);
4077 [ # # ]: 0 : else if (kstrtobool(tmp, &new_state) != 0)
4078 : : return -EINVAL;
4079 : :
4080 [ # # ]: 0 : DRM_DEBUG_KMS("%sabling HPD short storm detection\n",
4081 : : new_state ? "En" : "Dis");
4082 : :
4083 : 0 : spin_lock_irq(&dev_priv->irq_lock);
4084 : 0 : hotplug->hpd_short_storm_enabled = new_state;
4085 : : /* Reset the HPD storm stats so we don't accidentally trigger a storm */
4086 [ # # ]: 0 : for_each_hpd_pin(i)
4087 : 0 : hotplug->stats[i].count = 0;
4088 : 0 : spin_unlock_irq(&dev_priv->irq_lock);
4089 : :
4090 : : /* Re-enable hpd immediately if we were in an irq storm */
4091 : 0 : flush_delayed_work(&dev_priv->hotplug.reenable_work);
4092 : :
4093 : 0 : return len;
4094 : : }
4095 : :
4096 : : static const struct file_operations i915_hpd_short_storm_ctl_fops = {
4097 : : .owner = THIS_MODULE,
4098 : : .open = i915_hpd_short_storm_ctl_open,
4099 : : .read = seq_read,
4100 : : .llseek = seq_lseek,
4101 : : .release = single_release,
4102 : : .write = i915_hpd_short_storm_ctl_write,
4103 : : };
4104 : :
4105 : 0 : static int i915_drrs_ctl_set(void *data, u64 val)
4106 : : {
4107 : 0 : struct drm_i915_private *dev_priv = data;
4108 : 0 : struct drm_device *dev = &dev_priv->drm;
4109 : 0 : struct intel_crtc *crtc;
4110 : :
4111 [ # # ]: 0 : if (INTEL_GEN(dev_priv) < 7)
4112 : : return -ENODEV;
4113 : :
4114 [ # # ]: 0 : for_each_intel_crtc(dev, crtc) {
4115 : 0 : struct drm_connector_list_iter conn_iter;
4116 : 0 : struct intel_crtc_state *crtc_state;
4117 : 0 : struct drm_connector *connector;
4118 : 0 : struct drm_crtc_commit *commit;
4119 : 0 : int ret;
4120 : :
4121 : 0 : ret = drm_modeset_lock_single_interruptible(&crtc->base.mutex);
4122 [ # # ]: 0 : if (ret)
4123 : 0 : return ret;
4124 : :
4125 : 0 : crtc_state = to_intel_crtc_state(crtc->base.state);
4126 : :
4127 [ # # ]: 0 : if (!crtc_state->hw.active ||
4128 [ # # ]: 0 : !crtc_state->has_drrs)
4129 : 0 : goto out;
4130 : :
4131 : 0 : commit = crtc_state->uapi.commit;
4132 [ # # ]: 0 : if (commit) {
4133 : 0 : ret = wait_for_completion_interruptible(&commit->hw_done);
4134 [ # # ]: 0 : if (ret)
4135 : 0 : goto out;
4136 : : }
4137 : :
4138 : 0 : drm_connector_list_iter_begin(dev, &conn_iter);
4139 [ # # ]: 0 : drm_for_each_connector_iter(connector, &conn_iter) {
4140 : 0 : struct intel_encoder *encoder;
4141 : 0 : struct intel_dp *intel_dp;
4142 : :
4143 : 0 : if (!(crtc_state->uapi.connector_mask &
4144 [ # # ]: 0 : drm_connector_mask(connector)))
4145 : 0 : continue;
4146 : :
4147 [ # # ]: 0 : encoder = intel_attached_encoder(to_intel_connector(connector));
4148 [ # # ]: 0 : if (encoder->type != INTEL_OUTPUT_EDP)
4149 : 0 : continue;
4150 : :
4151 [ # # ]: 0 : DRM_DEBUG_DRIVER("Manually %sabling DRRS. %llu\n",
4152 : : val ? "en" : "dis", val);
4153 : :
4154 [ # # ]: 0 : intel_dp = enc_to_intel_dp(encoder);
4155 [ # # ]: 0 : if (val)
4156 : 0 : intel_edp_drrs_enable(intel_dp,
4157 : : crtc_state);
4158 : : else
4159 : 0 : intel_edp_drrs_disable(intel_dp,
4160 : : crtc_state);
4161 : : }
4162 : 0 : drm_connector_list_iter_end(&conn_iter);
4163 : :
4164 : 0 : out:
4165 : 0 : drm_modeset_unlock(&crtc->base.mutex);
4166 [ # # ]: 0 : if (ret)
4167 : 0 : return ret;
4168 : : }
4169 : :
4170 : : return 0;
4171 : : }
4172 : :
4173 : 0 : DEFINE_SIMPLE_ATTRIBUTE(i915_drrs_ctl_fops, NULL, i915_drrs_ctl_set, "%llu\n");
4174 : :
4175 : : static ssize_t
4176 : 0 : i915_fifo_underrun_reset_write(struct file *filp,
4177 : : const char __user *ubuf,
4178 : : size_t cnt, loff_t *ppos)
4179 : : {
4180 : 0 : struct drm_i915_private *dev_priv = filp->private_data;
4181 : 0 : struct intel_crtc *intel_crtc;
4182 : 0 : struct drm_device *dev = &dev_priv->drm;
4183 : 0 : int ret;
4184 : 0 : bool reset;
4185 : :
4186 : 0 : ret = kstrtobool_from_user(ubuf, cnt, &reset);
4187 [ # # ]: 0 : if (ret)
4188 : 0 : return ret;
4189 : :
4190 [ # # ]: 0 : if (!reset)
4191 : 0 : return cnt;
4192 : :
4193 [ # # ]: 0 : for_each_intel_crtc(dev, intel_crtc) {
4194 : 0 : struct drm_crtc_commit *commit;
4195 : 0 : struct intel_crtc_state *crtc_state;
4196 : :
4197 : 0 : ret = drm_modeset_lock_single_interruptible(&intel_crtc->base.mutex);
4198 [ # # ]: 0 : if (ret)
4199 : 0 : return ret;
4200 : :
4201 : 0 : crtc_state = to_intel_crtc_state(intel_crtc->base.state);
4202 : 0 : commit = crtc_state->uapi.commit;
4203 [ # # ]: 0 : if (commit) {
4204 : 0 : ret = wait_for_completion_interruptible(&commit->hw_done);
4205 [ # # ]: 0 : if (!ret)
4206 : 0 : ret = wait_for_completion_interruptible(&commit->flip_done);
4207 : : }
4208 : :
4209 [ # # # # ]: 0 : if (!ret && crtc_state->hw.active) {
4210 : 0 : DRM_DEBUG_KMS("Re-arming FIFO underruns on pipe %c\n",
4211 : : pipe_name(intel_crtc->pipe));
4212 : :
4213 : 0 : intel_crtc_arm_fifo_underrun(intel_crtc, crtc_state);
4214 : : }
4215 : :
4216 : 0 : drm_modeset_unlock(&intel_crtc->base.mutex);
4217 : :
4218 [ # # ]: 0 : if (ret)
4219 : 0 : return ret;
4220 : : }
4221 : :
4222 : 0 : ret = intel_fbc_reset_underrun(dev_priv);
4223 [ # # ]: 0 : if (ret)
4224 : 0 : return ret;
4225 : :
4226 : 0 : return cnt;
4227 : : }
4228 : :
4229 : : static const struct file_operations i915_fifo_underrun_reset_ops = {
4230 : : .owner = THIS_MODULE,
4231 : : .open = simple_open,
4232 : : .write = i915_fifo_underrun_reset_write,
4233 : : .llseek = default_llseek,
4234 : : };
4235 : :
4236 : : static const struct drm_info_list i915_debugfs_list[] = {
4237 : : {"i915_capabilities", i915_capabilities, 0},
4238 : : {"i915_gem_objects", i915_gem_object_info, 0},
4239 : : {"i915_gem_fence_regs", i915_gem_fence_regs_info, 0},
4240 : : {"i915_gem_interrupt", i915_interrupt_info, 0},
4241 : : {"i915_guc_info", i915_guc_info, 0},
4242 : : {"i915_guc_load_status", i915_guc_load_status_info, 0},
4243 : : {"i915_guc_log_dump", i915_guc_log_dump, 0},
4244 : : {"i915_guc_load_err_log_dump", i915_guc_log_dump, 0, (void *)1},
4245 : : {"i915_guc_stage_pool", i915_guc_stage_pool, 0},
4246 : : {"i915_huc_load_status", i915_huc_load_status_info, 0},
4247 : : {"i915_frequency_info", i915_frequency_info, 0},
4248 : : {"i915_drpc_info", i915_drpc_info, 0},
4249 : : {"i915_ring_freq_table", i915_ring_freq_table, 0},
4250 : : {"i915_frontbuffer_tracking", i915_frontbuffer_tracking, 0},
4251 : : {"i915_fbc_status", i915_fbc_status, 0},
4252 : : {"i915_ips_status", i915_ips_status, 0},
4253 : : {"i915_sr_status", i915_sr_status, 0},
4254 : : {"i915_opregion", i915_opregion, 0},
4255 : : {"i915_vbt", i915_vbt, 0},
4256 : : {"i915_gem_framebuffer", i915_gem_framebuffer_info, 0},
4257 : : {"i915_context_status", i915_context_status, 0},
4258 : : {"i915_forcewake_domains", i915_forcewake_domains, 0},
4259 : : {"i915_swizzle_info", i915_swizzle_info, 0},
4260 : : {"i915_llc", i915_llc, 0},
4261 : : {"i915_edp_psr_status", i915_edp_psr_status, 0},
4262 : : {"i915_energy_uJ", i915_energy_uJ, 0},
4263 : : {"i915_runtime_pm_status", i915_runtime_pm_status, 0},
4264 : : {"i915_power_domain_info", i915_power_domain_info, 0},
4265 : : {"i915_dmc_info", i915_dmc_info, 0},
4266 : : {"i915_display_info", i915_display_info, 0},
4267 : : {"i915_engine_info", i915_engine_info, 0},
4268 : : {"i915_rcs_topology", i915_rcs_topology, 0},
4269 : : {"i915_shrinker_info", i915_shrinker_info, 0},
4270 : : {"i915_shared_dplls_info", i915_shared_dplls_info, 0},
4271 : : {"i915_dp_mst_info", i915_dp_mst_info, 0},
4272 : : {"i915_wa_registers", i915_wa_registers, 0},
4273 : : {"i915_ddb_info", i915_ddb_info, 0},
4274 : : {"i915_sseu_status", i915_sseu_status, 0},
4275 : : {"i915_drrs_status", i915_drrs_status, 0},
4276 : : {"i915_rps_boost_info", i915_rps_boost_info, 0},
4277 : : };
4278 : : #define I915_DEBUGFS_ENTRIES ARRAY_SIZE(i915_debugfs_list)
4279 : :
4280 : : static const struct i915_debugfs_files {
4281 : : const char *name;
4282 : : const struct file_operations *fops;
4283 : : } i915_debugfs_files[] = {
4284 : : {"i915_perf_noa_delay", &i915_perf_noa_delay_fops},
4285 : : {"i915_wedged", &i915_wedged_fops},
4286 : : {"i915_cache_sharing", &i915_cache_sharing_fops},
4287 : : {"i915_gem_drop_caches", &i915_drop_caches_fops},
4288 : : #if IS_ENABLED(CONFIG_DRM_I915_CAPTURE_ERROR)
4289 : : {"i915_error_state", &i915_error_state_fops},
4290 : : {"i915_gpu_info", &i915_gpu_info_fops},
4291 : : #endif
4292 : : {"i915_fifo_underrun_reset", &i915_fifo_underrun_reset_ops},
4293 : : {"i915_pri_wm_latency", &i915_pri_wm_latency_fops},
4294 : : {"i915_spr_wm_latency", &i915_spr_wm_latency_fops},
4295 : : {"i915_cur_wm_latency", &i915_cur_wm_latency_fops},
4296 : : {"i915_fbc_false_color", &i915_fbc_false_color_fops},
4297 : : {"i915_dp_test_data", &i915_displayport_test_data_fops},
4298 : : {"i915_dp_test_type", &i915_displayport_test_type_fops},
4299 : : {"i915_dp_test_active", &i915_displayport_test_active_fops},
4300 : : {"i915_guc_log_level", &i915_guc_log_level_fops},
4301 : : {"i915_guc_log_relay", &i915_guc_log_relay_fops},
4302 : : {"i915_hpd_storm_ctl", &i915_hpd_storm_ctl_fops},
4303 : : {"i915_hpd_short_storm_ctl", &i915_hpd_short_storm_ctl_fops},
4304 : : {"i915_ipc_status", &i915_ipc_status_fops},
4305 : : {"i915_drrs_ctl", &i915_drrs_ctl_fops},
4306 : : {"i915_edp_psr_debug", &i915_edp_psr_debug_fops}
4307 : : };
4308 : :
4309 : 0 : int i915_debugfs_register(struct drm_i915_private *dev_priv)
4310 : : {
4311 : 0 : struct drm_minor *minor = dev_priv->drm.primary;
4312 : 0 : int i;
4313 : :
4314 : 0 : debugfs_create_file("i915_forcewake_user", S_IRUSR, minor->debugfs_root,
4315 : 0 : to_i915(minor->dev), &i915_forcewake_fops);
4316 : :
4317 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(i915_debugfs_files); i++) {
4318 : 0 : debugfs_create_file(i915_debugfs_files[i].name,
4319 : : S_IRUGO | S_IWUSR,
4320 : : minor->debugfs_root,
4321 : 0 : to_i915(minor->dev),
4322 : : i915_debugfs_files[i].fops);
4323 : : }
4324 : :
4325 : 0 : return drm_debugfs_create_files(i915_debugfs_list,
4326 : : I915_DEBUGFS_ENTRIES,
4327 : : minor->debugfs_root, minor);
4328 : : }
4329 : :
4330 : : struct dpcd_block {
4331 : : /* DPCD dump start address. */
4332 : : unsigned int offset;
4333 : : /* DPCD dump end address, inclusive. If unset, .size will be used. */
4334 : : unsigned int end;
4335 : : /* DPCD dump size. Used if .end is unset. If unset, defaults to 1. */
4336 : : size_t size;
4337 : : /* Only valid for eDP. */
4338 : : bool edp;
4339 : : };
4340 : :
4341 : : static const struct dpcd_block i915_dpcd_debug[] = {
4342 : : { .offset = DP_DPCD_REV, .size = DP_RECEIVER_CAP_SIZE },
4343 : : { .offset = DP_PSR_SUPPORT, .end = DP_PSR_CAPS },
4344 : : { .offset = DP_DOWNSTREAM_PORT_0, .size = 16 },
4345 : : { .offset = DP_LINK_BW_SET, .end = DP_EDP_CONFIGURATION_SET },
4346 : : { .offset = DP_SINK_COUNT, .end = DP_ADJUST_REQUEST_LANE2_3 },
4347 : : { .offset = DP_SET_POWER },
4348 : : { .offset = DP_EDP_DPCD_REV },
4349 : : { .offset = DP_EDP_GENERAL_CAP_1, .end = DP_EDP_GENERAL_CAP_3 },
4350 : : { .offset = DP_EDP_DISPLAY_CONTROL_REGISTER, .end = DP_EDP_BACKLIGHT_FREQ_CAP_MAX_LSB },
4351 : : { .offset = DP_EDP_DBC_MINIMUM_BRIGHTNESS_SET, .end = DP_EDP_DBC_MAXIMUM_BRIGHTNESS_SET },
4352 : : };
4353 : :
4354 : 0 : static int i915_dpcd_show(struct seq_file *m, void *data)
4355 : : {
4356 : 0 : struct drm_connector *connector = m->private;
4357 : 0 : struct intel_dp *intel_dp =
4358 [ # # ]: 0 : enc_to_intel_dp(intel_attached_encoder(to_intel_connector(connector)));
4359 : 0 : u8 buf[16];
4360 : 0 : ssize_t err;
4361 : 0 : int i;
4362 : :
4363 [ # # ]: 0 : if (connector->status != connector_status_connected)
4364 : : return -ENODEV;
4365 : :
4366 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(i915_dpcd_debug); i++) {
4367 : 0 : const struct dpcd_block *b = &i915_dpcd_debug[i];
4368 [ # # ]: 0 : size_t size = b->end ? b->end - b->offset + 1 : (b->size ?: 1);
4369 : :
4370 [ # # ]: 0 : if (b->edp &&
4371 [ # # ]: 0 : connector->connector_type != DRM_MODE_CONNECTOR_eDP)
4372 : 0 : continue;
4373 : :
4374 : : /* low tech for now */
4375 [ # # # # ]: 0 : if (WARN_ON(size > sizeof(buf)))
4376 : 0 : continue;
4377 : :
4378 : 0 : err = drm_dp_dpcd_read(&intel_dp->aux, b->offset, buf, size);
4379 [ # # ]: 0 : if (err < 0)
4380 : 0 : seq_printf(m, "%04x: ERROR %d\n", b->offset, (int)err);
4381 : : else
4382 : 0 : seq_printf(m, "%04x: %*ph\n", b->offset, (int)err, buf);
4383 : : }
4384 : :
4385 : : return 0;
4386 : : }
4387 : 0 : DEFINE_SHOW_ATTRIBUTE(i915_dpcd);
4388 : :
4389 : 0 : static int i915_panel_show(struct seq_file *m, void *data)
4390 : : {
4391 : 0 : struct drm_connector *connector = m->private;
4392 : 0 : struct intel_dp *intel_dp =
4393 [ # # ]: 0 : enc_to_intel_dp(intel_attached_encoder(to_intel_connector(connector)));
4394 : :
4395 [ # # ]: 0 : if (connector->status != connector_status_connected)
4396 : : return -ENODEV;
4397 : :
4398 : 0 : seq_printf(m, "Panel power up delay: %d\n",
4399 : : intel_dp->panel_power_up_delay);
4400 : 0 : seq_printf(m, "Panel power down delay: %d\n",
4401 : : intel_dp->panel_power_down_delay);
4402 : 0 : seq_printf(m, "Backlight on delay: %d\n",
4403 : : intel_dp->backlight_on_delay);
4404 : 0 : seq_printf(m, "Backlight off delay: %d\n",
4405 : : intel_dp->backlight_off_delay);
4406 : :
4407 : 0 : return 0;
4408 : : }
4409 : 0 : DEFINE_SHOW_ATTRIBUTE(i915_panel);
4410 : :
4411 : 0 : static int i915_hdcp_sink_capability_show(struct seq_file *m, void *data)
4412 : : {
4413 : 0 : struct drm_connector *connector = m->private;
4414 : 0 : struct intel_connector *intel_connector = to_intel_connector(connector);
4415 : :
4416 [ # # ]: 0 : if (connector->status != connector_status_connected)
4417 : : return -ENODEV;
4418 : :
4419 : : /* HDCP is supported by connector */
4420 [ # # ]: 0 : if (!intel_connector->hdcp.shim)
4421 : : return -EINVAL;
4422 : :
4423 : 0 : seq_printf(m, "%s:%d HDCP version: ", connector->name,
4424 : : connector->base.id);
4425 : 0 : intel_hdcp_info(m, intel_connector);
4426 : :
4427 : 0 : return 0;
4428 : : }
4429 : 0 : DEFINE_SHOW_ATTRIBUTE(i915_hdcp_sink_capability);
4430 : :
4431 : 0 : static int i915_dsc_fec_support_show(struct seq_file *m, void *data)
4432 : : {
4433 : 0 : struct drm_connector *connector = m->private;
4434 : 0 : struct drm_device *dev = connector->dev;
4435 : 0 : struct drm_crtc *crtc;
4436 : 0 : struct intel_dp *intel_dp;
4437 : 0 : struct drm_modeset_acquire_ctx ctx;
4438 : 0 : struct intel_crtc_state *crtc_state = NULL;
4439 : 0 : int ret = 0;
4440 : 0 : bool try_again = false;
4441 : :
4442 : 0 : drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE);
4443 : :
4444 : 0 : do {
4445 : 0 : try_again = false;
4446 : 0 : ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
4447 : : &ctx);
4448 [ # # ]: 0 : if (ret) {
4449 [ # # # # ]: 0 : if (ret == -EDEADLK && !drm_modeset_backoff(&ctx)) {
4450 : 0 : try_again = true;
4451 : 0 : continue;
4452 : : }
4453 : : break;
4454 : : }
4455 : 0 : crtc = connector->state->crtc;
4456 [ # # # # ]: 0 : if (connector->status != connector_status_connected || !crtc) {
4457 : : ret = -ENODEV;
4458 : : break;
4459 : : }
4460 : 0 : ret = drm_modeset_lock(&crtc->mutex, &ctx);
4461 [ # # ]: 0 : if (ret == -EDEADLK) {
4462 : 0 : ret = drm_modeset_backoff(&ctx);
4463 [ # # ]: 0 : if (!ret) {
4464 : 0 : try_again = true;
4465 : 0 : continue;
4466 : : }
4467 : : break;
4468 [ # # ]: 0 : } else if (ret) {
4469 : : break;
4470 : : }
4471 [ # # ]: 0 : intel_dp = enc_to_intel_dp(intel_attached_encoder(to_intel_connector(connector)));
4472 : 0 : crtc_state = to_intel_crtc_state(crtc->state);
4473 : 0 : seq_printf(m, "DSC_Enabled: %s\n",
4474 [ # # ]: 0 : yesno(crtc_state->dsc.compression_enable));
4475 : 0 : seq_printf(m, "DSC_Sink_Support: %s\n",
4476 [ # # ]: 0 : yesno(drm_dp_sink_supports_dsc(intel_dp->dsc_dpcd)));
4477 : 0 : seq_printf(m, "Force_DSC_Enable: %s\n",
4478 [ # # ]: 0 : yesno(intel_dp->force_dsc_en));
4479 [ # # ]: 0 : if (!intel_dp_is_edp(intel_dp))
4480 : 0 : seq_printf(m, "FEC_Sink_Support: %s\n",
4481 [ # # ]: 0 : yesno(drm_dp_sink_supports_fec(intel_dp->fec_capable)));
4482 : 0 : } while (try_again);
4483 : :
4484 : 0 : drm_modeset_drop_locks(&ctx);
4485 : 0 : drm_modeset_acquire_fini(&ctx);
4486 : :
4487 : 0 : return ret;
4488 : : }
4489 : :
4490 : 0 : static ssize_t i915_dsc_fec_support_write(struct file *file,
4491 : : const char __user *ubuf,
4492 : : size_t len, loff_t *offp)
4493 : : {
4494 : 0 : bool dsc_enable = false;
4495 : 0 : int ret;
4496 : 0 : struct drm_connector *connector =
4497 : 0 : ((struct seq_file *)file->private_data)->private;
4498 [ # # ]: 0 : struct intel_encoder *encoder = intel_attached_encoder(to_intel_connector(connector));
4499 [ # # ]: 0 : struct intel_dp *intel_dp = enc_to_intel_dp(encoder);
4500 : :
4501 [ # # ]: 0 : if (len == 0)
4502 : : return 0;
4503 : :
4504 : 0 : DRM_DEBUG_DRIVER("Copied %zu bytes from user to force DSC\n",
4505 : : len);
4506 : :
4507 : 0 : ret = kstrtobool_from_user(ubuf, len, &dsc_enable);
4508 [ # # ]: 0 : if (ret < 0)
4509 : 0 : return ret;
4510 : :
4511 [ # # ]: 0 : DRM_DEBUG_DRIVER("Got %s for DSC Enable\n",
4512 : : (dsc_enable) ? "true" : "false");
4513 : 0 : intel_dp->force_dsc_en = dsc_enable;
4514 : :
4515 : 0 : *offp += len;
4516 : 0 : return len;
4517 : : }
4518 : :
4519 : 0 : static int i915_dsc_fec_support_open(struct inode *inode,
4520 : : struct file *file)
4521 : : {
4522 : 0 : return single_open(file, i915_dsc_fec_support_show,
4523 : : inode->i_private);
4524 : : }
4525 : :
4526 : : static const struct file_operations i915_dsc_fec_support_fops = {
4527 : : .owner = THIS_MODULE,
4528 : : .open = i915_dsc_fec_support_open,
4529 : : .read = seq_read,
4530 : : .llseek = seq_lseek,
4531 : : .release = single_release,
4532 : : .write = i915_dsc_fec_support_write
4533 : : };
4534 : :
4535 : : /**
4536 : : * i915_debugfs_connector_add - add i915 specific connector debugfs files
4537 : : * @connector: pointer to a registered drm_connector
4538 : : *
4539 : : * Cleanup will be done by drm_connector_unregister() through a call to
4540 : : * drm_debugfs_connector_remove().
4541 : : *
4542 : : * Returns 0 on success, negative error codes on error.
4543 : : */
4544 : 0 : int i915_debugfs_connector_add(struct drm_connector *connector)
4545 : : {
4546 : 0 : struct dentry *root = connector->debugfs_entry;
4547 [ # # ]: 0 : struct drm_i915_private *dev_priv = to_i915(connector->dev);
4548 : :
4549 : : /* The connector must have been registered beforehands. */
4550 [ # # ]: 0 : if (!root)
4551 : : return -ENODEV;
4552 : :
4553 [ # # ]: 0 : if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
4554 : : connector->connector_type == DRM_MODE_CONNECTOR_eDP)
4555 : 0 : debugfs_create_file("i915_dpcd", S_IRUGO, root,
4556 : : connector, &i915_dpcd_fops);
4557 : :
4558 [ # # ]: 0 : if (connector->connector_type == DRM_MODE_CONNECTOR_eDP) {
4559 : 0 : debugfs_create_file("i915_panel_timings", S_IRUGO, root,
4560 : : connector, &i915_panel_fops);
4561 : 0 : debugfs_create_file("i915_psr_sink_status", S_IRUGO, root,
4562 : : connector, &i915_psr_sink_status_fops);
4563 : : }
4564 : :
4565 : 0 : if (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
4566 [ # # ]: 0 : connector->connector_type == DRM_MODE_CONNECTOR_HDMIA ||
4567 : : connector->connector_type == DRM_MODE_CONNECTOR_HDMIB) {
4568 : 0 : debugfs_create_file("i915_hdcp_sink_capability", S_IRUGO, root,
4569 : : connector, &i915_hdcp_sink_capability_fops);
4570 : : }
4571 : :
4572 [ # # ]: 0 : if (INTEL_GEN(dev_priv) >= 10 &&
4573 [ # # ]: 0 : (connector->connector_type == DRM_MODE_CONNECTOR_DisplayPort ||
4574 : : connector->connector_type == DRM_MODE_CONNECTOR_eDP))
4575 : 0 : debugfs_create_file("i915_dsc_fec_support", S_IRUGO, root,
4576 : : connector, &i915_dsc_fec_support_fops);
4577 : :
4578 : : return 0;
4579 : : }
|
