amdgpu_amdkfd.c 13.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * Copyright 2014 Advanced Micro Devices, Inc.
 *
 * 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 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 COPYRIGHT HOLDER(S) OR AUTHOR(S) 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.
 */

#include "amdgpu_amdkfd.h"
24
#include "amd_shared.h"
25 26
#include <drm/drmP.h>
#include "amdgpu.h"
27
#include "amdgpu_gfx.h"
28 29 30
#include <linux/module.h>

const struct kgd2kfd_calls *kgd2kfd;
31
bool (*kgd2kfd_init_p)(unsigned int, const struct kgd2kfd_calls**);
32

33 34
static const unsigned int compute_vmid_bitmap = 0xFF00;

35
int amdgpu_amdkfd_init(void)
36
{
37 38
	int ret;

39
#if defined(CONFIG_HSA_AMD_MODULE)
40
	int (*kgd2kfd_init_p)(unsigned int, const struct kgd2kfd_calls**);
41 42 43 44

	kgd2kfd_init_p = symbol_request(kgd2kfd_init);

	if (kgd2kfd_init_p == NULL)
45 46 47 48 49 50 51 52
		return -ENOENT;

	ret = kgd2kfd_init_p(KFD_INTERFACE_VERSION, &kgd2kfd);
	if (ret) {
		symbol_put(kgd2kfd_init);
		kgd2kfd = NULL;
	}

53

54
#elif defined(CONFIG_HSA_AMD)
55

56 57 58 59 60
	ret = kgd2kfd_init(KFD_INTERFACE_VERSION, &kgd2kfd);
	if (ret)
		kgd2kfd = NULL;

#else
61
	kgd2kfd = NULL;
62
	ret = -ENOENT;
63
#endif
64 65

#if defined(CONFIG_HSA_AMD_MODULE) || defined(CONFIG_HSA_AMD)
66
	amdgpu_amdkfd_gpuvm_init_mem_limits();
67
#endif
68 69

	return ret;
70 71
}

72 73 74 75 76 77 78 79 80
void amdgpu_amdkfd_fini(void)
{
	if (kgd2kfd) {
		kgd2kfd->exit();
		symbol_put(kgd2kfd_init);
	}
}

void amdgpu_amdkfd_device_probe(struct amdgpu_device *adev)
81
{
82 83 84 85 86
	const struct kfd2kgd_calls *kfd2kgd;

	if (!kgd2kfd)
		return;

87
	switch (adev->asic_type) {
88
#ifdef CONFIG_DRM_AMDGPU_CIK
89
	case CHIP_KAVERI:
90
	case CHIP_HAWAII:
91 92
		kfd2kgd = amdgpu_amdkfd_gfx_7_get_functions();
		break;
93
#endif
94
	case CHIP_CARRIZO:
95 96 97 98
	case CHIP_TONGA:
	case CHIP_FIJI:
	case CHIP_POLARIS10:
	case CHIP_POLARIS11:
99 100
		kfd2kgd = amdgpu_amdkfd_gfx_8_0_get_functions();
		break;
101 102 103 104
	case CHIP_VEGA10:
	case CHIP_RAVEN:
		kfd2kgd = amdgpu_amdkfd_gfx_9_0_get_functions();
		break;
105
	default:
106
		dev_info(adev->dev, "kfd not supported on this ASIC\n");
107
		return;
108 109
	}

110 111
	adev->kfd = kgd2kfd->probe((struct kgd_dev *)adev,
				   adev->pdev, kfd2kgd);
112 113
}

114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
/**
 * amdgpu_doorbell_get_kfd_info - Report doorbell configuration required to
 *                                setup amdkfd
 *
 * @adev: amdgpu_device pointer
 * @aperture_base: output returning doorbell aperture base physical address
 * @aperture_size: output returning doorbell aperture size in bytes
 * @start_offset: output returning # of doorbell bytes reserved for amdgpu.
 *
 * amdgpu and amdkfd share the doorbell aperture. amdgpu sets it up,
 * takes doorbells required for its own rings and reports the setup to amdkfd.
 * amdgpu reserved doorbells are at the start of the doorbell aperture.
 */
