[PATCH 20/33] drm/xe: Create scoped cleanup class for force_wake_get_any_engine()

[Matt Roper <matthew.d.roper@intel.com>]

force_wake_get_any_engine() is a single-use function to pick any engine
present on the platform and grab its forcewake.  The signature
(returning a boolean success and both the engine pointer and a forcewake
ref by reference) is a bit awkward.  Rewrite it such that the
forcewake ref is the function's return value and the caller can
determine success/failure by checking the engine pointer against NULL.

With this new signature, the function can serve as a scoped cleanup
class constructor, so define the corresponding class.  Note that if we
fail to obtain forcewake (or if the platform somehow has no engines),
the constructor can fail, returning an invalid fw_ref.  In such cases,
fw_ref.fw will be NULL, making it clear that the reference is invalid;
this fact can be used to create a thin wrapper around xe_force_wake_put
that can be used as a destructor for this class.

Signed-off-by: Matt Roper <matthew.d.roper@intel.com>
---
 drivers/gpu/drm/xe/xe_drm_client.c | 45 ++++++++++++++++++++----------
 1 file changed, 31 insertions(+), 14 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_drm_client.c b/drivers/gpu/drm/xe/xe_drm_client.c
index 182526864286..6e0a05eeb587 100644
--- a/drivers/gpu/drm/xe/xe_drm_client.c
+++ b/drivers/gpu/drm/xe/xe_drm_client.c
@@ -6,6 +6,7 @@
 
 #include <drm/drm_print.h>
 #include <uapi/drm/xe_drm.h>
+#include <linux/cleanup.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/types.h>
@@ -285,34 +286,49 @@ static struct xe_hw_engine *any_engine(struct xe_device *xe)
 	return NULL;
 }
 
-static bool force_wake_get_any_engine(struct xe_device *xe,
-				      struct xe_hw_engine **phwe,
-				      struct xe_force_wake_ref *pfw_ref)
+/*
+ * Pick any engine and grab its forcewake.  On error phwe will be NULL and
+ * the returned forcewake reference will be invalid.  Callers should check
+ * phwe against NULL.
+ */
+static struct xe_force_wake_ref force_wake_get_any_engine(struct xe_device *xe,
+							  struct xe_hw_engine **phwe)
 {
 	enum xe_force_wake_domains domain;
-	struct xe_force_wake_ref fw_ref;
+	struct xe_force_wake_ref fw_ref = {};
 	struct xe_hw_engine *hwe;
 	struct xe_force_wake *fw;
 
+	*phwe = NULL;
+
 	hwe = any_engine(xe);
 	if (!hwe)
-		return false;
+		return fw_ref;	/* will be invalid */
 
 	domain = xe_hw_engine_to_fw_domain(hwe);
 	fw = gt_to_fw(hwe->gt);
 
 	fw_ref = xe_force_wake_get(fw, domain);
-	if (!xe_force_wake_ref_has_domain(fw_ref, domain)) {
+	if (xe_force_wake_ref_has_domain(fw_ref, domain))
+		*phwe = hwe;	/* valid forcewake */
+
+	return fw_ref;
+}
+
+static void drop_fw_if_valid(struct xe_force_wake_ref fw_ref)
+{
+	/*
+	 * If force_wake_get_any_engine() fails, there's no real forcewake
+	 * reference to drop, and fw_ref.fw will be NULL.
+	 */
+	if (fw_ref.fw)
 		xe_force_wake_put(fw_ref);
-		return false;
-	}
-
-	*phwe = hwe;
-	*pfw_ref = fw_ref;
-
-	return true;
 }
 
+DEFINE_CLASS(xe_force_wake_any_engine, struct xe_force_wake_ref,
+	     drop_fw_if_valid(_T), force_wake_get_any_engine(xe, phwe),
+	     struct xe_device *xe, struct xe_hw_engine **phwe);
+
 static void show_run_ticks(struct drm_printer *p, struct drm_file *file)
 {
 	unsigned long class, i, gt_id, capacity[XE_ENGINE_CLASS_MAX] = { };
@@ -340,7 +356,8 @@ static void show_run_ticks(struct drm_printer *p, struct drm_file *file)
 		       !atomic_read(&xef->exec_queue.pending_removal));
 
 	xe_pm_runtime_get(xe);
-	if (!force_wake_get_any_engine(xe, &hwe, &fw_ref)) {
+	fw_ref = force_wake_get_any_engine(xe, &hwe);
+	if (!hwe) {
 		xe_pm_runtime_put(xe);
 		return;
 	}
-- 
2.51.1