drm/xe: check pcode init status only on root gt of root tile

The root tile indicates the pcode initialization is complete
when all tiles have completed their initialization.
So the mailbox can be polled only on the root tile.
Check pcode init status only on root tile and move it to
device probe early as root tile is initialized there.
Also make similar changes in resume paths.

v2: add lock/unlocked version of pcode_mailbox_rw
    to allow pcode init to be called in device
    early probe (Rodrigo)

v3: add code description about using root tile
    change function names to xe_pcode_probe_early
    and xe_pcode_init (Rodrigo)

Signed-off-by: Riana Tauro <riana.tauro@intel.com>
Reviewed-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
Reviewed-by: Himal Prasad Ghimiray <himal.prasad.ghimiray@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20240410085005.1126343-2-riana.tauro@intel.com
Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>

diff --git a/drivers/gpu/drm/xe/xe_device.c b/drivers/gpu/drm/xe/xe_device.c
index 9083f5e02dd9e3c42c0263a5a1cd9f418a997e97..a05623a8c163b67836f2f87f668d04f3c2776fea 100644 (file)
--- a/drivers/gpu/drm/xe/xe_device.c
+++ b/drivers/gpu/drm/xe/xe_device.c
@@ -422,8 +422,14 @@ mask_err:
        return err;
 }
 
-/*
- * Initialize MMIO resources that don't require any knowledge about tile count.
+/**
+ * xe_device_probe_early: Device early probe
+ * @xe: xe device instance
+ *
+ * Initialize MMIO resources that don't require any
+ * knowledge about tile count. Also initialize pcode
+ *
+ * Return: 0 on success, error code on failure
  */
 int xe_device_probe_early(struct xe_device *xe)
 {
@@ -439,6 +445,10 @@ int xe_device_probe_early(struct xe_device *xe)
        if (err)
                return err;
 
+       err = xe_pcode_probe_early(xe);
+       if (err)
+               return err;
+
        return 0;
 }
 
@@ -517,11 +527,8 @@ int xe_device_probe(struct xe_device *xe)
        if (err)
                return err;
 
-       for_each_gt(gt, xe, id) {
-               err = xe_pcode_probe(gt);
-               if (err)
-                       return err;
-       }
+       for_each_gt(gt, xe, id)
+               xe_pcode_init(gt);
 
        err = xe_display_init_noirq(xe);
        if (err)

diff --git a/drivers/gpu/drm/xe/xe_pcode.c b/drivers/gpu/drm/xe/xe_pcode.c
index 627e094c7cbe89ef2b0e29ab52f2649ff7a63303..c010ef16fbf57451e55ededd46adc43e107153a5 100644 (file)
--- a/drivers/gpu/drm/xe/xe_pcode.c
+++ b/drivers/gpu/drm/xe/xe_pcode.c
@@ -10,6 +10,7 @@
 
 #include <drm/drm_managed.h>
 
+#include "xe_device.h"
 #include "xe_gt.h"
 #include "xe_mmio.h"
 #include "xe_pcode_api.h"
@@ -43,8 +44,6 @@ static int pcode_mailbox_status(struct xe_gt *gt)
                [PCODE_ERROR_MASK] = {-EPROTO, "Unknown"},
        };
 
