 @@ -1,14 +1,14 @@
-/*	$NetBSD: intel_engine.h,v 1.2 2021/12/18 23:45:30 riastradh Exp $	*/
+/*	$NetBSD: intel_engine.h,v 1.3 2021/12/19 11:08:40 riastradh Exp $	*/
 /* SPDX-License-Identifier: MIT */
 #ifndef _INTEL_RINGBUFFER_H_
 #define _INTEL_RINGBUFFER_H_
 #include <drm/drm_util.h>
 #include <linux/hashtable.h>
 #include <linux/irq_work.h>
 #include <linux/random.h>
 #include <linux/seqlock.h>
 #include "i915_pmu.h"
 @@ -102,39 +102,56 @@ struct intel_gt;
 static inline unsigned int
 execlists_num_ports(const struct intel_engine_execlists * const execlists)
+{
 	return execlists->port_mask + 1;
+}
 static inline struct i915_request *
 execlists_active(const struct intel_engine_execlists *execlists)
+{
 	return *READ_ONCE(execlists->active);
+}
 #ifdef __linux__
 static inline void
 execlists_active_lock_bh(struct intel_engine_execlists *execlists)
+{
 	local_bh_disable(); /* prevent local softirq and lock recursion */
 	tasklet_lock(&execlists->tasklet);
+}
 static inline void
 execlists_active_unlock_bh(struct intel_engine_execlists *execlists)
+{
 	tasklet_unlock(&execlists->tasklet);
 	local_bh_enable(); /* restore softirq, and kick ksoftirqd! */
+}
 #else
 static inline int
 execlists_active_lock_bh(struct intel_engine_execlists *execlists)
+{
 	int s = splsoftserial(); /* prevent local softirq and lock recursion */
 	tasklet_lock(&execlists->tasklet);
 	return s;
+}
 static inline void
 execlists_active_unlock_bh(struct intel_engine_execlists *execlists, int s)
+{
 	tasklet_unlock(&execlists->tasklet);
 	splraise(s); /* restore softirq, and kick ksoftirqd! */
+}
 #endif
 struct i915_request *
 execlists_unwind_incomplete_requests(struct intel_engine_execlists *execlists);
 static inline u32
 intel_read_status_page(const struct intel_engine_cs *engine, int reg)
+{
 	/* Ensure that the compiler doesn't optimize away the load. */
 	return READ_ONCE(engine->status_page.addr[reg]);
+}
 static inline void
 intel_write_status_page(struct intel_engine_cs *engine, int reg, u32 value)

 @@ -1,41 +1,41 @@
