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 }
176