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