-       lockdep_assert_held(&gt->pcode.lock);
-
        err = xe_mmio_read32(gt, PCODE_MAILBOX) & PCODE_ERROR_MASK;
        if (err) {
                drm_err(&gt_to_xe(gt)->drm, "PCODE Mailbox failed: %d %s", err,
@@ -55,17 +54,15 @@ static int pcode_mailbox_status(struct xe_gt *gt)
        return 0;
 }
 
-static int pcode_mailbox_rw(struct xe_gt *gt, u32 mbox, u32 *data0, u32 *data1,
-                           unsigned int timeout_ms, bool return_data,
-                           bool atomic)
+static int __pcode_mailbox_rw(struct xe_gt *gt, u32 mbox, u32 *data0, u32 *data1,
+                             unsigned int timeout_ms, bool return_data,
+                             bool atomic)
 {
        int err;
 
        if (gt_to_xe(gt)->info.skip_pcode)
                return 0;
 
-       lockdep_assert_held(&gt->pcode.lock);
-
        if ((xe_mmio_read32(gt, PCODE_MAILBOX) & PCODE_READY) != 0)
                return -EAGAIN;
 
@@ -87,6 +84,18 @@ static int pcode_mailbox_rw(struct xe_gt *gt, u32 mbox, u32 *data0, u32 *data1,
        return pcode_mailbox_status(gt);
 }
 
+static int pcode_mailbox_rw(struct xe_gt *gt, u32 mbox, u32 *data0, u32 *data1,
+                           unsigned int timeout_ms, bool return_data,
+                           bool atomic)
+{
+       if (gt_to_xe(gt)->info.skip_pcode)
+               return 0;
+
+       lockdep_assert_held(&gt->pcode.lock);
+
+       return __pcode_mailbox_rw(gt, mbox, data0, data1, timeout_ms, return_data, atomic);
+}
+
 int xe_pcode_write_timeout(struct xe_gt *gt, u32 mbox, u32 data, int timeout)
 {
        int err;
@@ -109,15 +118,19 @@ int xe_pcode_read(struct xe_gt *gt, u32 mbox, u32 *val, u32 *val1)
        return err;
 }
 
-static int xe_pcode_try_request(struct xe_gt *gt, u32 mbox,
-                               u32 request, u32 reply_mask, u32 reply,
-                               u32 *status, bool atomic, int timeout_us)
+static int pcode_try_request(struct xe_gt *gt, u32 mbox,
+                            u32 request, u32 reply_mask, u32 reply,
+                            u32 *status, bool atomic, int timeout_us, bool locked)
 {
        int slept, wait = 10;
 
        for (slept = 0; slept < timeout_us; slept += wait) {
-               *status = pcode_mailbox_rw(gt, mbox, &request, NULL, 1, true,
-                                          atomic);
+               if (locked)
+                       *status = pcode_mailbox_rw(gt, mbox, &request, NULL, 1, true,
+                                                  atomic);
+               else
+                       *status = __pcode_mailbox_rw(gt, mbox, &request, NULL, 1, true,
+                                                    atomic);
                if ((*status == 0) && ((request & reply_mask) == reply))
                        return 0;
 
@@ -158,8 +171,8 @@ int xe_pcode_request(struct xe_gt *gt, u32 mbox, u32 request,
 
        mutex_lock(&gt->pcode.lock);
 
-       ret = xe_pcode_try_request(gt, mbox, request, reply_mask, reply, &status,
-                                  false, timeout_base_ms * 1000);
+       ret = pcode_try_request(gt, mbox, request, reply_mask, reply, &status,
+                               false, timeout_base_ms * 1000, true);
        if (!ret)
                goto out;
 
@@ -177,8 +190,8 @@ int xe_pcode_request(struct xe_gt *gt, u32 mbox, u32 request,
                "PCODE timeout, retrying with preemption disabled\n");
        drm_WARN_ON_ONCE(&gt_to_xe(gt)->drm, timeout_base_ms > 1);
        preempt_disable();
-       ret = xe_pcode_try_request(gt, mbox, request, reply_mask, reply, &status,
-                                  true, timeout_base_ms * 1000);
+       ret = pcode_try_request(gt, mbox, request, reply_mask, reply, &status,
+                               true, timeout_base_ms * 1000, true);
        preempt_enable();
 
 out:
@@ -238,59 +251,71 @@ unlock:
 }
 
 /**
- * xe_pcode_init - Ensure PCODE is initialized
- * @gt: gt instance
+ * xe_pcode_ready - Ensure PCODE is initialized
+ * @xe: xe instance
+ * @locked: true if lock held, false otherwise
  *
- * This function ensures that PCODE is properly initialized. To be called during
- * probe and resume paths.
+ * PCODE init mailbox is polled only on root gt of root tile
+ * as the root tile provides the initialization is complete only
+ * after all the tiles have completed the initialization.
+ * Called only on early probe without locks and with locks in
+ * resume path.
  *
- * It returns 0 on success, and -error number on failure.
+ * Returns 0 on success, and -error number on failure.
  */
-int xe_pcode_init(struct xe_gt *gt)
+int xe_pcode_ready(struct xe_device *xe, bool locked)
 {
        u32 status, request = DGFX_GET_INIT_STATUS;
+       struct xe_gt *gt = xe_root_mmio_gt(xe);
        int timeout_us = 180000000; /* 3 min */
        int ret;
 
-       if (gt_to_xe(gt)->info.skip_pcode)
+       if (xe->info.skip_pcode)
                return 0;
 
-       if (!IS_DGFX(gt_to_xe(gt)))
+       if (!IS_DGFX(xe))
                return 0;
 
-       mutex_lock(&gt->pcode.lock);
-       ret = xe_pcode_try_request(gt, DGFX_PCODE_STATUS, request,
-                                  DGFX_INIT_STATUS_COMPLETE,
-                                  DGFX_INIT_STATUS_COMPLETE,
-                                  &status, false, timeout_us);
-       mutex_unlock(&gt->pcode.lock);
+       if (locked)
+               mutex_lock(&gt->pcode.lock);
+
+       ret = pcode_try_request(gt, DGFX_PCODE_STATUS, request,
+                               DGFX_INIT_STATUS_COMPLETE,
+                               DGFX_INIT_STATUS_COMPLETE,
+                               &status, false, timeout_us, locked);
+
+       if (locked)
+               mutex_unlock(&gt->pcode.lock);
 
        if (ret)
-               drm_err(&gt_to_xe(gt)->drm,
+               drm_err(&xe->drm,
                        "PCODE initialization timedout after: 3 min\n");
 
        return ret;
 }
 
 /**
- * xe_pcode_probe - Prepare xe_pcode and also ensure PCODE is initialized.
+ * xe_pcode_init: initialize components of PCODE
  * @gt: gt instance
  *
- * This function initializes the xe_pcode component, and when needed, it ensures
- * that PCODE has properly performed its initialization and it is really ready
- * to go. To be called once only during probe.
- *
- * It returns 0 on success, and -error number on failure.
+ * This function initializes the xe_pcode component.
+ * To be called once only during probe.
  */
-int xe_pcode_probe(struct xe_gt *gt)
+void xe_pcode_init(struct xe_gt *gt)
 {
        drmm_mutex_init(&gt_to_xe(gt)->drm, &gt->pcode.lock);
+}
 
-       if (gt_to_xe(gt)->info.skip_pcode)
-               return 0;
-
-       if (!IS_DGFX(gt_to_xe(gt)))
-               return 0;
-
-       return xe_pcode_init(gt);
+/**
+ * xe_pcode_probe_early: initializes PCODE
+ * @xe: xe instance
+ *
+ * This function checks the initialization status of PCODE
+ * To be called once only during early probe without locks.
+ *
+ * Returns 0 on success, error code otherwise
+ */
+int xe_pcode_probe_early(struct xe_device *xe)
+{
+       return xe_pcode_ready(xe, false);
 }

diff --git a/drivers/gpu/drm/xe/xe_pcode.h b/drivers/gpu/drm/xe/xe_pcode.h
index 08cb1d047cba26165ec210217f050fa2a1cf3e4a..3f54c6d2a57d2e88f22d4698aeb94441fe4ca9e9 100644 (file)
--- a/drivers/gpu/drm/xe/xe_pcode.h
+++ b/drivers/gpu/drm/xe/xe_pcode.h
@@ -8,9 +8,11 @@
 
 #include <linux/types.h>
 struct xe_gt;
+struct xe_device;
 
-int xe_pcode_probe(struct xe_gt *gt);
-int xe_pcode_init(struct xe_gt *gt);
+void xe_pcode_init(struct xe_gt *gt);
+int xe_pcode_probe_early(struct xe_device *xe);
+int xe_pcode_ready(struct xe_device *xe, bool locked);
 int xe_pcode_init_min_freq_table(struct xe_gt *gt, u32 min_gt_freq,
                                 u32 max_gt_freq);
 int xe_pcode_read(struct xe_gt *gt, u32 mbox, u32 *val, u32 *val1);

diff --git a/drivers/gpu/drm/xe/xe_pm.c b/drivers/gpu/drm/xe/xe_pm.c
index cc650a92c2fcdb73edb87080ff9fd6c1f8f4ba9d..f1fc83845c01fc878bde7a32f81118d543b5b696 100644 (file)
--- a/drivers/gpu/drm/xe/xe_pm.c
+++ b/drivers/gpu/drm/xe/xe_pm.c
@@ -129,11 +129,9 @@ int xe_pm_resume(struct xe_device *xe)
        for_each_tile(tile, xe, id)
                xe_wa_apply_tile_workarounds(tile);
 
-       for_each_gt(gt, xe, id) {
-               err = xe_pcode_init(gt);
-               if (err)
-                       goto err;
-       }
+       err = xe_pcode_ready(xe, true);
+       if (err)
+               return err;
 
        xe_display_pm_resume_early(xe);
 
@@ -386,11 +384,9 @@ int xe_pm_runtime_resume(struct xe_device *xe)
        xe->d3cold.power_lost = xe_guc_in_reset(&gt->uc.guc);
 
        if (xe->d3cold.allowed && xe->d3cold.power_lost) {
-               for_each_gt(gt, xe, id) {
-                       err = xe_pcode_init(gt);
-                       if (err)
-                               goto out;
-               }
+               err = xe_pcode_ready(xe, true);
+               if (err)
+                       goto out;
 
                /*
                 * This only restores pinned memory which is the memory