gvt.h 19.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * Copyright(c) 2011-2016 Intel Corporation. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
22 23 24 25 26 27 28 29 30
 *
 * Authors:
 *    Kevin Tian <kevin.tian@intel.com>
 *    Eddie Dong <eddie.dong@intel.com>
 *
 * Contributors:
 *    Niu Bing <bing.niu@intel.com>
 *    Zhi Wang <zhi.a.wang@intel.com>
 *
31 32 33 34 35 36 37
 */

#ifndef _GVT_H_
#define _GVT_H_

#include "debug.h"
#include "hypercall.h"
38
#include "mmio.h"
39
#include "reg.h"
40
#include "interrupt.h"
41
#include "gtt.h"
42 43
#include "display.h"
#include "edid.h"
44
#include "execlist.h"
Z
Zhi Wang 已提交
45
#include "scheduler.h"
46
#include "sched_policy.h"
47
#include "mmio_context.h"
Z
Zhi Wang 已提交
48
#include "cmd_parser.h"
49
#include "fb_decoder.h"
50
#include "dmabuf.h"
51
#include "page_track.h"
52 53 54 55

#define GVT_MAX_VGPU 8

struct intel_gvt_host {
56
	struct device *dev;
57 58 59 60 61 62 63 64 65 66
	bool initialized;
	int hypervisor_type;
	struct intel_gvt_mpt *mpt;
};

extern struct intel_gvt_host intel_gvt_host;

/* Describe per-platform limitations. */
struct intel_gvt_device_info {
	u32 max_support_vgpus;
67
	u32 cfg_space_size;
68
	u32 mmio_size;
69
	u32 mmio_bar;
70
	unsigned long msi_cap_offset;
71 72 73
	u32 gtt_start_offset;
	u32 gtt_entry_size;
	u32 gtt_entry_size_shift;
Z
Zhi Wang 已提交
74 75
	int gmadr_bytes_in_cmd;
	u32 max_surface_size;
76 77
};

78 79 80 81 82 83 84 85 86 87 88 89
/* GM resources owned by a vGPU */
struct intel_vgpu_gm {
	u64 aperture_sz;
	u64 hidden_sz;
	struct drm_mm_node low_gm_node;
	struct drm_mm_node high_gm_node;
};

#define INTEL_GVT_MAX_NUM_FENCES 32

/* Fences owned by a vGPU */
struct intel_vgpu_fence {
90
	struct i915_fence_reg *regs[INTEL_GVT_MAX_NUM_FENCES];
91 92 93 94
	u32 base;
	u32 size;
};

95 96 97 98 99 100 101 102 103 104 105 106
struct intel_vgpu_mmio {
	void *vreg;
};

#define INTEL_GVT_MAX_BAR_NUM 4

struct intel_vgpu_pci_bar {
	u64 size;
	bool tracked;
};

struct intel_vgpu_cfg_space {
107
	unsigned char virtual_cfg_space[PCI_CFG_SPACE_EXP_SIZE];
108 109 110 111 112
	struct intel_vgpu_pci_bar bar[INTEL_GVT_MAX_BAR_NUM];
};

#define vgpu_cfg_space(vgpu) ((vgpu)->cfg_space.virtual_cfg_space)

113 114
struct intel_vgpu_irq {
	bool irq_warn_once[INTEL_GVT_EVENT_MAX];
115
	DECLARE_BITMAP(flip_done_event[I915_MAX_PIPES],
116
		       INTEL_GVT_EVENT_MAX);
117 118
};

119
struct intel_vgpu_opregion {
120
	bool mapped;
121 122 123 124 125 126
	void *va;
	u32 gfn[INTEL_GVT_OPREGION_PAGES];
};

#define vgpu_opregion(vgpu) (&(vgpu->opregion))

127 128
struct intel_vgpu_display {
	struct intel_vgpu_i2c_edid i2c_edid;
129
	struct intel_vgpu_port ports[I915_MAX_PORTS];
130 131 132
	struct intel_vgpu_sbi sbi;
};

133 134 135 136
struct vgpu_sched_ctl {
	int weight;
};

137 138 139 140 141 142 143
enum {
	INTEL_VGPU_EXECLIST_SUBMISSION = 1,
	INTEL_VGPU_GUC_SUBMISSION,
};

