tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

drm/ttm: Replace multiple booleans with flags in device init

Multiple consecutive boolean function arguments are usually not very
readable.

Replace the ones in ttm_device_init() with flags with the additional
benefit of soon being able to pass in more data with just a one off
code base churning cost.

Signed-off-by: Tvrtko Ursulin <tvrtko.ursulin@igalia.com>
Cc: Alex Deucher <alexander.deucher@amd.com>
Cc: Christian König <christian.koenig@amd.com>
Cc: Danilo Krummrich <dakr@kernel.org>
Cc: Dave Airlie <airlied@redhat.com>
Cc: Gerd Hoffmann <kraxel@redhat.com>
Cc: Joonas Lahtinen <joonas.lahtinen@linux.intel.com>
Cc: Lucas De Marchi <lucas.demarchi@intel.com>
Cc: Lyude Paul <lyude@redhat.com>
Cc: Maarten Lankhorst <maarten.lankhorst@linux.intel.com>
Cc: Maxime Ripard <mripard@kernel.org>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Sui Jingfeng <suijingfeng@loongson.cn>
Cc: Thomas Hellström <thomas.hellstrom@linux.intel.com>
Cc: Thomas Zimmermann <tzimmermann@suse.de>
Cc: Zack Rusin <zack.rusin@broadcom.com>
Acked-by: Christian König <christian.koenig@amd.com>
Acked-by: Zack Rusin <zack.rusin@broadcom.com>
Acked-by: Thomas Hellström <thomas.hellstrom@linux.intel.com> # For xe
Reviewed-by: Christian König <christian.koenig@amd.com>
Signed-off-by: Tvrtko Ursulin <tursulin@ursulin.net>
Link: https://lore.kernel.org/r/20251020115411.36818-4-tvrtko.ursulin@igalia.com
[tursulin: fixup checkpatch while applying]

authored by

Tvrtko Ursulin and committed by
Tvrtko Ursulin 77e19f8d 0af5b6a8

