drm/i915/guc: Update CTB helpers to use CT_ERROR

Update GuC CTB action helpers to benefit from new CT_ERROR macro.

Signed-off-by: Michal Wajdeczko <michal.wajdeczko@intel.com>
Cc: Chris Wilson <chris@chris-wilson.co.uk>
Cc: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Reviewed-by: Daniele Ceraolo Spurio <daniele.ceraolospurio@intel.com>
Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk>
Link: https://patchwork.freedesktop.org/patch/msgid/20200111231114.59208-4-michal.wajdeczko@intel.com

diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c
index eb123543392a6d2b197e87b4461191c13a020b70..eb4e56e97f459b05381b251f3a5cf03280ca04ee 100644 (file)
--- a/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c
+++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_ct.c
@@ -107,31 +107,40 @@ static int guc_action_register_ct_buffer(struct intel_guc *guc,
                sizeof(struct guc_ct_buffer_desc),
                type
        };
-       int err;
 
        /* Can't use generic send(), CT registration must go over MMIO */
-       err = intel_guc_send_mmio(guc, action, ARRAY_SIZE(action), NULL, 0);
-       if (err)
-               DRM_ERROR("CT: register %s buffer failed; err=%d\n",
-                         guc_ct_buffer_type_to_str(type), err);
+       return intel_guc_send_mmio(guc, action, ARRAY_SIZE(action), NULL, 0);
+}
+
+static int ct_register_buffer(struct intel_guc_ct *ct, u32 desc_addr, u32 type)
+{
+       int err = guc_action_register_ct_buffer(ct_to_guc(ct), desc_addr, type);
+
+       if (unlikely(err))
+               CT_ERROR(ct, "Failed to register %s buffer (err=%d)\n",
+                        guc_ct_buffer_type_to_str(type), err);
        return err;
 }
 
-static int guc_action_deregister_ct_buffer(struct intel_guc *guc,
-                                          u32 type)
+static int guc_action_deregister_ct_buffer(struct intel_guc *guc, u32 type)
 {
        u32 action[] = {
                INTEL_GUC_ACTION_DEREGISTER_COMMAND_TRANSPORT_BUFFER,
                CTB_OWNER_HOST,
                type
        };
-       int err;
 
        /* Can't use generic send(), CT deregistration must go over MMIO */
-       err = intel_guc_send_mmio(guc, action, ARRAY_SIZE(action), NULL, 0);
-       if (err)
-               DRM_ERROR("CT: deregister %s buffer failed; err=%d\n",
-                         guc_ct_buffer_type_to_str(type), err);
+       return intel_guc_send_mmio(guc, action, ARRAY_SIZE(action), NULL, 0);
+}
+
+static int ct_deregister_buffer(struct intel_guc_ct *ct, u32 type)
+{
+       int err = guc_action_deregister_ct_buffer(ct_to_guc(ct), type);
+
+       if (unlikely(err))
+               CT_ERROR(ct, "Failed to deregister %s buffer (err=%d)\n",
+                        guc_ct_buffer_type_to_str(type), err);
        return err;
 }
 
@@ -235,18 +244,17 @@ int intel_guc_ct_enable(struct intel_guc_ct *ct)
                                        PAGE_SIZE/4);
        }
 
-       /* register buffers, starting wirh RECV buffer
-        * descriptors are in first half of the blob
+       /*
+        * Register both CT buffers starting with RECV buffer.
+        * Descriptors are in first half of the blob.
         */
-       err = guc_action_register_ct_buffer(guc,
-                                           base + PAGE_SIZE/4 * CTB_RECV,
-                                           INTEL_GUC_CT_BUFFER_TYPE_RECV);
+       err = ct_register_buffer(ct, base + PAGE_SIZE / 4 * CTB_RECV,
+                                INTEL_GUC_CT_BUFFER_TYPE_RECV);
        if (unlikely(err))
                goto err_out;
 
-       err = guc_action_register_ct_buffer(guc,
-                                           base + PAGE_SIZE/4 * CTB_SEND,
-                                           INTEL_GUC_CT_BUFFER_TYPE_SEND);
+       err = ct_register_buffer(ct, base + PAGE_SIZE / 4 * CTB_SEND,
+                                INTEL_GUC_CT_BUFFER_TYPE_SEND);
        if (unlikely(err))
                goto err_deregister;
 
@@ -255,8 +263,7 @@ int intel_guc_ct_enable(struct intel_guc_ct *ct)
        return 0;
 
 err_deregister:
-       guc_action_deregister_ct_buffer(guc,
-                                       INTEL_GUC_CT_BUFFER_TYPE_RECV);
+       ct_deregister_buffer(ct, INTEL_GUC_CT_BUFFER_TYPE_RECV);
 err_out:
        CT_ERROR(ct, "Failed to open open CT channel (err=%d)\n", err);
        return err;
@@ -275,10 +282,8 @@ void intel_guc_ct_disable(struct intel_guc_ct *ct)
        ct->enabled = false;
 
        if (intel_guc_is_running(guc)) {
-               guc_action_deregister_ct_buffer(guc,
-                                               INTEL_GUC_CT_BUFFER_TYPE_SEND);
-               guc_action_deregister_ct_buffer(guc,
-                                               INTEL_GUC_CT_BUFFER_TYPE_RECV);
+               ct_deregister_buffer(ct, INTEL_GUC_CT_BUFFER_TYPE_SEND);
+               ct_deregister_buffer(ct, INTEL_GUC_CT_BUFFER_TYPE_RECV);
        }
 }