drm/i915: properly init lockdep class
[sfrench/cifs-2.6.git] / drivers / gpu / drm / i915 / gvt / render.c
1 /*
2  * Copyright(c) 2011-2016 Intel Corporation. All rights reserved.
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21  * SOFTWARE.
22  *
23  * Authors:
24  *    Eddie Dong <eddie.dong@intel.com>
25  *    Kevin Tian <kevin.tian@intel.com>
26  *
27  * Contributors:
28  *    Zhi Wang <zhi.a.wang@intel.com>
29  *    Changbin Du <changbin.du@intel.com>
30  *    Zhenyu Wang <zhenyuw@linux.intel.com>
31  *    Tina Zhang <tina.zhang@intel.com>
32  *    Bing Niu <bing.niu@intel.com>
33  *
34  */
35
36 #include "i915_drv.h"
37 #include "gvt.h"
38 #include "trace.h"
39
40 struct render_mmio {
41         int ring_id;
42         i915_reg_t reg;
43         u32 mask;
44         bool in_context;
45         u32 value;
46 };
47
48 static struct render_mmio gen8_render_mmio_list[] __cacheline_aligned = {
49         {RCS, _MMIO(0x229c), 0xffff, false},
50         {RCS, _MMIO(0x2248), 0x0, false},
51         {RCS, _MMIO(0x2098), 0x0, false},
52         {RCS, _MMIO(0x20c0), 0xffff, true},
53         {RCS, _MMIO(0x24d0), 0, false},
54         {RCS, _MMIO(0x24d4), 0, false},
55         {RCS, _MMIO(0x24d8), 0, false},
56         {RCS, _MMIO(0x24dc), 0, false},
57         {RCS, _MMIO(0x24e0), 0, false},
58         {RCS, _MMIO(0x24e4), 0, false},
59         {RCS, _MMIO(0x24e8), 0, false},
60         {RCS, _MMIO(0x24ec), 0, false},
61         {RCS, _MMIO(0x24f0), 0, false},
62         {RCS, _MMIO(0x24f4), 0, false},
63         {RCS, _MMIO(0x24f8), 0, false},
64         {RCS, _MMIO(0x24fc), 0, false},
65         {RCS, _MMIO(0x7004), 0xffff, true},
66         {RCS, _MMIO(0x7008), 0xffff, true},
67         {RCS, _MMIO(0x7000), 0xffff, true},
68         {RCS, _MMIO(0x7010), 0xffff, true},
69         {RCS, _MMIO(0x7300), 0xffff, true},
70         {RCS, _MMIO(0x83a4), 0xffff, true},
71
72         {BCS, _MMIO(0x2229c), 0xffff, false},
73         {BCS, _MMIO(0x2209c), 0xffff, false},
74         {BCS, _MMIO(0x220c0), 0xffff, false},
75         {BCS, _MMIO(0x22098), 0x0, false},
76         {BCS, _MMIO(0x22028), 0x0, false},
77 };
78
79 static struct render_mmio gen9_render_mmio_list[] __cacheline_aligned = {
80         {RCS, _MMIO(0x229c), 0xffff, false},
81         {RCS, _MMIO(0x2248), 0x0, false},
82         {RCS, _MMIO(0x2098), 0x0, false},
83         {RCS, _MMIO(0x20c0), 0xffff, true},
84         {RCS, _MMIO(0x24d0), 0, false},
85         {RCS, _MMIO(0x24d4), 0, false},
86         {RCS, _MMIO(0x24d8), 0, false},
87         {RCS, _MMIO(0x24dc), 0, false},
88         {RCS, _MMIO(0x24e0), 0, false},
89         {RCS, _MMIO(0x24e4), 0, false},
90         {RCS, _MMIO(0x24e8), 0, false},
91         {RCS, _MMIO(0x24ec), 0, false},
92         {RCS, _MMIO(0x24f0), 0, false},
93         {RCS, _MMIO(0x24f4), 0, false},
94         {RCS, _MMIO(0x24f8), 0, false},
95         {RCS, _MMIO(0x24fc), 0, false},
96         {RCS, _MMIO(0x7004), 0xffff, true},
97         {RCS, _MMIO(0x7008), 0xffff, true},
98         {RCS, _MMIO(0x7000), 0xffff, true},
99         {RCS, _MMIO(0x7010), 0xffff, true},
100         {RCS, _MMIO(0x7300), 0xffff, true},
101         {RCS, _MMIO(0x83a4), 0xffff, true},
102
103         {RCS, _MMIO(0x40e0), 0, false},
104         {RCS, _MMIO(0x40e4), 0, false},
105         {RCS, _MMIO(0x2580), 0xffff, true},
106         {RCS, _MMIO(0x7014), 0xffff, true},
107         {RCS, _MMIO(0x20ec), 0xffff, false},
108         {RCS, _MMIO(0xb118), 0, false},
109         {RCS, _MMIO(0xe100), 0xffff, true},
110         {RCS, _MMIO(0xe180), 0xffff, true},
111         {RCS, _MMIO(0xe184), 0xffff, true},
112         {RCS, _MMIO(0xe188), 0xffff, true},
113         {RCS, _MMIO(0xe194), 0xffff, true},
114         {RCS, _MMIO(0x4de0), 0, false},
115         {RCS, _MMIO(0x4de4), 0, false},
116         {RCS, _MMIO(0x4de8), 0, false},
117         {RCS, _MMIO(0x4dec), 0, false},
118         {RCS, _MMIO(0x4df0), 0, false},
119         {RCS, _MMIO(0x4df4), 0, false},
120
121         {BCS, _MMIO(0x2229c), 0xffff, false},
122         {BCS, _MMIO(0x2209c), 0xffff, false},
123         {BCS, _MMIO(0x220c0), 0xffff, false},
124         {BCS, _MMIO(0x22098), 0x0, false},
125         {BCS, _MMIO(0x22028), 0x0, false},
126
127         {VCS2, _MMIO(0x1c028), 0xffff, false},
128
129         {VECS, _MMIO(0x1a028), 0xffff, false},
130
131         {RCS, _MMIO(0x7304), 0xffff, true},
132         {RCS, _MMIO(0x2248), 0x0, false},
133         {RCS, _MMIO(0x940c), 0x0, false},
134         {RCS, _MMIO(0x4ab8), 0x0, false},
135
136         {RCS, _MMIO(0x4ab0), 0x0, false},
137         {RCS, _MMIO(0x20d4), 0x0, false},
138
139         {RCS, _MMIO(0xb004), 0x0, false},
140         {RCS, _MMIO(0x20a0), 0x0, false},
141         {RCS, _MMIO(0x20e4), 0xffff, false},
142 };
143
144 static u32 gen9_render_mocs[I915_NUM_ENGINES][64];
145 static u32 gen9_render_mocs_L3[32];
146
147 static void handle_tlb_pending_event(struct intel_vgpu *vgpu, int ring_id)
148 {
149         struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
150         struct intel_vgpu_submission *s = &vgpu->submission;
151         enum forcewake_domains fw;
152         i915_reg_t reg;
153         u32 regs[] = {
154                 [RCS] = 0x4260,
155                 [VCS] = 0x4264,
156                 [VCS2] = 0x4268,
157                 [BCS] = 0x426c,
158                 [VECS] = 0x4270,
159         };
160
161         if (WARN_ON(ring_id >= ARRAY_SIZE(regs)))
162                 return;
163
164         if (!test_and_clear_bit(ring_id, (void *)s->tlb_handle_pending))
165                 return;
166
167         reg = _MMIO(regs[ring_id]);
168
169         /* WaForceWakeRenderDuringMmioTLBInvalidate:skl
170          * we need to put a forcewake when invalidating RCS TLB caches,
171          * otherwise device can go to RC6 state and interrupt invalidation
172          * process
173          */
174         fw = intel_uncore_forcewake_for_reg(dev_priv, reg,
175                                             FW_REG_READ | FW_REG_WRITE);
176         if (ring_id == RCS && (IS_SKYLAKE(dev_priv) || IS_KABYLAKE(dev_priv)))
177                 fw |= FORCEWAKE_RENDER;
178
179         intel_uncore_forcewake_get(dev_priv, fw);
180
181         I915_WRITE_FW(reg, 0x1);
182
183         if (wait_for_atomic((I915_READ_FW(reg) == 0), 50))
184                 gvt_vgpu_err("timeout in invalidate ring (%d) tlb\n", ring_id);
185         else
186                 vgpu_vreg(vgpu, regs[ring_id]) = 0;
187
188         intel_uncore_forcewake_put(dev_priv, fw);
189
190         gvt_dbg_core("invalidate TLB for ring %d\n", ring_id);
191 }
192
193 static void load_mocs(struct intel_vgpu *vgpu, int ring_id)
194 {
195         struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
196         i915_reg_t offset, l3_offset;
197         u32 regs[] = {
198                 [RCS] = 0xc800,
199                 [VCS] = 0xc900,
200                 [VCS2] = 0xca00,
201                 [BCS] = 0xcc00,
202                 [VECS] = 0xcb00,
203         };
204         int i;
205
206         if (WARN_ON(ring_id >= ARRAY_SIZE(regs)))
207                 return;
208
209         offset.reg = regs[ring_id];
210         for (i = 0; i < 64; i++) {
211                 gen9_render_mocs[ring_id][i] = I915_READ_FW(offset);
212                 I915_WRITE_FW(offset, vgpu_vreg(vgpu, offset));
213                 offset.reg += 4;
214         }
215
216         if (ring_id == RCS) {
217                 l3_offset.reg = 0xb020;
218                 for (i = 0; i < 32; i++) {
219                         gen9_render_mocs_L3[i] = I915_READ_FW(l3_offset);
220                         I915_WRITE_FW(l3_offset, vgpu_vreg(vgpu, l3_offset));
221                         l3_offset.reg += 4;
222                 }
223         }
224 }
225
226 static void restore_mocs(struct intel_vgpu *vgpu, int ring_id)
227 {
228         struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
229         i915_reg_t offset, l3_offset;
230         u32 regs[] = {
231                 [RCS] = 0xc800,
232                 [VCS] = 0xc900,
233                 [VCS2] = 0xca00,
234                 [BCS] = 0xcc00,
235                 [VECS] = 0xcb00,
236         };
237         int i;
238
239         if (WARN_ON(ring_id >= ARRAY_SIZE(regs)))
240                 return;
241
242         offset.reg = regs[ring_id];
243         for (i = 0; i < 64; i++) {
244                 vgpu_vreg(vgpu, offset) = I915_READ_FW(offset);
245                 I915_WRITE_FW(offset, gen9_render_mocs[ring_id][i]);
246                 offset.reg += 4;
247         }
248
249         if (ring_id == RCS) {
250                 l3_offset.reg = 0xb020;
251                 for (i = 0; i < 32; i++) {
252                         vgpu_vreg(vgpu, l3_offset) = I915_READ_FW(l3_offset);
253                         I915_WRITE_FW(l3_offset, gen9_render_mocs_L3[i]);
254                         l3_offset.reg += 4;
255                 }
256         }
257 }
258
259 #define CTX_CONTEXT_CONTROL_VAL 0x03
260
261 /* Switch ring mmio values (context) from host to a vgpu. */
262 static void switch_mmio_to_vgpu(struct intel_vgpu *vgpu, int ring_id)
263 {
264         struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
265         struct intel_vgpu_submission *s = &vgpu->submission;
266         u32 *reg_state = s->shadow_ctx->engine[ring_id].lrc_reg_state;
267         u32 ctx_ctrl = reg_state[CTX_CONTEXT_CONTROL_VAL];
268         u32 inhibit_mask =
269                 _MASKED_BIT_ENABLE(CTX_CTRL_ENGINE_CTX_RESTORE_INHIBIT);
270         i915_reg_t last_reg = _MMIO(0);
271         struct render_mmio *mmio;
272         u32 v;
273         int i, array_size;
274
275         if (IS_SKYLAKE(vgpu->gvt->dev_priv)
276                 || IS_KABYLAKE(vgpu->gvt->dev_priv)) {
277                 mmio = gen9_render_mmio_list;
278                 array_size = ARRAY_SIZE(gen9_render_mmio_list);
279                 load_mocs(vgpu, ring_id);
280         } else {
281                 mmio = gen8_render_mmio_list;
282                 array_size = ARRAY_SIZE(gen8_render_mmio_list);
283         }
284
285         for (i = 0; i < array_size; i++, mmio++) {
286                 if (mmio->ring_id != ring_id)
287                         continue;
288
289                 mmio->value = I915_READ_FW(mmio->reg);
290
291                 /*
292                  * if it is an inhibit context, load in_context mmio
293                  * into HW by mmio write. If it is not, skip this mmio
294                  * write.
295                  */
296                 if (mmio->in_context &&
297                     (ctx_ctrl & inhibit_mask) != inhibit_mask)
298                         continue;
299
300                 if (mmio->mask)
301                         v = vgpu_vreg(vgpu, mmio->reg) | (mmio->mask << 16);
302                 else
303                         v = vgpu_vreg(vgpu, mmio->reg);
304
305                 I915_WRITE_FW(mmio->reg, v);
306                 last_reg = mmio->reg;
307
308                 trace_render_mmio(vgpu->id, "load",
309                                   i915_mmio_reg_offset(mmio->reg),
310                                   mmio->value, v);
311         }
312
313         /* Make sure the swiched MMIOs has taken effect. */
314         if (likely(INTEL_GVT_MMIO_OFFSET(last_reg)))
315                 I915_READ_FW(last_reg);
316
317         handle_tlb_pending_event(vgpu, ring_id);
318 }
319
320 /* Switch ring mmio values (context) from vgpu to host. */
321 static void switch_mmio_to_host(struct intel_vgpu *vgpu, int ring_id)
322 {
323         struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
324         struct render_mmio *mmio;
325         i915_reg_t last_reg = _MMIO(0);
326         u32 v;
327         int i, array_size;
328
329         if (IS_SKYLAKE(dev_priv) || IS_KABYLAKE(dev_priv)) {
330                 mmio = gen9_render_mmio_list;
331                 array_size = ARRAY_SIZE(gen9_render_mmio_list);
332                 restore_mocs(vgpu, ring_id);
333         } else {
334                 mmio = gen8_render_mmio_list;
335                 array_size = ARRAY_SIZE(gen8_render_mmio_list);
336         }
337
338         for (i = 0; i < array_size; i++, mmio++) {
339                 if (mmio->ring_id != ring_id)
340                         continue;
341
342                 vgpu_vreg(vgpu, mmio->reg) = I915_READ_FW(mmio->reg);
343
344                 if (mmio->mask) {
345                         vgpu_vreg(vgpu, mmio->reg) &= ~(mmio->mask << 16);
346                         v = mmio->value | (mmio->mask << 16);
347                 } else
348                         v = mmio->value;
349
350                 if (mmio->in_context)
351                         continue;
352
353                 I915_WRITE_FW(mmio->reg, v);
354                 last_reg = mmio->reg;
355
356                 trace_render_mmio(vgpu->id, "restore",
357                                   i915_mmio_reg_offset(mmio->reg),
358                                   mmio->value, v);
359         }
360
361         /* Make sure the swiched MMIOs has taken effect. */
362         if (likely(INTEL_GVT_MMIO_OFFSET(last_reg)))
363                 I915_READ_FW(last_reg);
364 }
365
366 /**
367  * intel_gvt_switch_render_mmio - switch mmio context of specific engine
368  * @pre: the last vGPU that own the engine
369  * @next: the vGPU to switch to
370  * @ring_id: specify the engine
371  *
372  * If pre is null indicates that host own the engine. If next is null
373  * indicates that we are switching to host workload.
374  */
375 void intel_gvt_switch_mmio(struct intel_vgpu *pre,
376                            struct intel_vgpu *next, int ring_id)
377 {
378         struct drm_i915_private *dev_priv;
379
380         if (WARN_ON(!pre && !next))
381                 return;
382
383         gvt_dbg_render("switch ring %d from %s to %s\n", ring_id,
384                        pre ? "vGPU" : "host", next ? "vGPU" : "HOST");
385
386         dev_priv = pre ? pre->gvt->dev_priv : next->gvt->dev_priv;
387
388         /**
389          * We are using raw mmio access wrapper to improve the
390          * performace for batch mmio read/write, so we need
391          * handle forcewake mannually.
392          */
393         intel_uncore_forcewake_get(dev_priv, FORCEWAKE_ALL);
394
395         /**
396          * TODO: Optimize for vGPU to vGPU switch by merging
397          * switch_mmio_to_host() and switch_mmio_to_vgpu().
398          */
399         if (pre)
400                 switch_mmio_to_host(pre, ring_id);
401
402         if (next)
403                 switch_mmio_to_vgpu(next, ring_id);
404
405         intel_uncore_forcewake_put(dev_priv, FORCEWAKE_ALL);
406 }