+50 -54
+4 -2
drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
··· 1930 1930 r = ttm_device_init(&adev->mman.bdev, &amdgpu_bo_driver, adev->dev, 1931 1931 adev_to_drm(adev)->anon_inode->i_mapping, 1932 1932 adev_to_drm(adev)->vma_offset_manager, 1933 - adev->need_swiotlb, 1934 - dma_addressing_limited(adev->dev)); 1933 + (adev->need_swiotlb ? 1934 + TTM_ALLOCATION_POOL_USE_DMA_ALLOC : 0) | 1935 + (dma_addressing_limited(adev->dev) ? 1936 + TTM_ALLOCATION_POOL_USE_DMA32 : 0)); 1935 1937 if (r) { 1936 1938 dev_err(adev->dev, 1937 1939 "failed initializing buffer object driver(%d).\n", r);
+1 -1
drivers/gpu/drm/drm_gem_vram_helper.c
··· 860 860 ret = ttm_device_init(&vmm->bdev, &bo_driver, dev->dev, 861 861 dev->anon_inode->i_mapping, 862 862 dev->vma_offset_manager, 863 - false, true); 863 + TTM_ALLOCATION_POOL_USE_DMA32); 864 864 if (ret) 865 865 return ret; 866 866
+1 -1
drivers/gpu/drm/i915/intel_region_ttm.c
··· 34 34 35 35 return ttm_device_init(&dev_priv->bdev, i915_ttm_driver(), 36 36 drm->dev, drm->anon_inode->i_mapping, 37 - drm->vma_offset_manager, false, false); 37 + drm->vma_offset_manager, 0); 38 38 } 39 39 40 40 /**
+2 -1
drivers/gpu/drm/loongson/lsdc_ttm.c
··· 545 545 546 546 ret = ttm_device_init(&ldev->bdev, &lsdc_bo_driver, ddev->dev, 547 547 ddev->anon_inode->i_mapping, 548 - ddev->vma_offset_manager, false, true); 548 + ddev->vma_offset_manager, 549 + TTM_ALLOCATION_POOL_USE_DMA32); 549 550 if (ret) 550 551 return ret; 551 552
+4 -2
drivers/gpu/drm/nouveau/nouveau_ttm.c
··· 302 302 ret = ttm_device_init(&drm->ttm.bdev, &nouveau_bo_driver, drm->dev->dev, 303 303 dev->anon_inode->i_mapping, 304 304 dev->vma_offset_manager, 305 - drm_need_swiotlb(drm->client.mmu.dmabits), 306 - drm->client.mmu.dmabits <= 32); 305 + (drm_need_swiotlb(drm->client.mmu.dmabits) ? 306 + TTM_ALLOCATION_POOL_USE_DMA_ALLOC : 0) | 307 + (drm->client.mmu.dmabits <= 32 ? 308 + TTM_ALLOCATION_POOL_USE_DMA32 : 0)); 307 309 if (ret) { 308 310 NV_ERROR(drm, "error initialising bo driver, %d\n", ret); 309 311 return ret;
+1 -1
drivers/gpu/drm/qxl/qxl_ttm.c
··· 197 197 r = ttm_device_init(&qdev->mman.bdev, &qxl_bo_driver, NULL, 198 198 qdev->ddev.anon_inode->i_mapping, 199 199 qdev->ddev.vma_offset_manager, 200 - false, false); 200 + 0); 201 201 if (r) { 202 202 DRM_ERROR("failed initializing buffer object driver(%d).\n", r); 203 203 return r;
+4 -2
drivers/gpu/drm/radeon/radeon_ttm.c
··· 683 683 r = ttm_device_init(&rdev->mman.bdev, &radeon_bo_driver, rdev->dev, 684 684 rdev_to_drm(rdev)->anon_inode->i_mapping, 685 685 rdev_to_drm(rdev)->vma_offset_manager, 686 - rdev->need_swiotlb, 687 - dma_addressing_limited(&rdev->pdev->dev)); 686 + (rdev->need_swiotlb ? 687 + TTM_ALLOCATION_POOL_USE_DMA_ALLOC : 0) | 688 + (dma_addressing_limited(&rdev->pdev->dev) ? 689 + TTM_ALLOCATION_POOL_USE_DMA32 : 0)); 688 690 if (r) { 689 691 DRM_ERROR("failed initializing buffer object driver(%d).\n", r); 690 692 return r;
+8 -8
drivers/gpu/drm/ttm/tests/ttm_bo_test.c
··· 251 251 ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL); 252 252 KUNIT_ASSERT_NOT_NULL(test, ttm_dev); 253 253 254 - err = ttm_device_kunit_init(priv, ttm_dev, false, false); 254 + err = ttm_device_kunit_init(priv, ttm_dev, 0); 255 255 KUNIT_ASSERT_EQ(test, err, 0); 256 256 priv->ttm_dev = ttm_dev; 257 257 ··· 290 290 ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL); 291 291 KUNIT_ASSERT_NOT_NULL(test, ttm_dev); 292 292 293 - err = ttm_device_kunit_init(priv, ttm_dev, false, false); 293 + err = ttm_device_kunit_init(priv, ttm_dev, 0); 294 294 KUNIT_ASSERT_EQ(test, err, 0); 295 295 priv->ttm_dev = ttm_dev; 296 296 ··· 342 342 resv = kunit_kzalloc(test, sizeof(*resv), GFP_KERNEL); 343 343 KUNIT_ASSERT_NOT_NULL(test, resv); 344 344 345 - err = ttm_device_kunit_init(priv, ttm_dev, false, false); 345 + err = ttm_device_kunit_init(priv, ttm_dev, 0); 346 346 KUNIT_ASSERT_EQ(test, err, 0); 347 347 priv->ttm_dev = ttm_dev; 348 348 ··· 394 394 ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL); 395 395 KUNIT_ASSERT_NOT_NULL(test, ttm_dev); 396 396 397 - err = ttm_device_kunit_init(priv, ttm_dev, false, false); 397 + err = ttm_device_kunit_init(priv, ttm_dev, 0); 398 398 KUNIT_ASSERT_EQ(test, err, 0); 399 399 priv->ttm_dev = ttm_dev; 400 400 ··· 437 437 ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL); 438 438 KUNIT_ASSERT_NOT_NULL(test, ttm_dev); 439 439 440 - err = ttm_device_kunit_init(priv, ttm_dev, false, false); 440 + err = ttm_device_kunit_init(priv, ttm_dev, 0); 441 441 KUNIT_ASSERT_EQ(test, err, 0); 442 442 priv->ttm_dev = ttm_dev; 443 443 ··· 477 477 ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL); 478 478 KUNIT_ASSERT_NOT_NULL(test, ttm_dev); 479 479 480 - err = ttm_device_kunit_init(priv, ttm_dev, false, false); 480 + err = ttm_device_kunit_init(priv, ttm_dev, 0); 481 481 KUNIT_ASSERT_EQ(test, err, 0); 482 482 priv->ttm_dev = ttm_dev; 483 483 ··· 512 512 ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL); 513 513 KUNIT_ASSERT_NOT_NULL(test, ttm_dev); 514 514 515 - err = ttm_device_kunit_init(priv, ttm_dev, false, false); 515 + err = ttm_device_kunit_init(priv, ttm_dev, 0); 516 516 KUNIT_ASSERT_EQ(test, err, 0); 517 517 priv->ttm_dev = ttm_dev; 518 518 ··· 563 563 ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL); 564 564 KUNIT_ASSERT_NOT_NULL(test, ttm_dev); 565 565 566 - err = ttm_device_kunit_init(priv, ttm_dev, false, false); 566 + err = ttm_device_kunit_init(priv, ttm_dev, 0); 567 567 KUNIT_ASSERT_EQ(test, err, 0); 568 568 priv->ttm_dev = ttm_dev; 569 569
+1 -1
drivers/gpu/drm/ttm/tests/ttm_bo_validate_test.c
··· 995 995 */ 996 996 ttm_device_fini(priv->ttm_dev); 997 997 998 - err = ttm_device_kunit_init_bad_evict(test->priv, priv->ttm_dev, false, false); 998 + err = ttm_device_kunit_init_bad_evict(test->priv, priv->ttm_dev); 999 999 KUNIT_ASSERT_EQ(test, err, 0); 1000 1000 1001 1001 ttm_mock_manager_init(priv->ttm_dev, mem_type, MANAGER_SIZE);
+5 -7
drivers/gpu/drm/ttm/tests/ttm_device_test.c
··· 25 25 ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL); 26 26 KUNIT_ASSERT_NOT_NULL(test, ttm_dev); 27 27 28 - err = ttm_device_kunit_init(priv, ttm_dev, false, false); 28 + err = ttm_device_kunit_init(priv, ttm_dev, 0); 29 29 KUNIT_ASSERT_EQ(test, err, 0); 30 30 31 31 KUNIT_EXPECT_PTR_EQ(test, ttm_dev->funcs, &ttm_dev_funcs); ··· 55 55 KUNIT_ASSERT_NOT_NULL(test, ttm_devs); 56 56 57 57 for (i = 0; i < num_dev; i++) { 58 - err = ttm_device_kunit_init(priv, &ttm_devs[i], false, false); 58 + err = ttm_device_kunit_init(priv, &ttm_devs[i], 0); 59 59 KUNIT_ASSERT_EQ(test, err, 0); 60 60 61 61 KUNIT_EXPECT_PTR_EQ(test, ttm_devs[i].dev_mapping, ··· 81 81 ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL); 82 82 KUNIT_ASSERT_NOT_NULL(test, ttm_dev); 83 83 84 - err = ttm_device_kunit_init(priv, ttm_dev, false, false); 84 + err = ttm_device_kunit_init(priv, ttm_dev, 0); 85 85 KUNIT_ASSERT_EQ(test, err, 0); 86 86 87 87 man = ttm_manager_type(ttm_dev, TTM_PL_SYSTEM); ··· 109 109 vma_man = drm->vma_offset_manager; 110 110 drm->vma_offset_manager = NULL; 111 111 112 - err = ttm_device_kunit_init(priv, ttm_dev, false, false); 112 + err = ttm_device_kunit_init(priv, ttm_dev, 0); 113 113 KUNIT_EXPECT_EQ(test, err, -EINVAL); 114 114 115 115 /* Bring the manager back for a graceful cleanup */ ··· 158 158 ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL); 159 159 KUNIT_ASSERT_NOT_NULL(test, ttm_dev); 160 160 161 - err = ttm_device_kunit_init(priv, ttm_dev, 162 - params->alloc_flags & TTM_ALLOCATION_POOL_USE_DMA_ALLOC, 163 - params->alloc_flags & TTM_ALLOCATION_POOL_USE_DMA32); 161 + err = ttm_device_kunit_init(priv, ttm_dev, params->alloc_flags); 164 162 KUNIT_ASSERT_EQ(test, err, 0); 165 163 166 164 pool = &ttm_dev->pool;
+9 -13
drivers/gpu/drm/ttm/tests/ttm_kunit_helpers.c
··· 117 117 118 118 static int ttm_device_kunit_init_with_funcs(struct ttm_test_devices *priv, 119 119 struct ttm_device *ttm, 120 - bool use_dma_alloc, 121 - bool use_dma32, 120 + unsigned int alloc_flags, 122 121 struct ttm_device_funcs *funcs) 123 122 { 124 123 struct drm_device *drm = priv->drm; ··· 126 127 err = ttm_device_init(ttm, funcs, drm->dev, 127 128 drm->anon_inode->i_mapping, 128 129 drm->vma_offset_manager, 129 - use_dma_alloc, use_dma32); 130 + alloc_flags); 130 131 131 132 return err; 132 133 } ··· 142 143 143 144 int ttm_device_kunit_init(struct ttm_test_devices *priv, 144 145 struct ttm_device *ttm, 145 - bool use_dma_alloc, 146 - bool use_dma32) 146 + unsigned int alloc_flags) 147 147 { 148 - return ttm_device_kunit_init_with_funcs(priv, ttm, use_dma_alloc, 149 - use_dma32, &ttm_dev_funcs); 148 + return ttm_device_kunit_init_with_funcs(priv, ttm, alloc_flags, 149 + &ttm_dev_funcs); 150 150 } 151 151 EXPORT_SYMBOL_GPL(ttm_device_kunit_init); 152 152 ··· 159 161 EXPORT_SYMBOL_GPL(ttm_dev_funcs_bad_evict); 160 162 161 163 int ttm_device_kunit_init_bad_evict(struct ttm_test_devices *priv, 162 - struct ttm_device *ttm, 163 - bool use_dma_alloc, 164 - bool use_dma32) 164 + struct ttm_device *ttm) 165 165 { 166 - return ttm_device_kunit_init_with_funcs(priv, ttm, use_dma_alloc, 167 - use_dma32, &ttm_dev_funcs_bad_evict); 166 + return ttm_device_kunit_init_with_funcs(priv, ttm, 0, 167 + &ttm_dev_funcs_bad_evict); 168 168 } 169 169 EXPORT_SYMBOL_GPL(ttm_device_kunit_init_bad_evict); 170 170 ··· 248 252 ttm_dev = kunit_kzalloc(test, sizeof(*ttm_dev), GFP_KERNEL); 249 253 KUNIT_ASSERT_NOT_NULL(test, ttm_dev); 250 254 251 - err = ttm_device_kunit_init(devs, ttm_dev, false, false); 255 + err = ttm_device_kunit_init(devs, ttm_dev, 0); 252 256 KUNIT_ASSERT_EQ(test, err, 0); 253 257 254 258 devs->ttm_dev = ttm_dev;
+2 -5
drivers/gpu/drm/ttm/tests/ttm_kunit_helpers.h
··· 28 28 /* Building blocks for test-specific init functions */ 29 29 int ttm_device_kunit_init(struct ttm_test_devices *priv, 30 30 struct ttm_device *ttm, 31 - bool use_dma_alloc, 32 - bool use_dma32); 31 + unsigned int alloc_flags); 33 32 int ttm_device_kunit_init_bad_evict(struct ttm_test_devices *priv, 34 - struct ttm_device *ttm, 35 - bool use_dma_alloc, 36 - bool use_dma32); 33 + struct ttm_device *ttm); 37 34 struct ttm_buffer_object *ttm_bo_kunit_init(struct kunit *test, 38 35 struct ttm_test_devices *devs, 39 36 size_t size,
+3 -6
drivers/gpu/drm/ttm/ttm_device.c
··· 199 199 * @dev: The core kernel device pointer for DMA mappings and allocations. 200 200 * @mapping: The address space to use for this bo. 201 201 * @vma_manager: A pointer to a vma manager. 202 - * @use_dma_alloc: If coherent DMA allocation API should be used. 203 - * @use_dma32: If we should use GFP_DMA32 for device memory allocations. 202 + * @alloc_flags: TTM_ALLOCATION_ flags. 204 203 * 205 204 * Initializes a struct ttm_device: 206 205 * Returns: ··· 208 209 int ttm_device_init(struct ttm_device *bdev, const struct ttm_device_funcs *funcs, 209 210 struct device *dev, struct address_space *mapping, 210 211 struct drm_vma_offset_manager *vma_manager, 211 - bool use_dma_alloc, bool use_dma32) 212 + unsigned int alloc_flags) 212 213 { 213 214 struct ttm_global *glob = &ttm_glob; 214 215 int ret, nid; ··· 236 237 else 237 238 nid = NUMA_NO_NODE; 238 239 239 - ttm_pool_init(&bdev->pool, dev, nid, 240 - (use_dma_alloc ? TTM_ALLOCATION_POOL_USE_DMA_ALLOC : 0) | 241 - (use_dma32 ? TTM_ALLOCATION_POOL_USE_DMA32 : 0)); 240 + ttm_pool_init(&bdev->pool, dev, nid, alloc_flags); 242 241 243 242 bdev->vma_manager = vma_manager; 244 243 spin_lock_init(&bdev->lru_lock);
+2 -2
drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
··· 1023 1023 dev_priv->drm.dev, 1024 1024 dev_priv->drm.anon_inode->i_mapping, 1025 1025 dev_priv->drm.vma_offset_manager, 1026 - dev_priv->map_mode == vmw_dma_alloc_coherent, 1027 - false); 1026 + (dev_priv->map_mode == vmw_dma_alloc_coherent) ? 1027 + TTM_ALLOCATION_POOL_USE_DMA_ALLOC : 0); 1028 1028 if (unlikely(ret != 0)) { 1029 1029 drm_err(&dev_priv->drm, 1030 1030 "Failed initializing TTM buffer object driver.\n");
+1 -1
drivers/gpu/drm/xe/xe_device.c
··· 437 437 438 438 err = ttm_device_init(&xe->ttm, &xe_ttm_funcs, xe->drm.dev, 439 439 xe->drm.anon_inode->i_mapping, 440 - xe->drm.vma_offset_manager, false, false); 440 + xe->drm.vma_offset_manager, 0); 441 441 if (WARN_ON(err)) 442 442 goto err; 443 443
+2 -1
include/drm/ttm/ttm_device.h
··· 27 27 28 28 #include <linux/types.h> 29 29 #include <linux/workqueue.h> 30 + #include <drm/ttm/ttm_allocation.h> 30 31 #include <drm/ttm/ttm_resource.h> 31 32 #include <drm/ttm/ttm_pool.h> 32 33 ··· 293 292 int ttm_device_init(struct ttm_device *bdev, const struct ttm_device_funcs *funcs, 294 293 struct device *dev, struct address_space *mapping, 295 294 struct drm_vma_offset_manager *vma_manager, 296 - bool use_dma_alloc, bool use_dma32); 295 + unsigned int alloc_flags); 297 296 void ttm_device_fini(struct ttm_device *bdev); 298 297 void ttm_device_clear_dma_mappings(struct ttm_device *bdev); 299 298