struct intel_vgpu_submission_ops {
	const char *name;
144 145 146
	int (*init)(struct intel_vgpu *vgpu, intel_engine_mask_t engine_mask);
	void (*clean)(struct intel_vgpu *vgpu, intel_engine_mask_t engine_mask);
	void (*reset)(struct intel_vgpu *vgpu, intel_engine_mask_t engine_mask);
147 148
};

149 150 151
struct intel_vgpu_submission {
	struct intel_vgpu_execlist execlist[I915_NUM_ENGINES];
	struct list_head workload_q_head[I915_NUM_ENGINES];
152
	struct intel_context *shadow[I915_NUM_ENGINES];
153 154
	struct kmem_cache *workloads;
	atomic_t running_workload_num;
155 156 157 158
	union {
		u64 i915_context_pml4;
		u64 i915_context_pdps[GEN8_3LVL_PDPES];
	};
159
	DECLARE_BITMAP(shadow_ctx_desc_updated, I915_NUM_ENGINES);
160
	DECLARE_BITMAP(tlb_handle_pending, I915_NUM_ENGINES);
161 162
	void *ring_scan_buffer[I915_NUM_ENGINES];
	int ring_scan_buffer_size[I915_NUM_ENGINES];
163 164 165
	const struct intel_vgpu_submission_ops *ops;
	int virtual_submission_interface;
	bool active;
166 167
};

168 169
struct intel_vgpu {
	struct intel_gvt *gvt;
170
	struct mutex vgpu_lock;
171 172
	int id;
	unsigned long handle; /* vGPU handle used by hypervisor MPT modules */
173
	bool active;
174 175
	bool pv_notified;
	bool failsafe;
176
	unsigned int resetting_eng;
177 178 179 180 181

	/* Both sched_data and sched_ctl can be seen a part of the global gvt
	 * scheduler structure. So below 2 vgpu data are protected
	 * by sched_lock, not vgpu_lock.
	 */
182
	void *sched_data;
183
	struct vgpu_sched_ctl sched_ctl;
184 185 186

	struct intel_vgpu_fence fence;
	struct intel_vgpu_gm gm;
187 188
	struct intel_vgpu_cfg_space cfg_space;
	struct intel_vgpu_mmio mmio;
189
	struct intel_vgpu_irq irq;
190
	struct intel_vgpu_gtt gtt;
191
	struct intel_vgpu_opregion opregion;
192
	struct intel_vgpu_display display;
193
	struct intel_vgpu_submission submission;
194
	struct radix_tree_root page_track_tree;
195
	u32 hws_pga[I915_NUM_ENGINES];
J
Jike Song 已提交
196

197 198
	struct dentry *debugfs;

J
Jike Song 已提交
199 200
#if IS_ENABLED(CONFIG_DRM_I915_GVT_KVMGT)
	struct {
201
		struct mdev_device *mdev;
J
Jike Song 已提交
202 203 204 205
		struct vfio_region *region;
		int num_regions;
		struct eventfd_ctx *intx_trigger;
		struct eventfd_ctx *msi_trigger;
206 207 208 209 210 211 212

		/*
		 * Two caches are used to avoid mapping duplicated pages (eg.
		 * scratch pages). This help to reduce dma setup overhead.
		 */
		struct rb_root gfn_cache;
		struct rb_root dma_addr_cache;
213
		unsigned long nr_cache_entries;
J
Jike Song 已提交
214
		struct mutex cache_lock;
215

J
Jike Song 已提交
216
		struct notifier_block iommu_notifier;
217 218 219
		struct notifier_block group_notifier;
		struct kvm *kvm;
		struct work_struct release_work;
220
		atomic_t released;
221
		struct vfio_device *vfio_device;
J
Jike Song 已提交
222 223
	} vdev;
#endif
224 225 226 227 228 229 230

	struct list_head dmabuf_obj_list_head;
	struct mutex dmabuf_lock;
	struct idr object_idr;

	struct completion vblank_done;

231
	u32 scan_nonprivbb;
232 233
};

234 235 236 237
/* validating GM healthy status*/
#define vgpu_is_vm_unhealthy(ret_val) \
	(((ret_val) == -EBADRQC) || ((ret_val) == -EFAULT))

238 239 240 241 242 243 244
struct intel_gvt_gm {
	unsigned long vgpu_allocated_low_gm_size;
	unsigned long vgpu_allocated_high_gm_size;
};