static void amdgpu_doorbell_get_kfd_info(struct amdgpu_device *adev,
					 phys_addr_t *aperture_base,
					 size_t *aperture_size,
					 size_t *start_offset)
{
	/*
	 * The first num_doorbells are used by amdgpu.
	 * amdkfd takes whatever's left in the aperture.
	 */
	if (adev->doorbell.size > adev->doorbell.num_doorbells * sizeof(u32)) {
		*aperture_base = adev->doorbell.base;
		*aperture_size = adev->doorbell.size;
		*start_offset = adev->doorbell.num_doorbells * sizeof(u32);
	} else {
		*aperture_base = 0;
		*aperture_size = 0;
		*start_offset = 0;
	}
}

147
void amdgpu_amdkfd_device_init(struct amdgpu_device *adev)
148
{
149 150
	int i;
	int last_valid_bit;
151
	if (adev->kfd) {
152
		struct kgd2kfd_shared_resources gpu_resources = {
153
			.compute_vmid_bitmap = compute_vmid_bitmap,
154
			.num_pipe_per_mec = adev->gfx.mec.num_pipe_per_mec,
155 156 157 158 159
			.num_queue_per_pipe = adev->gfx.mec.num_queue_per_pipe,
			.gpuvm_size = min(adev->vm_manager.max_pfn
					  << AMDGPU_GPU_PAGE_SHIFT,
					  AMDGPU_VA_HOLE_START),
			.drm_render_minor = adev->ddev->render->index
160 161
		};

162 163 164 165 166 167
		/* this is going to have a few of the MSBs set that we need to
		 * clear */
		bitmap_complement(gpu_resources.queue_bitmap,
				  adev->gfx.mec.queue_bitmap,
				  KGD_MAX_QUEUES);

168 169
		/* remove the KIQ bit as well */
		if (adev->gfx.kiq.ring.ready)
170 171 172 173
			clear_bit(amdgpu_gfx_queue_to_bit(adev,
							  adev->gfx.kiq.ring.me - 1,
							  adev->gfx.kiq.ring.pipe,
							  adev->gfx.kiq.ring.queue),
174 175
				  gpu_resources.queue_bitmap);

176 177
		/* According to linux/bitmap.h we shouldn't use bitmap_clear if
		 * nbits is not compile time constant */
178
		last_valid_bit = 1 /* only first MEC can have compute queues */
179 180 181 182 183
				* adev->gfx.mec.num_pipe_per_mec
				* adev->gfx.mec.num_queue_per_pipe;
		for (i = last_valid_bit; i < KGD_MAX_QUEUES; ++i)
			clear_bit(i, gpu_resources.queue_bitmap);

184
		amdgpu_doorbell_get_kfd_info(adev,
185 186 187
				&gpu_resources.doorbell_physical_address,
				&gpu_resources.doorbell_aperture_size,
				&gpu_resources.doorbell_start_offset);
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
		if (adev->asic_type >= CHIP_VEGA10) {
			/* On SOC15 the BIF is involved in routing
			 * doorbells using the low 12 bits of the
			 * address. Communicate the assignments to
			 * KFD. KFD uses two doorbell pages per
			 * process in case of 64-bit doorbells so we
			 * can use each doorbell assignment twice.
			 */
			gpu_resources.sdma_doorbell[0][0] =
				AMDGPU_DOORBELL64_sDMA_ENGINE0;
			gpu_resources.sdma_doorbell[0][1] =
				AMDGPU_DOORBELL64_sDMA_ENGINE0 + 0x200;
			gpu_resources.sdma_doorbell[1][0] =
				AMDGPU_DOORBELL64_sDMA_ENGINE1;
			gpu_resources.sdma_doorbell[1][1] =
				AMDGPU_DOORBELL64_sDMA_ENGINE1 + 0x200;
			/* Doorbells 0x0f0-0ff and 0x2f0-2ff are reserved for
			 * SDMA, IH and VCN. So don't use them for the CP.
			 */
			gpu_resources.reserved_doorbell_mask = 0x1f0;
			gpu_resources.reserved_doorbell_val  = 0x0f0;
		}
210

211
		kgd2kfd->device_init(adev->kfd, &gpu_resources);
212 213 214
	}
}

