2560c3aaac45f980abb309071a9ea3f68efb6bb3
[sfrench/cifs-2.6.git] / drivers / gpu / drm / i915 / gvt / gvt.h
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  *    Kevin Tian <kevin.tian@intel.com>
25  *    Eddie Dong <eddie.dong@intel.com>
26  *
27  * Contributors:
28  *    Niu Bing <bing.niu@intel.com>
29  *    Zhi Wang <zhi.a.wang@intel.com>
30  *
31  */
32
33 #ifndef _GVT_H_
34 #define _GVT_H_
35
36 #include "debug.h"
37 #include "hypercall.h"
38 #include "mmio.h"
39 #include "reg.h"
40 #include "interrupt.h"
41 #include "gtt.h"
42
43 #define GVT_MAX_VGPU 8
44
45 enum {
46         INTEL_GVT_HYPERVISOR_XEN = 0,
47         INTEL_GVT_HYPERVISOR_KVM,
48 };
49
50 struct intel_gvt_host {
51         bool initialized;
52         int hypervisor_type;
53         struct intel_gvt_mpt *mpt;
54 };
55
56 extern struct intel_gvt_host intel_gvt_host;
57
58 /* Describe per-platform limitations. */
59 struct intel_gvt_device_info {
60         u32 max_support_vgpus;
61         u32 cfg_space_size;
62         u32 mmio_size;
63         u32 mmio_bar;
64         unsigned long msi_cap_offset;
65         u32 gtt_start_offset;
66         u32 gtt_entry_size;
67         u32 gtt_entry_size_shift;
68 };
69
70 /* GM resources owned by a vGPU */
71 struct intel_vgpu_gm {
72         u64 aperture_sz;
73         u64 hidden_sz;
74         struct drm_mm_node low_gm_node;
75         struct drm_mm_node high_gm_node;
76 };
77
78 #define INTEL_GVT_MAX_NUM_FENCES 32
79
80 /* Fences owned by a vGPU */
81 struct intel_vgpu_fence {
82         struct drm_i915_fence_reg *regs[INTEL_GVT_MAX_NUM_FENCES];
83         u32 base;
84         u32 size;
85 };
86
87 struct intel_vgpu_mmio {
88         void *vreg;
89         void *sreg;
90         bool disable_warn_untrack;
91 };
92
93 #define INTEL_GVT_MAX_CFG_SPACE_SZ 256
94 #define INTEL_GVT_MAX_BAR_NUM 4
95
96 struct intel_vgpu_pci_bar {
97         u64 size;
98         bool tracked;
99 };
100
101 struct intel_vgpu_cfg_space {
102         unsigned char virtual_cfg_space[INTEL_GVT_MAX_CFG_SPACE_SZ];
103         struct intel_vgpu_pci_bar bar[INTEL_GVT_MAX_BAR_NUM];
104 };
105
106 #define vgpu_cfg_space(vgpu) ((vgpu)->cfg_space.virtual_cfg_space)
107
108 struct intel_vgpu_irq {
109         bool irq_warn_once[INTEL_GVT_EVENT_MAX];
110 };
111
112 struct intel_vgpu_opregion {
113         void *va;
114         u32 gfn[INTEL_GVT_OPREGION_PAGES];
115         struct page *pages[INTEL_GVT_OPREGION_PAGES];
116 };
117
118 #define vgpu_opregion(vgpu) (&(vgpu->opregion))
119
120 struct intel_vgpu {
121         struct intel_gvt *gvt;
122         int id;
123         unsigned long handle; /* vGPU handle used by hypervisor MPT modules */
124         bool active;
125         bool resetting;
126
127         struct intel_vgpu_fence fence;
128         struct intel_vgpu_gm gm;
129         struct intel_vgpu_cfg_space cfg_space;
130         struct intel_vgpu_mmio mmio;
131         struct intel_vgpu_irq irq;
132         struct intel_vgpu_gtt gtt;
133         struct intel_vgpu_opregion opregion;
134 };
135
136 struct intel_gvt_gm {
137         unsigned long vgpu_allocated_low_gm_size;
138         unsigned long vgpu_allocated_high_gm_size;
139 };
140
141 struct intel_gvt_fence {
142         unsigned long vgpu_allocated_fence_num;
143 };
144
145 #define INTEL_GVT_MMIO_HASH_BITS 9
146
147 struct intel_gvt_mmio {
148         u32 *mmio_attribute;
149         DECLARE_HASHTABLE(mmio_info_table, INTEL_GVT_MMIO_HASH_BITS);
150 };
151
152 struct intel_gvt_firmware {
153         void *cfg_space;
154         void *mmio;
155         bool firmware_loaded;
156 };
157
158 struct intel_gvt_opregion {
159         void *opregion_va;
160         u32 opregion_pa;
161 };
162
163 struct intel_gvt {
164         struct mutex lock;
165         bool initialized;
166
167         struct drm_i915_private *dev_priv;
168         struct idr vgpu_idr;    /* vGPU IDR pool */
169
170         struct intel_gvt_device_info device_info;
171         struct intel_gvt_gm gm;
172         struct intel_gvt_fence fence;
173         struct intel_gvt_mmio mmio;
174         struct intel_gvt_firmware firmware;
175         struct intel_gvt_irq irq;
176         struct intel_gvt_gtt gtt;
177         struct intel_gvt_opregion opregion;
178 };
179
180 void intel_gvt_free_firmware(struct intel_gvt *gvt);
181 int intel_gvt_load_firmware(struct intel_gvt *gvt);
182
183 /* Aperture/GM space definitions for GVT device */
184 #define gvt_aperture_sz(gvt)      (gvt->dev_priv->ggtt.mappable_end)
185 #define gvt_aperture_pa_base(gvt) (gvt->dev_priv->ggtt.mappable_base)
186
187 #define gvt_ggtt_gm_sz(gvt)       (gvt->dev_priv->ggtt.base.total)
188 #define gvt_ggtt_sz(gvt) \
189         ((gvt->dev_priv->ggtt.base.total >> PAGE_SHIFT) << 3)
190 #define gvt_hidden_sz(gvt)        (gvt_ggtt_gm_sz(gvt) - gvt_aperture_sz(gvt))
191
192 #define gvt_aperture_gmadr_base(gvt) (0)
193 #define gvt_aperture_gmadr_end(gvt) (gvt_aperture_gmadr_base(gvt) \
194                                      + gvt_aperture_sz(gvt) - 1)
195
196 #define gvt_hidden_gmadr_base(gvt) (gvt_aperture_gmadr_base(gvt) \
197                                     + gvt_aperture_sz(gvt))
198 #define gvt_hidden_gmadr_end(gvt) (gvt_hidden_gmadr_base(gvt) \
199                                    + gvt_hidden_sz(gvt) - 1)
200
201 #define gvt_fence_sz(gvt) (gvt->dev_priv->num_fence_regs)
202
203 /* Aperture/GM space definitions for vGPU */
204 #define vgpu_aperture_offset(vgpu)      ((vgpu)->gm.low_gm_node.start)
205 #define vgpu_hidden_offset(vgpu)        ((vgpu)->gm.high_gm_node.start)
206 #define vgpu_aperture_sz(vgpu)          ((vgpu)->gm.aperture_sz)
207 #define vgpu_hidden_sz(vgpu)            ((vgpu)->gm.hidden_sz)
208
209 #define vgpu_aperture_pa_base(vgpu) \
210         (gvt_aperture_pa_base(vgpu->gvt) + vgpu_aperture_offset(vgpu))
211
212 #define vgpu_ggtt_gm_sz(vgpu) ((vgpu)->gm.aperture_sz + (vgpu)->gm.hidden_sz)
213
214 #define vgpu_aperture_pa_end(vgpu) \
215         (vgpu_aperture_pa_base(vgpu) + vgpu_aperture_sz(vgpu) - 1)
216
217 #define vgpu_aperture_gmadr_base(vgpu) (vgpu_aperture_offset(vgpu))
218 #define vgpu_aperture_gmadr_end(vgpu) \
219         (vgpu_aperture_gmadr_base(vgpu) + vgpu_aperture_sz(vgpu) - 1)
220
221 #define vgpu_hidden_gmadr_base(vgpu) (vgpu_hidden_offset(vgpu))
222 #define vgpu_hidden_gmadr_end(vgpu) \
223         (vgpu_hidden_gmadr_base(vgpu) + vgpu_hidden_sz(vgpu) - 1)
224
225 #define vgpu_fence_base(vgpu) (vgpu->fence.base)
226 #define vgpu_fence_sz(vgpu) (vgpu->fence.size)
227
228 struct intel_vgpu_creation_params {
229         __u64 handle;
230         __u64 low_gm_sz;  /* in MB */
231         __u64 high_gm_sz; /* in MB */
232         __u64 fence_sz;
233         __s32 primary;
234         __u64 vgpu_id;
235 };
236
237 int intel_vgpu_alloc_resource(struct intel_vgpu *vgpu,
238                               struct intel_vgpu_creation_params *param);
239 void intel_vgpu_free_resource(struct intel_vgpu *vgpu);
240 void intel_vgpu_write_fence(struct intel_vgpu *vgpu,
241         u32 fence, u64 value);
242
243 /* Macros for easily accessing vGPU virtual/shadow register */
244 #define vgpu_vreg(vgpu, reg) \
245         (*(u32 *)(vgpu->mmio.vreg + INTEL_GVT_MMIO_OFFSET(reg)))
246 #define vgpu_vreg8(vgpu, reg) \
247         (*(u8 *)(vgpu->mmio.vreg + INTEL_GVT_MMIO_OFFSET(reg)))
248 #define vgpu_vreg16(vgpu, reg) \
249         (*(u16 *)(vgpu->mmio.vreg + INTEL_GVT_MMIO_OFFSET(reg)))
250 #define vgpu_vreg64(vgpu, reg) \
251         (*(u64 *)(vgpu->mmio.vreg + INTEL_GVT_MMIO_OFFSET(reg)))
252 #define vgpu_sreg(vgpu, reg) \
253         (*(u32 *)(vgpu->mmio.sreg + INTEL_GVT_MMIO_OFFSET(reg)))
254 #define vgpu_sreg8(vgpu, reg) \
255         (*(u8 *)(vgpu->mmio.sreg + INTEL_GVT_MMIO_OFFSET(reg)))
256 #define vgpu_sreg16(vgpu, reg) \
257         (*(u16 *)(vgpu->mmio.sreg + INTEL_GVT_MMIO_OFFSET(reg)))
258 #define vgpu_sreg64(vgpu, reg) \
259         (*(u64 *)(vgpu->mmio.sreg + INTEL_GVT_MMIO_OFFSET(reg)))
260
261 #define for_each_active_vgpu(gvt, vgpu, id) \
262         idr_for_each_entry((&(gvt)->vgpu_idr), (vgpu), (id)) \
263                 for_each_if(vgpu->active)
264
265 static inline void intel_vgpu_write_pci_bar(struct intel_vgpu *vgpu,
266                                             u32 offset, u32 val, bool low)
267 {
268         u32 *pval;
269
270         /* BAR offset should be 32 bits algiend */
271         offset = rounddown(offset, 4);
272         pval = (u32 *)(vgpu_cfg_space(vgpu) + offset);
273
274         if (low) {
275                 /*
276                  * only update bit 31 - bit 4,
277                  * leave the bit 3 - bit 0 unchanged.
278                  */
279                 *pval = (val & GENMASK(31, 4)) | (*pval & GENMASK(3, 0));
280         }
281 }
282
283 struct intel_vgpu *intel_gvt_create_vgpu(struct intel_gvt *gvt,
284                                          struct intel_vgpu_creation_params *
285                                          param);
286
287 void intel_gvt_destroy_vgpu(struct intel_vgpu *vgpu);
288
289 /* validating GM functions */
290 #define vgpu_gmadr_is_aperture(vgpu, gmadr) \
291         ((gmadr >= vgpu_aperture_gmadr_base(vgpu)) && \
292          (gmadr <= vgpu_aperture_gmadr_end(vgpu)))
293
294 #define vgpu_gmadr_is_hidden(vgpu, gmadr) \
295         ((gmadr >= vgpu_hidden_gmadr_base(vgpu)) && \
296          (gmadr <= vgpu_hidden_gmadr_end(vgpu)))
297
298 #define vgpu_gmadr_is_valid(vgpu, gmadr) \
299          ((vgpu_gmadr_is_aperture(vgpu, gmadr) || \
300           (vgpu_gmadr_is_hidden(vgpu, gmadr))))
301
302 #define gvt_gmadr_is_aperture(gvt, gmadr) \
303          ((gmadr >= gvt_aperture_gmadr_base(gvt)) && \
304           (gmadr <= gvt_aperture_gmadr_end(gvt)))
305
306 #define gvt_gmadr_is_hidden(gvt, gmadr) \
307           ((gmadr >= gvt_hidden_gmadr_base(gvt)) && \
308            (gmadr <= gvt_hidden_gmadr_end(gvt)))
309
310 #define gvt_gmadr_is_valid(gvt, gmadr) \
311           (gvt_gmadr_is_aperture(gvt, gmadr) || \
312             gvt_gmadr_is_hidden(gvt, gmadr))
313
314 bool intel_gvt_ggtt_validate_range(struct intel_vgpu *vgpu, u64 addr, u32 size);
315 int intel_gvt_ggtt_gmadr_g2h(struct intel_vgpu *vgpu, u64 g_addr, u64 *h_addr);
316 int intel_gvt_ggtt_gmadr_h2g(struct intel_vgpu *vgpu, u64 h_addr, u64 *g_addr);
317 int intel_gvt_ggtt_index_g2h(struct intel_vgpu *vgpu, unsigned long g_index,
318                              unsigned long *h_index);
319 int intel_gvt_ggtt_h2g_index(struct intel_vgpu *vgpu, unsigned long h_index,
320                              unsigned long *g_index);
321
322 int intel_vgpu_emulate_cfg_read(void *__vgpu, unsigned int offset,
323                 void *p_data, unsigned int bytes);
324
325 int intel_vgpu_emulate_cfg_write(void *__vgpu, unsigned int offset,
326                 void *p_data, unsigned int bytes);
327
328 void intel_gvt_clean_opregion(struct intel_gvt *gvt);
329 int intel_gvt_init_opregion(struct intel_gvt *gvt);
330
331 void intel_vgpu_clean_opregion(struct intel_vgpu *vgpu);
332 int intel_vgpu_init_opregion(struct intel_vgpu *vgpu, u32 gpa);
333
334 int intel_vgpu_emulate_opregion_request(struct intel_vgpu *vgpu, u32 swsci);
335
336 #include "mpt.h"
337
338 #endif