struct intel_gvt_fence {
	unsigned long vgpu_allocated_fence_num;
245 246
};

247 248 249 250 251 252 253 254 255
/* Special MMIO blocks. */
struct gvt_mmio_block {
	unsigned int device;
	i915_reg_t   offset;
	unsigned int size;
	gvt_mmio_func read;
	gvt_mmio_func write;
};

256
#define INTEL_GVT_MMIO_HASH_BITS 11
257 258

struct intel_gvt_mmio {
259
	u8 *mmio_attribute;
260 261 262 263 264 265 266 267 268 269 270 271 272 273
/* Register contains RO bits */
#define F_RO		(1 << 0)
/* Register contains graphics address */
#define F_GMADR		(1 << 1)
/* Mode mask registers with high 16 bits as the mask bits */
#define F_MODE_MASK	(1 << 2)
/* This reg can be accessed by GPU commands */
#define F_CMD_ACCESS	(1 << 3)
/* This reg has been accessed by a VM */
#define F_ACCESSED	(1 << 4)
/* This reg has been accessed through GPU commands */
#define F_CMD_ACCESSED	(1 << 5)
/* This reg could be accessed by unaligned address */
#define F_UNALIGN	(1 << 6)
274 275
/* This reg is saved/restored in context */
#define F_IN_CTX	(1 << 7)
276

277 278 279
	struct gvt_mmio_block *mmio_block;
	unsigned int num_mmio_block;

280
	DECLARE_HASHTABLE(mmio_info_table, INTEL_GVT_MMIO_HASH_BITS);
281
	unsigned long num_tracked_mmio;
282 283
};

284 285 286 287 288 289
struct intel_gvt_firmware {
	void *cfg_space;
	void *mmio;
	bool firmware_loaded;
};

290 291 292 293 294 295 296
#define NR_MAX_INTEL_VGPU_TYPES 20
struct intel_vgpu_type {
	char name[16];
	unsigned int avail_instance;
	unsigned int low_gm_size;
	unsigned int high_gm_size;
	unsigned int fence;
297
	unsigned int weight;
298
	enum intel_vgpu_edid resolution;
299 300
};

301
struct intel_gvt {
302 303 304
	/* GVT scope lock, protect GVT itself, and all resource currently
	 * not yet protected by special locks(vgpu and scheduler lock).
	 */
305
	struct mutex lock;
306 307 308
	/* scheduler scope lock, protect gvt and vgpu schedule related data */
	struct mutex sched_lock;

309 310 311 312
	struct drm_i915_private *dev_priv;
	struct idr vgpu_idr;	/* vGPU IDR pool */

	struct intel_gvt_device_info device_info;
313 314
	struct intel_gvt_gm gm;
	struct intel_gvt_fence fence;
315
	struct intel_gvt_mmio mmio;
316
	struct intel_gvt_firmware firmware;
317
	struct intel_gvt_irq irq;
318
	struct intel_gvt_gtt gtt;
Z
Zhi Wang 已提交
319
	struct intel_gvt_workload_scheduler scheduler;
320
	struct notifier_block shadow_ctx_notifier_block[I915_NUM_ENGINES];
Z
Zhi Wang 已提交
321
	DECLARE_HASHTABLE(cmd_table, GVT_CMD_HASH_BITS);
322 323
	struct intel_vgpu_type *types;
	unsigned int num_types;
P
Ping Gao 已提交
324
	struct intel_vgpu *idle_vgpu;
325 326 327

	struct task_struct *service_thread;
	wait_queue_head_t service_thread_wq;
328 329 330 331

	/* service_request is always used in bit operation, we should always
	 * use it with atomic bit ops so that no need to use gvt big lock.
	 */
332
	unsigned long service_request;
333

334 335 336 337
	struct {
		struct engine_mmio *mmio;
		int ctx_mmio_count[I915_NUM_ENGINES];
	} engine_mmio_list;
338

339
	struct dentry *debugfs_root;
340 341
};

342 343 344 345 346
static inline struct intel_gvt *to_gvt(struct drm_i915_private *i915)
{
	return i915->gvt;
}

347 348
enum {
	INTEL_GVT_REQUEST_EMULATE_VBLANK = 0,
349 350