215
void amdgpu_amdkfd_device_fini(struct amdgpu_device *adev)
216
{
217 218 219
	if (adev->kfd) {
		kgd2kfd->device_exit(adev->kfd);
		adev->kfd = NULL;
220 221 222
	}
}

223
void amdgpu_amdkfd_interrupt(struct amdgpu_device *adev,
224 225
		const void *ih_ring_entry)
{
226 227
	if (adev->kfd)
		kgd2kfd->interrupt(adev->kfd, ih_ring_entry);
228 229
}

230
void amdgpu_amdkfd_suspend(struct amdgpu_device *adev)
231
{
232 233
	if (adev->kfd)
		kgd2kfd->suspend(adev->kfd);
234 235
}

236
int amdgpu_amdkfd_resume(struct amdgpu_device *adev)
237 238 239
{
	int r = 0;

240 241
	if (adev->kfd)
		r = kgd2kfd->resume(adev->kfd);
242 243 244 245 246 247 248 249

	return r;
}

int alloc_gtt_mem(struct kgd_dev *kgd, size_t size,
			void **mem_obj, uint64_t *gpu_addr,
			void **cpu_ptr)
{
250
	struct amdgpu_device *adev = (struct amdgpu_device *)kgd;
251
	struct amdgpu_bo *bo = NULL;
252
	struct amdgpu_bo_param bp;
253
	int r;
254 255
	uint64_t gpu_addr_tmp = 0;
	void *cpu_ptr_tmp = NULL;
256

257 258 259 260 261 262 263 264
	memset(&bp, 0, sizeof(bp));
	bp.size = size;
	bp.byte_align = PAGE_SIZE;
	bp.domain = AMDGPU_GEM_DOMAIN_GTT;
	bp.flags = AMDGPU_GEM_CREATE_CPU_GTT_USWC;
	bp.type = ttm_bo_type_kernel;
	bp.resv = NULL;
	r = amdgpu_bo_create(adev, &bp, &bo);
265
	if (r) {
266
		dev_err(adev->dev,
267 268 269 270 271
			"failed to allocate BO for amdkfd (%d)\n", r);
		return r;
	}

	/* map the buffer */
272
	r = amdgpu_bo_reserve(bo, true);
273
	if (r) {
274
		dev_err(adev->dev, "(%d) failed to reserve bo for amdkfd\n", r);
275 276 277
		goto allocate_mem_reserve_bo_failed;
	}

278 279
	r = amdgpu_bo_pin(bo, AMDGPU_GEM_DOMAIN_GTT,
				&gpu_addr_tmp);
280
	if (r) {
281
		dev_err(adev->dev, "(%d) failed to pin bo for amdkfd\n", r);
282 283 284
		goto allocate_mem_pin_bo_failed;
	}

285
	r = amdgpu_bo_kmap(bo, &cpu_ptr_tmp);
286
	if (r) {
287
		dev_err(adev->dev,
288 289 290 291
			"(%d) failed to map bo to kernel for amdkfd\n", r);
		goto allocate_mem_kmap_bo_failed;
	}

292 293 294 295 296
	*mem_obj = bo;
	*gpu_addr = gpu_addr_tmp;
	*cpu_ptr = cpu_ptr_tmp;

	amdgpu_bo_unreserve(bo);
297 298 299 300

	return 0;

allocate_mem_kmap_bo_failed:
301
	amdgpu_bo_unpin(bo);
302
allocate_mem_pin_bo_failed:
303
	amdgpu_bo_unreserve(bo);
304
allocate_mem_reserve_bo_failed:
305
	amdgpu_bo_unref(&bo);
306 307 308 309 310 311

	return r;
}

