Merge tag 'drm-xe-next-2026-03-02' of https://gitlab.freedesktop.org/drm/xe/kernel into drm-next (17b95278) · Commits · git / linux-net

Documentation/ABI/testing/sysfs-driver-intel-xe-sriov

+31 −0

Original line number	Diff line number	Diff line
		@@ -129,6 +129,37 @@ Description:
		-EIO if FW refuses to change the provisioning.


		What: /sys/bus/pci/drivers/xe/.../sriov_admin/.bulk_profile/vram_quota
		What: /sys/bus/pci/drivers/xe/.../sriov_admin/vf<n>/profile/vram_quota
		Date: February 2026
		KernelVersion: 7.0
		Contact: intel-xe@lists.freedesktop.org
		Description:
		These files allow to perform initial VFs VRAM provisioning prior to VFs
		enabling or to change VFs VRAM provisioning once the VFs are enabled.
		Any non-zero initial VRAM provisioning will block VFs auto-provisioning.
		Without initial VRAM provisioning those files will show result of the
		VRAM auto-provisioning performed by the PF once the VFs are enabled.
		Once the VFs are disabled, all VRAM provisioning will be released.
		These files are visible only on discrete Intel Xe platforms with VRAM
		and are writeable only if dynamic VFs VRAM provisioning is supported.

		.bulk_profile/vram_quota: (WO) unsigned integer
		The amount of the provisioned VRAM in [bytes] for each VF.
		Actual quota value might be aligned per HW/FW requirements.

		profile/vram_quota: (RW) unsigned integer
		The amount of the provisioned VRAM in [bytes] for this VF.
		Actual quota value might be aligned per HW/FW requirements.

		Default is 0 (unprovisioned).

		Writes to these attributes may fail with errors like:
		-EINVAL if provided input is malformed or not recognized,
		-EPERM if change is not applicable on given HW/FW,
		-EIO if FW refuses to change the provisioning.


		What: /sys/bus/pci/drivers/xe/.../sriov_admin/vf<n>/stop
		Date: October 2025
		KernelVersion: 6.19

Documentation/gpu/xe/xe_firmware.rst

+3 −0

Original line number	Diff line number	Diff line
		@@ -31,6 +31,9 @@ GuC Power Conservation (PC)
		.. kernel-doc:: drivers/gpu/drm/xe/xe_guc_pc.c
		:doc: GuC Power Conservation (PC)

		.. kernel-doc:: drivers/gpu/drm/xe/xe_guc_rc.c
		:doc: GuC Render C-states (GuC RC)

		PCIe Gen5 Limitations
		=====================

drivers/gpu/drm/drm_gpusvm.c

+4 −3