	/* Scheduling trigger by timer */
351
	INTEL_GVT_REQUEST_SCHED = 1,
352 353 354

	/* Scheduling trigger by event */
	INTEL_GVT_REQUEST_EVENT_SCHED = 2,
355 356 357 358 359 360 361 362 363
};

static inline void intel_gvt_request_service(struct intel_gvt *gvt,
		int service)
{
	set_bit(service, (void *)&gvt->service_request);
	wake_up(&gvt->service_thread_wq);
}

364 365 366
void intel_gvt_free_firmware(struct intel_gvt *gvt);
int intel_gvt_load_firmware(struct intel_gvt *gvt);

367 368 369 370 371 372 373 374
/* Aperture/GM space definitions for GVT device */
#define MB_TO_BYTES(mb) ((mb) << 20ULL)
#define BYTES_TO_MB(b) ((b) >> 20ULL)

#define HOST_LOW_GM_SIZE MB_TO_BYTES(128)
#define HOST_HIGH_GM_SIZE MB_TO_BYTES(384)
#define HOST_FENCE 4

375 376
/* Aperture/GM space definitions for GVT device */
#define gvt_aperture_sz(gvt)	  (gvt->dev_priv->ggtt.mappable_end)
377
#define gvt_aperture_pa_base(gvt) (gvt->dev_priv->ggtt.gmadr.start)
378

379
#define gvt_ggtt_gm_sz(gvt)	  (gvt->dev_priv->ggtt.vm.total)
Z
Zhi Wang 已提交
380
#define gvt_ggtt_sz(gvt) \
381
	((gvt->dev_priv->ggtt.vm.total >> PAGE_SHIFT) << 3)
382 383 384 385 386 387 388 389 390 391 392
#define gvt_hidden_sz(gvt)	  (gvt_ggtt_gm_sz(gvt) - gvt_aperture_sz(gvt))

#define gvt_aperture_gmadr_base(gvt) (0)
#define gvt_aperture_gmadr_end(gvt) (gvt_aperture_gmadr_base(gvt) \
				     + gvt_aperture_sz(gvt) - 1)

#define gvt_hidden_gmadr_base(gvt) (gvt_aperture_gmadr_base(gvt) \
				    + gvt_aperture_sz(gvt))
#define gvt_hidden_gmadr_end(gvt) (gvt_hidden_gmadr_base(gvt) \
				   + gvt_hidden_sz(gvt) - 1)

393
#define gvt_fence_sz(gvt) ((gvt)->dev_priv->ggtt.num_fences)
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424

/* Aperture/GM space definitions for vGPU */
#define vgpu_aperture_offset(vgpu)	((vgpu)->gm.low_gm_node.start)
#define vgpu_hidden_offset(vgpu)	((vgpu)->gm.high_gm_node.start)
#define vgpu_aperture_sz(vgpu)		((vgpu)->gm.aperture_sz)
#define vgpu_hidden_sz(vgpu)		((vgpu)->gm.hidden_sz)

#define vgpu_aperture_pa_base(vgpu) \
	(gvt_aperture_pa_base(vgpu->gvt) + vgpu_aperture_offset(vgpu))

#define vgpu_ggtt_gm_sz(vgpu) ((vgpu)->gm.aperture_sz + (vgpu)->gm.hidden_sz)

#define vgpu_aperture_pa_end(vgpu) \
	(vgpu_aperture_pa_base(vgpu) + vgpu_aperture_sz(vgpu) - 1)

#define vgpu_aperture_gmadr_base(vgpu) (vgpu_aperture_offset(vgpu))
#define vgpu_aperture_gmadr_end(vgpu) \
	(vgpu_aperture_gmadr_base(vgpu) + vgpu_aperture_sz(vgpu) - 1)

#define vgpu_hidden_gmadr_base(vgpu) (vgpu_hidden_offset(vgpu))
#define vgpu_hidden_gmadr_end(vgpu) \
	(vgpu_hidden_gmadr_base(vgpu) + vgpu_hidden_sz(vgpu) - 1)

#define vgpu_fence_base(vgpu) (vgpu->fence.base)
#define vgpu_fence_sz(vgpu) (vgpu->fence.size)

struct intel_vgpu_creation_params {
	__u64 handle;
	__u64 low_gm_sz;  /* in MB */
	__u64 high_gm_sz; /* in MB */
	__u64 fence_sz;
425
	__u64 resolution;
426 427
	__s32 primary;
	__u64 vgpu_id;
428 429