void free_gtt_mem(struct kgd_dev *kgd, void *mem_obj)
{
312 313 314 315 316 317 318
	struct amdgpu_bo *bo = (struct amdgpu_bo *) mem_obj;

	amdgpu_bo_reserve(bo, true);
	amdgpu_bo_kunmap(bo);
	amdgpu_bo_unpin(bo);
	amdgpu_bo_unreserve(bo);
	amdgpu_bo_unref(&(bo));
319 320
}

321 322 323 324 325 326
void get_local_mem_info(struct kgd_dev *kgd,
			struct kfd_local_mem_info *mem_info)
{
	struct amdgpu_device *adev = (struct amdgpu_device *)kgd;
	uint64_t address_mask = adev->dev->dma_mask ? ~*adev->dev->dma_mask :
					     ~((1ULL << 32) - 1);
327
	resource_size_t aper_limit = adev->gmc.aper_base + adev->gmc.aper_size;
328 329

	memset(mem_info, 0, sizeof(*mem_info));
330 331 332 333
	if (!(adev->gmc.aper_base & address_mask || aper_limit & address_mask)) {
		mem_info->local_mem_size_public = adev->gmc.visible_vram_size;
		mem_info->local_mem_size_private = adev->gmc.real_vram_size -
				adev->gmc.visible_vram_size;
334 335
	} else {
		mem_info->local_mem_size_public = 0;
336
		mem_info->local_mem_size_private = adev->gmc.real_vram_size;
337
	}
338
	mem_info->vram_width = adev->gmc.vram_width;
339

340
	pr_debug("Address base: %pap limit %pap public 0x%llx private 0x%llx\n",
341
			&adev->gmc.aper_base, &aper_limit,
342 343 344 345 346
			mem_info->local_mem_size_public,
			mem_info->local_mem_size_private);

	if (amdgpu_sriov_vf(adev))
		mem_info->mem_clk_max = adev->clock.default_mclk / 100;
347
	else if (adev->powerplay.pp_funcs)
348
		mem_info->mem_clk_max = amdgpu_dpm_get_mclk(adev, false) / 100;
349 350
	else
		mem_info->mem_clk_max = 100;
351 352
}

353 354
uint64_t get_gpu_clock_counter(struct kgd_dev *kgd)
{
355
	struct amdgpu_device *adev = (struct amdgpu_device *)kgd;
356

357 358
	if (adev->gfx.funcs->get_gpu_clock_counter)
		return adev->gfx.funcs->get_gpu_clock_counter(adev);
359 360 361 362 363
	return 0;
}

uint32_t get_max_engine_clock_in_mhz(struct kgd_dev *kgd)
{
364
	struct amdgpu_device *adev = (struct amdgpu_device *)kgd;
365

366 367 368
	/* the sclk is in quantas of 10kHz */
	if (amdgpu_sriov_vf(adev))
		return adev->clock.default_sclk / 100;
369 370 371 372
	else if (adev->powerplay.pp_funcs)
		return amdgpu_dpm_get_sclk(adev, false) / 100;
	else
		return 100;
373
}
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396

void get_cu_info(struct kgd_dev *kgd, struct kfd_cu_info *cu_info)
{
	struct amdgpu_device *adev = (struct amdgpu_device *)kgd;
	struct amdgpu_cu_info acu_info = adev->gfx.cu_info;

	memset(cu_info, 0, sizeof(*cu_info));
	if (sizeof(cu_info->cu_bitmap) != sizeof(acu_info.bitmap))
		return;

	cu_info->cu_active_number = acu_info.number;
	cu_info->cu_ao_mask = acu_info.ao_cu_mask;
	memcpy(&cu_info->cu_bitmap[0], &acu_info.bitmap[0],
	       sizeof(acu_info.bitmap));
	cu_info->num_shader_engines = adev->gfx.config.max_shader_engines;
	cu_info->num_shader_arrays_per_engine = adev->gfx.config.max_sh_per_se;
	cu_info->num_cu_per_sh = adev->gfx.config.max_cu_per_sh;
	cu_info->simd_per_cu = acu_info.simd_per_cu;
	cu_info->max_waves_per_simd = acu_info.max_waves_per_simd;
	cu_info->wave_front_size = acu_info.wave_front_size;
	cu_info->max_scratch_slots_per_cu = acu_info.max_scratch_slots_per_cu;
	cu_info->lds_size = acu_info.lds_size;
}
397 398 399 400 401 402 403