Original line number	Diff line number	Diff line
		@@ -819,7 +819,7 @@ enum drm_gpusvm_scan_result drm_gpusvm_scan_mm(struct drm_gpusvm_range *range,

		if (!(pfns[i] & HMM_PFN_VALID)) {
		state = DRM_GPUSVM_SCAN_UNPOPULATED;
		goto err_free;
		break;
		}

		page = hmm_pfn_to_page(pfns[i]);
		@@ -856,9 +856,9 @@ enum drm_gpusvm_scan_result drm_gpusvm_scan_mm(struct drm_gpusvm_range *range,
		i += 1ul << drm_gpusvm_hmm_pfn_to_order(pfns[i], i, npages);
		}

		err_free:
		drm_gpusvm_notifier_unlock(range->gpusvm);

		err_free:
		kvfree(pfns);
		return state;
		}
		@@ -1495,7 +1495,7 @@ int drm_gpusvm_get_pages(struct drm_gpusvm *gpusvm,
		}
		zdd = page->zone_device_data;
		if (pagemap != page_pgmap(page)) {
		if (i > 0) {
		if (pagemap) {
		err = -EOPNOTSUPP;
		goto err_unmap;
		}
		@@ -1572,6 +1572,7 @@ int drm_gpusvm_get_pages(struct drm_gpusvm *gpusvm,
		return 0;

		err_unmap:
		svm_pages->flags.has_dma_mapping = true;
		__drm_gpusvm_unmap_pages(gpusvm, svm_pages, num_dma_mapped);
		drm_gpusvm_notifier_unlock(gpusvm);
		err_free:

drivers/gpu/drm/drm_pagemap.c

+2 −12

Original line number	Diff line number	Diff line
		@@ -480,18 +480,8 @@ int drm_pagemap_migrate_to_devmem(struct drm_pagemap_devmem *devmem_allocation,
		.start = start,
		.end = end,
		.pgmap_owner = pagemap->owner,
		/*
		* FIXME: MIGRATE_VMA_SELECT_DEVICE_PRIVATE intermittently
		* causes 'xe_exec_system_allocator --r raceno*' to trigger aa
		* engine reset and a hard hang due to getting stuck on a folio
		* lock. This should work and needs to be root-caused. The only
		* downside of not selecting MIGRATE_VMA_SELECT_DEVICE_PRIVATE
		* is that device-to-device migrations won’t work; instead,
		* memory will bounce through system memory. This path should be
		* rare and only occur when the madvise attributes of memory are
		* changed or atomics are being used.
		*/
		.flags = MIGRATE_VMA_SELECT_SYSTEM \| MIGRATE_VMA_SELECT_DEVICE_COHERENT,
		.flags = MIGRATE_VMA_SELECT_SYSTEM \| MIGRATE_VMA_SELECT_DEVICE_COHERENT \|
		MIGRATE_VMA_SELECT_DEVICE_PRIVATE,
		};
		unsigned long i, npages = npages_in_range(start, end);
		unsigned long own_pages = 0, migrated_pages = 0;

drivers/gpu/drm/drm_suballoc.c

+86 −20

Original line number	Diff line number	Diff line
		@@ -293,45 +293,66 @@ static bool drm_suballoc_next_hole(struct drm_suballoc_manager *sa_manager,
		}

		/**
		* drm_suballoc_new() - Make a suballocation.
		* drm_suballoc_alloc() - Allocate uninitialized suballoc object.
		* @gfp: gfp flags used for memory allocation.
		*
		* Allocate memory for an uninitialized suballoc object. Intended usage is
		* allocate memory for suballoc object outside of a reclaim tainted context
		* and then be initialized at a later time in a reclaim tainted context.
		*
		* @drm_suballoc_free() should be used to release the memory if returned
		* suballoc object is in uninitialized state.
		*
		* Return: a new uninitialized suballoc object, or an ERR_PTR(-ENOMEM).
		*/
		struct drm_suballoc *drm_suballoc_alloc(gfp_t gfp)
		{
		struct drm_suballoc *sa;

		sa = kmalloc_obj(*sa, gfp);
		if (!sa)
		return ERR_PTR(-ENOMEM);

		sa->manager = NULL;

		return sa;
		}
		EXPORT_SYMBOL(drm_suballoc_alloc);

		/**
		* drm_suballoc_insert() - Initialize a suballocation and insert a hole.
		* @sa_manager: pointer to the sa_manager
		* @sa: The struct drm_suballoc.
		* @size: number of bytes we want to suballocate.
		* @gfp: gfp flags used for memory allocation. Typically GFP_KERNEL but
		* the argument is provided for suballocations from reclaim context or
		* where the caller wants to avoid pipelining rather than wait for
		* reclaim.
		* @intr: Whether to perform waits interruptible. This should typically
		* always be true, unless the caller needs to propagate a
		* non-interruptible context from above layers.
		* @align: Alignment. Must not exceed the default manager alignment.
		* If @align is zero, then the manager alignment is used.
		*
		* Try to make a suballocation of size @size, which will be rounded
		* up to the alignment specified in specified in drm_suballoc_manager_init().
		* Try to make a suballocation on a pre-allocated suballoc object of size @size,
		* which will be rounded up to the alignment specified in specified in
		* drm_suballoc_manager_init().
		*
		* Return: a new suballocated bo, or an ERR_PTR.
		* Return: zero on success, errno on failure.
		*/
		struct drm_suballoc *
		drm_suballoc_new(struct drm_suballoc_manager *sa_manager, size_t size,
		gfp_t gfp, bool intr, size_t align)
		int drm_suballoc_insert(struct drm_suballoc_manager *sa_manager,
		struct drm_suballoc *sa, size_t size,
		bool intr, size_t align)
		{
		struct dma_fence *fences[DRM_SUBALLOC_MAX_QUEUES];
		unsigned int tries[DRM_SUBALLOC_MAX_QUEUES];
		unsigned int count;
		int i, r;
		struct drm_suballoc *sa;

		if (WARN_ON_ONCE(align > sa_manager->align))
		return ERR_PTR(-EINVAL);
		return -EINVAL;
		if (WARN_ON_ONCE(size > sa_manager->size \|\| !size))
		return ERR_PTR(-EINVAL);
		return -EINVAL;

		if (!align)
		align = sa_manager->align;

		sa = kmalloc_obj(*sa, gfp);
		if (!sa)
		return ERR_PTR(-ENOMEM);
		sa->manager = sa_manager;
		sa->fence = NULL;
		INIT_LIST_HEAD(&sa->olist);
		@@ -348,7 +369,7 @@ drm_suballoc_new(struct drm_suballoc_manager *sa_manager, size_t size,
		if (drm_suballoc_try_alloc(sa_manager, sa,
		size, align)) {
		spin_unlock(&sa_manager->wq.lock);
		return sa;
		return 0;
		}

		/* see if we can skip over some allocations */
		@@ -385,8 +406,48 @@ drm_suballoc_new(struct drm_suballoc_manager *sa_manager, size_t size,
		} while (!r);

		spin_unlock(&sa_manager->wq.lock);
		kfree(sa);
		return ERR_PTR(r);
		sa->manager = NULL;
		return r;
		}
		EXPORT_SYMBOL(drm_suballoc_insert);

		/**
		* drm_suballoc_new() - Make a suballocation.
		* @sa_manager: pointer to the sa_manager
		* @size: number of bytes we want to suballocate.
		* @gfp: gfp flags used for memory allocation. Typically GFP_KERNEL but
		* the argument is provided for suballocations from reclaim context or
		* where the caller wants to avoid pipelining rather than wait for
		* reclaim.
		* @intr: Whether to perform waits interruptible. This should typically
		* always be true, unless the caller needs to propagate a
		* non-interruptible context from above layers.
		* @align: Alignment. Must not exceed the default manager alignment.
		* If @align is zero, then the manager alignment is used.
		*
		* Try to make a suballocation of size @size, which will be rounded
		* up to the alignment specified in specified in drm_suballoc_manager_init().
		*
		* Return: a new suballocated bo, or an ERR_PTR.
		*/
		struct drm_suballoc *
		drm_suballoc_new(struct drm_suballoc_manager *sa_manager, size_t size,
		gfp_t gfp, bool intr, size_t align)
		{
		struct drm_suballoc *sa;
		int err;

		sa = drm_suballoc_alloc(gfp);
		if (IS_ERR(sa))
		return sa;

		err = drm_suballoc_insert(sa_manager, sa, size, intr, align);
		if (err) {
		drm_suballoc_free(sa, NULL);
		return ERR_PTR(err);
		}

		return sa;
		}
		EXPORT_SYMBOL(drm_suballoc_new);

		@@ -405,6 +466,11 @@ void drm_suballoc_free(struct drm_suballoc *suballoc,
		if (!suballoc)
		return;

		if (!suballoc->manager) {
		kfree(suballoc);
		return;
		}

		sa_manager = suballoc->manager;

		spin_lock(&sa_manager->wq.lock);