	__u32 weight;
430 431 432 433
};

int intel_vgpu_alloc_resource(struct intel_vgpu *vgpu,
			      struct intel_vgpu_creation_params *param);
434
void intel_vgpu_reset_resource(struct intel_vgpu *vgpu);
435 436 437 438
void intel_vgpu_free_resource(struct intel_vgpu *vgpu);
void intel_vgpu_write_fence(struct intel_vgpu *vgpu,
	u32 fence, u64 value);

439 440 441 442 443 444 445 446 447 448
/* Macros for easily accessing vGPU virtual/shadow register.
   Explicitly seperate use for typed MMIO reg or real offset.*/
#define vgpu_vreg_t(vgpu, reg) \
	(*(u32 *)(vgpu->mmio.vreg + i915_mmio_reg_offset(reg)))
#define vgpu_vreg(vgpu, offset) \
	(*(u32 *)(vgpu->mmio.vreg + (offset)))
#define vgpu_vreg64_t(vgpu, reg) \
	(*(u64 *)(vgpu->mmio.vreg + i915_mmio_reg_offset(reg)))
#define vgpu_vreg64(vgpu, offset) \
	(*(u64 *)(vgpu->mmio.vreg + (offset)))
449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468

#define for_each_active_vgpu(gvt, vgpu, id) \
	idr_for_each_entry((&(gvt)->vgpu_idr), (vgpu), (id)) \
		for_each_if(vgpu->active)

static inline void intel_vgpu_write_pci_bar(struct intel_vgpu *vgpu,
					    u32 offset, u32 val, bool low)
{
	u32 *pval;

	/* BAR offset should be 32 bits algiend */
	offset = rounddown(offset, 4);
	pval = (u32 *)(vgpu_cfg_space(vgpu) + offset);

	if (low) {
		/*
		 * only update bit 31 - bit 4,
		 * leave the bit 3 - bit 0 unchanged.
		 */
		*pval = (val & GENMASK(31, 4)) | (*pval & GENMASK(3, 0));
469 470
	} else {
		*pval = val;
471 472 473
	}
}

474 475
int intel_gvt_init_vgpu_types(struct intel_gvt *gvt);
void intel_gvt_clean_vgpu_types(struct intel_gvt *gvt);
476

P
Ping Gao 已提交
477 478
struct intel_vgpu *intel_gvt_create_idle_vgpu(struct intel_gvt *gvt);
void intel_gvt_destroy_idle_vgpu(struct intel_vgpu *vgpu);
479 480
struct intel_vgpu *intel_gvt_create_vgpu(struct intel_gvt *gvt,
					 struct intel_vgpu_type *type);
481
void intel_gvt_destroy_vgpu(struct intel_vgpu *vgpu);
482
void intel_gvt_release_vgpu(struct intel_vgpu *vgpu);
483
void intel_gvt_reset_vgpu_locked(struct intel_vgpu *vgpu, bool dmlr,
484
				 intel_engine_mask_t engine_mask);
485
void intel_gvt_reset_vgpu(struct intel_vgpu *vgpu);
486 487
void intel_gvt_activate_vgpu(struct intel_vgpu *vgpu);
void intel_gvt_deactivate_vgpu(struct intel_vgpu *vgpu);
488

489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520
/* validating GM functions */
#define vgpu_gmadr_is_aperture(vgpu, gmadr) \
	((gmadr >= vgpu_aperture_gmadr_base(vgpu)) && \
	 (gmadr <= vgpu_aperture_gmadr_end(vgpu)))

#define vgpu_gmadr_is_hidden(vgpu, gmadr) \
	((gmadr >= vgpu_hidden_gmadr_base(vgpu)) && \
	 (gmadr <= vgpu_hidden_gmadr_end(vgpu)))

#define vgpu_gmadr_is_valid(vgpu, gmadr) \
	 ((vgpu_gmadr_is_aperture(vgpu, gmadr) || \
	  (vgpu_gmadr_is_hidden(vgpu, gmadr))))

#define gvt_gmadr_is_aperture(gvt, gmadr) \
	 ((gmadr >= gvt_aperture_gmadr_base(gvt)) && \
	  (gmadr <= gvt_aperture_gmadr_end(gvt)))

