2 * Copyright 2016 Advanced Micro Devices, Inc.
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:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
25 #define MAX_KIQ_REG_WAIT 100000000 /* in usecs */
27 int amdgpu_allocate_static_csa(struct amdgpu_device
*adev
)
32 r
= amdgpu_bo_create_kernel(adev
, AMDGPU_CSA_SIZE
, PAGE_SIZE
,
33 AMDGPU_GEM_DOMAIN_VRAM
, &adev
->virt
.csa_obj
,
34 &adev
->virt
.csa_vmid0_addr
, &ptr
);
38 memset(ptr
, 0, AMDGPU_CSA_SIZE
);
43 * amdgpu_map_static_csa should be called during amdgpu_vm_init
44 * it maps virtual address "AMDGPU_VA_RESERVED_SIZE - AMDGPU_CSA_SIZE"
45 * to this VM, and each command submission of GFX should use this virtual
46 * address within META_DATA init package to support SRIOV gfx preemption.
49 int amdgpu_map_static_csa(struct amdgpu_device
*adev
, struct amdgpu_vm
*vm
,
50 struct amdgpu_bo_va
**bo_va
)
52 struct ww_acquire_ctx ticket
;
53 struct list_head list
;
54 struct amdgpu_bo_list_entry pd
;
55 struct ttm_validate_buffer csa_tv
;
58 INIT_LIST_HEAD(&list
);
59 INIT_LIST_HEAD(&csa_tv
.head
);
60 csa_tv
.bo
= &adev
->virt
.csa_obj
->tbo
;
63 list_add(&csa_tv
.head
, &list
);
64 amdgpu_vm_get_pd_bo(vm
, &list
, &pd
);
66 r
= ttm_eu_reserve_buffers(&ticket
, &list
, true, NULL
);
68 DRM_ERROR("failed to reserve CSA,PD BOs: err=%d\n", r
);
72 *bo_va
= amdgpu_vm_bo_add(adev
, vm
, adev
->virt
.csa_obj
);
74 ttm_eu_backoff_reservation(&ticket
, &list
);
75 DRM_ERROR("failed to create bo_va for static CSA\n");
79 r
= amdgpu_vm_alloc_pts(adev
, (*bo_va
)->base
.vm
, AMDGPU_CSA_VADDR
,
82 DRM_ERROR("failed to allocate pts for static CSA, err=%d\n", r
);
83 amdgpu_vm_bo_rmv(adev
, *bo_va
);
84 ttm_eu_backoff_reservation(&ticket
, &list
);
88 r
= amdgpu_vm_bo_map(adev
, *bo_va
, AMDGPU_CSA_VADDR
, 0, AMDGPU_CSA_SIZE
,
89 AMDGPU_PTE_READABLE
| AMDGPU_PTE_WRITEABLE
|
90 AMDGPU_PTE_EXECUTABLE
);
93 DRM_ERROR("failed to do bo_map on static CSA, err=%d\n", r
);
94 amdgpu_vm_bo_rmv(adev
, *bo_va
);
95 ttm_eu_backoff_reservation(&ticket
, &list
);
99 ttm_eu_backoff_reservation(&ticket
, &list
);
103 void amdgpu_virt_init_setting(struct amdgpu_device
*adev
)
105 /* enable virtual display */
106 adev
->mode_info
.num_crtc
= 1;
107 adev
->enable_virtual_display
= true;
111 mutex_init(&adev
->virt
.lock_reset
);
114 uint32_t amdgpu_virt_kiq_rreg(struct amdgpu_device
*adev
, uint32_t reg
)
118 struct amdgpu_kiq
*kiq
= &adev
->gfx
.kiq
;
119 struct amdgpu_ring
*ring
= &kiq
->ring
;
121 BUG_ON(!ring
->funcs
->emit_rreg
);
123 spin_lock(&kiq
->ring_lock
);
124 amdgpu_ring_alloc(ring
, 32);
125 amdgpu_ring_emit_rreg(ring
, reg
);
126 amdgpu_fence_emit_polling(ring
, &seq
);
127 amdgpu_ring_commit(ring
);
128 spin_unlock(&kiq
->ring_lock
);
130 r
= amdgpu_fence_wait_polling(ring
, seq
, MAX_KIQ_REG_WAIT
);
132 DRM_ERROR("wait for kiq fence error: %ld\n", r
);
135 val
= adev
->wb
.wb
[adev
->virt
.reg_val_offs
];
140 void amdgpu_virt_kiq_wreg(struct amdgpu_device
*adev
, uint32_t reg
, uint32_t v
)
144 struct amdgpu_kiq
*kiq
= &adev
->gfx
.kiq
;
145 struct amdgpu_ring
*ring
= &kiq
->ring
;
147 BUG_ON(!ring
->funcs
->emit_wreg
);
149 spin_lock(&kiq
->ring_lock
);
150 amdgpu_ring_alloc(ring
, 32);
151 amdgpu_ring_emit_wreg(ring
, reg
, v
);
152 amdgpu_fence_emit_polling(ring
, &seq
);
153 amdgpu_ring_commit(ring
);
154 spin_unlock(&kiq
->ring_lock
);
156 r
= amdgpu_fence_wait_polling(ring
, seq
, MAX_KIQ_REG_WAIT
);
158 DRM_ERROR("wait for kiq fence error: %ld\n", r
);
162 * amdgpu_virt_request_full_gpu() - request full gpu access
163 * @amdgpu: amdgpu device.
164 * @init: is driver init time.
165 * When start to init/fini driver, first need to request full gpu access.
166 * Return: Zero if request success, otherwise will return error.
168 int amdgpu_virt_request_full_gpu(struct amdgpu_device
*adev
, bool init
)
170 struct amdgpu_virt
*virt
= &adev
->virt
;
173 if (virt
->ops
&& virt
->ops
->req_full_gpu
) {
174 r
= virt
->ops
->req_full_gpu(adev
, init
);
178 adev
->virt
.caps
&= ~AMDGPU_SRIOV_CAPS_RUNTIME
;
185 * amdgpu_virt_release_full_gpu() - release full gpu access
186 * @amdgpu: amdgpu device.
187 * @init: is driver init time.
188 * When finishing driver init/fini, need to release full gpu access.
189 * Return: Zero if release success, otherwise will returen error.
191 int amdgpu_virt_release_full_gpu(struct amdgpu_device
*adev
, bool init
)
193 struct amdgpu_virt
*virt
= &adev
->virt
;
196 if (virt
->ops
&& virt
->ops
->rel_full_gpu
) {
197 r
= virt
->ops
->rel_full_gpu(adev
, init
);
201 adev
->virt
.caps
|= AMDGPU_SRIOV_CAPS_RUNTIME
;
207 * amdgpu_virt_reset_gpu() - reset gpu
208 * @amdgpu: amdgpu device.
209 * Send reset command to GPU hypervisor to reset GPU that VM is using
210 * Return: Zero if reset success, otherwise will return error.
212 int amdgpu_virt_reset_gpu(struct amdgpu_device
*adev
)
214 struct amdgpu_virt
*virt
= &adev
->virt
;
217 if (virt
->ops
&& virt
->ops
->reset_gpu
) {
218 r
= virt
->ops
->reset_gpu(adev
);
222 adev
->virt
.caps
&= ~AMDGPU_SRIOV_CAPS_RUNTIME
;
229 * amdgpu_virt_alloc_mm_table() - alloc memory for mm table
230 * @amdgpu: amdgpu device.
231 * MM table is used by UVD and VCE for its initialization
232 * Return: Zero if allocate success.
234 int amdgpu_virt_alloc_mm_table(struct amdgpu_device
*adev
)
238 if (!amdgpu_sriov_vf(adev
) || adev
->virt
.mm_table
.gpu_addr
)
241 r
= amdgpu_bo_create_kernel(adev
, PAGE_SIZE
, PAGE_SIZE
,
242 AMDGPU_GEM_DOMAIN_VRAM
,
243 &adev
->virt
.mm_table
.bo
,
244 &adev
->virt
.mm_table
.gpu_addr
,
245 (void *)&adev
->virt
.mm_table
.cpu_addr
);
247 DRM_ERROR("failed to alloc mm table and error = %d.\n", r
);
251 memset((void *)adev
->virt
.mm_table
.cpu_addr
, 0, PAGE_SIZE
);
252 DRM_INFO("MM table gpu addr = 0x%llx, cpu addr = %p.\n",
253 adev
->virt
.mm_table
.gpu_addr
,
254 adev
->virt
.mm_table
.cpu_addr
);
259 * amdgpu_virt_free_mm_table() - free mm table memory
260 * @amdgpu: amdgpu device.
261 * Free MM table memory
263 void amdgpu_virt_free_mm_table(struct amdgpu_device
*adev
)
265 if (!amdgpu_sriov_vf(adev
) || !adev
->virt
.mm_table
.gpu_addr
)
268 amdgpu_bo_free_kernel(&adev
->virt
.mm_table
.bo
,
269 &adev
->virt
.mm_table
.gpu_addr
,
270 (void *)&adev
->virt
.mm_table
.cpu_addr
);
271 adev
->virt
.mm_table
.gpu_addr
= 0;
275 int amdgpu_virt_fw_reserve_get_checksum(void *obj
,
276 unsigned long obj_size
,
280 unsigned int ret
= key
;
285 /* calculate checksum */
286 for (i
= 0; i
< obj_size
; ++i
)
288 /* minus the chksum itself */
289 pos
= (char *)&chksum
;
290 for (i
= 0; i
< sizeof(chksum
); ++i
)
295 void amdgpu_virt_init_data_exchange(struct amdgpu_device
*adev
)
297 uint32_t pf2vf_ver
= 0;
298 uint32_t pf2vf_size
= 0;
299 uint32_t checksum
= 0;
303 adev
->virt
.fw_reserve
.p_pf2vf
= NULL
;
304 adev
->virt
.fw_reserve
.p_vf2pf
= NULL
;
306 if (adev
->fw_vram_usage
.va
!= NULL
) {
307 adev
->virt
.fw_reserve
.p_pf2vf
=
308 (struct amdgim_pf2vf_info_header
*)(
309 adev
->fw_vram_usage
.va
+ AMDGIM_DATAEXCHANGE_OFFSET
);
310 pf2vf_ver
= adev
->virt
.fw_reserve
.p_pf2vf
->version
;
311 AMDGPU_FW_VRAM_PF2VF_READ(adev
, header
.size
, &pf2vf_size
);
312 AMDGPU_FW_VRAM_PF2VF_READ(adev
, checksum
, &checksum
);
314 /* pf2vf message must be in 4K */
315 if (pf2vf_size
> 0 && pf2vf_size
< 4096) {
316 checkval
= amdgpu_virt_fw_reserve_get_checksum(
317 adev
->virt
.fw_reserve
.p_pf2vf
, pf2vf_size
,
318 adev
->virt
.fw_reserve
.checksum_key
, checksum
);
319 if (checkval
== checksum
) {
320 adev
->virt
.fw_reserve
.p_vf2pf
=
321 ((void *)adev
->virt
.fw_reserve
.p_pf2vf
+
323 memset((void *)adev
->virt
.fw_reserve
.p_vf2pf
, 0,
324 sizeof(amdgim_vf2pf_info
));
325 AMDGPU_FW_VRAM_VF2PF_WRITE(adev
, header
.version
,
326 AMDGPU_FW_VRAM_VF2PF_VER
);
327 AMDGPU_FW_VRAM_VF2PF_WRITE(adev
, header
.size
,
328 sizeof(amdgim_vf2pf_info
));
329 AMDGPU_FW_VRAM_VF2PF_READ(adev
, driver_version
,
331 if (THIS_MODULE
->version
!= NULL
)
332 strcpy(str
, THIS_MODULE
->version
);
335 AMDGPU_FW_VRAM_VF2PF_WRITE(adev
, driver_cert
,
337 AMDGPU_FW_VRAM_VF2PF_WRITE(adev
, checksum
,
338 amdgpu_virt_fw_reserve_get_checksum(
339 adev
->virt
.fw_reserve
.p_vf2pf
,
341 adev
->virt
.fw_reserve
.checksum_key
, 0));