drivers/gpu/drm/i915/pxp/intel_pxp_session.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright(c) 2020, Intel Corporation. All rights reserved.
   4  */
   5
   6 #include "drm/i915_drm.h"
   7 #include "i915_drv.h"
   8
   9 #include "intel_pxp.h"
  10 #include "intel_pxp_cmd.h"
  11 #include "intel_pxp_session.h"
  12 #include "intel_pxp_tee.h"
  13 #include "intel_pxp_types.h"
  14
  15 #define ARB_SESSION I915_PROTECTED_CONTENT_DEFAULT_SESSION /* shorter define */
  16
  17 #define GEN12_KCR_SIP _MMIO(0x32260) /* KCR hwdrm session in play 0-31 */
  18
  19 /* PXP global terminate register for session termination */
  20 #define PXP_GLOBAL_TERMINATE _MMIO(0x320f8)
  21
  22 static bool intel_pxp_session_is_in_play(struct intel_pxp *pxp, u32 id)
  23 {
  24         struct intel_uncore *uncore = pxp_to_gt(pxp)->uncore;
  25         intel_wakeref_t wakeref;
  26         u32 sip = 0;
  27
  28         /* if we're suspended the session is considered off */
  29         with_intel_runtime_pm_if_in_use(uncore->rpm, wakeref)
  30                 sip = intel_uncore_read(uncore, GEN12_KCR_SIP);
  31
  32         return sip & BIT(id);
  33 }
  34
  35 static int pxp_wait_for_session_state(struct intel_pxp *pxp, u32 id, bool in_play)
  36 {
  37         struct intel_uncore *uncore = pxp_to_gt(pxp)->uncore;
  38         intel_wakeref_t wakeref;
  39         u32 mask = BIT(id);
  40         int ret;
  41
  42         /* if we're suspended the session is considered off */
  43         wakeref = intel_runtime_pm_get_if_in_use(uncore->rpm);
  44         if (!wakeref)
  45                 return in_play ? -ENODEV : 0;
  46
  47         ret = intel_wait_for_register(uncore,
  48                                       GEN12_KCR_SIP,
  49                                       mask,
  50                                       in_play ? mask : 0,
  51                                       100);
  52
  53         intel_runtime_pm_put(uncore->rpm, wakeref);
  54
  55         return ret;
  56 }
  57
  58 static int pxp_create_arb_session(struct intel_pxp *pxp)
  59 {
  60         struct intel_gt *gt = pxp_to_gt(pxp);
  61         int ret;
  62
  63         pxp->arb_is_valid = false;
  64
  65         if (intel_pxp_session_is_in_play(pxp, ARB_SESSION)) {
  66                 drm_err(&gt->i915->drm, "arb session already in play at creation time\n");
  67                 return -EEXIST;
  68         }
  69
  70         ret = intel_pxp_tee_cmd_create_arb_session(pxp, ARB_SESSION);
  71         if (ret) {
  72                 drm_err(&gt->i915->drm, "tee cmd for arb session creation failed\n");
  73                 return ret;
  74         }
  75
  76         ret = pxp_wait_for_session_state(pxp, ARB_SESSION, true);
  77         if (ret) {
  78                 drm_err(&gt->i915->drm, "arb session failed to go in play\n");
  79                 return ret;
  80         }
  81
  82         if (!++pxp->key_instance)
  83                 ++pxp->key_instance;
  84
  85         pxp->arb_is_valid = true;
  86
  87         return 0;
  88 }
  89
  90 static int pxp_terminate_arb_session_and_global(struct intel_pxp *pxp)
  91 {
  92         int ret;
  93         struct intel_gt *gt = pxp_to_gt(pxp);
  94
  95         /* must mark termination in progress calling this function */
  96         GEM_WARN_ON(pxp->arb_is_valid);
  97
  98         /* terminate the hw sessions */
  99         ret = intel_pxp_terminate_session(pxp, ARB_SESSION);
 100         if (ret) {
 101                 drm_err(&gt->i915->drm, "Failed to submit session termination\n");
 102                 return ret;
 103         }
 104
 105         ret = pxp_wait_for_session_state(pxp, ARB_SESSION, false);
 106         if (ret) {
 107                 drm_err(&gt->i915->drm, "Session state did not clear\n");
 108                 return ret;
 109         }
 110
 111         intel_uncore_write(gt->uncore, PXP_GLOBAL_TERMINATE, 1);
 112
 113         return ret;
 114 }
 115
 116 static void pxp_terminate(struct intel_pxp *pxp)
 117 {
 118         int ret;
 119
 120         pxp->hw_state_invalidated = true;
 121
 122         /*
 123          * if we fail to submit the termination there is no point in waiting for
 124          * it to complete. PXP will be marked as non-active until the next
 125          * termination is issued.
 126          */
 127         ret = pxp_terminate_arb_session_and_global(pxp);
 128         if (ret)
 129                 complete_all(&pxp->termination);
 130 }
 131
 132 static void pxp_terminate_complete(struct intel_pxp *pxp)
 133 {
 134         /* Re-create the arb session after teardown handle complete */
 135         if (fetch_and_zero(&pxp->hw_state_invalidated))
 136                 pxp_create_arb_session(pxp);
 137
 138         complete_all(&pxp->termination);
 139 }
 140
 141 void intel_pxp_session_work(struct work_struct *work)
 142 {
 143         struct intel_pxp *pxp = container_of(work, typeof(*pxp), session_work);
 144         struct intel_gt *gt = pxp_to_gt(pxp);
 145         intel_wakeref_t wakeref;
 146         u32 events = 0;
 147
 148         spin_lock_irq(&gt->irq_lock);
 149         events = fetch_and_zero(&pxp->session_events);
 150         spin_unlock_irq(&gt->irq_lock);
 151
 152         if (!events)
 153                 return;
 154
 155         if (events & PXP_INVAL_REQUIRED)
 156                 intel_pxp_invalidate(pxp);
 157
 158         /*
 159          * If we're processing an event while suspending then don't bother,
 160          * we're going to re-init everything on resume anyway.
 161          */
 162         wakeref = intel_runtime_pm_get_if_in_use(gt->uncore->rpm);
 163         if (!wakeref)
 164                 return;
 165
 166         if (events & PXP_TERMINATION_REQUEST) {
 167                 events &= ~PXP_TERMINATION_COMPLETE;
 168                 pxp_terminate(pxp);
 169         }
 170
 171         if (events & PXP_TERMINATION_COMPLETE)
 172                 pxp_terminate_complete(pxp);
 173
 174         intel_runtime_pm_put(gt->uncore->rpm, wakeref);
 175 }