mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-09-27 21:03:32 +00:00
Code Issues Releases Wiki Activity

drm/xe: Add a helper for DRM device-lifetime BO create

Browse source 
A helper for managed BO allocations makes it possible to remove specific
"fini" actions and will simplify the following patches adding ability to
execute a release action for specific BO directly.

Signed-off-by: Michał Winiarski <michal.winiarski@intel.com>
Reviewed-by: Matthew Brost <matthew.brost@intel.com>
Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>
This commit is contained in:
Michał Winiarski 2023-12-05 02:33:04 +01:00 committed by Rodrigo Vivi
parent 791d0362a9
commit 0e1a47fcab
10 changed files with 63 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
drivers/gpu/drm/xe/xe_bo.c
View file

@ -9,6 +9,7 @@
#include <drm/drm_drv.h>
#include <drm/drm_gem_ttm_helper.h>
#include <drm/drm_managed.h>
#include <drm/ttm/ttm_device.h>
#include <drm/ttm/ttm_placement.h>
#include <drm/ttm/ttm_tt.h>
@ -1540,6 +1541,41 @@ struct xe_bo *xe_bo_create_from_data(struct xe_device *xe, struct xe_tile *tile,
return bo;
}
static void __xe_bo_unpin_map_no_vm(struct drm_device *drm, void *arg)
{
xe_bo_unpin_map_no_vm(arg);
}
struct xe_bo *xe_managed_bo_create_pin_map(struct xe_device *xe, struct xe_tile *tile,
size_t size, u32 flags)
{
struct xe_bo *bo;
int ret;
bo = xe_bo_create_pin_map(xe, tile, NULL, size, ttm_bo_type_kernel, flags);
if (IS_ERR(bo))
return bo;
ret = drmm_add_action_or_reset(&xe->drm, __xe_bo_unpin_map_no_vm, bo);
if (ret)
return ERR_PTR(ret);
return bo;
}
struct xe_bo *xe_managed_bo_create_from_data(struct xe_device *xe, struct xe_tile *tile,
const void *data, size_t size, u32 flags)
{
struct xe_bo *bo = xe_managed_bo_create_pin_map(xe, tile, size, flags);
if (IS_ERR(bo))
return bo;
xe_map_memcpy_to(xe, &bo->vmap, 0, data, size);
return bo;
}
/*
* XXX: This is in the VM bind data path, likely should calculate this once and
* store, with a recalculation if the BO is moved.

4
drivers/gpu/drm/xe/xe_bo.h
View file

@ -124,6 +124,10 @@ struct xe_bo *xe_bo_create_pin_map_at(struct xe_device *xe, struct xe_tile *tile
struct xe_bo *xe_bo_create_from_data(struct xe_device *xe, struct xe_tile *tile,
const void *data, size_t size,
enum ttm_bo_type type, u32 flags);
struct xe_bo *xe_managed_bo_create_pin_map(struct xe_device *xe, struct xe_tile *tile,
size_t size, u32 flags);
struct xe_bo *xe_managed_bo_create_from_data(struct xe_device *xe, struct xe_tile *tile,
const void *data, size_t size, u32 flags);
int xe_bo_placement_for_flags(struct xe_device *xe, struct xe_bo *bo,
u32 bo_flags);

6
drivers/gpu/drm/xe/xe_ggtt.c
View file

@ -108,7 +108,6 @@ static void ggtt_fini(struct drm_device *drm, void *arg)
{
struct xe_ggtt *ggtt = arg;
xe_bo_unpin_map_no_vm(ggtt->scratch);
ggtt->scratch = NULL;
}
@ -227,10 +226,7 @@ int xe_ggtt_init(struct xe_ggtt *ggtt)
else
flags |= XE_BO_CREATE_VRAM_IF_DGFX(ggtt->tile);
ggtt->scratch = xe_bo_create_pin_map(xe, ggtt->tile, NULL, XE_PAGE_SIZE,
ttm_bo_type_kernel,
flags);
ggtt->scratch = xe_managed_bo_create_pin_map(xe, ggtt->tile, XE_PAGE_SIZE, flags);
if (IS_ERR(ggtt->scratch)) {
err = PTR_ERR(ggtt->scratch);
goto err;

16
drivers/gpu/drm/xe/xe_guc_ads.c
View file

@ -202,13 +202,6 @@ static size_t guc_ads_size(struct xe_guc_ads *ads)
guc_ads_private_data_size(ads);
}
static void guc_ads_fini(struct drm_device *drm, void *arg)
{
struct xe_guc_ads *ads = arg;
xe_bo_unpin_map_no_vm(ads->bo);
}
static bool needs_wa_1607983814(struct xe_device *xe)
{
return GRAPHICS_VERx100(xe) < 1250;
@ -274,14 +267,11 @@ int xe_guc_ads_init(struct xe_guc_ads *ads)
struct xe_gt *gt = ads_to_gt(ads);
struct xe_tile *tile = gt_to_tile(gt);
struct xe_bo *bo;
int err;
ads->golden_lrc_size = calculate_golden_lrc_size(ads);
ads->regset_size = calculate_regset_size(gt);
bo = xe_bo_create_pin_map(xe, tile, NULL, guc_ads_size(ads) +
MAX_GOLDEN_LRC_SIZE,
ttm_bo_type_kernel,
bo = xe_managed_bo_create_pin_map(xe, tile, guc_ads_size(ads) + MAX_GOLDEN_LRC_SIZE,
XE_BO_CREATE_VRAM_IF_DGFX(tile) |
XE_BO_CREATE_GGTT_BIT);
if (IS_ERR(bo))
@ -289,10 +279,6 @@ int xe_guc_ads_init(struct xe_guc_ads *ads)
ads->bo = bo;
err = drmm_add_action_or_reset(&xe->drm, guc_ads_fini, ads);
if (err)
return err;
return 0;
}

4
drivers/gpu/drm/xe/xe_guc_ct.c
View file

@ -114,7 +114,6 @@ static void guc_ct_fini(struct drm_device *drm, void *arg)
struct xe_guc_ct *ct = arg;
xa_destroy(&ct->fence_lookup);
xe_bo_unpin_map_no_vm(ct->bo);
}
static void g2h_worker_func(struct work_struct *w);
@ -148,8 +147,7 @@ int xe_guc_ct_init(struct xe_guc_ct *ct)
primelockdep(ct);
bo = xe_bo_create_pin_map(xe, tile, NULL, guc_ct_size(),
ttm_bo_type_kernel,
bo = xe_managed_bo_create_pin_map(xe, tile, guc_ct_size(),
XE_BO_CREATE_VRAM_IF_DGFX(tile) |
XE_BO_CREATE_GGTT_BIT);
if (IS_ERR(bo))

14
drivers/gpu/drm/xe/xe_guc_hwconfig.c
View file

@ -48,13 +48,6 @@ static int guc_hwconfig_copy(struct xe_guc *guc)
return 0;
}
static void guc_hwconfig_fini(struct drm_device *drm, void *arg)
{
struct xe_guc *guc = arg;
xe_bo_unpin_map_no_vm(guc->hwconfig.bo);
}
int xe_guc_hwconfig_init(struct xe_guc *guc)
{
struct xe_device *xe = guc_to_xe(guc);
@ -84,8 +77,7 @@ int xe_guc_hwconfig_init(struct xe_guc *guc)
if (!size)
return -EINVAL;
bo = xe_bo_create_pin_map(xe, tile, NULL, PAGE_ALIGN(size),
ttm_bo_type_kernel,
bo = xe_managed_bo_create_pin_map(xe, tile, PAGE_ALIGN(size),
XE_BO_CREATE_VRAM_IF_DGFX(tile) |
XE_BO_CREATE_GGTT_BIT);
if (IS_ERR(bo))
@ -93,10 +85,6 @@ int xe_guc_hwconfig_init(struct xe_guc *guc)
guc->hwconfig.bo = bo;
guc->hwconfig.size = size;
err = drmm_add_action_or_reset(&xe->drm, guc_hwconfig_fini, guc);
if (err)
return err;
return guc_hwconfig_copy(guc);
}

15
drivers/gpu/drm/xe/xe_guc_log.c
View file

@ -77,22 +77,13 @@ void xe_guc_log_print(struct xe_guc_log *log, struct drm_printer *p)
}
}
static void guc_log_fini(struct drm_device *drm, void *arg)
{
struct xe_guc_log *log = arg;
xe_bo_unpin_map_no_vm(log->bo);
}
int xe_guc_log_init(struct xe_guc_log *log)
{
struct xe_device *xe = log_to_xe(log);
struct xe_tile *tile = gt_to_tile(log_to_gt(log));
struct xe_bo *bo;
int err;
bo = xe_bo_create_pin_map(xe, tile, NULL, guc_log_size(),
ttm_bo_type_kernel,
bo = xe_managed_bo_create_pin_map(xe, tile, guc_log_size(),
XE_BO_CREATE_VRAM_IF_DGFX(tile) |
XE_BO_CREATE_GGTT_BIT);
if (IS_ERR(bo))
@ -102,9 +93,5 @@ int xe_guc_log_init(struct xe_guc_log *log)
log->bo = bo;
log->level = xe_modparam.guc_log_level;
err = drmm_add_action_or_reset(&xe->drm, guc_log_fini, log);
if (err)
return err;
return 0;
}

5
drivers/gpu/drm/xe/xe_guc_pc.c
View file

@ -964,7 +964,6 @@ void xe_guc_pc_fini(struct xe_guc_pc *pc)
XE_WARN_ON(xe_guc_pc_gucrc_disable(pc));
XE_WARN_ON(xe_guc_pc_stop(pc));
sysfs_remove_files(pc_to_gt(pc)->sysfs, pc_attrs);
xe_bo_unpin_map_no_vm(pc->bo);
mutex_destroy(&pc->freq_lock);
}
@ -986,11 +985,9 @@ int xe_guc_pc_init(struct xe_guc_pc *pc)
mutex_init(&pc->freq_lock);
bo = xe_bo_create_pin_map(xe, tile, NULL, size,
ttm_bo_type_kernel,
bo = xe_managed_bo_create_pin_map(xe, tile, size,
XE_BO_CREATE_VRAM_IF_DGFX(tile) |
XE_BO_CREATE_GGTT_BIT);
if (IS_ERR(bo))
return PTR_ERR(bo);

4
drivers/gpu/drm/xe/xe_hw_engine.c
View file

@ -239,8 +239,6 @@ static void hw_engine_fini(struct drm_device *drm, void *arg)
xe_execlist_port_destroy(hwe->exl_port);
xe_lrc_finish(&hwe->kernel_lrc);
xe_bo_unpin_map_no_vm(hwe->hwsp);
hwe->gt = NULL;
}
@ -428,7 +426,7 @@ static int hw_engine_init(struct xe_gt *gt, struct xe_hw_engine *hwe,
xe_reg_sr_apply_mmio(&hwe->reg_sr, gt);
xe_reg_sr_apply_whitelist(hwe);
hwe->hwsp = xe_bo_create_pin_map(xe, tile, NULL, SZ_4K, ttm_bo_type_kernel,
hwe->hwsp = xe_managed_bo_create_pin_map(xe, tile, SZ_4K,
XE_BO_CREATE_VRAM_IF_DGFX(tile) |
XE_BO_CREATE_GGTT_BIT);
if (IS_ERR(hwe->hwsp)) {

5
drivers/gpu/drm/xe/xe_uc_fw.c
View file

@ -292,7 +292,6 @@ static void uc_fw_fini(struct drm_device *drm, void *arg)
if (!xe_uc_fw_is_available(uc_fw))
return;
xe_bo_unpin_map_no_vm(uc_fw->bo);
xe_uc_fw_change_status(uc_fw, XE_UC_FIRMWARE_SELECTED);
}
@ -692,8 +691,7 @@ int xe_uc_fw_init(struct xe_uc_fw *uc_fw)
goto fail;
}
obj = xe_bo_create_from_data(xe, tile, fw->data, fw->size,
ttm_bo_type_kernel,
obj = xe_managed_bo_create_from_data(xe, tile, fw->data, fw->size,
XE_BO_CREATE_VRAM_IF_DGFX(tile) |
XE_BO_CREATE_GGTT_BIT);
if (IS_ERR(obj)) {
@ -726,6 +724,7 @@ int xe_uc_fw_init(struct xe_uc_fw *uc_fw)
xe_uc_fw_type_repr(uc_fw->type), XE_UC_FIRMWARE_URL);
release_firmware(fw); /* OK even if fw is NULL */
return err;
}