-/*	$NetBSD: intel_engine_cs.c,v 1.3 2021/12/19 01:21:53 riastradh Exp $	*/
+/*	$NetBSD: intel_engine_cs.c,v 1.4 2021/12/19 11:08:40 riastradh Exp $	*/
 /*
  * Copyright © 2016 Intel Corporation
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
+ *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  * IN THE SOFTWARE.
+ *
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: intel_engine_cs.c,v 1.3 2021/12/19 01:21:53 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: intel_engine_cs.c,v 1.4 2021/12/19 11:08:40 riastradh Exp $");
 #include <drm/drm_print.h>
 #include "gem/i915_gem_context.h"
 #include "i915_drv.h"
 #include "intel_context.h"
 #include "intel_engine.h"
 #include "intel_engine_pm.h"
 #include "intel_engine_pool.h"
 #include "intel_engine_user.h"
 #include "intel_gt.h"
 @@ -1335,27 +1335,31 @@ static void intel_engine_print_registers
 		if (read >= num_entries)
 			read = 0;
 		if (write >= num_entries)
 			write = 0;
 		if (read > write)
 			write += num_entries;
 		while (read < write) {
 			idx = ++read % num_entries;
 			drm_printf(m, "\tExeclist CSB[%d]: 0x%08x, context: %d\n",
 				   idx, hws[idx * 2], hws[idx * 2 + 1]);
+		}
 #ifdef __linux__
 		execlists_active_lock_bh(execlists);
 #else
 		int s = execlists_active_lock_bh(execlists);
 #endif
 		rcu_read_lock();
 		for (port = execlists->active; (rq = *port); port++) {
 			char hdr[80];
 			int len;
 			len = snprintf(hdr, sizeof(hdr),
 				       "\t\tActive[%d]: ",
 				       (int)(port - execlists->active));
 			if (!i915_request_signaled(rq)) {
 				struct intel_timeline *tl = get_timeline(rq);
 				len += snprintf(hdr + len, sizeof(hdr) - len,
 						"ring:{start:%08x, hwsp:%08x, seqno:%08x}, ",
 @@ -1375,27 +1379,31 @@ static void intel_engine_print_registers
 			snprintf(hdr, sizeof(hdr),
 				 "\t\tPending[%d] ring:{start:%08x, hwsp:%08x, seqno:%08x}, rq: ",
 				 (int)(port - execlists->pending),
 				 i915_ggtt_offset(rq->ring->vma),
 				 tl ? tl->hwsp_offset : 0,
 				 hwsp_seqno(rq));
 			print_request(m, rq, hdr);
 			if (tl)
 				intel_timeline_put(tl);
+		}
 		rcu_read_unlock();
 #ifdef __linux__
 		execlists_active_unlock_bh(execlists);
 #else
 		execlists_active_unlock_bh(execlists, s);
 #endif
 	} else if (INTEL_GEN(dev_priv) > 6) {
 		drm_printf(m, "\tPP_DIR_BASE: 0x%08x\n",
 			   ENGINE_READ(engine, RING_PP_DIR_BASE));
 		drm_printf(m, "\tPP_DIR_BASE_READ: 0x%08x\n",
 			   ENGINE_READ(engine, RING_PP_DIR_BASE_READ));
 		drm_printf(m, "\tPP_DIR_DCLV: 0x%08x\n",
 			   ENGINE_READ(engine, RING_PP_DIR_DCLV));
+	}
+}
 static void print_request_ring(struct drm_printer *m, struct i915_request *rq)
+{
 	void *ring;
 @@ -1538,27 +1546,31 @@ void intel_engine_dump(struct intel_engi
  * Start collecting the engine busyness data for @engine.
+ *
  * Returns 0 on success or a negative error code.
  */
 int intel_enable_engine_stats(struct intel_engine_cs *engine)
+{
 	struct intel_engine_execlists *execlists = &engine->execlists;
 	unsigned long flags;
 	int err = 0;
 	if (!intel_engine_supports_stats(engine))
 		return -ENODEV;
 #ifdef __linux__
 	execlists_active_lock_bh(execlists);
 #else
 	int s = execlists_active_lock_bh(execlists);
 #endif
 	write_seqlock_irqsave(&engine->stats.lock, flags);
 	if (unlikely(engine->stats.enabled == ~0)) {
 		err = -EBUSY;
 		goto unlock;
+	}
 	if (engine->stats.enabled++ == 0) {
 		struct i915_request * const *port;
 		struct i915_request *rq;
 		engine->stats.enabled_at = ktime_get();
 @@ -1568,27 +1580,31 @@ int intel_enable_engine_stats(struct int
 		for (port = execlists->pending; (rq = *port); port++) {
 			/* Exclude any contexts already counted in active */
 			if (!intel_context_inflight_count(rq->context))
 				engine->stats.active++;
+		}
 		if (engine->stats.active)
 			engine->stats.start = engine->stats.enabled_at;
+	}
 unlock:
 	write_sequnlock_irqrestore(&engine->stats.lock, flags);
 #ifdef __linux__
 	execlists_active_unlock_bh(execlists);
 #else
 	execlists_active_unlock_bh(execlists, s);
 #endif
 	return err;
+}
 static ktime_t __intel_engine_get_busy_time(struct intel_engine_cs *engine)
+{
 	ktime_t total = engine->stats.total;
 	/*
 	 * If the engine is executing something at the moment
 	 * add it to the total.
 	 */
 	if (engine->stats.active)