#define gvt_gmadr_is_hidden(gvt, gmadr) \
	  ((gmadr >= gvt_hidden_gmadr_base(gvt)) && \
	   (gmadr <= gvt_hidden_gmadr_end(gvt)))

#define gvt_gmadr_is_valid(gvt, gmadr) \
	  (gvt_gmadr_is_aperture(gvt, gmadr) || \
	    gvt_gmadr_is_hidden(gvt, gmadr))

bool intel_gvt_ggtt_validate_range(struct intel_vgpu *vgpu, u64 addr, u32 size);
int intel_gvt_ggtt_gmadr_g2h(struct intel_vgpu *vgpu, u64 g_addr, u64 *h_addr);
int intel_gvt_ggtt_gmadr_h2g(struct intel_vgpu *vgpu, u64 h_addr, u64 *g_addr);
int intel_gvt_ggtt_index_g2h(struct intel_vgpu *vgpu, unsigned long g_index,
			     unsigned long *h_index);
int intel_gvt_ggtt_h2g_index(struct intel_vgpu *vgpu, unsigned long h_index,
			     unsigned long *g_index);
521

522 523
void intel_vgpu_init_cfg_space(struct intel_vgpu *vgpu,
		bool primary);
524 525
void intel_vgpu_reset_cfg_space(struct intel_vgpu *vgpu);

526
int intel_vgpu_emulate_cfg_read(struct intel_vgpu *vgpu, unsigned int offset,
527 528
		void *p_data, unsigned int bytes);

529
int intel_vgpu_emulate_cfg_write(struct intel_vgpu *vgpu, unsigned int offset,
530 531
		void *p_data, unsigned int bytes);

H
Hang Yuan 已提交
532 533
void intel_vgpu_emulate_hotplug(struct intel_vgpu *vgpu, bool connected);

534 535 536 537 538 539 540
static inline u64 intel_vgpu_get_bar_gpa(struct intel_vgpu *vgpu, int bar)
{
	/* We are 64bit bar. */
	return (*(u64 *)(vgpu->cfg_space.virtual_cfg_space + bar)) &
			PCI_BASE_ADDRESS_MEM_MASK;
}

541
void intel_vgpu_clean_opregion(struct intel_vgpu *vgpu);
542 543
int intel_vgpu_init_opregion(struct intel_vgpu *vgpu);
int intel_vgpu_opregion_base_write_handler(struct intel_vgpu *vgpu, u32 gpa);
544 545

int intel_vgpu_emulate_opregion_request(struct intel_vgpu *vgpu, u32 swsci);
546
void populate_pvinfo_page(struct intel_vgpu *vgpu);
547

548
int intel_gvt_scan_and_shadow_workload(struct intel_vgpu_workload *workload);
549
void enter_failsafe_mode(struct intel_vgpu *vgpu, int reason);
550

551 552 553 554 555 556 557 558 559 560 561
struct intel_gvt_ops {
	int (*emulate_cfg_read)(struct intel_vgpu *, unsigned int, void *,
				unsigned int);
	int (*emulate_cfg_write)(struct intel_vgpu *, unsigned int, void *,
				unsigned int);
	int (*emulate_mmio_read)(struct intel_vgpu *, u64, void *,
				unsigned int);
	int (*emulate_mmio_write)(struct intel_vgpu *, u64, void *,
				unsigned int);
	struct intel_vgpu *(*vgpu_create)(struct intel_gvt *,
				struct intel_vgpu_type *);
562 563
	void (*vgpu_destroy)(struct intel_vgpu *vgpu);
	void (*vgpu_release)(struct intel_vgpu *vgpu);
564
	void (*vgpu_reset)(struct intel_vgpu *);
565 566
	void (*vgpu_activate)(struct intel_vgpu *);
	void (*vgpu_deactivate)(struct intel_vgpu *);
567 568 569 570
	struct intel_vgpu_type *(*gvt_find_vgpu_type)(struct intel_gvt *gvt,
			const char *name);
	bool (*get_gvt_attrs)(struct attribute ***type_attrs,
			struct attribute_group ***intel_vgpu_type_groups);
571 572
	int (*vgpu_query_plane)(struct intel_vgpu *vgpu, void *);
	int (*vgpu_get_dmabuf)(struct intel_vgpu *vgpu, unsigned int);
573 574
	int (*write_protect_handler)(struct intel_vgpu *, u64, void *,
				     unsigned int);
H
Hang Yuan 已提交
575
	void (*emulate_hotplug)(struct intel_vgpu *vgpu, bool connected);
576 577 578
};