uint64_t amdgpu_amdkfd_get_vram_usage(struct kgd_dev *kgd)
{
	struct amdgpu_device *adev = (struct amdgpu_device *)kgd;

	return amdgpu_vram_mgr_usage(&adev->mman.bdev.man[TTM_PL_VRAM]);
}
404

405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
int amdgpu_amdkfd_submit_ib(struct kgd_dev *kgd, enum kgd_engine_type engine,
				uint32_t vmid, uint64_t gpu_addr,
				uint32_t *ib_cmd, uint32_t ib_len)
{
	struct amdgpu_device *adev = (struct amdgpu_device *)kgd;
	struct amdgpu_job *job;
	struct amdgpu_ib *ib;
	struct amdgpu_ring *ring;
	struct dma_fence *f = NULL;
	int ret;

	switch (engine) {
	case KGD_ENGINE_MEC1:
		ring = &adev->gfx.compute_ring[0];
		break;
	case KGD_ENGINE_SDMA1:
		ring = &adev->sdma.instance[0].ring;
		break;
	case KGD_ENGINE_SDMA2:
		ring = &adev->sdma.instance[1].ring;
		break;
	default:
		pr_err("Invalid engine in IB submission: %d\n", engine);
		ret = -EINVAL;
		goto err;
	}

	ret = amdgpu_job_alloc(adev, 1, &job, NULL);
	if (ret)
		goto err;

	ib = &job->ibs[0];
	memset(ib, 0, sizeof(struct amdgpu_ib));

	ib->gpu_addr = gpu_addr;
	ib->ptr = ib_cmd;
	ib->length_dw = ib_len;
	/* This works for NO_HWS. TODO: need to handle without knowing VMID */
	job->vmid = vmid;

	ret = amdgpu_ib_schedule(ring, 1, ib, job, &f);
	if (ret) {
		DRM_ERROR("amdgpu: failed to schedule IB.\n");
		goto err_ib_sched;
	}

	ret = dma_fence_wait(f, false);

err_ib_sched:
	dma_fence_put(f);
	amdgpu_job_free(job);
err:
	return ret;
}

460 461 462 463 464 465 466 467 468
bool amdgpu_amdkfd_is_kfd_vmid(struct amdgpu_device *adev, u32 vmid)
{
	if (adev->kfd) {
		if ((1 << vmid) & compute_vmid_bitmap)
			return true;
	}

	return false;
}
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509

#if !defined(CONFIG_HSA_AMD_MODULE) && !defined(CONFIG_HSA_AMD)
bool amdkfd_fence_check_mm(struct dma_fence *f, struct mm_struct *mm)
{
	return false;
}

void amdgpu_amdkfd_unreserve_system_memory_limit(struct amdgpu_bo *bo)
{
}

void amdgpu_amdkfd_gpuvm_destroy_cb(struct amdgpu_device *adev,
					struct amdgpu_vm *vm)
{
}

struct amdgpu_amdkfd_fence *to_amdgpu_amdkfd_fence(struct dma_fence *f)
{
	return NULL;
}

int amdgpu_amdkfd_evict_userptr(struct kgd_mem *mem, struct mm_struct *mm)
{
	return 0;
}

struct kfd2kgd_calls *amdgpu_amdkfd_gfx_7_get_functions(void)
{
	return NULL;
}

struct kfd2kgd_calls *amdgpu_amdkfd_gfx_8_0_get_functions(void)
{
	return NULL;
}

struct kfd2kgd_calls *amdgpu_amdkfd_gfx_9_0_get_functions(void)
{
	return NULL;
}
#endif