579 580
enum {
	GVT_FAILSAFE_UNSUPPORTED_GUEST,
581
	GVT_FAILSAFE_INSUFFICIENT_RESOURCE,
582
	GVT_FAILSAFE_GUEST_ERR,
583 584
};

585 586
static inline void mmio_hw_access_pre(struct drm_i915_private *dev_priv)
{
587
	intel_runtime_pm_get(&dev_priv->runtime_pm);
588 589 590 591
}

static inline void mmio_hw_access_post(struct drm_i915_private *dev_priv)
{
592
	intel_runtime_pm_put_unchecked(&dev_priv->runtime_pm);
593 594
}

595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657
/**
 * intel_gvt_mmio_set_accessed - mark a MMIO has been accessed
 * @gvt: a GVT device
 * @offset: register offset
 *
 */
static inline void intel_gvt_mmio_set_accessed(
			struct intel_gvt *gvt, unsigned int offset)
{
	gvt->mmio.mmio_attribute[offset >> 2] |= F_ACCESSED;
}

/**
 * intel_gvt_mmio_is_cmd_accessed - mark a MMIO could be accessed by command
 * @gvt: a GVT device
 * @offset: register offset
 *
 */
static inline bool intel_gvt_mmio_is_cmd_access(
			struct intel_gvt *gvt, unsigned int offset)
{
	return gvt->mmio.mmio_attribute[offset >> 2] & F_CMD_ACCESS;
}

/**
 * intel_gvt_mmio_is_unalign - mark a MMIO could be accessed unaligned
 * @gvt: a GVT device
 * @offset: register offset
 *
 */
static inline bool intel_gvt_mmio_is_unalign(
			struct intel_gvt *gvt, unsigned int offset)
{
	return gvt->mmio.mmio_attribute[offset >> 2] & F_UNALIGN;
}

/**
 * intel_gvt_mmio_set_cmd_accessed - mark a MMIO has been accessed by command
 * @gvt: a GVT device
 * @offset: register offset
 *
 */
static inline void intel_gvt_mmio_set_cmd_accessed(
			struct intel_gvt *gvt, unsigned int offset)
{
	gvt->mmio.mmio_attribute[offset >> 2] |= F_CMD_ACCESSED;
}

/**
 * intel_gvt_mmio_has_mode_mask - if a MMIO has a mode mask
 * @gvt: a GVT device
 * @offset: register offset
 *
 * Returns:
 * True if a MMIO has a mode mask in its higher 16 bits, false if it isn't.
 *
 */
static inline bool intel_gvt_mmio_has_mode_mask(
			struct intel_gvt *gvt, unsigned int offset)
{
	return gvt->mmio.mmio_attribute[offset >> 2] & F_MODE_MASK;
}

658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
/**
 * intel_gvt_mmio_is_in_ctx - check if a MMIO has in-ctx mask
 * @gvt: a GVT device
 * @offset: register offset
 *
 * Returns:
 * True if a MMIO has a in-context mask, false if it isn't.
 *
 */
static inline bool intel_gvt_mmio_is_in_ctx(
			struct intel_gvt *gvt, unsigned int offset)
{
	return gvt->mmio.mmio_attribute[offset >> 2] & F_IN_CTX;
}

/**
 * intel_gvt_mmio_set_in_ctx - mask a MMIO in logical context
 * @gvt: a GVT device
 * @offset: register offset
 *
 */
static inline void intel_gvt_mmio_set_in_ctx(
			struct intel_gvt *gvt, unsigned int offset)
{
	gvt->mmio.mmio_attribute[offset >> 2] |= F_IN_CTX;
}

685
void intel_gvt_debugfs_add_vgpu(struct intel_vgpu *vgpu);
686
void intel_gvt_debugfs_remove_vgpu(struct intel_vgpu *vgpu);
687
void intel_gvt_debugfs_init(struct intel_gvt *gvt);
688 689 690
void intel_gvt_debugfs_clean(struct intel_gvt *gvt);


691
#include "trace.h"
692 693 694
#include "mpt.h"

#endif