diff options
| author | Linus Torvalds <torvalds@linux-foundation.org> | 2026-11-20 20:43:06 -0800 |
|---|---|---|
| committer | Linus Torvalds <torvalds@linux-foundation.org> | 2026-11-20 20:43:06 -0800 |
| commit | c44104f3642da720164042623e4832836aefdd8e (patch) | |
| tree | 76fc4494b40b186831ee690b8a335a0cb6b87480 /drivers | |
| parent | aa31d5f8b151b786b748c6bfc9a8c4f1855c8adc (diff) | |
| parent | ce29b8f9fb606f87014c2d05483a3fef05a11f38 (diff) | |
Pull drm fixes from Dave Airlie:
"Weekly fixes, around the usual size, though it looks like vmwgfx got
hit with a lot of analysis and has a bunch of validation fixes.
nouveau fixes for a 7.3 regression.
I know of one open i915 7.3 regressions that hopefully a fix will land
next week. Otherwise amdgpu and xe have the most with a scattering for
others.
core:
- syncobj: Limit allocations
- vblank: Resolve deadlock in timer
amdgpu:
- GPUVM fixes
- SMU 8 fix
- PCO quirk
- ATPX lifetime fix
- Unwinding fix for module loading failure
- UserQ fix
- HDMI fixes
- DML2 fix
- DC DRAM config fixes
- DCN 4.2 fixes
- DC pre-OS clock handling fixes
- DPMS fix
- Cleaner shader fixes for multi-XCC parts
- Vblank fix for GPU resets
- Properly handle firmware with different trust athorities
- Freesync/VRR fixes
- Backlight fix
- Display warning fixes
- PSR fixes
amdkfd:
- SVM fixes
radeon:
- Bounds checks in vbios parsing
- ATPX lifetime fix
xe:
- hwmon error handling fixes
- Treat CT-disabled TLB invalidation as cancelled
- Validate BOs on export to charge the exporter
- Always free requested IRQs on uninstall
- Reset TLB invalidation state in submit fini
- Use ordered clock reads for engine cycles cpu_delta
- Treat non-fatal PCIe errors as recovered
i915:
- Regression fix for GitLab #16595 and #17423: 4K displays
corrupt/black on CML/KBL
- DSB programming fix for GOSUB
imagination:
- Use correct function for polling non-iomem
ivpu:
- Fix race condition in recovery
nouveau:
- Fix instmem io_mapping faults and slowdowns
omap:
- dss: Fix handling deferrals
qaic:
- Harden ioctl checks
rocket:
- iommu fixes
- lifetime and validation fixes
- clock request fix
- devicetre core count fix
tilcdc:
- Fix drvdata in suspend/resume
vc4:
- async flip fixes
- off by one shader record
- object lifetime fixes
- two dsi fixes
vmwgfx:
- bounds checking fixes
- validation fixes"
* tag 'drm-fixes-2026-11-21' of https://gitlab.freedesktop.org/drm/kernel: (111 commits)
drm/vc4: Clear the slice caches before resetting a stalled GPU
drm/vc4: Start shader code at varying offsets in its BO
drm/vc4: Check for a validated shader before reading its thread mode
drm/vc4: Fix off-by-one in the shader record BO handle check
MAINTAINERS: Add Dmitry Baryshkov as bridge maintainer
MAINTAINERS: Remove myself for VC4 DRM driver
MAINTAINERS: Remove Andrzej Hajda from bridge maintainers
MAINTAINERS: Remove Jonas Karlman from bridge reviewers
MAINTAINERS: Move Tegra DRM under drm-misc
MAINTAINERS: Move Keem Bay DRM under drm-misc
MAINTAINERS: Move armada DRM under drm-misc
drm/xe/hwmon: Propagate all hardware read errors
drm/xe/hwmon: Report errors using structured xe_log API
drm/xe/log: Add VRAM, PAT, and HWMON DRIVER_HARDWARE components
drm/xe/guc: Treat CT-disabled TLB invalidation as cancelled
drm/xe/dma-buf: Validate BOs on export to charge the exporter
drm/xe/irq: Always free requested IRQs on uninstall
drm/xe/guc: Reset TLB invalidation state in submit fini
drm/xe/query: Use ordered clock reads for engine cycles cpu_delta
drm/xe/ras: Treat non-fatal PCIe errors as recovered
...
Diffstat (limited to 'drivers')
109 files changed, 2045 insertions, 624 deletions
diff --git a/drivers/accel/ivpu/ivpu_pm.c b/drivers/accel/ivpu/ivpu_pm.c index aa813262253e..e4b79c946ca0 100644 --- a/drivers/accel/ivpu/ivpu_pm.c +++ b/drivers/accel/ivpu/ivpu_pm.c @@ -150,8 +150,8 @@ static void ivpu_pm_reset_complete(struct ivpu_device *vdev) up_write(&vdev->pm->reset_lock); atomic_set(&vdev->pm->reset_pending, 0); - pm_runtime_mark_last_busy(vdev->drm.dev); pm_runtime_enable(vdev->drm.dev); + pm_request_autosuspend(vdev->drm.dev); } static void ivpu_pm_recovery_work(struct work_struct *work) @@ -415,6 +415,7 @@ void ivpu_pm_init(struct ivpu_device *vdev) atomic_set(&pm->engine_reset_counter, 0); INIT_WORK(&pm->recovery_work, ivpu_pm_recovery_work); + disable_work(&pm->recovery_work); INIT_DELAYED_WORK(&pm->job_timeout_work, ivpu_job_timeout_work); if (ivpu_disable_recovery) @@ -439,6 +440,12 @@ void ivpu_pm_enable(struct ivpu_device *vdev) { struct device *dev = vdev->drm.dev; + enable_work(&vdev->pm->recovery_work); + if (atomic_read(&vdev->pm->reset_pending)) { + queue_work(system_dfl_wq, &vdev->pm->recovery_work); + flush_work(&vdev->pm->recovery_work); + } + pm_runtime_allow(dev); pm_runtime_put_autosuspend(dev); } diff --git a/drivers/accel/qaic/qaic_data.c b/drivers/accel/qaic/qaic_data.c index ee35e13091b3..be3ceb8c51a0 100644 --- a/drivers/accel/qaic/qaic_data.c +++ b/drivers/accel/qaic/qaic_data.c @@ -1256,6 +1256,11 @@ static int send_bo_list_to_device(struct qaic_device *qdev, struct drm_file *fil goto unlock_bo; } + if (bo->dbc->id != dbc->id) { + ret = -EINVAL; + goto unlock_bo; + } + if (is_partial && pexec[i].resize > bo->base.size) { ret = -EINVAL; goto unlock_bo; @@ -1769,6 +1774,17 @@ int qaic_wait_bo_ioctl(struct drm_device *dev, void *data, struct drm_file *file } bo = to_qaic_bo(obj); + + if (!bo->sliced) { + ret = -EINVAL; + goto put_obj; + } + + if (bo->dbc->id != dbc->id) { + ret = -EINVAL; + goto put_obj; + } + timeout = args->timeout ? args->timeout : wait_exec_default_timeout_ms; timeout = msecs_to_jiffies(timeout); ret = wait_for_completion_interruptible_timeout(&bo->xfer_done, timeout); diff --git a/drivers/accel/rocket/rocket_core.c b/drivers/accel/rocket/rocket_core.c index b3b2fa9ba645..d4c06ad4ba95 100644 --- a/drivers/accel/rocket/rocket_core.c +++ b/drivers/accel/rocket/rocket_core.c @@ -28,6 +28,10 @@ int rocket_core_init(struct rocket_core *core) if (err) return dev_err_probe(dev, err, "failed to get resets for core %d\n", core->index); + core->clks[ROCKET_CLK_ACLK].id = "aclk"; + core->clks[ROCKET_CLK_HCLK].id = "hclk"; + core->clks[ROCKET_CLK_NPU].id = "npu"; + core->clks[ROCKET_CLK_PCLK].id = "pclk"; err = devm_clk_bulk_get(dev, ARRAY_SIZE(core->clks), core->clks); if (err) return dev_err_probe(dev, err, "failed to get clocks for core %d\n", core->index); diff --git a/drivers/accel/rocket/rocket_core.h b/drivers/accel/rocket/rocket_core.h index f6d7382854ca..0b7e82ae7ef2 100644 --- a/drivers/accel/rocket/rocket_core.h +++ b/drivers/accel/rocket/rocket_core.h @@ -27,16 +27,28 @@ #define rocket_core_writel(core, reg, value) \ writel(value, (core)->core_iomem + (REG_CORE_##reg) - REG_CORE_S_STATUS) +enum rocket_clk { + ROCKET_CLK_ACLK, + ROCKET_CLK_HCLK, + ROCKET_CLK_NPU, + ROCKET_CLK_PCLK, + ROCKET_CLK_MAX, +}; + struct rocket_core { struct device *dev; struct rocket_device *rdev; + /* + * Hardware number of the core: its position among the core nodes in + * the devicetree. + */ unsigned int index; int irq; void __iomem *pc_iomem; void __iomem *cna_iomem; void __iomem *core_iomem; - struct clk_bulk_data clks[4]; + struct clk_bulk_data clks[ROCKET_CLK_MAX]; struct reset_control_bulk_data resets[2]; struct iommu_group *iommu_group; diff --git a/drivers/accel/rocket/rocket_drv.c b/drivers/accel/rocket/rocket_drv.c index 5d7805c41dc3..e62a20edeca7 100644 --- a/drivers/accel/rocket/rocket_drv.c +++ b/drivers/accel/rocket/rocket_drv.c @@ -24,48 +24,57 @@ */ static struct platform_device *drm_dev; static struct rocket_device *rdev; +static void *rdev_group; static void -rocket_iommu_domain_destroy(struct kref *kref) +rocket_vm_destroy(struct kref *kref) { - struct rocket_iommu_domain *domain = container_of(kref, struct rocket_iommu_domain, kref); + struct rocket_vm *vm = container_of(kref, struct rocket_vm, kref); - iommu_domain_free(domain->domain); - domain->domain = NULL; - kfree(domain); + drm_mm_takedown(&vm->mm); + mutex_destroy(&vm->lock); + iommu_domain_free(vm->domain); + vm->domain = NULL; + kfree(vm); } -static struct rocket_iommu_domain* -rocket_iommu_domain_create(struct device *dev) +static struct rocket_vm * +rocket_vm_create(struct device *dev) { - struct rocket_iommu_domain *domain = kmalloc_obj(*domain); + struct rocket_vm *vm = kmalloc_obj(*vm); + u64 start, end; void *err; - if (!domain) + if (!vm) return ERR_PTR(-ENOMEM); - domain->domain = iommu_paging_domain_alloc(dev); - if (IS_ERR(domain->domain)) { - err = ERR_CAST(domain->domain); - kfree(domain); + vm->domain = iommu_paging_domain_alloc(dev); + if (IS_ERR(vm->domain)) { + err = ERR_CAST(vm->domain); + kfree(vm); return err; } - kref_init(&domain->kref); - return domain; + start = vm->domain->geometry.aperture_start; + end = vm->domain->geometry.aperture_end; + drm_mm_init(&vm->mm, start, end - start + 1); + mutex_init(&vm->lock); + kref_init(&vm->kref); + + return vm; } -struct rocket_iommu_domain * -rocket_iommu_domain_get(struct rocket_file_priv *rocket_priv) +struct rocket_vm * +rocket_vm_get(struct rocket_file_priv *rocket_priv) { - kref_get(&rocket_priv->domain->kref); - return rocket_priv->domain; + kref_get(&rocket_priv->vm->kref); + return rocket_priv->vm; } void -rocket_iommu_domain_put(struct rocket_iommu_domain *domain) +rocket_vm_put(struct rocket_vm *vm) { - kref_put(&domain->kref, rocket_iommu_domain_destroy); + kref_put(&vm->kref, rocket_vm_destroy); } static int @@ -73,7 +82,6 @@ rocket_open(struct drm_device *dev, struct drm_file *file) { struct rocket_device *rdev = to_rocket_device(dev); struct rocket_file_priv *rocket_priv; - u64 start, end; int ret; if (!try_module_get(THIS_MODULE)) @@ -86,29 +94,22 @@ rocket_open(struct drm_device *dev, struct drm_file *file) } rocket_priv->rdev = rdev; - rocket_priv->domain = rocket_iommu_domain_create(rdev->cores[0].dev); - if (IS_ERR(rocket_priv->domain)) { - ret = PTR_ERR(rocket_priv->domain); + rocket_priv->vm = rocket_vm_create(rdev->cores[0].dev); + if (IS_ERR(rocket_priv->vm)) { + ret = PTR_ERR(rocket_priv->vm); goto err_free; } file->driver_priv = rocket_priv; - start = rocket_priv->domain->domain->geometry.aperture_start; - end = rocket_priv->domain->domain->geometry.aperture_end; - drm_mm_init(&rocket_priv->mm, start, end - start + 1); - mutex_init(&rocket_priv->mm_lock); - ret = rocket_job_open(rocket_priv); if (ret) - goto err_mm_takedown; + goto err_vm_put; return 0; -err_mm_takedown: - mutex_destroy(&rocket_priv->mm_lock); - drm_mm_takedown(&rocket_priv->mm); - rocket_iommu_domain_put(rocket_priv->domain); +err_vm_put: + rocket_vm_put(rocket_priv->vm); err_free: kfree(rocket_priv); err_put_mod: @@ -122,9 +123,7 @@ rocket_postclose(struct drm_device *dev, struct drm_file *file) struct rocket_file_priv *rocket_priv = file->driver_priv; rocket_job_close(rocket_priv); - mutex_destroy(&rocket_priv->mm_lock); - drm_mm_takedown(&rocket_priv->mm); - rocket_iommu_domain_put(rocket_priv->domain); + rocket_vm_put(rocket_priv->vm); kfree(rocket_priv); module_put(THIS_MODULE); } @@ -157,20 +156,45 @@ static const struct drm_driver rocket_drm_driver = { .desc = "rocket DRM", }; +static int rocket_core_hw_index(struct device *dev) +{ + struct device_node *np; + int index = 0; + + for_each_matching_node(np, dev->driver->of_match_table) { + if (np == dev->of_node) { + of_node_put(np); + return index; + } + index++; + } + + return -ENODEV; +} + static int rocket_probe(struct platform_device *pdev) { + int index = rocket_core_hw_index(&pdev->dev); int ret; + if (index < 0) + return index; + if (rdev == NULL) { /* First core probing, initialize DRM device. */ + rdev_group = devres_open_group(&drm_dev->dev, NULL, GFP_KERNEL); + if (!rdev_group) + return -ENOMEM; rdev = rocket_device_init(drm_dev, &rocket_drm_driver); if (IS_ERR(rdev)) { int err = PTR_ERR(rdev); dev_err(&pdev->dev, "failed to initialize rocket device\n"); rdev = NULL; + devres_release_group(&drm_dev->dev, rdev_group); return err; } + devres_close_group(&drm_dev->dev, rdev_group); } unsigned int core = rdev->num_cores; @@ -179,7 +203,7 @@ static int rocket_probe(struct platform_device *pdev) rdev->cores[core].rdev = rdev; rdev->cores[core].dev = &pdev->dev; - rdev->cores[core].index = core; + rdev->cores[core].index = index; rdev->num_cores++; @@ -190,6 +214,7 @@ static int rocket_probe(struct platform_device *pdev) if (rdev->num_cores == 0) { rocket_device_fini(rdev); rdev = NULL; + devres_release_group(&drm_dev->dev, rdev_group); } } @@ -213,6 +238,7 @@ static void rocket_remove(struct platform_device *pdev) /* Last core removed, deinitialize DRM device. */ rocket_device_fini(rdev); rdev = NULL; + devres_release_group(&drm_dev->dev, rdev_group); } } diff --git a/drivers/accel/rocket/rocket_drv.h b/drivers/accel/rocket/rocket_drv.h index 2c673bb99ccc..7069ececffc4 100644 --- a/drivers/accel/rocket/rocket_drv.h +++ b/drivers/accel/rocket/rocket_drv.h @@ -11,22 +11,24 @@ extern const struct dev_pm_ops rocket_pm_ops; -struct rocket_iommu_domain { +struct rocket_vm { struct iommu_domain *domain; + struct drm_mm mm; + /* protects @mm */ + struct mutex lock; struct kref kref; }; struct rocket_file_priv { struct rocket_device *rdev; - struct rocket_iommu_domain *domain; - struct drm_mm mm; - struct mutex mm_lock; + struct rocket_vm *vm; + struct drm_gpu_scheduler **scheds; struct drm_sched_entity sched_entity; }; -struct rocket_iommu_domain *rocket_iommu_domain_get(struct rocket_file_priv *rocket_priv); -void rocket_iommu_domain_put(struct rocket_iommu_domain *domain); +struct rocket_vm *rocket_vm_get(struct rocket_file_priv *rocket_priv); +void rocket_vm_put(struct rocket_vm *vm); #endif diff --git a/drivers/accel/rocket/rocket_gem.c b/drivers/accel/rocket/rocket_gem.c index d981c6a93ff1..8f802df3e0f1 100644 --- a/drivers/accel/rocket/rocket_gem.c +++ b/drivers/accel/rocket/rocket_gem.c @@ -14,20 +14,20 @@ static void rocket_gem_bo_free(struct drm_gem_object *obj) { struct rocket_gem_object *bo = to_rocket_bo(obj); - struct rocket_file_priv *rocket_priv = bo->driver_priv; + struct rocket_vm *vm = bo->vm; size_t unmapped; drm_WARN_ON(obj->dev, refcount_read(&bo->base.pages_use_count) > 1); - unmapped = iommu_unmap(bo->domain->domain, bo->mm.start, bo->size); + unmapped = iommu_unmap(vm->domain, bo->mm.start, bo->size); drm_WARN_ON(obj->dev, unmapped != bo->size); - mutex_lock(&rocket_priv->mm_lock); + mutex_lock(&vm->lock); drm_mm_remove_node(&bo->mm); - mutex_unlock(&rocket_priv->mm_lock); + mutex_unlock(&vm->lock); - rocket_iommu_domain_put(bo->domain); - bo->domain = NULL; + rocket_vm_put(vm); + bo->vm = NULL; drm_gem_shmem_free(&bo->base); } @@ -64,6 +64,7 @@ int rocket_ioctl_create_bo(struct drm_device *dev, void *data, struct drm_file * struct drm_gem_shmem_object *shmem_obj; struct rocket_gem_object *rkt_obj; struct drm_gem_object *gem_obj; + struct rocket_vm *vm; struct sg_table *sgt; int ret; @@ -74,8 +75,8 @@ int rocket_ioctl_create_bo(struct drm_device *dev, void *data, struct drm_file * gem_obj = &shmem_obj->base; rkt_obj = to_rocket_bo(gem_obj); - rkt_obj->driver_priv = rocket_priv; - rkt_obj->domain = rocket_iommu_domain_get(rocket_priv); + vm = rocket_vm_get(rocket_priv); + rkt_obj->vm = vm; rkt_obj->size = args->size; rkt_obj->offset = 0; @@ -85,15 +86,15 @@ int rocket_ioctl_create_bo(struct drm_device *dev, void *data, struct drm_file * goto err; } - mutex_lock(&rocket_priv->mm_lock); - ret = drm_mm_insert_node_generic(&rocket_priv->mm, &rkt_obj->mm, + mutex_lock(&vm->lock); + ret = drm_mm_insert_node_generic(&vm->mm, &rkt_obj->mm, rkt_obj->size, PAGE_SIZE, 0, 0); - mutex_unlock(&rocket_priv->mm_lock); + mutex_unlock(&vm->lock); if (ret) goto err; - ret = iommu_map_sgtable(rocket_priv->domain->domain, + ret = iommu_map_sgtable(vm->domain, rkt_obj->mm.start, shmem_obj->sgt, IOMMU_READ | IOMMU_WRITE); @@ -118,15 +119,17 @@ int rocket_ioctl_create_bo(struct drm_device *dev, void *data, struct drm_file * return 0; err_unmap: - iommu_unmap(rocket_priv->domain->domain, + iommu_unmap(vm->domain, rkt_obj->mm.start, rkt_obj->size); err_remove_node: - mutex_lock(&rocket_priv->mm_lock); + mutex_lock(&vm->lock); drm_mm_remove_node(&rkt_obj->mm); - mutex_unlock(&rocket_priv->mm_lock); + mutex_unlock(&vm->lock); err: + rocket_vm_put(rkt_obj->vm); + rkt_obj->vm = NULL; drm_gem_shmem_object_free(gem_obj); return ret; diff --git a/drivers/accel/rocket/rocket_gem.h b/drivers/accel/rocket/rocket_gem.h index 240430334509..e1fbbd8cf719 100644 --- a/drivers/accel/rocket/rocket_gem.h +++ b/drivers/accel/rocket/rocket_gem.h @@ -9,9 +9,7 @@ struct rocket_gem_object { struct drm_gem_shmem_object base; - struct rocket_file_priv *driver_priv; - - struct rocket_iommu_domain *domain; + struct rocket_vm *vm; struct drm_mm_node mm; size_t size; u32 offset; diff --git a/drivers/accel/rocket/rocket_job.c b/drivers/accel/rocket/rocket_job.c index c3edb94355a3..454d465a39e3 100644 --- a/drivers/accel/rocket/rocket_job.c +++ b/drivers/accel/rocket/rocket_job.c @@ -201,12 +201,13 @@ static int rocket_acquire_object_fences(struct drm_gem_object **bos, static void rocket_attach_object_fences(struct drm_gem_object **bos, int bo_count, - struct dma_fence *fence) + struct dma_fence *fence, + enum dma_resv_usage usage) { int i; for (i = 0; i < bo_count; i++) - dma_resv_add_fence(bos[i]->resv, fence, DMA_RESV_USAGE_WRITE); + dma_resv_add_fence(bos[i]->resv, fence, usage); } static int rocket_job_push(struct rocket_job *job) @@ -248,7 +249,10 @@ static int rocket_job_push(struct rocket_job *job) drm_sched_entity_push_job(&job->base); } - rocket_attach_object_fences(job->out_bos, job->out_bo_count, job->inference_done_fence); + rocket_attach_object_fences(job->in_bos, job->in_bo_count, + job->inference_done_fence, DMA_RESV_USAGE_READ); + rocket_attach_object_fences(job->out_bos, job->out_bo_count, + job->inference_done_fence, DMA_RESV_USAGE_WRITE); err_unlock: drm_gem_unlock_reservations(bos, bo_count, &acquire_ctx); @@ -264,7 +268,7 @@ static void rocket_job_cleanup(struct kref *ref) refcount); unsigned int i; - rocket_iommu_domain_put(job->domain); + rocket_vm_put(job->vm); dma_fence_put(job->done_fence); dma_fence_put(job->inference_done_fence); @@ -345,7 +349,7 @@ static struct dma_fence *rocket_job_run(struct drm_sched_job *sched_job) if (ret < 0) goto err_put_fences; - ret = iommu_attach_group(job->domain->domain, core->iommu_group); + ret = iommu_attach_group(job->vm->domain, core->iommu_group); if (ret < 0) goto err_put_pm; @@ -369,39 +373,56 @@ static void rocket_job_handle_irq(struct rocket_core *core) { pm_runtime_mark_last_busy(core->dev); - rocket_pc_writel(core, OPERATION_ENABLE, 0x0); - rocket_pc_writel(core, INTERRUPT_CLEAR, 0x1ffff); + scoped_guard(mutex, &core->job_lock) { + /* + * Stopping the block belongs under the lock. hw_submit() writes + * OPERATION_ENABLE too, and outside the lock this zero can land + * after that one and stop a task that has only just started. + */ + rocket_pc_writel(core, OPERATION_ENABLE, 0x0); + rocket_pc_writel(core, INTERRUPT_CLEAR, 0x1ffff); - scoped_guard(mutex, &core->job_lock) if (core->in_flight_job) { if (core->in_flight_job->next_task_idx < core->in_flight_job->task_count) { rocket_job_hw_submit(core, core->in_flight_job); return; } - iommu_detach_group(NULL, iommu_group_get(core->dev)); + iommu_detach_group(NULL, core->iommu_group); dma_fence_signal(core->in_flight_job->done_fence); pm_runtime_put_autosuspend(core->dev); core->in_flight_job = NULL; } + } } static void rocket_reset(struct rocket_core *core, struct drm_sched_job *bad) { + bool put_job_ref; + if (!atomic_read(&core->reset.pending)) return; drm_sched_stop(&core->sched, bad); + scoped_guard(mutex, &core->job_lock) { + if (pm_runtime_get_if_active(core->dev) > 0) { + rocket_pc_writel(core, INTERRUPT_MASK, 0x0); + rocket_pc_writel(core, INTERRUPT_CLEAR, 0x1ffff); + pm_runtime_put_autosuspend(core->dev); + } + } + + synchronize_irq(core->irq); + /* * Remaining interrupts have been handled, but we might still have * stuck jobs. Let's make sure the PM counters stay balanced by - * manually calling pm_runtime_put_noidle(). + * dropping the job's reference once the core has been reset. */ scoped_guard(mutex, &core->job_lock) { - if (core->in_flight_job) - pm_runtime_put_noidle(core->dev); + put_job_ref = core->in_flight_job; iommu_detach_group(NULL, core->iommu_group); @@ -411,6 +432,9 @@ rocket_reset(struct rocket_core *core, struct drm_sched_job *bad) /* Proceed with reset now. */ rocket_core_reset(core); + if (put_job_ref) + pm_runtime_put_autosuspend(core->dev); + /* NPU has been reset, we can clear the reset pending bit. */ atomic_set(&core->reset.pending, 0); @@ -538,6 +562,9 @@ int rocket_job_open(struct rocket_file_priv *rocket_priv) unsigned int core; int ret; + if (!scheds) + return -ENOMEM; + for (core = 0; core < rdev->num_cores; core++) scheds[core] = &rdev->cores[core].sched; @@ -545,18 +572,20 @@ int rocket_job_open(struct rocket_file_priv *rocket_priv) DRM_SCHED_PRIORITY_NORMAL, scheds, rdev->num_cores, NULL); - if (WARN_ON(ret)) - return ret; + if (ret) + kfree(scheds); + else + rocket_priv->scheds = scheds; - return 0; + return ret; } void rocket_job_close(struct rocket_file_priv *rocket_priv) { struct drm_sched_entity *entity = &rocket_priv->sched_entity; - kfree(entity->sched_list); drm_sched_entity_destroy(entity); + kfree(rocket_priv->scheds); } int rocket_job_is_idle(struct rocket_core *core) @@ -586,7 +615,7 @@ static int rocket_ioctl_submit_job(struct drm_device *dev, struct drm_file *file kref_init(&rjob->refcount); rjob->rdev = rdev; - rjob->domain = rocket_iommu_domain_get(file_priv); + rjob->vm = rocket_vm_get(file_priv); ret = drm_sched_job_init(&rjob->base, &file_priv->sched_entity, diff --git a/drivers/accel/rocket/rocket_job.h b/drivers/accel/rocket/rocket_job.h index 4ae00feec3b9..9373c3d0273b 100644 --- a/drivers/accel/rocket/rocket_job.h +++ b/drivers/accel/rocket/rocket_job.h @@ -36,7 +36,7 @@ struct rocket_job { /* Fence to be signaled by IRQ handler when the job is complete. */ struct dma_fence *done_fence; - struct rocket_iommu_domain *domain; + struct rocket_vm *vm; struct kref refcount; }; diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c index e2a4644896ca..f9467786aab9 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c @@ -45,6 +45,7 @@ struct amdgpu_atpx { static struct amdgpu_atpx_priv { bool atpx_detected; bool bridge_pm_usable; + bool handler_registered; unsigned int quirks; /* handle for device - and atpx */ acpi_handle dhandle; @@ -663,7 +664,8 @@ void amdgpu_register_atpx_handler(void) if (!r) return; - vga_switcheroo_register_handler(&amdgpu_atpx_handler, handler_flags); + if (!vga_switcheroo_register_handler(&amdgpu_atpx_handler, handler_flags)) + amdgpu_atpx_priv.handler_registered = true; } /** @@ -673,5 +675,14 @@ void amdgpu_register_atpx_handler(void) */ void amdgpu_unregister_atpx_handler(void) { + /* + * vga_switcheroo has a single handler slot and unregistering clears it + * no matter who set it, so leave a handler registered by another + * driver, such as apple-gmux, in place. + */ + if (!amdgpu_atpx_priv.handler_registered) + return; + vga_switcheroo_unregister_handler(); + amdgpu_atpx_priv.handler_registered = false; } diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c index 19a566187dfb..b24ccdd958a7 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c @@ -2101,6 +2101,10 @@ static int amdgpu_device_ip_early_init(struct amdgpu_device *adev) amdgpu_ip_version((adev), GC_HWIP, 0) == IP_VERSION(9, 4, 4); } + /* Needs the register bases, and must be known before requesting firmware */ + if (adev->firmware.load_type == AMDGPU_FW_LOAD_PSP) + amdgpu_psp_init_fw_variant(adev); + total = true; for (i = 0; i < adev->num_ip_blocks; i++) { ip_block = &adev->ip_blocks[i]; diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c index 3e5634de077f..e3b3a2eebd95 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c @@ -3221,7 +3221,7 @@ static int __init amdgpu_init(void) /* Ignore KFD init failures when CONFIG_HSA_AMD is not set. */ r = amdgpu_amdkfd_init(); if (r && r != -ENOENT) - goto error_fini_sync; + goto error_release_acpi; if (amdgpu_pp_feature_mask & PP_OVERDRIVE_MASK) { add_taint(TAINT_CPU_OUT_OF_SPEC, LOCKDEP_STILL_OK); @@ -3230,9 +3230,17 @@ static int __init amdgpu_init(void) } /* let modprobe override vga console setting */ - return pci_register_driver(&amdgpu_kms_pci_driver); + r = pci_register_driver(&amdgpu_kms_pci_driver); + if (r) + goto error_fini_kfd; + + return 0; -error_fini_sync: +error_fini_kfd: + amdgpu_amdkfd_fini(); +error_release_acpi: + amdgpu_acpi_release(); + amdgpu_unregister_atpx_handler(); amdgpu_sync_fini(); return r; } diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c index b190b6c9adf2..c1d715749e02 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c @@ -340,7 +340,7 @@ static void amdgpu_gem_object_close(struct drm_gem_object *obj, drm_exec_init(&exec, DRM_EXEC_IGNORE_DUPLICATES, 0); drm_exec_until_all_locked(&exec) { - r = drm_exec_prepare_obj(&exec, &bo->tbo.base, 1); + r = drm_exec_prepare_obj(&exec, &bo->tbo.base, 2); /* clear_freed + last_tlb_inv */ drm_exec_retry_on_contention(&exec); if (unlikely(r)) goto out_unlock; @@ -371,11 +371,14 @@ static void amdgpu_gem_object_close(struct drm_gem_object *obj, dev_err(adev->dev, "failed to clear page " "tables on GEM object close (%ld)\n", r); if (r || !fence) - goto out_unlock; + goto out_tlb; - amdgpu_bo_fence(bo, fence, true); + dma_resv_add_fence(bo->tbo.base.resv, fence, DMA_RESV_USAGE_BOOKKEEP); dma_fence_put(fence); +out_tlb: + dma_resv_add_fence(bo->tbo.base.resv, vm->last_tlb_inv, DMA_RESV_USAGE_BOOKKEEP); + out_unlock: if (r && !drm_dev_is_unplugged(adev_to_drm(adev))) dev_err(adev->dev, "leaking bo va (%ld)\n", r); diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c index 335c523592bf..d442a2d96394 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c @@ -474,7 +474,7 @@ static int amdgpu_hw_ip_info(struct amdgpu_device *adev, !adev->gfx.compute_ring[i].no_user_submission) ++num_rings; - if (!adev->sdma.disable_uq) { + if (!adev->gfx.disable_uq) { for (i = 0; i < AMDGPU_MES_MAX_COMPUTE_PIPES; i++) num_slots += hweight32(adev->mes.compute_hqd_mask[i]); } @@ -489,7 +489,7 @@ static int amdgpu_hw_ip_info(struct amdgpu_device *adev, !adev->sdma.instance[i].ring.no_user_submission) ++num_rings; - if (!adev->gfx.disable_uq) { + if (!adev->sdma.disable_uq) { for (i = 0; i < AMDGPU_MES_MAX_SDMA_PIPES; i++) num_slots += hweight32(adev->mes.sdma_hqd_mask[i]); } @@ -1688,6 +1688,7 @@ u32 amdgpu_get_vblank_counter_kms(struct drm_crtc *crtc) struct drm_device *dev = crtc->dev; unsigned int pipe = crtc->index; struct amdgpu_device *adev = drm_to_adev(dev); + bool locked = false; int vpos, hpos, stat; u32 count; @@ -1695,9 +1696,26 @@ u32 amdgpu_get_vblank_counter_kms(struct drm_crtc *crtc) DRM_ERROR("Invalid crtc %u\n", pipe); return -EINVAL; } - if (!down_read_trylock(&adev->reset_domain->sem)) - return drm_crtc_vblank_count(crtc); + /* + * A GPU reset is in progress and the display hardware cannot be read + * safely. Return the hardware counter value DRM already cached rather + * than the software vblank count: the core feeds this callback's + * result back into vblank->last, and a software count lives in a + * different numeric domain, which later trips + * drm_WARN_ON_ONCE(cur_vblank != vblank->last) in + * drm_update_vblank_count(). + * + * Only task context has to back off. Vblank interrupts only arrive + * while a CRTC is scanning out, so the interrupt path can read the + * hardware, and it has to keep counting: vblank waits that already + * sleep when a reset takes the semaphore never complete otherwise. + */ + if (in_task()) { + if (!down_read_trylock(&adev->reset_domain->sem)) + return drm_crtc_vblank_crtc(crtc)->last; + locked = true; + } /* The hw increments its frame counter at start of vsync, not at start * of vblank, as is required by DRM core vblank counter handling. @@ -1743,7 +1761,8 @@ u32 amdgpu_get_vblank_counter_kms(struct drm_crtc *crtc) DRM_DEBUG_VBL("NULL mode info! Returned count may be wrong.\n"); } - up_read(&adev->reset_domain->sem); + if (locked) + up_read(&adev->reset_domain->sem); return count; } diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.c index 82a2684dbd2e..6d693b5249dd 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.c @@ -404,6 +404,26 @@ static uint64_t psp_get_runtime_db_header_pos(struct amdgpu_device *adev) } /* + * Which firmware the platform needs, as reported by the PSP in C2PMSG_63: the + * signing scheme and whether this is a preproduction part. The defaults are kept if + * the ASIC doesn't report it or it can't be read. + */ +void amdgpu_psp_init_fw_variant(struct amdgpu_device *adev) +{ + if (amdgpu_sriov_vf(adev)) + return; + + switch (amdgpu_ip_version(adev, MP0_HWIP, 0)) { + case IP_VERSION(15, 0, 0): + case IP_VERSION(15, 0, 9): + psp_v15_0_0_get_fw_variant(adev); + break; + default: + break; + } +} + +/* * Helper funciton to query psp runtime database entry * * @adev: amdgpu_device pointer diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.h index a4ec60f6c317..7d8fc8eb2b12 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.h +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_psp.h @@ -631,6 +631,7 @@ int psp_ta_invoke(struct psp_context *psp, int psp_xgmi_initialize(struct psp_context *psp, bool set_extended_data, bool load_ta); bool psp_is_xgmi_ta_supported(struct psp_context *psp); +void amdgpu_psp_init_fw_variant(struct amdgpu_device *adev); int psp_xgmi_terminate(struct psp_context *psp); int psp_xgmi_invoke(struct psp_context *psp, uint32_t ta_cmd_id); int psp_xgmi_get_hive_id(struct psp_context *psp, uint64_t *hive_id); diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.c index d2ce526dd95c..1632eda91acd 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.c @@ -1527,6 +1527,37 @@ void amdgpu_ucode_ip_version_decode(struct amdgpu_device *adev, int block_type, snprintf(ucode_prefix, len, "%s_%d_%d_%d", ip_name, maj, min, rev); } +/* Add the suffix of the firmware variant before the extension: foo.bin -> foo_l.bin */ +static int amdgpu_ucode_set_suffix(struct amdgpu_device *adev, char *fname) +{ + const char *suffix; + size_t base; + + switch (adev->firmware.sign_type) { + case AMDGPU_FW_SIGN_PREPROD: + suffix = "_p.bin"; + break; + case AMDGPU_FW_SIGN_ALT: + suffix = "_l.bin"; + break; + case AMDGPU_FW_SIGN_UNKNOWN: + drm_warn(adev_to_drm(adev), "Unknown firmware signing\n"); + return -EINVAL; + default: + /* Default variant: the name is unchanged */ + return 0; + } + + if (!strends(fname, ".bin")) + return -EINVAL; + + base = strlen(fname) - strlen(".bin"); + if (strscpy(fname + base, suffix, AMDGPU_UCODE_NAME_MAX - base) < 0) + return -EOVERFLOW; + + return 0; +} + /* * amdgpu_ucode_request - Fetch and validate amdgpu microcode * @@ -1555,6 +1586,10 @@ int amdgpu_ucode_request(struct amdgpu_device *adev, const struct firmware **fw, return -EOVERFLOW; } + r = amdgpu_ucode_set_suffix(adev, fname); + if (r) + return r; + if (required == AMDGPU_UCODE_REQUIRED) r = request_firmware(fw, fname, adev->dev); else { diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.h index 35277b240f25..0b2d1bccb999 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.h +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ucode.h @@ -571,6 +571,14 @@ enum amdgpu_firmware_load_type { AMDGPU_FW_LOAD_RLC_BACKDOOR_AUTO, }; +enum amdgpu_firmware_sign_type { + AMDGPU_FW_SIGN_DEFAULT = 0, + AMDGPU_FW_SIGN_ALT, + AMDGPU_FW_SIGN_PREPROD, + /* Unexpected combination of signing bits, default firmware may not work */ + AMDGPU_FW_SIGN_UNKNOWN, +}; + enum amdgpu_ucode_required { AMDGPU_UCODE_OPTIONAL, AMDGPU_UCODE_REQUIRED, @@ -606,6 +614,7 @@ struct amdgpu_firmware_info { struct amdgpu_firmware { struct amdgpu_firmware_info ucode[AMDGPU_UCODE_ID_MAXIMUM]; enum amdgpu_firmware_load_type load_type; + enum amdgpu_firmware_sign_type sign_type; struct amdgpu_bo *fw_buf; unsigned int fw_size; unsigned int max_ucodes; diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c index 6c12d8aa3c76..1df2725d31e0 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c @@ -66,6 +66,8 @@ #define FIRMWARE_VCN5_0_1 "amdgpu/vcn_5_0_1.bin" #define FIRMWARE_VCN5_0_2 "amdgpu/vcn_5_0_2.bin" #define FIRMWARE_VCN5_3_0 "amdgpu/vcn_5_3_0.bin" +#define FIRMWARE_VCN5_3_0_ALT "amdgpu/vcn_5_3_0_l.bin" +#define FIRMWARE_VCN5_3_0_PREPROD "amdgpu/vcn_5_3_0_p.bin" MODULE_FIRMWARE(FIRMWARE_RAVEN); MODULE_FIRMWARE(FIRMWARE_PICASSO); @@ -95,6 +97,8 @@ MODULE_FIRMWARE(FIRMWARE_VCN5_0_0); MODULE_FIRMWARE(FIRMWARE_VCN5_0_1); MODULE_FIRMWARE(FIRMWARE_VCN5_0_2); MODULE_FIRMWARE(FIRMWARE_VCN5_3_0); +MODULE_FIRMWARE(FIRMWARE_VCN5_3_0_ALT); +MODULE_FIRMWARE(FIRMWARE_VCN5_3_0_PREPROD); static void amdgpu_vcn_idle_work_handler(struct work_struct *work); static void amdgpu_vcn_reg_dump_fini(struct amdgpu_device *adev); diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm_pt.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm_pt.c index c73eb416c0e2..a6d389c08524 100644 --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm_pt.c +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm_pt.c @@ -346,6 +346,33 @@ static void amdgpu_vm_pt_next_dfs(struct amdgpu_device *adev, amdgpu_vm_pt_continue_dfs((start), (entry)); \ (entry) = (cursor).entry, amdgpu_vm_pt_next_dfs((adev), &(cursor))) +/* Return the flags used for cleared PDEs/PTES */ +static uint64_t amdgpu_vm_pt_clear_flags(struct amdgpu_device *adev, + struct amdgpu_vm *vm, + unsigned int level) +{ + uint64_t flags; + + if (adev->asic_type < CHIP_VEGA10) + return 0; + + if (level != AMDGPU_VM_PTB) { + uint64_t value = 0; + + flags = AMDGPU_PDE_PTE_FLAG(adev); + if (vm->is_npa) + flags |= adev->gmc.noretry_flags; + amdgpu_gmc_get_vm_pde(adev, level, &value, &flags); + } else if (vm->is_npa) { + flags = adev->gmc.noretry_flags; + } else { + /* Workaround for fault priority problem on GMC9 */ + flags = AMDGPU_PTE_EXECUTABLE | adev->gmc.init_pte_flags; + } + + return flags; +} + /** * amdgpu_vm_pt_clear - initially clear the PDs/PTs * @@ -366,10 +393,9 @@ int amdgpu_vm_pt_clear(struct amdgpu_device *adev, struct amdgpu_vm *vm, struct ttm_operation_ctx ctx = { true, false }; struct amdgpu_vm_update_params params; struct amdgpu_bo *ancestor = &vmbo->bo; - unsigned int entries; struct amdgpu_bo *bo = &vmbo->bo; - uint64_t value = 0, flags = 0; - uint64_t addr; + unsigned int entries; + uint64_t flags; int r, idx; /* Figure out our place in the hierarchy */ @@ -404,26 +430,8 @@ int amdgpu_vm_pt_clear(struct amdgpu_device *adev, struct amdgpu_vm *vm, if (r) goto exit; - addr = 0; - - if (adev->asic_type >= CHIP_VEGA10) { - if (level != AMDGPU_VM_PTB) { - if (vm->is_npa) - flags = adev->gmc.noretry_flags; - /* Handle leaf PDEs as PTEs */ - flags |= AMDGPU_PDE_PTE_FLAG(adev); - amdgpu_gmc_get_vm_pde(adev, level, - &value, &flags); - } else if (vm->is_npa) { - flags = adev->gmc.noretry_flags; - } else { - /* Workaround for fault priority problem on GMC9 */ - flags = AMDGPU_PTE_EXECUTABLE | adev->gmc.init_pte_flags; - } - } - - r = vm->update_funcs->update(¶ms, vmbo, addr, 0, entries, - value, flags); + flags = amdgpu_vm_pt_clear_flags(adev, vm, level); + r = vm->update_funcs->update(¶ms, vmbo, 0, 0, entries, 0, flags); if (r) goto exit; @@ -714,15 +722,9 @@ static void amdgpu_vm_pte_update_flags(struct amdgpu_vm_update_params *params, flags |= AMDGPU_PDE_PTE_FLAG(params->adev); amdgpu_gmc_get_vm_pde(adev, level, &addr, &flags); - } else if (adev->asic_type >= CHIP_VEGA10 && - !(flags & AMDGPU_PTE_VALID) && + } else if (!(flags & AMDGPU_PTE_VALID) && !(flags & AMDGPU_PTE_PRT_FLAG(params->adev))) { - - /* Workaround for fault priority problem on GMC9 and GFX12, - * EXECUTABLE for GMC9 fault priority and init_pte_flags - * (e.g. AMDGPU_PTE_IS_PTE on GFX12) - */ - flags |= AMDGPU_PTE_EXECUTABLE | adev->gmc.init_pte_flags; + flags |= amdgpu_vm_pt_clear_flags(adev, params->vm, level); } /* diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v11_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v11_0.c index 11388b666037..da4e1cf9ed63 100644 --- a/drivers/gpu/drm/amd/amdgpu/gfx_v11_0.c +++ b/drivers/gpu/drm/amd/amdgpu/gfx_v11_0.c @@ -134,13 +134,29 @@ MODULE_FIRMWARE("amdgpu/gc_11_5_6_me.bin"); MODULE_FIRMWARE("amdgpu/gc_11_5_6_mec.bin"); MODULE_FIRMWARE("amdgpu/gc_11_5_6_rlc.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_0_pfp.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_pfp_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_pfp_p.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_0_me.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_me_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_me_p.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_0_mec.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_mec_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_mec_p.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_0_rlc.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_rlc_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_rlc_p.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_1_pfp.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_pfp_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_pfp_p.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_1_me.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_me_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_me_p.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_1_mec.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_mec_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_mec_p.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_1_rlc.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_rlc_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_rlc_p.bin"); static const struct amdgpu_hwip_reg_entry gc_reg_list_11_0[] = { SOC15_REG_ENTRY_STR(GC, 0, regGRBM_STATUS), diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c index 1678015ce5a9..ae1d94c5f528 100644 --- a/drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c +++ b/drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c @@ -1369,6 +1369,9 @@ struct amdgpu_gfxoff_quirk { u8 revision; }; +/* Match any chip revision in amdgpu_gfxoff_quirk.revision */ +#define AMDGPU_GFXOFF_QUIRK_ANY_REV 0xff + static const struct amdgpu_gfxoff_quirk amdgpu_gfxoff_quirk_list[] = { /* https://bugzilla.kernel.org/show_bug.cgi?id=204689 */ { 0x1002, 0x15dd, 0x1002, 0x15dd, 0xc8 }, @@ -1378,6 +1381,7 @@ static const struct amdgpu_gfxoff_quirk amdgpu_gfxoff_quirk_list[] = { { 0x1002, 0x15dd, 0x1002, 0x15dd, 0xc6 }, /* Apple MacBook Pro (15-inch, 2019) Radeon Pro Vega 20 4 GB */ { 0x1002, 0x69af, 0x106b, 0x019a, 0xc0 }, + { 0x1002, 0x15d8, 0x17aa, 0x318f, AMDGPU_GFXOFF_QUIRK_ANY_REV }, /* https://bbs.openkylin.top/t/topic/171497 */ { 0x1002, 0x15d8, 0x19e5, 0x3e14, 0xc2 }, /* HP 705G4 DM with R5 2400G */ @@ -1394,7 +1398,8 @@ static bool gfx_v9_0_should_disable_gfxoff(struct pci_dev *pdev) pdev->device == p->chip_device && pdev->subsystem_vendor == p->subsys_vendor && pdev->subsystem_device == p->subsys_device && - pdev->revision == p->revision) { + (p->revision == AMDGPU_GFXOFF_QUIRK_ANY_REV || + pdev->revision == p->revision)) { return true; } ++p; diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v9_4_2.c b/drivers/gpu/drm/amd/amdgpu/gfx_v9_4_2.c index 54bcb5fdca24..66a389121ad4 100644 --- a/drivers/gpu/drm/amd/amdgpu/gfx_v9_4_2.c +++ b/drivers/gpu/drm/amd/amdgpu/gfx_v9_4_2.c @@ -23,12 +23,14 @@ #include "amdgpu.h" #include "soc15.h" #include "soc15d.h" +#include "soc15_common.h" #include "gc/gc_9_4_2_offset.h" #include "gc/gc_9_4_2_sh_mask.h" #include "gfx_v9_0.h" #include "gfx_v9_4_2.h" +#include "gfx_v9_4_3.h" #include "amdgpu_ras.h" #include "amdgpu_gfx.h" @@ -716,56 +718,88 @@ pro_end: static int gfx_v9_clean_shaders(struct amdgpu_device *adev) { - int r; + int r = 0; /* CU_ID: 0~15, SIMD_ID: 0~3, WAVE_ID: 0 ~ 9 */ int wb_size = adev->gfx.config.max_shader_engines * CU_ID_MAX * SIMD_ID_MAX * WAVE_ID_MAX; struct amdgpu_ib wb_ib; + struct amdgpu_ring *ring; struct dma_fence *fence = NULL; + const struct soc15_reg_entry *init_regs; + u32 init_regs_size; u32 pattern = 0xa; + int xcc_id; - /* bail if the compute ring is not ready */ - if (!adev->gfx.compute_ring[0].sched.ready) + if (adev->gfx.disable_kq) { + dev_warn(adev->dev, "Cannot run shader cleaner with kernel queues disabled"); return 0; + } - /* allocate the write-back buffer from IB */ - memset(&wb_ib, 0, sizeof(wb_ib)); - r = amdgpu_ib_get(adev, NULL, (1 + wb_size) * sizeof(uint32_t), - AMDGPU_IB_POOL_DIRECT, &wb_ib); - if (r) { - dev_err(adev->dev, "failed to get ib (%d) for wb.\n", r); - return r; + /* gfx943+ has different register layout compared to gfx942.*/ + switch (amdgpu_ip_version(adev, GC_HWIP, 0)) { + case IP_VERSION(9, 4, 3): + case IP_VERSION(9, 4, 4): + case IP_VERSION(9, 5, 0): + init_regs = gfx_v9_4_3_fault_cleaner_init_regs; + init_regs_size = gfx_v9_4_3_fault_cleaner_init_regs_size; + break; + default: + init_regs = fault_cleaner_init_regs_aldebaran; + init_regs_size = ARRAY_SIZE(fault_cleaner_init_regs_aldebaran); + break; } - memset(wb_ib.ptr, 0, (1 + wb_size) * sizeof(uint32_t)); - r = gfx_v9_4_2_run_shader(adev, - &adev->gfx.compute_ring[0], - fault_cleaner_compute_shader_aldebaran, - sizeof(fault_cleaner_compute_shader_aldebaran), - fault_cleaner_init_regs_aldebaran, - ARRAY_SIZE(fault_cleaner_init_regs_aldebaran), - adev->gfx.cu_info.number * 32, - wb_ib.gpu_addr, pattern, &fence); + for_each_inst(xcc_id, adev->gfx.xcc_mask) { + ring = &adev->gfx.compute_ring[xcc_id * adev->gfx.num_compute_rings]; - if (r) { - dev_err(adev->dev, "failed to clear MI200\n"); - goto pro_end; - } + /* bail if the compute ring is not ready */ + if (!ring->sched.ready) + continue; - /* wait for the GPU to finish processing the IB */ - r = dma_fence_wait(fence, false); - if (r) - dev_err(adev->dev, "timeout to clear MI200\n"); + /* allocate the write-back buffer from IB */ + memset(&wb_ib, 0, sizeof(wb_ib)); + r = amdgpu_ib_get(adev, NULL, (1 + wb_size) * sizeof(uint32_t), + AMDGPU_IB_POOL_DIRECT, &wb_ib); + if (r) { + dev_err(adev->dev, "failed to get ib (%d) for wb.\n", r); + return r; + } + memset(wb_ib.ptr, 0, (1 + wb_size) * sizeof(uint32_t)); + + r = gfx_v9_4_2_run_shader(adev, + ring, + fault_cleaner_compute_shader_aldebaran, + sizeof(fault_cleaner_compute_shader_aldebaran), + init_regs, + init_regs_size, + adev->gfx.cu_info.number * SIMD_ID_MAX * WAVE_ID_MAX, + wb_ib.gpu_addr, pattern, &fence); + + if (r) { + dev_err(adev->dev, "failed to clear GPR on xcc %d\n", xcc_id); + goto pro_end; + } + + /* wait for the GPU to finish processing the IB */ + r = dma_fence_wait(fence, false); + if (r) + dev_err(adev->dev, "timeout to clear GPR on xcc %d\n", xcc_id); pro_end: - if (fence) - dma_fence_put(fence); - amdgpu_ib_free(&wb_ib, NULL); + if (fence) { + dma_fence_put(fence); + fence = NULL; + } + amdgpu_ib_free(&wb_ib, NULL); + + if (r) + break; + } if (r) - dev_dbg(adev->dev, "Clean GPR Failed\n"); + dev_dbg(adev->dev, "Clearing fault state failed\n"); else - dev_dbg(adev->dev, "Clean GPR Successfully\n"); + dev_dbg(adev->dev, "Fault state cleared Successfully\n"); return r; } diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v9_4_3.c b/drivers/gpu/drm/amd/amdgpu/gfx_v9_4_3.c index 01ed1701c781..968bf911542d 100644 --- a/drivers/gpu/drm/amd/amdgpu/gfx_v9_4_3.c +++ b/drivers/gpu/drm/amd/amdgpu/gfx_v9_4_3.c @@ -163,6 +163,22 @@ static const struct amdgpu_hwip_reg_entry gc_cp_reg_list_9_4_3[] = { struct amdgpu_gfx_ras gfx_v9_4_3_ras; +const struct soc15_reg_entry gfx_v9_4_3_fault_cleaner_init_regs[] = { + { SOC15_REG_ENTRY(GC, 0, regCOMPUTE_RESOURCE_LIMITS), 0x000000000 }, + { SOC15_REG_ENTRY(GC, 0, regCOMPUTE_NUM_THREAD_X), 0x40 }, + { SOC15_REG_ENTRY(GC, 0, regCOMPUTE_NUM_THREAD_Y), 1 }, + { SOC15_REG_ENTRY(GC, 0, regCOMPUTE_NUM_THREAD_Z), 1 }, + { SOC15_REG_ENTRY(GC, 0, regCOMPUTE_PGM_RSRC1), 0x00af0000 }, + { SOC15_REG_ENTRY(GC, 0, regCOMPUTE_PGM_RSRC2), 0x000000c0 }, + { SOC15_REG_ENTRY(GC, 0, regCOMPUTE_PGM_RSRC3), 0x00000000 }, + { SOC15_REG_ENTRY(GC, 0, regCOMPUTE_STATIC_THREAD_MGMT_SE0), 0xffffffff }, + { SOC15_REG_ENTRY(GC, 0, regCOMPUTE_STATIC_THREAD_MGMT_SE1), 0xffffffff }, + { SOC15_REG_ENTRY(GC, 0, regCOMPUTE_STATIC_THREAD_MGMT_SE2), 0xffffffff }, + { SOC15_REG_ENTRY(GC, 0, regCOMPUTE_STATIC_THREAD_MGMT_SE3), 0xffffffff }, +}; + +const size_t gfx_v9_4_3_fault_cleaner_init_regs_size = ARRAY_SIZE(gfx_v9_4_3_fault_cleaner_init_regs); + static void gfx_v9_4_3_set_ring_funcs(struct amdgpu_device *adev); static void gfx_v9_4_3_set_irq_funcs(struct amdgpu_device *adev); static void gfx_v9_4_3_set_gds_init(struct amdgpu_device *adev); diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v9_4_3.h b/drivers/gpu/drm/amd/amdgpu/gfx_v9_4_3.h index 42d67ee0e7ef..81f8805a1fbc 100644 --- a/drivers/gpu/drm/amd/amdgpu/gfx_v9_4_3.h +++ b/drivers/gpu/drm/amd/amdgpu/gfx_v9_4_3.h @@ -28,4 +28,7 @@ extern const struct amdgpu_ip_block_version gfx_v9_4_3_ip_block; extern struct amdgpu_xcp_ip_funcs gfx_v9_4_3_xcp_funcs; +extern const struct soc15_reg_entry gfx_v9_4_3_fault_cleaner_init_regs[]; +extern const size_t gfx_v9_4_3_fault_cleaner_init_regs_size; + #endif /* __GFX_V9_4_3_H__ */ diff --git a/drivers/gpu/drm/amd/amdgpu/imu_v11_0.c b/drivers/gpu/drm/amd/amdgpu/imu_v11_0.c index 09dc01a425d1..b6c4ae35ca03 100644 --- a/drivers/gpu/drm/amd/amdgpu/imu_v11_0.c +++ b/drivers/gpu/drm/amd/amdgpu/imu_v11_0.c @@ -44,7 +44,11 @@ MODULE_FIRMWARE("amdgpu/gc_11_5_3_imu.bin"); MODULE_FIRMWARE("amdgpu/gc_11_5_4_imu.bin"); MODULE_FIRMWARE("amdgpu/gc_11_5_6_imu.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_0_imu.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_imu_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_imu_p.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_1_imu.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_imu_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_imu_p.bin"); static int imu_v11_0_init_microcode(struct amdgpu_device *adev) { @@ -52,16 +56,25 @@ static int imu_v11_0_init_microcode(struct amdgpu_device *adev) int err; const struct imu_firmware_header_v1_0 *imu_hdr; struct amdgpu_firmware_info *info = NULL; + bool imu_in_ifwi; + enum amdgpu_ucode_required required; DRM_DEBUG("\n"); + /* On GFX 11 APUs, ASP loads the IFWI IMU ucode by default. */ + imu_in_ifwi = adev->firmware.load_type == AMDGPU_FW_LOAD_PSP && + (adev->flags & AMD_IS_APU); + required = imu_in_ifwi ? AMDGPU_UCODE_OPTIONAL : AMDGPU_UCODE_REQUIRED; + amdgpu_ucode_ip_version_decode(adev, GC_HWIP, ucode_prefix, sizeof(ucode_prefix)); if (amdgpu_is_kicker_fw(adev)) - err = amdgpu_ucode_request(adev, &adev->gfx.imu_fw, AMDGPU_UCODE_REQUIRED, + err = amdgpu_ucode_request(adev, &adev->gfx.imu_fw, required, "amdgpu/%s_imu_kicker.bin", ucode_prefix); else - err = amdgpu_ucode_request(adev, &adev->gfx.imu_fw, AMDGPU_UCODE_REQUIRED, + err = amdgpu_ucode_request(adev, &adev->gfx.imu_fw, required, "amdgpu/%s_imu.bin", ucode_prefix); + if (err == -ENODEV && imu_in_ifwi) + return 0; if (err) goto out; diff --git a/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c b/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c index 0895c29899d2..c76a6c4e6999 100644 --- a/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c +++ b/drivers/gpu/drm/amd/amdgpu/mes_v11_0.c @@ -61,9 +61,17 @@ MODULE_FIRMWARE("amdgpu/gc_11_5_4_mes1.bin"); MODULE_FIRMWARE("amdgpu/gc_11_5_6_mes_2.bin"); MODULE_FIRMWARE("amdgpu/gc_11_5_6_mes1.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_0_mes_2.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_mes_2_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_mes_2_p.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_0_mes1.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_mes1_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_0_mes1_p.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_1_mes_2.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_mes_2_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_mes_2_p.bin"); MODULE_FIRMWARE("amdgpu/gc_11_7_1_mes1.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_mes1_l.bin"); +MODULE_FIRMWARE("amdgpu/gc_11_7_1_mes1_p.bin"); static int mes_v11_0_hw_init(struct amdgpu_ip_block *ip_block); static int mes_v11_0_hw_fini(struct amdgpu_ip_block *ip_block); diff --git a/drivers/gpu/drm/amd/amdgpu/psp_v15_0.c b/drivers/gpu/drm/amd/amdgpu/psp_v15_0.c index abaa40b6def9..94b3fce1bc70 100644 --- a/drivers/gpu/drm/amd/amdgpu/psp_v15_0.c +++ b/drivers/gpu/drm/amd/amdgpu/psp_v15_0.c @@ -32,11 +32,19 @@ #include "mp/mp_15_0_0_sh_mask.h" MODULE_FIRMWARE("amdgpu/psp_15_0_0_toc.bin"); +MODULE_FIRMWARE("amdgpu/psp_15_0_0_toc_l.bin"); +MODULE_FIRMWARE("amdgpu/psp_15_0_0_toc_p.bin"); MODULE_FIRMWARE("amdgpu/psp_15_0_0_ta.bin"); +MODULE_FIRMWARE("amdgpu/psp_15_0_0_ta_l.bin"); +MODULE_FIRMWARE("amdgpu/psp_15_0_0_ta_p.bin"); MODULE_FIRMWARE("amdgpu/psp_15_0_5_toc.bin"); MODULE_FIRMWARE("amdgpu/psp_15_0_5_ta.bin"); MODULE_FIRMWARE("amdgpu/psp_15_0_9_toc.bin"); +MODULE_FIRMWARE("amdgpu/psp_15_0_9_toc_l.bin"); +MODULE_FIRMWARE("amdgpu/psp_15_0_9_toc_p.bin"); MODULE_FIRMWARE("amdgpu/psp_15_0_9_ta.bin"); +MODULE_FIRMWARE("amdgpu/psp_15_0_9_ta_l.bin"); +MODULE_FIRMWARE("amdgpu/psp_15_0_9_ta_p.bin"); #define regMPASP_PCRU0_MPASP_C2PMSG_64 0x4280 #define regMPASP_PCRU0_MPASP_C2PMSG_64_BASE_IDX 2 @@ -108,6 +116,45 @@ static int psp_v15_0_0_ring_stop(struct psp_context *psp, return ret; } +/* + * C2PMSG_63 bit 6: 0 = default firmware signing, 1 = alternative + * C2PMSG_63 bit 28: 0 = production part, 1 = preproduction part + */ +#define PSP_V15_0_0_FW_SIGN_ALT BIT(6) +#define PSP_V15_0_0_FW_PREPROD BIT(28) + +void psp_v15_0_0_get_fw_variant(struct amdgpu_device *adev) +{ + bool alt, preprod; + u32 val; + + if (!adev->reg_offset[MP0_HWIP][0]) + return; + + val = RREG32_SOC15(MP0, 0, regMPASP_SMN_C2PMSG_63); + if (val == 0xffffffff) { + drm_warn(adev_to_drm(adev), "Unable to access regMPASP_SMN_C2PMSG_63\n"); + return; + } + + alt = val & PSP_V15_0_0_FW_SIGN_ALT; + preprod = val & PSP_V15_0_0_FW_PREPROD; + + if (alt && preprod) { + adev->firmware.sign_type = AMDGPU_FW_SIGN_UNKNOWN; + return; + } + + if (preprod) + adev->firmware.sign_type = AMDGPU_FW_SIGN_PREPROD; + else if (alt) + adev->firmware.sign_type = AMDGPU_FW_SIGN_ALT; + + dev_info(adev->dev, "PSP firmware: %s signing, %s part (C2PMSG_63=0x%08x)\n", + alt ? "alternative" : "default", + preprod ? "preproduction" : "production", val); +} + static int psp_v15_0_0_ring_create(struct psp_context *psp, enum psp_ring_type ring_type) { diff --git a/drivers/gpu/drm/amd/amdgpu/psp_v15_0.h b/drivers/gpu/drm/amd/amdgpu/psp_v15_0.h index ebd612103526..081be8e8268b 100644 --- a/drivers/gpu/drm/amd/amdgpu/psp_v15_0.h +++ b/drivers/gpu/drm/amd/amdgpu/psp_v15_0.h @@ -26,5 +26,6 @@ #include "amdgpu_psp.h" void psp_v15_0_0_set_psp_funcs(struct psp_context *psp); +void psp_v15_0_0_get_fw_variant(struct amdgpu_device *adev); #endif diff --git a/drivers/gpu/drm/amd/amdgpu/sdma_v6_0.c b/drivers/gpu/drm/amd/amdgpu/sdma_v6_0.c index 4845588c4c24..2586d49f1e94 100644 --- a/drivers/gpu/drm/amd/amdgpu/sdma_v6_0.c +++ b/drivers/gpu/drm/amd/amdgpu/sdma_v6_0.c @@ -56,6 +56,8 @@ MODULE_FIRMWARE("amdgpu/sdma_6_1_1.bin"); MODULE_FIRMWARE("amdgpu/sdma_6_1_2.bin"); MODULE_FIRMWARE("amdgpu/sdma_6_1_3.bin"); MODULE_FIRMWARE("amdgpu/sdma_6_1_4.bin"); +MODULE_FIRMWARE("amdgpu/sdma_6_1_4_l.bin"); +MODULE_FIRMWARE("amdgpu/sdma_6_1_4_p.bin"); MODULE_FIRMWARE("amdgpu/sdma_6_4_0.bin"); #define SDMA1_REG_OFFSET 0x600 diff --git a/drivers/gpu/drm/amd/amdgpu/vpe_v2_0.c b/drivers/gpu/drm/amd/amdgpu/vpe_v2_0.c index c92c5fc59aeb..cefb8d739faf 100644 --- a/drivers/gpu/drm/amd/amdgpu/vpe_v2_0.c +++ b/drivers/gpu/drm/amd/amdgpu/vpe_v2_0.c @@ -31,6 +31,8 @@ #include "vpe/vpe_2_0_0_sh_mask.h" MODULE_FIRMWARE("amdgpu/vpe_2_0_0.bin"); +MODULE_FIRMWARE("amdgpu/vpe_2_0_0_l.bin"); +MODULE_FIRMWARE("amdgpu/vpe_2_0_0_p.bin"); MODULE_FIRMWARE("amdgpu/vpe_2_2_0.bin"); #define VPE_THREAD1_UCODE_OFFSET 0x8000 diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c index 61480e9119b8..4881684ed88f 100644 --- a/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c +++ b/drivers/gpu/drm/amd/amdkfd/kfd_device_queue_manager.c @@ -1534,9 +1534,12 @@ static int clean_process_queues_cpsch(struct device_queue_manager *dqm, int retval = 0; dqm_lock(dqm); - if (qpd->evicted++ > 0) /* already evicted, do nothing */ + if (qpd->fault_cleaned) goto out; + qpd->evicted++; + qpd->fault_cleaned = true; + pdd = qpd_to_pdd(qpd); /* The debugger creates processes that temporarily have not acquired diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_int_process_v9.c b/drivers/gpu/drm/amd/amdkfd/kfd_int_process_v9.c index 2ae1129fea55..1b597fab5395 100644 --- a/drivers/gpu/drm/amd/amdkfd/kfd_int_process_v9.c +++ b/drivers/gpu/drm/amd/amdkfd/kfd_int_process_v9.c @@ -370,7 +370,7 @@ static void gfx_9_clean_fault(uint16_t pasid) if (!pdd) return; - /* To Clean the GFX on the faulting device */ + /* To clean the GFX fault state on the faulting device */ dqm = pdd->dev->dqm; dqm->ops.clean_process_queues_cpsch(dqm, &pdd->qpd); diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_priv.h b/drivers/gpu/drm/amd/amdkfd/kfd_priv.h index 436160549386..a7b98a8b8e31 100644 --- a/drivers/gpu/drm/amd/amdkfd/kfd_priv.h +++ b/drivers/gpu/drm/amd/amdkfd/kfd_priv.h @@ -695,6 +695,11 @@ struct qcm_process_device { bool is_debug; unsigned int evicted; /* eviction counter, 0=active */ + /* Set after fault clean runs; never cleared. + * Prevents redundant cleaning from pipelined interrupt workers. + */ + bool fault_cleaned; + /* This flag tells if we should reset all wavefronts on * process termination */ @@ -906,6 +911,8 @@ struct svm_range_list { struct list_head deferred_range_list; struct list_head criu_svm_metadata_list; spinlock_t deferred_list_lock; + /* serializes XNACK-off evictions with the queue quiesce */ + struct mutex evict_lock; atomic_t evicted_ranges; atomic_t drain_pagefaults; struct delayed_work restore_work; diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_svm.c b/drivers/gpu/drm/amd/amdkfd/kfd_svm.c index 7fd331612f08..2835c1d73d63 100644 --- a/drivers/gpu/drm/amd/amdkfd/kfd_svm.c +++ b/drivers/gpu/drm/amd/amdkfd/kfd_svm.c @@ -1008,7 +1008,7 @@ svm_range_split_array(void *ppnew, void *ppold, size_t size, kvfree(new); return -ENOMEM; } - kvfree(pold); + /* The caller frees pold once all arrays of the range are split */ *(void **)ppold = old; *(void **)ppnew = new; @@ -1019,19 +1019,36 @@ static int svm_range_split_pages(struct svm_range *new, struct svm_range *old, uint64_t start, uint64_t last) { + dma_addr_t *old_dma[MAX_GPU_INSTANCE]; uint64_t npages = last - start + 1; bool has_dma_addr = false; int i, r; + /* + * Split the arrays of all GPUs before replacing any of them, the old + * range must stay intact if one fails. + */ for (i = 0; i < MAX_GPU_INSTANCE; i++) { + old_dma[i] = old->dma_addr[i]; if (old->dma_addr[i]) has_dma_addr = true; - r = svm_range_split_array(&new->dma_addr[i], &old->dma_addr[i], + r = svm_range_split_array(&new->dma_addr[i], &old_dma[i], sizeof(*old->dma_addr[i]), old->start, npages, new->start, new->npages, old->actual_loc ? &new->vram_pages : NULL); - if (r) + if (r) { + /* new->dma_addr[] goes with the new range */ + while (i--) + if (old_dma[i] != old->dma_addr[i]) + kvfree(old_dma[i]); return r; + } + } + for (i = 0; i < MAX_GPU_INSTANCE; i++) { + if (old_dma[i] == old->dma_addr[i]) + continue; + kvfree(old->dma_addr[i]); + old->dma_addr[i] = old_dma[i]; } if (old->actual_loc) { /* @@ -1892,11 +1909,12 @@ static int svm_range_validate_and_map(struct mm_struct *mm, svm_range_lock(prange); - /* Free backing memory of hmm_range if it was initialized - * Override return value to TRY AGAIN only if prior returns - * were successful + /* + * Retry if the pages were invalidated after they were taken. + * Only check that when taking them succeeded: a range can exist + * without a notifier, e.g. when allocating its PFN array failed. */ - if (range && !amdgpu_hmm_range_valid(range) && !r) { + if (!r && !amdgpu_hmm_range_valid(range)) { pr_debug("hmm update the range, need validate again\n"); r = -EAGAIN; } @@ -2116,21 +2134,30 @@ svm_range_evict(struct svm_range *prange, struct mm_struct *mm, if (prange->start <= last && prange->last >= start) atomic_inc(&prange->invalid); + /* The MMU notifier must not return before the GPU has stopped + * accessing the invalidated pages. Only the first eviction stops + * the queues, which takes milliseconds (HWS preemption on every + * GPU of the process). Serialize all evictions of this process so + * that a concurrent invalidation of another range waits until + * that quiesce has completed instead of returning while queues + * still run on stale PTEs. + */ + mutex_lock(&svms->evict_lock); evicted_ranges = atomic_inc_return(&svms->evicted_ranges); - if (evicted_ranges != 1) - return r; - - pr_debug("evicting svms 0x%p range [0x%lx 0x%lx]\n", - prange->svms, prange->start, prange->last); + if (evicted_ranges == 1) { + pr_debug("evicting svms 0x%p range [0x%lx 0x%lx]\n", + prange->svms, prange->start, prange->last); - /* First eviction, stop the queues */ - r = kgd2kfd_quiesce_mm(mm, KFD_QUEUE_EVICTION_TRIGGER_SVM); - if (r) - pr_debug("failed to quiesce KFD\n"); + /* First eviction, stop the queues */ + r = kgd2kfd_quiesce_mm(mm, KFD_QUEUE_EVICTION_TRIGGER_SVM); + if (r) + pr_debug("failed to quiesce KFD\n"); - pr_debug("schedule to restore svm %p ranges\n", svms); - queue_delayed_work(system_freezable_wq, &svms->restore_work, - msecs_to_jiffies(AMDGPU_SVM_RANGE_RESTORE_DELAY_MS)); + pr_debug("schedule to restore svm %p ranges\n", svms); + queue_delayed_work(system_freezable_wq, &svms->restore_work, + msecs_to_jiffies(AMDGPU_SVM_RANGE_RESTORE_DELAY_MS)); + } + mutex_unlock(&svms->evict_lock); } else { unsigned long s, l; uint32_t trigger; @@ -3412,6 +3439,7 @@ void svm_range_list_fini(struct kfd_process *p) svm_range_free(prange, true); } + mutex_destroy(&p->svms.evict_lock); mutex_destroy(&p->svms.lock); pr_debug("process pid %d svms 0x%p done\n", @@ -3425,6 +3453,7 @@ int svm_range_list_init(struct kfd_process *p) svms->objects = RB_ROOT_CACHED; mutex_init(&svms->lock); + mutex_init(&svms->evict_lock); INIT_LIST_HEAD(&svms->list); atomic_set(&svms->evicted_ranges, 0); atomic_set(&svms->drain_pagefaults, 0); diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c index 0ea45ab12119..5d1b010bec9b 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c @@ -886,6 +886,13 @@ static void amdgpu_dm_fini(struct amdgpu_device *adev) adev->dm.vblank_control_workqueue = NULL; } + /* The poll re-queues itself, so stop it before the wq and dc go away. */ + if (adev->dm.hdmi_frl_status_polling_wq) { + cancel_delayed_work_sync(&adev->dm.hdmi_frl_status_polling_work); + destroy_workqueue(adev->dm.hdmi_frl_status_polling_wq); + adev->dm.hdmi_frl_status_polling_wq = NULL; + } + if (adev->dm.idle_workqueue) { if (adev->dm.idle_workqueue->running) { adev->dm.idle_workqueue->enable = false; @@ -3851,6 +3858,25 @@ STATIC_IFN_KUNIT void dm_arm_vblank_event_pre_programming(struct amdgpu_crtc *ac } EXPORT_IF_KUNIT(dm_arm_vblank_event_pre_programming); +/* + * FreeSync times each frame from the plane's previous flip, and a plane + * reset gives the new DC plane zeroed flip timing, so copy it over. Do + * this at commit time, not in atomic check: by then the previous commit + * has finished writing it. + */ +static void +dm_plane_inherit_flip_time(struct dc_plane_state *dc_plane_state, + struct drm_plane_state *old_plane_state, + struct drm_plane_state *new_plane_state) +{ + struct dc_plane_state *old_dc_plane_state = + to_dm_plane_state(old_plane_state)->dc_state; + + if (old_dc_plane_state && old_dc_plane_state != dc_plane_state && + old_plane_state->crtc == new_plane_state->crtc) + dc_plane_state->time = old_dc_plane_state->time; +} + static void amdgpu_dm_commit_planes(struct drm_atomic_commit *state, struct drm_device *dev, struct amdgpu_display_manager *dm, @@ -3955,6 +3981,9 @@ static void amdgpu_dm_commit_planes(struct drm_atomic_commit *state, if (!dc_plane) continue; + dm_plane_inherit_flip_time(dc_plane, old_plane_state, + new_plane_state); + bundle->surface_updates[planes_count].surface = dc_plane; if (new_pcrtc_state->color_mgmt_changed || new_plane_state->color_mgmt_changed) { bundle->surface_updates[planes_count].gamma = &dc_plane->gamma_correction; @@ -4455,6 +4484,105 @@ STATIC_IFN_KUNIT void dm_clear_writeback(struct amdgpu_display_manager *dm, } EXPORT_IF_KUNIT(dm_clear_writeback); +static bool amdgpu_dm_self_refresh_pause_needed(struct drm_atomic_commit *state) +{ + struct drm_crtc_state *old_crtc_state, *new_crtc_state; + struct drm_crtc *crtc; + int i; + + for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) + if (drm_atomic_crtc_needs_modeset(new_crtc_state) && + (old_crtc_state->active || new_crtc_state->active)) + return true; + + return false; +} + +static bool amdgpu_dm_is_new_modeset_stream(struct drm_atomic_commit *state, + const struct dc_stream_state *stream) +{ + struct drm_crtc_state *new_crtc_state; + struct drm_crtc *crtc; + int i; + + for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) + if (drm_atomic_crtc_needs_modeset(new_crtc_state) && + to_dm_crtc_state(new_crtc_state)->stream == stream) + return true; + + return false; +} + +/* + * A modeset CRTC may have no PSR or Replay, such as an HDMI output being + * turned off, while an eDP on another CRTC is still in self-refresh. Pause + * self-refresh on every stream mod_power tracks before + * amdgpu_dm_mod_power_update_streams() changes the set: the old streams of + * the CRTCs in the commit and the unchanged streams of the new state. + * Unlike hw_programming, which a fast update on another CRTC clears, the + * pause holds until amdgpu_dm_resume_self_refresh() + */ +static void amdgpu_dm_pause_self_refresh(struct drm_atomic_commit *state, + struct amdgpu_display_manager *dm, + struct dc_state *dc_state) +{ + struct drm_crtc_state *old_crtc_state; + struct dc_stream_state *stream; + struct drm_crtc *crtc; + int i; + + if (!amdgpu_dm_self_refresh_pause_needed(state)) + return; + + guard(mutex)(&dm->dc_lock); + dc_exit_ips_for_hw_access(dm->dc); + + for_each_old_crtc_in_state(state, crtc, old_crtc_state, i) { + stream = to_dm_crtc_state(old_crtc_state)->stream; + if (!old_crtc_state->active || !stream) + continue; + + amdgpu_dm_psr_set_event(dm, stream, true, psr_event_pause, true); + amdgpu_dm_replay_set_event(dm, stream, true, replay_event_pause, true); + } + + for (i = 0; i < dc_state->stream_count; i++) { + stream = dc_state->streams[i]; + if (amdgpu_dm_is_new_modeset_stream(state, stream)) + continue; + + amdgpu_dm_psr_set_event(dm, stream, true, psr_event_pause, true); + amdgpu_dm_replay_set_event(dm, stream, true, replay_event_pause, true); + } +} + +/* + * Ends amdgpu_dm_pause_self_refresh() on the streams of the commit, which + * mod_power tracks from amdgpu_dm_mod_power_update_streams() on, even if + * dc_commit_streams() failed. mod_power keeps events across + * mod_power_replace_stream(), so the replaced streams carry the pause too. + * Runs after amdgpu_dm_mod_power_setup_streams(), since enabling a stream + * clears psr_feature_enabled and replay_feature_enabled on its link until + * then, and the set_event helpers skip a link without them + */ +static void amdgpu_dm_resume_self_refresh(struct drm_atomic_commit *state, + struct amdgpu_display_manager *dm, + struct dc_state *dc_state) +{ + int i; + + if (!dc_state || !amdgpu_dm_self_refresh_pause_needed(state)) + return; + + guard(mutex)(&dm->dc_lock); + for (i = 0; i < dc_state->stream_count; i++) { + amdgpu_dm_psr_set_event(dm, dc_state->streams[i], false, + psr_event_pause, false); + amdgpu_dm_replay_set_event(dm, dc_state->streams[i], false, + replay_event_pause, false); + } +} + /** * amdgpu_dm_mod_power_update_streams - update mod_power stream state on modeset * @state: the drm atomic state @@ -4611,6 +4739,7 @@ static void amdgpu_dm_commit_streams(struct drm_atomic_commit *state, acrtc->wb_enabled = false; } + amdgpu_dm_pause_self_refresh(state, dm, dc_state); amdgpu_dm_mod_power_update_streams(state, dm); for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, @@ -4733,6 +4862,11 @@ static void amdgpu_dm_commit_streams(struct drm_atomic_commit *state, dc_exit_ips_for_hw_access(dm->dc); WARN_ON(!dc_commit_streams(dm->dc, ¶ms)); + /* Allow idle optimization when vblank count is 0 for display off */ + if (dm->active_vblank_irq_count == 0 && amdgpu_dm_is_headless(dm->adev)) + dc_allow_idle_optimizations(dm->dc, true); + mutex_unlock(&dm->dc_lock); + bool frl_stream_found = false; for (i = 0; i < params.stream_count; i++) { @@ -4743,6 +4877,7 @@ static void amdgpu_dm_commit_streams(struct drm_atomic_commit *state, break; } } + if (frl_stream_found) { if (queue_delayed_work(dm->hdmi_frl_status_polling_wq, &dm->hdmi_frl_status_polling_work, @@ -4752,10 +4887,6 @@ static void amdgpu_dm_commit_streams(struct drm_atomic_commit *state, if (cancel_delayed_work_sync(&dm->hdmi_frl_status_polling_work)) drm_dbg_kms(dev, "200ms frl status polling stops ...\n"); } - /* Allow idle optimization when vblank count is 0 for display off */ - if ((dm->active_vblank_irq_count == 0) && amdgpu_dm_is_headless(dm->adev)) - dc_allow_idle_optimizations(dm->dc, true); - mutex_unlock(&dm->dc_lock); for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) { struct amdgpu_crtc *acrtc = to_amdgpu_crtc(crtc); @@ -5200,9 +5331,11 @@ static void amdgpu_dm_atomic_commit_tail(struct drm_atomic_commit *state) scaling_changed = is_scaling_state_different(dm_new_con_state, dm_old_con_state); - if ((new_con_state->hdmi.broadcast_rgb != old_con_state->hdmi.broadcast_rgb) && - (dm_old_crtc_state->stream->output_color_space != - amdgpu_dm_get_output_color_space(&dm_new_crtc_state->stream->timing, new_con_state))) + if (new_con_state->hdmi.broadcast_rgb != old_con_state->hdmi.broadcast_rgb && + dm_old_crtc_state->stream->output_color_space != + amdgpu_dm_get_output_color_space(&dm_new_crtc_state->stream->timing, + new_con_state, + dm_new_crtc_state->stream->signal)) output_color_space_changed = true; abm_changed = dm_new_crtc_state->abm_level != @@ -5224,8 +5357,10 @@ static void amdgpu_dm_atomic_commit_tail(struct drm_atomic_commit *state) } if (output_color_space_changed) { - dm_new_crtc_state->stream->output_color_space - = amdgpu_dm_get_output_color_space(&dm_new_crtc_state->stream->timing, new_con_state); + dm_new_crtc_state->stream->output_color_space = + amdgpu_dm_get_output_color_space(&dm_new_crtc_state->stream->timing, + new_con_state, + dm_new_crtc_state->stream->signal); stream_update.output_color_space = &dm_new_crtc_state->stream->output_color_space; } @@ -5356,6 +5491,7 @@ static void amdgpu_dm_atomic_commit_tail(struct drm_atomic_commit *state) } amdgpu_dm_mod_power_setup_streams(state, dm); + amdgpu_dm_resume_self_refresh(state, dm, dc_state); for_each_new_crtc_in_state(state, crtc, new_crtc_state, j) if (new_crtc_state->async_flip) diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_backlight.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_backlight.c index cb74b00723fd..8d27c2712c51 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_backlight.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_backlight.c @@ -122,10 +122,10 @@ static inline u32 scale_input_to_fw(int max, u64 input) return DIV_ROUND_CLOSEST_ULL(input * AMDGPU_MAX_BL_LEVEL, max); } -/* Rescale from [0..AMDGPU_MAX_BL_LEVEL] to [min..max] */ -static inline u32 scale_fw_to_input(int min, int max, u64 input) +/* Rescale from [0..AMDGPU_MAX_BL_LEVEL] to [0..max] */ +static inline u32 scale_fw_to_input(int max, u64 input) { - return min + DIV_ROUND_CLOSEST_ULL(input * (max - min), AMDGPU_MAX_BL_LEVEL); + return DIV_ROUND_CLOSEST_ULL(input * max, AMDGPU_MAX_BL_LEVEL); } static u32 backlight_signal_to_luminance(const struct amdgpu_dm_backlight_caps *caps, @@ -251,8 +251,7 @@ void convert_custom_brightness(const struct amdgpu_dm_backlight_caps *caps, (brightness - lower_signal), upper_signal - lower_signal); scale: - *user_brightness = scale_fw_to_input(min, max, - DIV_ROUND_CLOSEST(lum * brightness, 101)); + *user_brightness = scale_fw_to_input(max, DIV_ROUND_CLOSEST(lum * brightness, 101)); } EXPORT_IF_KUNIT(convert_custom_brightness); diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_connector.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_connector.c index b498fc5fbb14..8a039ef6e4b7 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_connector.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_connector.c @@ -737,7 +737,8 @@ EXPORT_IF_KUNIT(get_aspect_ratio); * With Broadcast RGB left at Automatic follow that default, as i915 does. */ static bool rgb_output_is_limited_range(const struct dc_crtc_timing *dc_crtc_timing, - const struct drm_connector_state *connector_state) + const struct drm_connector_state *connector_state, + enum signal_type signal) { switch (connector_state->hdmi.broadcast_rgb) { case DRM_HDMI_BROADCAST_RGB_FULL: @@ -745,14 +746,16 @@ static bool rgb_output_is_limited_range(const struct dc_crtc_timing *dc_crtc_tim case DRM_HDMI_BROADCAST_RGB_LIMITED: return true; default: - return connector_state->connector->display_info.is_hdmi && + return dc_is_hdmi_signal(signal) && + connector_state->connector->display_info.is_hdmi && dc_crtc_timing->vic > 1; } } enum dc_color_space amdgpu_dm_get_output_color_space(const struct dc_crtc_timing *dc_crtc_timing, - const struct drm_connector_state *connector_state) + const struct drm_connector_state *connector_state, + enum signal_type signal) { enum dc_color_space color_space = COLOR_SPACE_SRGB; @@ -775,7 +778,7 @@ amdgpu_dm_get_output_color_space(const struct dc_crtc_timing *dc_crtc_timing, case DRM_MODE_COLORIMETRY_BT2020_RGB: case DRM_MODE_COLORIMETRY_BT2020_YCC: if (dc_crtc_timing->pixel_encoding == PIXEL_ENCODING_RGB) { - if (rgb_output_is_limited_range(dc_crtc_timing, connector_state)) + if (rgb_output_is_limited_range(dc_crtc_timing, connector_state, signal)) color_space = COLOR_SPACE_2020_RGB_LIMITEDRANGE; else color_space = COLOR_SPACE_2020_RGB_FULLRANGE; @@ -787,7 +790,7 @@ amdgpu_dm_get_output_color_space(const struct dc_crtc_timing *dc_crtc_timing, default: if (dc_crtc_timing->pixel_encoding == PIXEL_ENCODING_RGB) { color_space = COLOR_SPACE_SRGB; - if (rgb_output_is_limited_range(dc_crtc_timing, connector_state)) + if (rgb_output_is_limited_range(dc_crtc_timing, connector_state, signal)) color_space = COLOR_SPACE_SRGB_LIMITED; /* * 27030khz is the separation point between HDTV and SDTV @@ -939,7 +942,8 @@ STATIC_IFN_KUNIT void fill_stream_properties_from_drm_display_mode( err = drm_hdmi_vendor_infoframe_from_display_mode(&hv_frame, (struct drm_connector *)connector, mode_in); - if (err < 0) + /* Sinks without HDMI infoframe support make it fail with -EINVAL. */ + if (err < 0 && info->has_hdmi_infoframe) drm_warn_once(connector->dev, "Failed to setup vendor infoframe on connector %s: %zd\n", connector->name, err); timing_out->hdmi_vic = hv_frame.vic; @@ -981,7 +985,8 @@ STATIC_IFN_KUNIT void fill_stream_properties_from_drm_display_mode( if (is_hdmi_ep) adjust_colour_depth_from_display_info(timing_out, info); - stream->output_color_space = amdgpu_dm_get_output_color_space(timing_out, connector_state); + stream->output_color_space = amdgpu_dm_get_output_color_space(timing_out, connector_state, + stream->signal); stream->content_type = get_output_content_type(connector_state); } EXPORT_IF_KUNIT(fill_stream_properties_from_drm_display_mode); diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_connector.h b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_connector.h index 79698deacf61..1528315d79e4 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_connector.h +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_connector.h @@ -129,7 +129,8 @@ int amdgpu_dm_fill_hdr_info_packet(const struct drm_connector_state *state, enum dc_color_space amdgpu_dm_get_output_color_space(const struct dc_crtc_timing *dc_crtc_timing, - const struct drm_connector_state *connector_state); + const struct drm_connector_state *connector_state, + enum signal_type signal); struct drm_display_mode * amdgpu_dm_get_highest_refresh_rate_mode(struct amdgpu_dm_connector *aconnector, diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_dmub.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_dmub.c index 383c53afd1f6..7cd08a9a957d 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_dmub.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_dmub.c @@ -62,6 +62,8 @@ MODULE_FIRMWARE(FIRMWARE_DCN_351_DMUB); MODULE_FIRMWARE(FIRMWARE_DCN_36_DMUB); MODULE_FIRMWARE(FIRMWARE_DCN_401_DMUB); MODULE_FIRMWARE(FIRMWARE_DCN_42_DMUB); +MODULE_FIRMWARE(FIRMWARE_DCN_42_DMUB_ALT); +MODULE_FIRMWARE(FIRMWARE_DCN_42_DMUB_PREPROD); MODULE_FIRMWARE(FIRMWARE_DCN_42B_DMUB); MODULE_FIRMWARE(FIRMWARE_DCN_60_DMUB); diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_dmub.h b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_dmub.h index df3e776c1ad1..219e9c042744 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_dmub.h +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_dmub.h @@ -61,6 +61,8 @@ int dm_init_microcode(struct amdgpu_device *adev); #define FIRMWARE_DCN_36_DMUB "amdgpu/dcn_3_6_dmcub.bin" #define FIRMWARE_DCN_401_DMUB "amdgpu/dcn_4_0_1_dmcub.bin" #define FIRMWARE_DCN_42_DMUB "amdgpu/dcn_4_2_dmcub.bin" +#define FIRMWARE_DCN_42_DMUB_ALT "amdgpu/dcn_4_2_dmcub_l.bin" +#define FIRMWARE_DCN_42_DMUB_PREPROD "amdgpu/dcn_4_2_dmcub_p.bin" #define FIRMWARE_DCN_42B_DMUB "amdgpu/dcn_4_2_1_dmcub.bin" #define FIRMWARE_DCN_60_DMUB "amdgpu/dcn_6_0_0_dmcub.bin" #define FIRMWARE_RAVEN_DMCU "amdgpu/raven_dmcu.bin" diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_freesync.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_freesync.c index 0be4506e9ae5..f2539bcf824f 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_freesync.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_freesync.c @@ -251,6 +251,13 @@ void amdgpu_dm_update_freesync_state_on_stream( mod_build_adaptive_sync_infopacket(new_stream, aconn->as_type, NULL, &new_stream->adaptive_sync_infopacket); + } else if (aconn && aconn->vsdb_info.amd_vsdb_version == 3 && + aconn->max_vfreq > 255) { + /* + * v1 saturates at 255 Hz. Keyed on the sink's max, not the mode's + * rate, so the packet version stays fixed per sink. + */ + packet_type = PACKET_TYPE_FS_V3; } app_tf = dm_dp_in_hdr_mode(new_stream) ? @@ -400,8 +407,16 @@ void amdgpu_dm_handle_vrr_transition(struct amdgpu_display_manager *dm, struct dm_crtc_state *new_state) { struct amdgpu_device *adev = dm->adev; - bool old_vrr_active = amdgpu_dm_crtc_vrr_active(old_state); - bool new_vrr_active = amdgpu_dm_crtc_vrr_active(new_state); + /* + * A disabled CRTC keeps its freesync state, but drm_crtc_vblank_get() + * fails there because vblank is off. Hold the reference only while + * the CRTC is active as well, which also covers resume, where the + * reset state lost track of the reference taken before suspend + */ + bool old_vrr_active = old_state->base.active && + amdgpu_dm_crtc_vrr_active(old_state); + bool new_vrr_active = new_state->base.active && + amdgpu_dm_crtc_vrr_active(new_state); /* Only DCE gates vupdate on VRR, keep it enabled for DCN */ bool vrr_gates_vupdate = amdgpu_ip_version(adev, DCE_HWIP, 0) == 0; diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_backlight_test.c b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_backlight_test.c index 5221050dec2f..e500c55a0672 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_backlight_test.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_backlight_test.c @@ -1125,10 +1125,10 @@ static void dm_test_custom_brightness_exact_match(struct kunit *test) /* * Exact match: lum=50, brightness_scaled=128 - * result = scale_fw_to_input(min, max, DIV_ROUND_CLOSEST(50*128, 101)) - * = scale_fw_to_input(0, 65535, DIV_ROUND_CLOSEST(6400, 101)) - * = scale_fw_to_input(0, 65535, 63) - * = 0 + DIV_ROUND_CLOSEST(63 * 65535, 255) = 16191 (approx) + * result = scale_fw_to_input(max, DIV_ROUND_CLOSEST(50*128, 101)) + * = scale_fw_to_input(65535, DIV_ROUND_CLOSEST(6400, 101)) + * = scale_fw_to_input(65535, 63) + * = DIV_ROUND_CLOSEST(63 * 65535, 255) = 16191 (approx) */ KUNIT_EXPECT_TRUE(test, brightness != 32896); KUNIT_EXPECT_TRUE(test, brightness < 32896); @@ -1171,9 +1171,9 @@ static void dm_test_custom_brightness_below_first(struct kunit *test) /* * Below first data point: lum = DIV_ROUND_CLOSEST(40 * 50, 100) = 20 - * Then: scale_fw_to_input(0, 65535, DIV_ROUND_CLOSEST(20 * 50, 101)) - * = scale_fw_to_input(0, 65535, DIV_ROUND_CLOSEST(1000, 101)) - * = scale_fw_to_input(0, 65535, 10) + * Then: scale_fw_to_input(65535, DIV_ROUND_CLOSEST(20 * 50, 101)) + * = scale_fw_to_input(65535, DIV_ROUND_CLOSEST(1000, 101)) + * = scale_fw_to_input(65535, 10) * The output should be significantly less than input. */ KUNIT_EXPECT_TRUE(test, brightness < 12850); diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_connector_test.c b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_connector_test.c index f09e2a72c534..5988f62f4709 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_connector_test.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_connector_test.c @@ -422,7 +422,8 @@ static void dm_test_output_color_space_default_rgb_full(struct kunit *test) state.colorspace = DRM_MODE_COLORIMETRY_DEFAULT; state.hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_AUTO; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_SRGB); } @@ -439,7 +440,8 @@ static void dm_test_output_color_space_default_rgb_limited(struct kunit *test) state.colorspace = DRM_MODE_COLORIMETRY_DEFAULT; state.hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_LIMITED; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_SRGB_LIMITED); } @@ -457,7 +459,8 @@ static void dm_test_output_color_space_default_ycbcr709(struct kunit *test) timing.flags.Y_ONLY = 0; state.colorspace = DRM_MODE_COLORIMETRY_DEFAULT; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_YCBCR709); } @@ -476,7 +479,8 @@ static void dm_test_output_color_space_default_ycbcr601_limited(struct kunit *te timing.flags.Y_ONLY = 1; state.colorspace = DRM_MODE_COLORIMETRY_DEFAULT; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_YCBCR601_LIMITED); } @@ -492,7 +496,8 @@ static void dm_test_output_color_space_bt601_y_only(struct kunit *test) timing.flags.Y_ONLY = 1; state.colorspace = DRM_MODE_COLORIMETRY_BT601_YCC; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_YCBCR601_LIMITED); } @@ -508,7 +513,8 @@ static void dm_test_output_color_space_bt601(struct kunit *test) timing.flags.Y_ONLY = 0; state.colorspace = DRM_MODE_COLORIMETRY_BT601_YCC; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_YCBCR601); } @@ -524,7 +530,8 @@ static void dm_test_output_color_space_bt709(struct kunit *test) timing.flags.Y_ONLY = 0; state.colorspace = DRM_MODE_COLORIMETRY_BT709_YCC; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_YCBCR709); } @@ -540,7 +547,8 @@ static void dm_test_output_color_space_bt709_y_only(struct kunit *test) timing.flags.Y_ONLY = 1; state.colorspace = DRM_MODE_COLORIMETRY_BT709_YCC; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_YCBCR709_LIMITED); } @@ -555,7 +563,8 @@ static void dm_test_output_color_space_oprgb(struct kunit *test) state.colorspace = DRM_MODE_COLORIMETRY_OPRGB; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_ADOBERGB); } @@ -573,7 +582,8 @@ static void dm_test_output_color_space_bt2020_rgb(struct kunit *test) timing.pixel_encoding = PIXEL_ENCODING_RGB; state.colorspace = DRM_MODE_COLORIMETRY_BT2020_RGB; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_2020_RGB_FULLRANGE); } @@ -590,7 +600,8 @@ static void dm_test_output_color_space_bt2020_rgb_limited(struct kunit *test) state.colorspace = DRM_MODE_COLORIMETRY_BT2020_RGB; state.hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_LIMITED; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_2020_RGB_LIMITEDRANGE); } @@ -611,7 +622,8 @@ static void dm_test_output_color_space_default_rgb_auto_hdmi_cta(struct kunit *t state.colorspace = DRM_MODE_COLORIMETRY_DEFAULT; state.hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_AUTO; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_SRGB_LIMITED); } @@ -632,7 +644,8 @@ static void dm_test_output_color_space_default_rgb_auto_hdmi_vga(struct kunit *t state.colorspace = DRM_MODE_COLORIMETRY_DEFAULT; state.hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_AUTO; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_SRGB); } @@ -652,7 +665,31 @@ static void dm_test_output_color_space_default_rgb_auto_dp_cta(struct kunit *tes state.colorspace = DRM_MODE_COLORIMETRY_DEFAULT; state.hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_AUTO; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_DISPLAY_PORT), + (int)COLOR_SPACE_SRGB); +} + +/** + * dm_test_output_color_space_default_rgb_auto_dp_hdmi_vsdb - Automatic on DP stays full range + * even when the EDID has an HDMI VSDB + * @test: The KUnit test context + */ +static void dm_test_output_color_space_default_rgb_auto_dp_hdmi_vsdb(struct kunit *test) +{ + struct dc_crtc_timing timing = {}; + struct drm_connector_state state = {}; + struct drm_connector *connector = kunit_kzalloc(test, sizeof(*connector), GFP_KERNEL); + + connector->display_info.is_hdmi = true; + timing.pixel_encoding = PIXEL_ENCODING_RGB; + timing.vic = 118; + state.connector = connector; + state.colorspace = DRM_MODE_COLORIMETRY_DEFAULT; + state.hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_AUTO; + + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_DISPLAY_PORT), (int)COLOR_SPACE_SRGB); } @@ -673,7 +710,8 @@ static void dm_test_output_color_space_default_rgb_full_hdmi_cta(struct kunit *t state.colorspace = DRM_MODE_COLORIMETRY_DEFAULT; state.hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_FULL; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_SRGB); } @@ -694,7 +732,8 @@ static void dm_test_output_color_space_bt2020_rgb_auto_hdmi_cta(struct kunit *te state.colorspace = DRM_MODE_COLORIMETRY_BT2020_RGB; state.hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_AUTO; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_2020_RGB_LIMITEDRANGE); } @@ -710,7 +749,8 @@ static void dm_test_output_color_space_bt2020_ycc(struct kunit *test) timing.pixel_encoding = PIXEL_ENCODING_YCBCR422; state.colorspace = DRM_MODE_COLORIMETRY_BT2020_YCC; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_2020_YCBCR_LIMITED); } @@ -729,7 +769,8 @@ static void dm_test_output_color_space_default_ycbcr709_y_only(struct kunit *tes timing.flags.Y_ONLY = 1; state.colorspace = DRM_MODE_COLORIMETRY_DEFAULT; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_YCBCR709_LIMITED); } @@ -748,7 +789,8 @@ static void dm_test_output_color_space_default_ycbcr601(struct kunit *test) timing.flags.Y_ONLY = 0; state.colorspace = DRM_MODE_COLORIMETRY_DEFAULT; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_YCBCR601); } @@ -767,7 +809,8 @@ static void dm_test_output_color_space_bt2020_ycc_rgb_encoding(struct kunit *tes timing.pixel_encoding = PIXEL_ENCODING_RGB; state.colorspace = DRM_MODE_COLORIMETRY_BT2020_YCC; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_2020_RGB_FULLRANGE); } @@ -785,7 +828,8 @@ static void dm_test_output_color_space_bt2020_ycc_rgb_encoding_limited(struct ku state.colorspace = DRM_MODE_COLORIMETRY_BT2020_YCC; state.hdmi.broadcast_rgb = DRM_HDMI_BROADCAST_RGB_LIMITED; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_2020_RGB_LIMITEDRANGE); } @@ -802,7 +846,8 @@ static void dm_test_output_color_space_bt2020_rgb_ycc_encoding(struct kunit *tes timing.pixel_encoding = PIXEL_ENCODING_YCBCR444; state.colorspace = DRM_MODE_COLORIMETRY_BT2020_RGB; - KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state), + KUNIT_EXPECT_EQ(test, (int)amdgpu_dm_get_output_color_space(&timing, &state, + SIGNAL_TYPE_HDMI_TYPE_A), (int)COLOR_SPACE_2020_YCBCR_LIMITED); } @@ -10010,6 +10055,7 @@ static struct kunit_case amdgpu_dm_connector_tests[] = { KUNIT_CASE(dm_test_output_color_space_default_rgb_auto_hdmi_cta), KUNIT_CASE(dm_test_output_color_space_default_rgb_auto_hdmi_vga), KUNIT_CASE(dm_test_output_color_space_default_rgb_auto_dp_cta), + KUNIT_CASE(dm_test_output_color_space_default_rgb_auto_dp_hdmi_vsdb), KUNIT_CASE(dm_test_output_color_space_default_rgb_full_hdmi_cta), KUNIT_CASE(dm_test_output_color_space_bt2020_rgb_auto_hdmi_cta), KUNIT_CASE(dm_test_output_color_space_bt2020_ycc), diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_freesync_test.c b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_freesync_test.c index 5ad50bc31613..8f219f08cd55 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_freesync_test.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/tests/amdgpu_dm_freesync_test.c @@ -622,6 +622,117 @@ static void dm_test_update_freesync_state_pcon_default(struct kunit *test) dm_test_update_freesync_state_pcon_version(test, 0); } +/* + * Build the VRR infopacket for a non-PCON, non-Replay sink with VRR inactive + * over 48Hz to @mode_hz, the max that mod_freesync_build_vrr_params() clamps + * to the mode's rate. + */ +static struct dc_info_packet +dm_test_freesync_packet(struct kunit *test, enum signal_type signal, + u8 vsdb_version, int sink_max_hz, int mode_hz) +{ + struct amdgpu_device *adev = dm_kunit_alloc_adev(test); + struct dc_link *link = dm_kunit_alloc_link(test); + struct dc_stream_state *stream = dm_kunit_alloc_stream(test, link); + struct amdgpu_dm_connector *aconnector; + struct mod_vrr_params *vrr; + struct amdgpu_crtc *acrtc; + struct dm_crtc_state crtc_state = { 0 }; + + acrtc = kunit_kzalloc(test, sizeof(*acrtc), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, acrtc); + aconnector = kunit_kzalloc(test, sizeof(*aconnector), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, aconnector); + crtc_state.base.crtc = &acrtc->base; + stream->timing.h_total = 2200; + stream->timing.v_total = 1125; + stream->signal = signal; + stream->dm_stream_context = aconnector; + aconnector->vsdb_info.amd_vsdb_version = vsdb_version; + aconnector->max_vfreq = sink_max_hz; + vrr = &acrtc->dm_irq_params.vrr_params; + vrr->send_info_frame = true; + vrr->state = VRR_STATE_INACTIVE; + vrr->min_refresh_in_uhz = 48000000; + vrr->max_refresh_in_uhz = mode_hz * 1000000; + adev->dm.adev = adev; + + amdgpu_dm_update_freesync_state_on_stream(&adev->dm, &crtc_state, stream, NULL, 0); + + return crtc_state.vrr_infopacket; +} + +/** + * dm_test_update_freesync_state_dp_v2_saturates - Test v1 saturates above 255Hz + * @test: The KUnit test context + * + * A VSDB v2 sink keeps the v1 packet, which cannot carry 320Hz. + */ +static void dm_test_update_freesync_state_dp_v2_saturates(struct kunit *test) +{ + struct dc_info_packet p = + dm_test_freesync_packet(test, SIGNAL_TYPE_DISPLAY_PORT, 2, 320, 320); + + KUNIT_EXPECT_EQ(test, p.hb3, 0x04); + KUNIT_EXPECT_EQ(test, p.sb[7], 255); + KUNIT_EXPECT_EQ(test, p.sb[8], 255); +} + +/** + * dm_test_update_freesync_state_dp_v3_above_255 - Test v3 for a VSDB v3 sink above 255Hz + * @test: The KUnit test context + */ +static void dm_test_update_freesync_state_dp_v3_above_255(struct kunit *test) +{ + struct dc_info_packet p = + dm_test_freesync_packet(test, SIGNAL_TYPE_DISPLAY_PORT, 3, 320, 320); + + KUNIT_EXPECT_EQ(test, p.hb3, 3 << 2); + KUNIT_EXPECT_EQ(test, p.sb[8], 320 & 0xff); + KUNIT_EXPECT_EQ(test, p.sb[12], 320 >> 8); +} + +/** + * dm_test_update_freesync_state_dp_v3_mode_240 - Test v3 follows the sink max, not the mode + * @test: The KUnit test context + */ +static void dm_test_update_freesync_state_dp_v3_mode_240(struct kunit *test) +{ + struct dc_info_packet p = + dm_test_freesync_packet(test, SIGNAL_TYPE_DISPLAY_PORT, 3, 320, 240); + + KUNIT_EXPECT_EQ(test, p.hb3, 3 << 2); + KUNIT_EXPECT_EQ(test, p.sb[8], 240); + KUNIT_EXPECT_EQ(test, p.sb[12], 0); +} + +/** + * dm_test_update_freesync_state_dp_v3_at_255 - Test a VSDB v3 sink at 255Hz keeps v1 + * @test: The KUnit test context + */ +static void dm_test_update_freesync_state_dp_v3_at_255(struct kunit *test) +{ + struct dc_info_packet p = + dm_test_freesync_packet(test, SIGNAL_TYPE_DISPLAY_PORT, 3, 255, 255); + + KUNIT_EXPECT_EQ(test, p.hb3, 0x04); + KUNIT_EXPECT_EQ(test, p.sb[8], 255); +} + +/** + * dm_test_update_freesync_state_hdmi_v3_above_255 - Test v3 for a VSDB v3 HDMI sink + * @test: The KUnit test context + */ +static void dm_test_update_freesync_state_hdmi_v3_above_255(struct kunit *test) +{ + struct dc_info_packet p = + dm_test_freesync_packet(test, SIGNAL_TYPE_HDMI_TYPE_A, 3, 320, 320); + + KUNIT_EXPECT_EQ(test, p.hb1, 3); + KUNIT_EXPECT_EQ(test, p.sb[8], 320 & 0xff); + KUNIT_EXPECT_EQ(test, p.sb[12], 320 >> 8); +} + /* Tests for amdgpu_dm_update_stream_irq_parameters() */ /** @@ -813,8 +924,10 @@ static void dm_test_handle_vrr_transition_round_trip(struct kunit *test) mutex_init(&adev->dm.dc_lock); old_state.base.crtc = &acrtc->base; + old_state.base.active = true; old_state.stream = stream; new_state.base.crtc = &acrtc->base; + new_state.base.active = true; new_state.stream = stream; new_state.freesync_config.state = VRR_STATE_ACTIVE_VARIABLE; @@ -825,6 +938,99 @@ static void dm_test_handle_vrr_transition_round_trip(struct kunit *test) KUNIT_EXPECT_EQ(test, atomic_read(&vblank->refcount), 0); } +/* + * Runs a transition on a CRTC whose vblank is on with two references held, + * so a get or put never has to enable or disable it, and returns the + * refcount afterwards + */ +static int dm_test_vrr_transition_refcount(struct kunit *test, + bool old_active, enum mod_vrr_state old_vrr, + bool new_active, enum mod_vrr_state new_vrr) +{ + struct amdgpu_device *adev = dm_kunit_alloc_adev(test); + struct amdgpu_display_manager *dm = dm_kunit_alloc_dm(test); + struct dm_crtc_state *old_state, *new_state; + struct drm_crtc *crtc; + int refcount; + + KUNIT_ASSERT_EQ(test, drm_vblank_init(&adev->ddev, 1), 0); + adev->ip_versions[DCE_HWIP][0] = IP_VERSION(2, 1, 0); + dm->adev = adev; + mutex_init(&dm->dc_lock); + + crtc = kunit_kzalloc(test, sizeof(*crtc), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, crtc); + crtc->dev = &adev->ddev; + + old_state = kunit_kzalloc(test, sizeof(*old_state), GFP_KERNEL); + new_state = kunit_kzalloc(test, sizeof(*new_state), GFP_KERNEL); + KUNIT_ASSERT_NOT_NULL(test, old_state); + KUNIT_ASSERT_NOT_NULL(test, new_state); + old_state->base.crtc = crtc; + old_state->base.active = old_active; + old_state->freesync_config.state = old_vrr; + new_state->base.crtc = crtc; + new_state->base.active = new_active; + new_state->freesync_config.state = new_vrr; + + adev->ddev.vblank[0].enabled = true; + atomic_set(&adev->ddev.vblank[0].refcount, 2); + + amdgpu_dm_handle_vrr_transition(dm, old_state, new_state); + refcount = atomic_read(&adev->ddev.vblank[0].refcount); + + /* drm_vblank_init_release() warns if vblank is still enabled */ + adev->ddev.vblank[0].enabled = false; + atomic_set(&adev->ddev.vblank[0].refcount, 0); + + return refcount; +} + +/** + * dm_test_vrr_transition_crtc_off_drops_ref - Test disabling the CRTC drops the ref + * @test: The KUnit test context + * + * Disabling the CRTC keeps the freesync state, as on suspend or DPMS off. + * The reference must still be dropped, since resume restores the state from + * a reset one and takes a new reference + */ +static void dm_test_vrr_transition_crtc_off_drops_ref(struct kunit *test) +{ + KUNIT_EXPECT_EQ(test, + dm_test_vrr_transition_refcount(test, true, VRR_STATE_ACTIVE_VARIABLE, + false, VRR_STATE_ACTIVE_VARIABLE), + 1); +} + +/** + * dm_test_vrr_transition_crtc_on_takes_ref - Test enabling the CRTC takes the ref + * @test: The KUnit test context + * + * Covers resume, where the old state is a reset one, and DPMS on + */ +static void dm_test_vrr_transition_crtc_on_takes_ref(struct kunit *test) +{ + KUNIT_EXPECT_EQ(test, + dm_test_vrr_transition_refcount(test, false, VRR_STATE_UNSUPPORTED, + true, VRR_STATE_ACTIVE_VARIABLE), + 3); +} + +/** + * dm_test_vrr_transition_crtc_off_keeps_ref - Test no ref change while off + * @test: The KUnit test context + * + * A disabled CRTC has vblank off, so a VRR change there must neither take + * nor drop a reference + */ +static void dm_test_vrr_transition_crtc_off_keeps_ref(struct kunit *test) +{ + KUNIT_EXPECT_EQ(test, + dm_test_vrr_transition_refcount(test, false, VRR_STATE_UNSUPPORTED, + false, VRR_STATE_ACTIVE_VARIABLE), + 2); +} + static struct kunit_case amdgpu_dm_freesync_tests[] = { /* amdgpu_dm_is_timing_unchanged_for_freesync */ KUNIT_CASE(dm_test_timing_unchanged_null_args), @@ -857,6 +1063,11 @@ static struct kunit_case amdgpu_dm_freesync_tests[] = { KUNIT_CASE(dm_test_update_freesync_state_pcon_v2), KUNIT_CASE(dm_test_update_freesync_state_pcon_v3), KUNIT_CASE(dm_test_update_freesync_state_pcon_default), + KUNIT_CASE(dm_test_update_freesync_state_dp_v2_saturates), + KUNIT_CASE(dm_test_update_freesync_state_dp_v3_above_255), + KUNIT_CASE(dm_test_update_freesync_state_dp_v3_mode_240), + KUNIT_CASE(dm_test_update_freesync_state_dp_v3_at_255), + KUNIT_CASE(dm_test_update_freesync_state_hdmi_v3_above_255), /* amdgpu_dm_update_stream_irq_parameters */ KUNIT_CASE(dm_test_update_stream_irq_parameters_no_stream), KUNIT_CASE(dm_test_update_stream_irq_parameters_invalid_timing), @@ -867,6 +1078,9 @@ static struct kunit_case amdgpu_dm_freesync_tests[] = { /* amdgpu_dm_handle_vrr_transition */ KUNIT_CASE(dm_test_handle_vrr_transition_inactive), KUNIT_CASE(dm_test_handle_vrr_transition_round_trip), + KUNIT_CASE(dm_test_vrr_transition_crtc_off_drops_ref), + KUNIT_CASE(dm_test_vrr_transition_crtc_on_takes_ref), + KUNIT_CASE(dm_test_vrr_transition_crtc_off_keeps_ref), {} }; diff --git a/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn42/dcn42_clk_mgr.c b/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn42/dcn42_clk_mgr.c index 405145889ba2..ae3d762955a9 100644 --- a/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn42/dcn42_clk_mgr.c +++ b/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn42/dcn42_clk_mgr.c @@ -643,6 +643,9 @@ DC_LOGGER_INIT(clk_mgr_base->ctx->logger); DC_LOG_SMU("dp_dto_source_clock %d, dprefclk %d\n", clk_mgr_base->dp_dto_source_clock_in_khz, clk_mgr_base->dprefclk_khz); dcn42_dump_clk_registers(&clk_mgr_base->boot_snapshot, clk_mgr); + /* Snapshot is in 10kHz units; seed clks so update_clocks() does not lower the pre-OS clocks */ + clk_mgr_base->clks.dispclk_khz = clk_mgr_base->boot_snapshot.dispclk * 10; + clk_mgr_base->clks.dppclk_khz = clk_mgr_base->boot_snapshot.dppclk * 10; clk_mgr_base->clks.ref_dtbclk_khz = clk_mgr_base->boot_snapshot.dtbclk * 10; clk_mgr_base->clks.dtbclk_en = clk_mgr_base->boot_snapshot.dtbclk > 59000; } diff --git a/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn42b/dcn42b_clk_mgr.c b/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn42b/dcn42b_clk_mgr.c index d500a3210eed..6aacc4f77ae7 100644 --- a/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn42b/dcn42b_clk_mgr.c +++ b/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn42b/dcn42b_clk_mgr.c @@ -242,6 +242,10 @@ DC_LOGGER_INIT(clk_mgr_base->ctx->logger); DC_LOG_SMU("dp_dto_source_clock %d, dprefclk %d\n", clk_mgr_base->dp_dto_source_clock_in_khz, clk_mgr_base->dprefclk_khz); dcn42b_dump_clk_registers(&clk_mgr_base->boot_snapshot, clk_mgr); + + /* Snapshot is in 10kHz units; seed clks so update_clocks() does not lower the pre-OS clocks */ + clk_mgr_base->clks.dispclk_khz = clk_mgr_base->boot_snapshot.dispclk * 10; + clk_mgr_base->clks.dppclk_khz = clk_mgr_base->boot_snapshot.dppclk * 10; } static struct clk_bw_params dcn42b_bw_params = { diff --git a/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn60/dalsmc.h b/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn60/dalsmc.h index 234777bdd183..ea3927223117 100644 --- a/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn60/dalsmc.h +++ b/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn60/dalsmc.h @@ -77,7 +77,8 @@ typedef struct { typedef struct { uint32_t NumUmcChannels; - uint32_t Reserved[3]; + uint32_t DramChannelWidthBytes; + uint32_t Reserved[2]; } MemoryConfig_t; /** diff --git a/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn60/dcn60_clk_mgr.c b/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn60/dcn60_clk_mgr.c index d8a0a482d984..e33140d45867 100644 --- a/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn60/dcn60_clk_mgr.c +++ b/drivers/gpu/drm/amd/display/dc/clk_mgr/dcn60/dcn60_clk_mgr.c @@ -815,8 +815,7 @@ static bool dcn60_fetch_dal_init_table(struct clk_mgr_internal *clk_mgr) //dcn60_populate_dc_mode_limit(&bw_params->dc_mode_limit, init_table); bw_params->num_channels = init_table->MemoryConfig.NumUmcChannels; - bw_params->dram_channel_width_bytes = - clk_mgr->base.ctx->dc_bios->vram_info.dram_channel_width_bytes; + bw_params->dram_channel_width_bytes = init_table->MemoryConfig.DramChannelWidthBytes; dcn60_populate_utm_qos_model(clk_mgr, &bw_params->utm_qos_model, init_table); diff --git a/drivers/gpu/drm/amd/display/dc/core/dc.c b/drivers/gpu/drm/amd/display/dc/core/dc.c index 348e8991f870..98e5aa160b74 100644 --- a/drivers/gpu/drm/amd/display/dc/core/dc.c +++ b/drivers/gpu/drm/amd/display/dc/core/dc.c @@ -1022,6 +1022,8 @@ static bool dc_construct_ctx(struct dc *dc, dc_ctx->perf_trace = dc_perf_trace_create(); if (!dc_ctx->perf_trace) { + kfree(dc_ctx->logger); + dc->dml.logger = NULL; kfree(dc_ctx); ASSERT_CRITICAL(false); return false; @@ -1663,12 +1665,25 @@ static void detect_edp_presence(struct dc *dc) } } +static void sync_current_state_clocks_from_clk_mgr(struct dc *dc) +{ + if (!dc->current_state || !dc->clk_mgr) + return; + + if (!(dc->ctx->dce_version == DCN_VERSION_4_2 || dc->ctx->dce_version == DCN_VERSION_4_2B)) + return; + + dc->current_state->bw_ctx.bw.dcn.clk = dc->clk_mgr->clks; +} + void legacy_hardware_init(struct dc *dc) { detect_edp_presence(dc); - if (dc->ctx->dce_environment != DCE_ENV_VIRTUAL_HW) + if (dc->ctx->dce_environment != DCE_ENV_VIRTUAL_HW) { dc->hwss.init_hw(dc); + sync_current_state_clocks_from_clk_mgr(dc); + } dc_dmub_srv_notify_fw_dc_power_state(dc->ctx->dmub_srv, DC_ACPI_CM_POWER_STATE_D0); } @@ -6312,6 +6327,7 @@ void dc_set_power_state(struct dc *dc, enum dc_acpi_cm_power_state power_state) dc_dmub_srv_notify_fw_dc_power_state(dc->ctx->dmub_srv, power_state); dc->hwss.init_hw(dc); + sync_current_state_clocks_from_clk_mgr(dc); if (dc->hwss.init_sys_ctx != NULL && dc->vm_pa_config.valid) { diff --git a/drivers/gpu/drm/amd/display/dc/dce/dce_link_encoder.c b/drivers/gpu/drm/amd/display/dc/dce/dce_link_encoder.c index c6a20378121b..0c1fcfd088ba 100644 --- a/drivers/gpu/drm/amd/display/dc/dce/dce_link_encoder.c +++ b/drivers/gpu/drm/amd/display/dc/dce/dce_link_encoder.c @@ -1841,8 +1841,11 @@ bool dce110_get_hpd_state(struct link_encoder *enc) bool dce110_program_hpd_filter(struct link_encoder *enc, int delay_on_connect_in_ms, int delay_on_disconnect_in_ms) { + if (!enc->hpd_gpio) + return false; + /* Setup HPD filtering */ - if (enc->hpd_gpio && dal_gpio_lock_pin(enc->hpd_gpio) == GPIO_RESULT_OK) { + if (dal_gpio_lock_pin(enc->hpd_gpio) == GPIO_RESULT_OK) { struct gpio_hpd_config config; config.delay_on_connect = delay_on_connect_in_ms; diff --git a/drivers/gpu/drm/amd/display/dc/dio/dcn10/dcn10_link_encoder.c b/drivers/gpu/drm/amd/display/dc/dio/dcn10/dcn10_link_encoder.c index 32e12d894e31..ddb40e6507b5 100644 --- a/drivers/gpu/drm/amd/display/dc/dio/dcn10/dcn10_link_encoder.c +++ b/drivers/gpu/drm/amd/display/dc/dio/dcn10/dcn10_link_encoder.c @@ -1506,8 +1506,11 @@ bool dcn10_get_hpd_state(struct link_encoder *enc) bool dcn10_program_hpd_filter(struct link_encoder *enc, int delay_on_connect_in_ms, int delay_on_disconnect_in_ms) { + if (!enc->hpd_gpio) + return false; + /* Setup HPD filtering */ - if (enc->hpd_gpio && dal_gpio_lock_pin(enc->hpd_gpio) == GPIO_RESULT_OK) { + if (dal_gpio_lock_pin(enc->hpd_gpio) == GPIO_RESULT_OK) { struct gpio_hpd_config config; config.delay_on_connect = delay_on_connect_in_ms; diff --git a/drivers/gpu/drm/amd/display/dc/dml2_0/dml21/inc/bounding_boxes/dcn42b_soc_bb.h b/drivers/gpu/drm/amd/display/dc/dml2_0/dml21/inc/bounding_boxes/dcn42b_soc_bb.h index e83a9ac018db..07f1bffc75ca 100644 --- a/drivers/gpu/drm/amd/display/dc/dml2_0/dml21/inc/bounding_boxes/dcn42b_soc_bb.h +++ b/drivers/gpu/drm/amd/display/dc/dml2_0/dml21/inc/bounding_boxes/dcn42b_soc_bb.h @@ -188,8 +188,8 @@ static const struct dml2_soc_bb dml2_socbb_dcn42b = { .dram_clk_change_blackout_us = 36, .fclk_change_blackout_us = 0, .g7_ppt_blackout_us = 0, - .stutter_enter_plus_exit_latency_us = 14, - .stutter_exit_latency_us = 12, + .stutter_enter_plus_exit_latency_us = 15.5, + .stutter_exit_latency_us = 13.5, .z8_stutter_enter_plus_exit_latency_us = 300, .z8_stutter_exit_latency_us = 200, }, diff --git a/drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn5_calcs_dchub.c b/drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn5_calcs_dchub.c index f407afefb37f..82dbf81defbb 100644 --- a/drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn5_calcs_dchub.c +++ b/drivers/gpu/drm/amd/display/dc/dml2_0/dml21/src/dml2_core/dml2_core_dcn5_calcs_dchub.c @@ -836,7 +836,7 @@ void dcn5_calculate_swath_and_det_configuration(struct dml2_core_internal_scratc p->SwathHeightC[k] = MaximumSwathHeightC[k]; RoundedUpSwathSizeBytesY[k] = p->full_swath_bytes_l[k] / 2; RoundedUpSwathSizeBytesC[k] = p->full_swath_bytes_c[k]; - p->request_size_bytes_luma[k] = dml2_core_utils_get_segment_horizontal_contiguous(p->BytePerPixY[k], p->display_cfg->plane_descriptors[k].surface.tiling) + p->request_size_bytes_luma[k] = dml2_core_utils_get_segment_horizontal_contiguous(p->display_cfg->plane_descriptors[k].surface.tiling, p->BytePerPixY[k]) == dml2_core_utils_is_vertical_rotation(p->display_cfg->plane_descriptors[k].composition.rotation_angle) ? 64 : 128; p->request_size_bytes_chroma[k] = 256; @@ -846,7 +846,7 @@ void dcn5_calculate_swath_and_det_configuration(struct dml2_core_internal_scratc RoundedUpSwathSizeBytesY[k] = p->full_swath_bytes_l[k]; RoundedUpSwathSizeBytesC[k] = p->full_swath_bytes_c[k] / 2; p->request_size_bytes_luma[k] = 256; - p->request_size_bytes_chroma[k] = dml2_core_utils_get_segment_horizontal_contiguous(p->BytePerPixC[k], p->display_cfg->plane_descriptors[k].surface.tiling) + p->request_size_bytes_chroma[k] = dml2_core_utils_get_segment_horizontal_contiguous(p->display_cfg->plane_descriptors[k].surface.tiling, p->BytePerPixC[k]) == dml2_core_utils_is_vertical_rotation(p->display_cfg->plane_descriptors[k].composition.rotation_angle) ? 64 : 128; } else { @@ -854,9 +854,9 @@ void dcn5_calculate_swath_and_det_configuration(struct dml2_core_internal_scratc p->SwathHeightC[k] = MaximumSwathHeightC[k] / 2; RoundedUpSwathSizeBytesY[k] = p->full_swath_bytes_l[k] / 2; RoundedUpSwathSizeBytesC[k] = p->full_swath_bytes_c[k] / 2; - p->request_size_bytes_luma[k] = dml2_core_utils_get_segment_horizontal_contiguous(p->BytePerPixY[k], p->display_cfg->plane_descriptors[k].surface.tiling) + p->request_size_bytes_luma[k] = dml2_core_utils_get_segment_horizontal_contiguous(p->display_cfg->plane_descriptors[k].surface.tiling, p->BytePerPixY[k]) == dml2_core_utils_is_vertical_rotation(p->display_cfg->plane_descriptors[k].composition.rotation_angle) ? 64 : 128; - p->request_size_bytes_chroma[k] = dml2_core_utils_get_segment_horizontal_contiguous(p->BytePerPixC[k], p->display_cfg->plane_descriptors[k].surface.tiling) + p->request_size_bytes_chroma[k] = dml2_core_utils_get_segment_horizontal_contiguous(p->display_cfg->plane_descriptors[k].surface.tiling, p->BytePerPixC[k]) == dml2_core_utils_is_vertical_rotation(p->display_cfg->plane_descriptors[k].composition.rotation_angle) ? 64 : 128; } diff --git a/drivers/gpu/drm/amd/display/dc/link/link_dpms.c b/drivers/gpu/drm/amd/display/dc/link/link_dpms.c index 382ad9bd4e57..1a5dca9d03ce 100644 --- a/drivers/gpu/drm/amd/display/dc/link/link_dpms.c +++ b/drivers/gpu/drm/amd/display/dc/link/link_dpms.c @@ -2815,11 +2815,11 @@ enum dc_status link_set_dpms_on( switch (step_result) { case DC_DPMS_SUCCESS: - case DC_DPMS_FAILED_HANDSHAKE: // Enum is ordered from "best" to "worst" results result = max(result, step_result); break; + case DC_DPMS_FAILED_HANDSHAKE: case DC_DPMS_SKIPPED_HANDSHAKE: return step_result; diff --git a/drivers/gpu/drm/amd/display/dmub/dmub_srv.h b/drivers/gpu/drm/amd/display/dmub/dmub_srv.h index 17579ff2e1bf..84f825c924bc 100644 --- a/drivers/gpu/drm/amd/display/dmub/dmub_srv.h +++ b/drivers/gpu/drm/amd/display/dmub/dmub_srv.h @@ -76,6 +76,8 @@ #define PSP_HEADER_BYTES_256 0x100 // 256 bytes #define PSP_FOOTER_BYTES_256 0x100 // 256 bytes +#define PSP_FOOTER_BYTES_512 0x200 // 512 bytes +#define PSP_FOOTER_BYTES_1932 0x78C // 1932 bytes /* Forward declarations */ struct dmub_srv; diff --git a/drivers/gpu/drm/amd/display/dmub/src/dmub_srv.c b/drivers/gpu/drm/amd/display/dmub/src/dmub_srv.c index 41b14b137643..72fc28feefb2 100644 --- a/drivers/gpu/drm/amd/display/dmub/src/dmub_srv.c +++ b/drivers/gpu/drm/amd/display/dmub/src/dmub_srv.c @@ -173,30 +173,43 @@ dmub_srv_get_fw_meta_info_from_raw_fw(struct dmub_srv_fw_meta_info_params *param uint32_t inst_const_size_temp = params->inst_const_size; /* First try custom psp footer size, if present */ - if (params->custom_psp_footer_size) { - params->inst_const_size -= params->custom_psp_footer_size; + if (params->custom_psp_footer_size && inst_const_size_temp > params->custom_psp_footer_size) { + params->inst_const_size = inst_const_size_temp - params->custom_psp_footer_size; fw_info = dmub_get_fw_meta_info(params); if (fw_info) { memcpy(fw_info_out, fw_info, sizeof(*fw_info)); return DMUB_STATUS_OK; } - params->inst_const_size = inst_const_size_temp; } /* Try 256-byte psp footer size */ - params->inst_const_size -= PSP_FOOTER_BYTES_256; - fw_info = dmub_get_fw_meta_info(params); - if (fw_info) { - memcpy(fw_info_out, fw_info, sizeof(*fw_info)); - return DMUB_STATUS_OK; + if (inst_const_size_temp > PSP_FOOTER_BYTES_256) { + params->inst_const_size = inst_const_size_temp - PSP_FOOTER_BYTES_256; + fw_info = dmub_get_fw_meta_info(params); + if (fw_info) { + memcpy(fw_info_out, fw_info, sizeof(*fw_info)); + return DMUB_STATUS_OK; + } } - /* Try 512-byte psp footer size - final attempt */ - params->inst_const_size -= PSP_FOOTER_BYTES_256; // 256 bytes already subtracted, subtract 256 again - fw_info = dmub_get_fw_meta_info(params); - if (fw_info) { - memcpy(fw_info_out, fw_info, sizeof(*fw_info)); - return DMUB_STATUS_OK; + /* Try 512-byte psp footer size */ + if (inst_const_size_temp > PSP_FOOTER_BYTES_512) { + params->inst_const_size = inst_const_size_temp - PSP_FOOTER_BYTES_512; + fw_info = dmub_get_fw_meta_info(params); + if (fw_info) { + memcpy(fw_info_out, fw_info, sizeof(*fw_info)); + return DMUB_STATUS_OK; + } + } + + /* Try 1932-byte psp footer size */ + if (inst_const_size_temp > PSP_FOOTER_BYTES_1932) { + params->inst_const_size = inst_const_size_temp - PSP_FOOTER_BYTES_1932; + fw_info = dmub_get_fw_meta_info(params); + if (fw_info) { + memcpy(fw_info_out, fw_info, sizeof(*fw_info)); + return DMUB_STATUS_OK; + } } /* Restore original inst_const_size and subtract default PSP footer size - default behaviour */ diff --git a/drivers/gpu/drm/amd/display/modules/freesync/freesync.c b/drivers/gpu/drm/amd/display/modules/freesync/freesync.c index f154a619b533..21165855cb92 100644 --- a/drivers/gpu/drm/amd/display/modules/freesync/freesync.c +++ b/drivers/gpu/drm/amd/display/modules/freesync/freesync.c @@ -571,6 +571,12 @@ static bool vrr_settings_require_update(struct core_freesync *core_freesync, return false; } +/* v1/v2 packets hold each rate in one byte; saturate instead of wrapping. */ +static unsigned char vrr_refresh_hz_u8(unsigned int refresh_in_uhz) +{ + return min((refresh_in_uhz + 500000) / 1000000, 255U); +} + static void build_vrr_infopacket_data_v1(const struct mod_vrr_params *vrr, struct dc_info_packet *infopacket, bool freesync_on_desktop) @@ -614,15 +620,15 @@ static void build_vrr_infopacket_data_v1(const struct mod_vrr_params *vrr, /* PB7 = FreeSync Minimum refresh rate (Hz) */ if (vrr->state == VRR_STATE_ACTIVE_VARIABLE || vrr->state == VRR_STATE_ACTIVE_FIXED) { - infopacket->sb[7] = (unsigned char)((vrr->min_refresh_in_uhz + 500000) / 1000000); + infopacket->sb[7] = vrr_refresh_hz_u8(vrr->min_refresh_in_uhz); } else { - infopacket->sb[7] = (unsigned char)((vrr->max_refresh_in_uhz + 500000) / 1000000); + infopacket->sb[7] = vrr_refresh_hz_u8(vrr->max_refresh_in_uhz); } /* PB8 = FreeSync Maximum refresh rate (Hz) * Note: We should never go above the field rate of the mode timing set. */ - infopacket->sb[8] = (unsigned char)((vrr->max_refresh_in_uhz + 500000) / 1000000); + infopacket->sb[8] = vrr_refresh_hz_u8(vrr->max_refresh_in_uhz); } static void build_vrr_infopacket_data_v3(const struct mod_vrr_params *vrr, diff --git a/drivers/gpu/drm/amd/display/modules/power/power_psr.c b/drivers/gpu/drm/amd/display/modules/power/power_psr.c index 96bb77fff05b..7139395b5c00 100644 --- a/drivers/gpu/drm/amd/display/modules/power/power_psr.c +++ b/drivers/gpu/drm/amd/display/modules/power/power_psr.c @@ -94,9 +94,12 @@ bool mod_power_psr_notify_mode_change(struct mod_power *mod_power, * The value of DSC slice height is determined in DSC Driver but it does not * propagated out here, so we need to calculate it as below 'slice_height'. */ - psr_su_set_dsc_slice_height(dc, link, - (struct dc_stream_state *) stream, - &psr_config); + if (link->psr_settings.psr_version == DC_PSR_VERSION_SU_1) { + if (!psr_su_set_dsc_slice_height(dc, link, + (struct dc_stream_state *)stream, + &psr_config)) + return false; + } dc_link_setup_psr(link, stream, &psr_config, &psr_context); diff --git a/drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu8_hwmgr.c b/drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu8_hwmgr.c index 8f82d7c07e8c..5a3f697a37a2 100644 --- a/drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu8_hwmgr.c +++ b/drivers/gpu/drm/amd/pm/powerplay/hwmgr/smu8_hwmgr.c @@ -1483,15 +1483,25 @@ static int smu8_store_cc6_data(struct pp_hwmgr *hwmgr, uint32_t separation_time, static int smu8_force_clock_level(struct pp_hwmgr *hwmgr, enum pp_clock_type type, uint32_t mask) { + struct phm_clock_voltage_dependency_table *table = + hwmgr->dyn_state.vddc_dependency_on_sclk; + uint32_t low, high; + switch (type) { case PP_SCLK: + /* the SMU takes level indices, not a mask of levels */ + low = mask ? (ffs(mask) - 1) : 0; + high = mask ? (fls(mask) - 1) : 0; + if (high >= min(table->count, smu8_get_max_sclk_level(hwmgr))) + return -EINVAL; + smum_send_msg_to_smc_with_parameter(hwmgr, PPSMC_MSG_SetSclkSoftMin, - mask, + low, NULL); smum_send_msg_to_smc_with_parameter(hwmgr, PPSMC_MSG_SetSclkSoftMax, - mask, + high, NULL); break; default: diff --git a/drivers/gpu/drm/drm_syncobj.c b/drivers/gpu/drm/drm_syncobj.c index 137397972a98..6cc654641183 100644 --- a/drivers/gpu/drm/drm_syncobj.c +++ b/drivers/gpu/drm/drm_syncobj.c @@ -199,6 +199,7 @@ #include <linux/file.h> #include <linux/fs.h> #include <linux/sched/signal.h> +#include <linux/sizes.h> #include <linux/sync_file.h> #include <linux/uaccess.h> @@ -220,6 +221,16 @@ struct syncobj_wait_entry { u64 point; }; +/* + * Upper limit for the number of handles passed to a single ioctl. This is a + * fixed number so that the limit is the same on all architectures. The + * largest per-handle allocation is the wait entry array, which must stay + * below the INT_MAX size limit of kvmalloc(). + */ +#define DRM_SYNCOBJ_MAX_HANDLES SZ_1M +static_assert(DRM_SYNCOBJ_MAX_HANDLES <= + INT_MAX / sizeof(struct syncobj_wait_entry)); + static void syncobj_wait_syncobj_func(struct drm_syncobj *syncobj, struct syncobj_wait_entry *wait); @@ -1051,7 +1062,7 @@ static signed long drm_syncobj_array_wait_timeout(struct drm_syncobj **syncobjs, lockdep_assert_none_held_once(); } - points = kmalloc_objs(*points, count); + points = kvmalloc_objs(*points, count); if (points == NULL) return -ENOMEM; @@ -1064,7 +1075,7 @@ static signed long drm_syncobj_array_wait_timeout(struct drm_syncobj **syncobjs, goto err_free_points; } - entries = kzalloc_objs(*entries, count); + entries = kvzalloc_objs(*entries, count); if (!entries) { timeout = -ENOMEM; goto err_free_points; @@ -1185,10 +1196,10 @@ cleanup_entries: &entries[i].fence_cb); dma_fence_put(entries[i].fence); } - kfree(entries); + kvfree(entries); err_free_points: - kfree(points); + kvfree(points); return timeout; } @@ -1238,7 +1249,10 @@ static int drm_syncobj_array_find(struct drm_file *file_private, struct drm_syncobj **syncobjs; int ret; - handles = kmalloc_objs(*handles, count_handles); + if (count_handles > DRM_SYNCOBJ_MAX_HANDLES) + return -EINVAL; + + handles = kvmalloc_objs(*handles, count_handles); if (handles == NULL) return -ENOMEM; @@ -1248,7 +1262,7 @@ static int drm_syncobj_array_find(struct drm_file *file_private, goto err_free_handles; } - syncobjs = kmalloc_objs(*syncobjs, count_handles); + syncobjs = kvmalloc_objs(*syncobjs, count_handles); if (syncobjs == NULL) { ret = -ENOMEM; goto err_free_handles; @@ -1262,16 +1276,16 @@ static int drm_syncobj_array_find(struct drm_file *file_private, } } - kfree(handles); + kvfree(handles); *syncobjs_out = syncobjs; return 0; err_put_syncobjs: while (i-- > 0) drm_syncobj_put(syncobjs[i]); - kfree(syncobjs); + kvfree(syncobjs); err_free_handles: - kfree(handles); + kvfree(handles); return ret; } @@ -1283,7 +1297,7 @@ static void drm_syncobj_array_free(struct drm_syncobj **syncobjs, for (i = 0; i < count; i++) drm_syncobj_put(syncobjs[i]); - kfree(syncobjs); + kvfree(syncobjs); } int @@ -1572,7 +1586,7 @@ drm_syncobj_timeline_signal_ioctl(struct drm_device *dev, void *data, if (ret < 0) return ret; - points = kmalloc_objs(*points, args->count_handles); + points = kvmalloc_objs(*points, args->count_handles); if (!points) { ret = -ENOMEM; goto out; @@ -1585,7 +1599,7 @@ drm_syncobj_timeline_signal_ioctl(struct drm_device *dev, void *data, goto err_points; } - chains = kmalloc_objs(*chains, args->count_handles); + chains = kvmalloc_objs(*chains, args->count_handles); if (!chains) { ret = -ENOMEM; goto err_points; @@ -1608,9 +1622,9 @@ drm_syncobj_timeline_signal_ioctl(struct drm_device *dev, void *data, dma_fence_put(fence); } err_chains: - kfree(chains); + kvfree(chains); err_points: - kfree(points); + kvfree(points); out: drm_syncobj_array_free(syncobjs, args->count_handles); diff --git a/drivers/gpu/drm/drm_vblank.c b/drivers/gpu/drm/drm_vblank.c index f90fb2d13e42..c26464ca4a12 100644 --- a/drivers/gpu/drm/drm_vblank.c +++ b/drivers/gpu/drm/drm_vblank.c @@ -1403,6 +1403,9 @@ void drm_crtc_vblank_off(struct drm_crtc *crtc) spin_unlock_irq(&dev->event_lock); + if (crtc->funcs->sync_vblank) + crtc->funcs->sync_vblank(crtc); + /* Will be reset by the modeset helpers when re-enabling the crtc by * calling drm_calc_timestamping_constants(). */ vblank->hwmode.crtc_clock = 0; @@ -2179,19 +2182,18 @@ static enum hrtimer_restart drm_vblank_timer_function(struct hrtimer *timer) struct drm_crtc *crtc = vtimer->crtc; const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private; struct drm_device *dev = crtc->dev; - unsigned long flags; - ktime_t interval; - u64 ret_overrun; + u64 ret_overrun = 1; bool succ; - spin_lock_irqsave(&vtimer->interval_lock, flags); - interval = vtimer->interval; - spin_unlock_irqrestore(&vtimer->interval_lock, flags); + scoped_guard(spinlock_irqsave, &vtimer->interval_lock) { + ktime_t interval = vtimer->interval; - if (!interval) - return HRTIMER_NORESTART; + if (!interval || hrtimer_is_queued(timer)) + return HRTIMER_NORESTART; + + ret_overrun = hrtimer_forward_now(timer, interval); + } - ret_overrun = hrtimer_forward_now(&vtimer->timer, interval); if (ret_overrun != 1) drm_dbg_vbl(dev, "vblank timer overrun\n"); @@ -2220,7 +2222,6 @@ int drm_crtc_vblank_start_timer(struct drm_crtc *crtc) { struct drm_vblank_crtc *vblank = drm_crtc_vblank_crtc(crtc); struct drm_vblank_crtc_timer *vtimer = &vblank->vblank_timer; - unsigned long flags; if (!vtimer->crtc) { /* @@ -2230,22 +2231,14 @@ int drm_crtc_vblank_start_timer(struct drm_crtc *crtc) spin_lock_init(&vtimer->interval_lock); hrtimer_setup(&vtimer->timer, drm_vblank_timer_function, CLOCK_MONOTONIC, HRTIMER_MODE_REL); - } else { - /* - * Timer should not be active. If it is, wait for the - * previous cancel operations to finish. - */ - while (hrtimer_active(&vtimer->timer)) - hrtimer_try_to_cancel(&vtimer->timer); } drm_calc_timestamping_constants(crtc, &crtc->mode); - spin_lock_irqsave(&vtimer->interval_lock, flags); - vtimer->interval = ns_to_ktime(vblank->framedur_ns); - spin_unlock_irqrestore(&vtimer->interval_lock, flags); - - hrtimer_start(&vtimer->timer, vtimer->interval, HRTIMER_MODE_REL); + scoped_guard(spinlock_irqsave, &vtimer->interval_lock) { + vtimer->interval = ns_to_ktime(vblank->framedur_ns); + hrtimer_start(&vtimer->timer, vtimer->interval, HRTIMER_MODE_REL); + } return 0; } @@ -2256,28 +2249,61 @@ EXPORT_SYMBOL(drm_crtc_vblank_start_timer); * @crtc: the CRTC * * Drivers should call this function from their CRTC's disable_vblank - * function to stop a vblank timer. + * function to stop a vblank timer. Only signals the timer to stop at + * the next invocation. Non-blocking. To fully stop the vblank timer, + * drivers should invoke drm_crtc_vblank_stop_timer(). */ void drm_crtc_vblank_cancel_timer(struct drm_crtc *crtc) { struct drm_vblank_crtc *vblank = drm_crtc_vblank_crtc(crtc); struct drm_vblank_crtc_timer *vtimer = &vblank->vblank_timer; - unsigned long flags; + + if (!vtimer->crtc) + return; /* - * Calling hrtimer_cancel() can result in a deadlock with DRM's - * vblank_time_lime_lock and hrtimers' softirq_expiry_lock. So + * Calling hrtimer_cancel() here can result in a deadlock between + * DRM's vblank_time_lock and hrtimers' softirq_expiry_lock. So * clear interval and indicate cancellation. The timer function - * will cancel itself on the next invocation. + * will cancel itself on the next invocation. Otherwise cancel it + * in drm_crtc_vblank_stop_canceled_timer(). */ + scoped_guard(spinlock_irqsave, &vtimer->interval_lock) + vtimer->interval = 0; +} +EXPORT_SYMBOL(drm_crtc_vblank_cancel_timer); - spin_lock_irqsave(&vtimer->interval_lock, flags); - vtimer->interval = 0; - spin_unlock_irqrestore(&vtimer->interval_lock, flags); +/** + * drm_crtc_vblank_stop_canceled_timer - Stops a CRTC's previously canceled vblank timer + * @crtc: the CRTC + * + * Drivers should call this function from their CRTC's sync_vblank + * function to fully stop a vblank timer. The timer must have been + * canceled before. Use drm_crtc_vblank_stop_timer() to stop a vblank + * timer unconditionally. + * + * The function blocks until a running timer function has returned. + */ +void drm_crtc_vblank_stop_canceled_timer(struct drm_crtc *crtc) +{ + struct drm_vblank_crtc *vblank = drm_crtc_vblank_crtc(crtc); + struct drm_vblank_crtc_timer *vtimer = &vblank->vblank_timer; + ktime_t interval; + + if (!vtimer->crtc) + return; + + /* + * The vblank timer is off if it has an interval of zero. Cancel + * it before drm_crtc_vblank_start_timer() reprograms it. + */ + scoped_guard(spinlock_irqsave, &vtimer->interval_lock) + interval = vtimer->interval; - hrtimer_try_to_cancel(&vtimer->timer); + if (!interval) + hrtimer_cancel(&vtimer->timer); } -EXPORT_SYMBOL(drm_crtc_vblank_cancel_timer); +EXPORT_SYMBOL(drm_crtc_vblank_stop_canceled_timer); /** * drm_crtc_vblank_get_vblank_timeout - Returns the vblank timeout diff --git a/drivers/gpu/drm/drm_vblank_helper.c b/drivers/gpu/drm/drm_vblank_helper.c index d3f8147ecdc1..7465d74ce29e 100644 --- a/drivers/gpu/drm/drm_vblank_helper.c +++ b/drivers/gpu/drm/drm_vblank_helper.c @@ -147,6 +147,22 @@ void drm_crtc_vblank_helper_disable_vblank_timer(struct drm_crtc *crtc) EXPORT_SYMBOL(drm_crtc_vblank_helper_disable_vblank_timer); /** + * drm_crtc_vblank_helper_sync_vblank_timer - Implements struct &drm_crtc_funcs.sync_vblank + * @crtc: The CRTC + * + * The helper drm_crtc_vblank_helper_sync_vblank_timer() implements + * sync_vblank of struct drm_crtc_funcs for CRTCs that require a + * VBLANK timer. + * + * See also struct &drm_crtc_funcs.sync_vblank. + */ +void drm_crtc_vblank_helper_sync_vblank_timer(struct drm_crtc *crtc) +{ + drm_crtc_vblank_stop_canceled_timer(crtc); +} +EXPORT_SYMBOL(drm_crtc_vblank_helper_sync_vblank_timer); + +/** * drm_crtc_vblank_helper_get_vblank_timestamp_from_timer - * Implements struct &drm_crtc_funcs.get_vblank_timestamp * @crtc: The CRTC diff --git a/drivers/gpu/drm/i915/display/intel_cdclk.c b/drivers/gpu/drm/i915/display/intel_cdclk.c index 92e6fca861f6..0f2f693c78d4 100644 --- a/drivers/gpu/drm/i915/display/intel_cdclk.c +++ b/drivers/gpu/drm/i915/display/intel_cdclk.c @@ -1269,18 +1269,7 @@ static void skl_set_cdclk(struct intel_display *display, static void skl_sanitize_cdclk(struct intel_display *display) { - u32 cdctl, expected, swf18; - - /* - * check if the pre-os initialized the display - * There is SWF18 scratchpad register defined which is set by the - * pre-os which can be used by the OS drivers to check the status - */ - swf18 = intel_de_read(display, SWF_ILK(0x18)); - if ((swf18 & 0x00FFFFFF) == 0) { - drm_dbg_kms(display->drm, "Sanitizing CDCLK due to SWF18 0x%x\n", swf18); - goto sanitize; - } + u32 cdctl, expected; intel_update_cdclk(display); intel_cdclk_dump_config(display, &display->cdclk.hw, "Current CDCLK"); diff --git a/drivers/gpu/drm/i915/display/intel_dsb.c b/drivers/gpu/drm/i915/display/intel_dsb.c index d9a270362a82..07d864039e82 100644 --- a/drivers/gpu/drm/i915/display/intel_dsb.c +++ b/drivers/gpu/drm/i915/display/intel_dsb.c @@ -589,10 +589,10 @@ static void intel_dsb_align_tail(struct intel_dsb *dsb) tail = dsb->free_pos * 4; aligned_tail = ALIGN(tail, CACHELINE_BYTES); - if (aligned_tail > tail) + if (aligned_tail > tail) { dsb_buffer_fill(dsb, dsb->free_pos, 0, aligned_tail - tail); - - dsb->free_pos = aligned_tail / 4; + dsb->free_pos = aligned_tail / 4; + } } static void intel_dsb_gosub_align(struct intel_dsb *dsb) @@ -607,11 +607,15 @@ static void intel_dsb_gosub_align(struct intel_dsb *dsb) /* * Wa_16024917128 * "Ensure GOSUB is not placed in cacheline QW slot 6 or 7 (numbered 0-7)" + * + * Move to the next cacheline only for those two slots. The skipped + * bytes stay in the programmed range, so fill them with NOPs. Any + * other slot can take the GOSUB directly. */ - if (aligned_tail - tail <= 2 * 8) + if (aligned_tail - tail <= 2 * 8) { dsb_buffer_fill(dsb, dsb->free_pos, 0, aligned_tail - tail); - - dsb->free_pos = aligned_tail / 4; + dsb->free_pos = aligned_tail / 4; + } } void intel_dsb_gosub(struct intel_dsb *dsb, diff --git a/drivers/gpu/drm/imagination/pvr_power.c b/drivers/gpu/drm/imagination/pvr_power.c index eb4b6ecdf4f4..c7c160913d7c 100644 --- a/drivers/gpu/drm/imagination/pvr_power.c +++ b/drivers/gpu/drm/imagination/pvr_power.c @@ -59,7 +59,8 @@ pvr_power_send_command(struct pvr_device *pvr_dev, struct rogue_fwif_kccb_cmd *p return err; /* Wait for FW to acknowledge. */ - return readl_poll_timeout(pvr_dev->fw_dev.power_sync, value, value != 0, 100, + return readx_poll_timeout(READ_ONCE, + *pvr_dev->fw_dev.power_sync, value, value != 0, 100, POWER_SYNC_TIMEOUT_US); } diff --git a/drivers/gpu/drm/nouveau/nouveau_sched.c b/drivers/gpu/drm/nouveau/nouveau_sched.c index b3f02c490ecb..680ddffefca1 100644 --- a/drivers/gpu/drm/nouveau/nouveau_sched.c +++ b/drivers/gpu/drm/nouveau/nouveau_sched.c @@ -328,7 +328,11 @@ nouveau_job_submit(struct nouveau_job *job) mutex_unlock(&sched->mutex); if (done_fence) { - dma_fence_wait(done_fence, true); + /* The job is queued and its VA space changes are applied. It + * can neither be restarted nor reported as failed, so wait + * until it has run. + */ + dma_fence_wait(done_fence, false); dma_fence_put(done_fence); } diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/bar/gf100.c b/drivers/gpu/drm/nouveau/nvkm/subdev/bar/gf100.c index a1fa1b0c8954..6950801d2e03 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/bar/gf100.c +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/bar/gf100.c @@ -133,6 +133,12 @@ gf100_bar_oneinit(struct nvkm_bar *base) if (ret) return ret; + if (bar->base.func->bar2.oneinit) { + ret = bar->base.func->bar2.oneinit(&bar->base); + if (ret) + return ret; + } + bar->base.subdev.oneinit = true; nvkm_bar_bar2_init(bar->base.subdev.device); } diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/bar/priv.h b/drivers/gpu/drm/nouveau/nvkm/subdev/bar/priv.h index d0168e0b78fb..5774bfa8d96d 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/bar/priv.h +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/bar/priv.h @@ -16,6 +16,7 @@ struct nvkm_bar_func { void (*init)(struct nvkm_bar *); struct { + int (*oneinit)(struct nvkm_bar *); void (*init)(struct nvkm_bar *); void (*fini)(struct nvkm_bar *); void (*wait)(struct nvkm_bar *); diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/bar.c b/drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/bar.c index fae08ac3b18c..9b907d9e80af 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/bar.c +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/bar.c @@ -24,9 +24,11 @@ #include <core/mm.h> #include <subdev/fb.h> #include <subdev/gsp.h> -#include <subdev/instmem.h> +#include <subdev/instmem/priv.h> #include <subdev/mmu/vmm.h> +#include <linux/io-mapping.h> + #include "nvrm/bar.h" #include "nvrm/rpcfn.h" @@ -65,6 +67,25 @@ r535_bar_bar2_update_pde(struct nvkm_gsp *gsp, u8 page_shift, u64 pdbe) return nvkm_gsp_rpc_wr(gsp, rpc, NVKM_GSP_RPC_REPLY_RECV); } +static int +r535_bar_bar2_oneinit(struct nvkm_bar *bar) +{ + struct io_mapping *iomap = nv50_instmem_bar2_iomap(bar->subdev.device->imem); + + if (!iomap) + return -ENOMEM; + + /* BAR2 writes are flushed by a read. While flushFBZero is not mapped, + * read the first page of the BAR2 io_mapping. + */ + bar->flushBAR2PhysMode = io_mapping_map_wc(iomap, 0, PAGE_SIZE); + if (!bar->flushBAR2PhysMode) + return -ENOMEM; + + bar->flushBAR2 = bar->flushBAR2PhysMode; + return 0; +} + static void r535_bar_bar2_fini(struct nvkm_bar *bar) { @@ -155,7 +176,7 @@ r535_bar_dtor(struct nvkm_bar *bar) nvkm_memory_unref(&bar->flushFBZero); if (bar->flushBAR2PhysMode) - iounmap(bar->flushBAR2PhysMode); + io_mapping_unmap(bar->flushBAR2PhysMode); kfree(bar->func); return data; @@ -178,6 +199,7 @@ r535_bar_new_(const struct nvkm_bar_func *hw, struct nvkm_device *device, rm->bar1.fini = r535_bar_bar1_fini; rm->bar1.wait = r535_bar_bar1_wait; rm->bar1.vmm = hw->bar1.vmm; + rm->bar2.oneinit = r535_bar_bar2_oneinit; rm->bar2.init = r535_bar_bar2_init; rm->bar2.fini = r535_bar_bar2_fini; rm->bar2.wait = r535_bar_bar2_wait; @@ -191,12 +213,6 @@ r535_bar_new_(const struct nvkm_bar_func *hw, struct nvkm_device *device, } *pbar = bar; - bar->flushBAR2PhysMode = ioremap(device->func->resource_addr(device, NVKM_BAR2_INST), PAGE_SIZE); - if (!bar->flushBAR2PhysMode) - return -ENOMEM; - - bar->flushBAR2 = bar->flushBAR2PhysMode; - gf100_bar(*pbar)->bar2_halve = true; return 0; } diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c b/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c index 22b0fde6ba34..1e7d439c2d59 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/nv50.c @@ -191,16 +191,17 @@ nv50_instobj_map(struct nvkm_memory *memory, u64 offset, struct nvkm_vmm *vmm, } static bool -check_io_mapping(struct nv50_instmem *imem) +check_io_mapping(struct nv50_instmem *imem, struct nvkm_vmm *vmm) { struct nvkm_device *device = imem->base.subdev.device; if (imem->iomap.size) return true; + /* Map the part of BAR2 that its address space covers. */ return io_mapping_init_wc(&imem->iomap, device->func->resource_addr(device, NVKM_BAR2_INST), - device->func->resource_size(device, NVKM_BAR2_INST)) != NULL; + vmm->limit - vmm->start) != NULL; } static void @@ -293,10 +294,10 @@ nv50_instobj_boot(struct nvkm_memory *memory, struct nvkm_vmm *vmm) } /* - * boot is only called on BAR2, if we can't remap the complete - * BAR it's unlikely things are functioning well. + * boot is only called on BAR2. If we can't map it, it's unlikely + * things are functioning well. */ - if (check_io_mapping(iobj->imem)) + if (check_io_mapping(iobj->imem, vmm)) nv50_instobj_kmap(iobj, vmm); nvkm_instmem_boot(imem); mutex_unlock(&imem->mutex); @@ -436,6 +437,14 @@ nv50_instmem_dtor(struct nvkm_instmem *base) return imem; } +struct io_mapping * +nv50_instmem_bar2_iomap(struct nvkm_instmem *base) +{ + struct nv50_instmem *imem = nv50_instmem(base); + + return imem->iomap.size ? &imem->iomap : NULL; +} + static const struct nvkm_instmem_func nv50_instmem = { .dtor = nv50_instmem_dtor, diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/priv.h b/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/priv.h index b423f01f5fcd..88990adda766 100644 --- a/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/priv.h +++ b/drivers/gpu/drm/nouveau/nvkm/subdev/instmem/priv.h @@ -4,6 +4,8 @@ #define nvkm_instmem(p) container_of((p), struct nvkm_instmem, subdev) #include <subdev/instmem.h> +struct io_mapping; + struct nvkm_instmem_func { void *(*dtor)(struct nvkm_instmem *); int (*oneinit)(struct nvkm_instmem *); @@ -27,6 +29,7 @@ int nv50_instobj_new(struct nvkm_instmem *, u32 size, u32 align, bool zero, int nv50_instobj_wrap(struct nvkm_instmem *, struct nvkm_memory *vram, struct nvkm_memory **bar2); void *nv50_instmem_dtor(struct nvkm_instmem *base); +struct io_mapping *nv50_instmem_bar2_iomap(struct nvkm_instmem *base); void nvkm_instmem_ctor(const struct nvkm_instmem_func *, struct nvkm_device *, enum nvkm_subdev_type, int, struct nvkm_instmem *); diff --git a/drivers/gpu/drm/omapdrm/dss/output.c b/drivers/gpu/drm/omapdrm/dss/output.c index 36d37deac802..b5cef5093a88 100644 --- a/drivers/gpu/drm/omapdrm/dss/output.c +++ b/drivers/gpu/drm/omapdrm/dss/output.c @@ -24,6 +24,9 @@ int omapdss_device_init_output(struct omap_dss_device *out, bridge = of_drm_get_bridge_by_endpoint(out->dev->of_node, out->of_port, 0); if (IS_ERR(bridge)) { + if (PTR_ERR(bridge) == -EPROBE_DEFER) + return PTR_ERR(bridge); + dev_dbg(out->dev, "failed to find video sink\n"); return 0; } diff --git a/drivers/gpu/drm/radeon/radeon_atombios.c b/drivers/gpu/drm/radeon/radeon_atombios.c index 3dd9724b331d..c4e1272cd843 100644 --- a/drivers/gpu/drm/radeon/radeon_atombios.c +++ b/drivers/gpu/drm/radeon/radeon_atombios.c @@ -125,6 +125,22 @@ static struct radeon_i2c_bus_rec radeon_get_bus_rec_for_i2c_gpio(ATOM_GPIO_I2C_A return i2c; } +/* + * The VBIOS table size is not checked against the image; cap the + * entry count to RADEON_MAX_I2C_BUS, the size of rdev->i2c_bus[]. + */ +static int radeon_atombios_gpio_i2c_num_entries(uint16_t size) +{ + u32 bytes; + + if (size < sizeof(ATOM_COMMON_TABLE_HEADER)) + return 0; + + bytes = size - sizeof(ATOM_COMMON_TABLE_HEADER); + return min_t(u32, bytes / sizeof(ATOM_GPIO_I2C_ASSIGMENT), + RADEON_MAX_I2C_BUS); +} + static struct radeon_i2c_bus_rec radeon_lookup_i2c_gpio(struct radeon_device *rdev, uint8_t id) { @@ -142,8 +158,7 @@ static struct radeon_i2c_bus_rec radeon_lookup_i2c_gpio(struct radeon_device *rd if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) { i2c_info = (struct _ATOM_GPIO_I2C_INFO *)(ctx->bios + data_offset); - num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) / - sizeof(ATOM_GPIO_I2C_ASSIGMENT); + num_indices = radeon_atombios_gpio_i2c_num_entries(size); gpio = &i2c_info->asGPIO_Info[0]; for (i = 0; i < num_indices; i++) { @@ -176,8 +191,7 @@ void radeon_atombios_i2c_init(struct radeon_device *rdev) if (atom_parse_data_header(ctx, index, &size, NULL, NULL, &data_offset)) { i2c_info = (struct _ATOM_GPIO_I2C_INFO *)(ctx->bios + data_offset); - num_indices = (size - sizeof(ATOM_COMMON_TABLE_HEADER)) / - sizeof(ATOM_GPIO_I2C_ASSIGMENT); + num_indices = radeon_atombios_gpio_i2c_num_entries(size); gpio = &i2c_info->asGPIO_Info[0]; for (i = 0; i < num_indices; i++) { diff --git a/drivers/gpu/drm/radeon/radeon_atpx_handler.c b/drivers/gpu/drm/radeon/radeon_atpx_handler.c index f557535c1d7b..9ed75c69c615 100644 --- a/drivers/gpu/drm/radeon/radeon_atpx_handler.c +++ b/drivers/gpu/drm/radeon/radeon_atpx_handler.c @@ -34,6 +34,7 @@ struct radeon_atpx { static struct radeon_atpx_priv { bool atpx_detected; bool bridge_pm_usable; + bool handler_registered; /* handle for device - and atpx */ acpi_handle dhandle; struct radeon_atpx atpx; @@ -605,7 +606,8 @@ void radeon_register_atpx_handler(void) if (!r) return; - vga_switcheroo_register_handler(&radeon_atpx_handler, handler_flags); + if (!vga_switcheroo_register_handler(&radeon_atpx_handler, handler_flags)) + radeon_atpx_priv.handler_registered = true; } /** @@ -615,5 +617,14 @@ void radeon_register_atpx_handler(void) */ void radeon_unregister_atpx_handler(void) { + /* + * vga_switcheroo has a single handler slot and unregistering clears it + * no matter who set it, so leave a handler registered by another + * driver, such as amdgpu or apple-gmux, in place. + */ + if (!radeon_atpx_priv.handler_registered) + return; + vga_switcheroo_unregister_handler(); + radeon_atpx_priv.handler_registered = false; } diff --git a/drivers/gpu/drm/tilcdc/tilcdc_drv.c b/drivers/gpu/drm/tilcdc/tilcdc_drv.c index 1d6c9a423a41..e82cb2686c5f 100644 --- a/drivers/gpu/drm/tilcdc/tilcdc_drv.c +++ b/drivers/gpu/drm/tilcdc/tilcdc_drv.c @@ -235,7 +235,8 @@ static const struct drm_driver tilcdc_driver = { static int tilcdc_pm_suspend(struct device *dev) { - struct drm_device *ddev = dev_get_drvdata(dev); + struct tilcdc_drm_private *priv = dev_get_drvdata(dev); + struct drm_device *ddev = &priv->ddev; int ret = 0; ret = drm_mode_config_helper_suspend(ddev); @@ -248,7 +249,8 @@ static int tilcdc_pm_suspend(struct device *dev) static int tilcdc_pm_resume(struct device *dev) { - struct drm_device *ddev = dev_get_drvdata(dev); + struct tilcdc_drm_private *priv = dev_get_drvdata(dev); + struct drm_device *ddev = &priv->ddev; /* Select default pin state */ pinctrl_pm_select_default_state(dev); diff --git a/drivers/gpu/drm/vc4/vc4_bo.c b/drivers/gpu/drm/vc4/vc4_bo.c index da4b11b7ce9f..2ab7c158b7ff 100644 --- a/drivers/gpu/drm/vc4/vc4_bo.c +++ b/drivers/gpu/drm/vc4/vc4_bo.c @@ -17,6 +17,7 @@ */ #include <linux/dma-buf.h> +#include <linux/overflow.h> #include <drm/drm_fourcc.h> #include <drm/drm_print.h> @@ -836,6 +837,19 @@ int vc4_mmap_bo_ioctl(struct drm_device *dev, void *data, return 0; } +/* + * QPUs sharing a slice's instruction cache can livelock evicting each + * other's fills. Considering that shader BOs are page aligned, any code + * at offset 0 maps every shader to the same cache sets. This makes a + * livelock more likely to happen due to GFXH-16. + * + * Start each shader at one of four offsets, cycled per client, to spread + * them across sets. The use of four different offsets is motivated by the + * number of QPUs per slice (4 QPUs). + */ +#define VC4_SHADER_OFFSET_STEP 256 +#define VC4_SHADER_OFFSET_NUM 4 + int vc4_create_shader_bo_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) @@ -844,6 +858,7 @@ vc4_create_shader_bo_ioctl(struct drm_device *dev, void *data, struct vc4_file *vc4file = file_priv->driver_priv; struct vc4_dev *vc4 = to_vc4_dev(dev); struct vc4_bo *bo = NULL; + u32 offset, size; int ret; if (WARN_ON_ONCE(vc4->gen > VC4_GEN_4)) @@ -865,29 +880,37 @@ vc4_create_shader_bo_ioctl(struct drm_device *dev, void *data, return -EINVAL; } + offset = ((u32)atomic_inc_return(&vc4file->shader_offset_idx) % + VC4_SHADER_OFFSET_NUM) * VC4_SHADER_OFFSET_STEP; + + if (check_add_overflow(offset, args->size, &size)) + return -EINVAL; + ret = vc4_grab_bin_bo(vc4, vc4file); if (ret) return ret; - bo = vc4_bo_create(dev, args->size, true, VC4_BO_TYPE_V3D_SHADER); + bo = vc4_bo_create(dev, size, true, VC4_BO_TYPE_V3D_SHADER); if (IS_ERR(bo)) return PTR_ERR(bo); bo->madv = VC4_MADV_WILLNEED; + bo->shader_offset = offset; - if (copy_from_user(bo->base.vaddr, - (void __user *)(uintptr_t)args->data, - args->size)) { + /* Clear the memory around the code, which may come from the BO + * cache. + */ + memset(bo->base.vaddr, 0, offset); + if (copy_from_user(bo->base.vaddr + offset, + (void __user *)(uintptr_t)args->data, + args->size)) { ret = -EFAULT; goto fail; } - /* Clear the rest of the memory from allocating from the BO - * cache. - */ - memset(bo->base.vaddr + args->size, 0, - bo->base.base.size - args->size); + memset(bo->base.vaddr + offset + args->size, 0, + bo->base.base.size - offset - args->size); - bo->validated_shader = vc4_validate_shader(&bo->base); + bo->validated_shader = vc4_validate_shader(&bo->base, offset); if (!bo->validated_shader) { ret = -EINVAL; goto fail; diff --git a/drivers/gpu/drm/vc4/vc4_crtc.c b/drivers/gpu/drm/vc4/vc4_crtc.c index f42cd5353230..4b6d4a5f7bc9 100644 --- a/drivers/gpu/drm/vc4/vc4_crtc.c +++ b/drivers/gpu/drm/vc4/vc4_crtc.c @@ -884,17 +884,21 @@ struct vc4_async_flip_state { struct drm_framebuffer *fb; struct drm_framebuffer *old_fb; struct drm_pending_vblank_event *event; + struct dma_fence *fence; struct dma_fence_cb cb; + struct work_struct work; }; -/* Called when the V3D execution for the BO being flipped to is done, so that - * we can actually update the plane's address to point to it. +/* Executed when the V3D execution for the BO being flipped to is done, so + * that we can actually update the plane's address to point to it. */ -static void -vc4_async_page_flip_complete(struct vc4_async_flip_state *flip_state) +static void vc4_async_page_flip_work(struct work_struct *work) { + struct vc4_async_flip_state *flip_state = + container_of(work, struct vc4_async_flip_state, work); struct drm_crtc *crtc = flip_state->crtc; struct drm_device *dev = crtc->dev; + struct vc4_dev *vc4 = to_vc4_dev(dev); struct drm_plane *plane = crtc->primary; vc4_plane_async_set_fb(plane, flip_state->fb); @@ -909,82 +913,57 @@ vc4_async_page_flip_complete(struct vc4_async_flip_state *flip_state) drm_crtc_vblank_put(crtc); drm_framebuffer_put(flip_state->fb); - if (flip_state->old_fb) - drm_framebuffer_put(flip_state->old_fb); - - kfree(flip_state); -} + if (flip_state->old_fb) { + /* + * Decrement the BO usecnt in order to keep the inc/dec + * calls balanced when the planes are updated through + * the async update path. + * + * FIXME: we should move to generic async-page-flip when + * it's available, so that we can get rid of this + * hand-made cleanup_fb() logic. + */ + if (vc4->gen == VC4_GEN_4) { + struct drm_gem_dma_object *dma_bo = + drm_fb_dma_get_gem_obj(flip_state->old_fb, 0); -static void vc4_async_page_flip_complete_with_cleanup(struct dma_fence *fence, - struct dma_fence_cb *cb) -{ - struct vc4_async_flip_state *flip_state = - container_of(cb, struct vc4_async_flip_state, cb); - struct vc4_bo *bo = NULL; + vc4_bo_dec_usecnt(to_vc4_bo(&dma_bo->base)); + } - if (flip_state->old_fb) { - struct drm_gem_dma_object *dma_bo = - drm_fb_dma_get_gem_obj(flip_state->old_fb, 0); - bo = to_vc4_bo(&dma_bo->base); + drm_framebuffer_put(flip_state->old_fb); } - vc4_async_page_flip_complete(flip_state); - dma_fence_put(fence); - - /* - * Decrement the BO usecnt in order to keep the inc/dec - * calls balanced when the planes are updated through - * the async update path. - * - * FIXME: we should move to generic async-page-flip when - * it's available, so that we can get rid of this - * hand-made cleanup_fb() logic. - */ - if (bo) - vc4_bo_dec_usecnt(bo); + dma_fence_put(flip_state->fence); + kfree(flip_state); } -static void vc4_async_page_flip_fence_complete(struct dma_fence *fence, - struct dma_fence_cb *cb) +static void vc4_async_page_flip_fence_cb(struct dma_fence *fence, + struct dma_fence_cb *cb) { struct vc4_async_flip_state *flip_state = container_of(cb, struct vc4_async_flip_state, cb); + struct vc4_crtc *vc4_crtc = to_vc4_crtc(flip_state->crtc); - vc4_async_page_flip_complete(flip_state); - dma_fence_put(fence); + /* Completing the flip may sleep, so defer it to a worker. */ + queue_work(vc4_crtc->async_flip_wq, &flip_state->work); } -static int vc4_async_set_fence_cb(struct drm_device *dev, - struct vc4_async_flip_state *flip_state) +static void vc4_async_set_fence_cb(struct vc4_async_flip_state *flip_state) { - struct drm_framebuffer *fb = flip_state->fb; - struct drm_gem_dma_object *dma_bo = drm_fb_dma_get_gem_obj(fb, 0); - dma_fence_func_t async_page_flip_complete_function; - struct vc4_dev *vc4 = to_vc4_dev(dev); - struct dma_fence *fence; - int ret; + struct vc4_crtc *vc4_crtc = to_vc4_crtc(flip_state->crtc); - if (vc4->gen == VC4_GEN_4) - async_page_flip_complete_function = vc4_async_page_flip_complete_with_cleanup; - else - async_page_flip_complete_function = vc4_async_page_flip_fence_complete; - - ret = dma_resv_get_singleton(dma_bo->base.resv, DMA_RESV_USAGE_READ, &fence); - if (ret) - return ret; - - /* If there's no fence, complete the page flip immediately */ - if (!fence) { - async_page_flip_complete_function(fence, &flip_state->cb); - return 0; - } + INIT_WORK(&flip_state->work, vc4_async_page_flip_work); - /* If the fence has already been completed, complete the page flip */ - if (dma_fence_add_callback(fence, &flip_state->cb, - async_page_flip_complete_function)) - async_page_flip_complete_function(fence, &flip_state->cb); + if (flip_state->fence && + !dma_fence_add_callback(flip_state->fence, &flip_state->cb, + vc4_async_page_flip_fence_cb)) + return; - return 0; + /* No fence or the fence has already signaled. Complete the flip + * immediately, after earlier queued flips. + */ + flush_workqueue(vc4_crtc->async_flip_wq); + vc4_async_page_flip_work(&flip_state->work); } static int @@ -993,14 +972,22 @@ vc4_async_page_flip_common(struct drm_crtc *crtc, struct drm_pending_vblank_event *event, uint32_t flags) { - struct drm_device *dev = crtc->dev; + struct drm_gem_dma_object *dma_bo = drm_fb_dma_get_gem_obj(fb, 0); struct drm_plane *plane = crtc->primary; struct vc4_async_flip_state *flip_state; + int ret; flip_state = kzalloc_obj(*flip_state); if (!flip_state) return -ENOMEM; + ret = dma_resv_get_singleton(dma_bo->base.resv, DMA_RESV_USAGE_READ, + &flip_state->fence); + if (ret) { + kfree(flip_state); + return ret; + } + drm_framebuffer_get(fb); flip_state->fb = fb; flip_state->crtc = crtc; @@ -1008,7 +995,7 @@ vc4_async_page_flip_common(struct drm_crtc *crtc, /* Save the current FB before it's replaced by the new one in * drm_atomic_set_fb_for_plane(). We'll need the old FB in - * vc4_async_page_flip_complete() to decrement the BO usecnt and keep + * vc4_async_page_flip_work() to decrement the BO usecnt and keep * it consistent. * FIXME: we should move to generic async-page-flip when it's * available, so that we can get rid of this hand-made cleanup_fb() @@ -1026,7 +1013,7 @@ vc4_async_page_flip_common(struct drm_crtc *crtc, */ drm_atomic_set_fb_for_plane(plane->state, fb); - vc4_async_set_fence_cb(dev, flip_state); + vc4_async_set_fence_cb(flip_state); /* Driver takes ownership of state on successful async commit. */ return 0; @@ -1413,6 +1400,11 @@ int __vc4_crtc_init(struct drm_device *drm, drm_crtc_helper_add(crtc, crtc_helper_funcs); + vc4_crtc->async_flip_wq = drmm_alloc_ordered_workqueue(drm, "%s-async-flip", + 0, crtc->name); + if (IS_ERR(vc4_crtc->async_flip_wq)) + return PTR_ERR(vc4_crtc->async_flip_wq); + if (vc4->gen == VC4_GEN_4) { drm_mode_crtc_set_gamma_size(crtc, ARRAY_SIZE(vc4_crtc->lut_r)); drm_crtc_enable_color_mgmt(crtc, 0, false, crtc->gamma_size); diff --git a/drivers/gpu/drm/vc4/vc4_drv.h b/drivers/gpu/drm/vc4/vc4_drv.h index 09134809bf15..dae325a3854d 100644 --- a/drivers/gpu/drm/vc4/vc4_drv.h +++ b/drivers/gpu/drm/vc4/vc4_drv.h @@ -218,6 +218,11 @@ struct vc4_dev { struct { struct timer_list timer; struct work_struct reset_work; + + /* The instruction and uniforms caches were cleared at the + * last check that found no progress. + */ + bool caches_cleared; } hangcheck; struct drm_modeset_lock ctm_state_lock; @@ -255,6 +260,9 @@ struct vc4_bo { */ struct vc4_validated_shader_info *validated_shader; + /* Byte offset of the shader code in the BO. */ + u32 shader_offset; + /* One of enum vc4_kernel_bo_type, or VC4_BO_TYPE_COUNT + i * for user-allocated labels. */ @@ -596,6 +604,12 @@ struct vc4_crtc { * access to that value. */ unsigned int current_hvs_channel; + + /** + * @async_flip_wq: Ordered workqueue completing the CRTC's async + * page flips. + */ + struct workqueue_struct *async_flip_wq; }; #define to_vc4_crtc(_crtc) \ @@ -796,6 +810,11 @@ struct vc4_file { struct xarray perfmons; bool bin_bo_used; + + /* Counter picking the start offset of the next shader BO's code, + * see vc4_create_shader_bo_ioctl(). + */ + atomic_t shader_offset_idx; }; static inline struct vc4_exec_info * @@ -1083,7 +1102,7 @@ bool vc4_check_tex_size(struct vc4_exec_info *exec, /* vc4_validate_shader.c */ struct vc4_validated_shader_info * -vc4_validate_shader(struct drm_gem_dma_object *shader_obj); +vc4_validate_shader(struct drm_gem_dma_object *shader_obj, u32 offset); /* vc4_perfmon.c */ void vc4_perfmon_get(struct vc4_perfmon *perfmon); diff --git a/drivers/gpu/drm/vc4/vc4_dsi.c b/drivers/gpu/drm/vc4/vc4_dsi.c index 0148f2befed1..762929ec471f 100644 --- a/drivers/gpu/drm/vc4/vc4_dsi.c +++ b/drivers/gpu/drm/vc4/vc4_dsi.c @@ -1527,8 +1527,8 @@ static irqreturn_t vc4_dsi_irq_handler(int irq, void *data) complete(&dsi->xfer_completion); ret = IRQ_HANDLED; } else if (stat & DSI_PORT_BIT(INT_HSTX_TO)) { - complete(&dsi->xfer_completion); dsi->xfer_result = -ETIMEDOUT; + complete(&dsi->xfer_completion); ret = IRQ_HANDLED; } @@ -1599,9 +1599,8 @@ vc4_dsi_init_phy_clocks(struct vc4_dsi *dsi) dsi->clk_onecell->hws[i] = &fix->hw; } - return of_clk_add_hw_provider(dev->of_node, - of_clk_hw_onecell_get, - dsi->clk_onecell); + return devm_of_clk_add_hw_provider(dev, of_clk_hw_onecell_get, + dsi->clk_onecell); } static void vc4_dsi_dma_mem_release(void *ptr) diff --git a/drivers/gpu/drm/vc4/vc4_gem.c b/drivers/gpu/drm/vc4/vc4_gem.c index 956be198f8a7..9898eb1ef077 100644 --- a/drivers/gpu/drm/vc4/vc4_gem.c +++ b/drivers/gpu/drm/vc4/vc4_gem.c @@ -43,8 +43,7 @@ vc4_queue_hangcheck(struct drm_device *dev) { struct vc4_dev *vc4 = to_vc4_dev(dev); - mod_timer(&vc4->hangcheck.timer, - round_jiffies_up(jiffies + msecs_to_jiffies(100))); + mod_timer(&vc4->hangcheck.timer, jiffies + msecs_to_jiffies(100)); } struct vc4_hang_state { @@ -355,6 +354,7 @@ vc4_hangcheck_elapsed(struct timer_list *t) /* If idle, we can stop watching for hangs. */ if (!bin_exec && !render_exec) { + vc4->hangcheck.caches_cleared = false; spin_unlock_irqrestore(&vc4->job_lock, irqflags); return; } @@ -371,11 +371,27 @@ vc4_hangcheck_elapsed(struct timer_list *t) bin_exec->last_ct0ca = ct0ca; if (render_exec) render_exec->last_ct1ca = ct1ca; + + vc4->hangcheck.caches_cleared = false; + spin_unlock_irqrestore(&vc4->job_lock, irqflags); vc4_queue_hangcheck(dev); return; } + /* Clear the slice caches to workaround GFXH-16 */ + if (!vc4->hangcheck.caches_cleared) { + V3D_WRITE(V3D_SLCACTL, VC4_SET_FIELD(0xf, V3D_SLCACTL_ICC) | + VC4_SET_FIELD(0xf, V3D_SLCACTL_UCC)); + + vc4->hangcheck.caches_cleared = true; + spin_unlock_irqrestore(&vc4->job_lock, irqflags); + vc4_queue_hangcheck(dev); + return; + } + + vc4->hangcheck.caches_cleared = false; + spin_unlock_irqrestore(&vc4->job_lock, irqflags); /* We've gone too long with no progress, reset. This has to diff --git a/drivers/gpu/drm/vc4/vc4_validate.c b/drivers/gpu/drm/vc4/vc4_validate.c index 565227657b43..b67ac1b21265 100644 --- a/drivers/gpu/drm/vc4/vc4_validate.c +++ b/drivers/gpu/drm/vc4/vc4_validate.c @@ -815,7 +815,7 @@ validate_gl_shader_rec(struct drm_device *dev, exec->shader_rec_size -= packet_size; for (i = 0; i < shader_reloc_count; i++) { - if (src_handles[i] > exec->bo_count) { + if (src_handles[i] >= exec->bo_count) { DRM_DEBUG("Shader handle %d too big\n", src_handles[i]); return -EINVAL; } @@ -823,6 +823,9 @@ validate_gl_shader_rec(struct drm_device *dev, bo[i] = to_drm_gem_dma_obj(exec->bo[src_handles[i]]); if (!bo[i]) return -EINVAL; + + if (!to_vc4_bo(&bo[i]->base)->validated_shader) + return -EINVAL; } for (i = shader_reloc_count; i < nr_relocs; i++) { bo[i] = vc4_use_bo(exec, src_handles[i]); @@ -843,14 +846,16 @@ validate_gl_shader_rec(struct drm_device *dev, } for (i = 0; i < shader_reloc_count; i++) { - struct vc4_validated_shader_info *validated_shader; + struct vc4_validated_shader_info *validated_shader = + to_vc4_bo(&bo[i]->base)->validated_shader; uint32_t o = shader_reloc_offsets[i]; uint32_t src_offset = *(uint32_t *)(pkt_u + o); uint32_t *texture_handles_u; void *uniform_data_u; uint32_t tex, uni; - *(uint32_t *)(pkt_v + o) = bo[i]->dma_addr + src_offset; + *(uint32_t *)(pkt_v + o) = bo[i]->dma_addr + src_offset + + to_vc4_bo(&bo[i]->base)->shader_offset; if (src_offset != 0) { DRM_DEBUG("Shaders must be at offset 0 of " @@ -858,10 +863,6 @@ validate_gl_shader_rec(struct drm_device *dev, return -EINVAL; } - validated_shader = to_vc4_bo(&bo[i]->base)->validated_shader; - if (!validated_shader) - return -EINVAL; - if (validated_shader->uniforms_src_size > exec->uniforms_size) { DRM_DEBUG("Uniforms src buffer overflow\n"); diff --git a/drivers/gpu/drm/vc4/vc4_validate_shaders.c b/drivers/gpu/drm/vc4/vc4_validate_shaders.c index db7c0dbdf60e..09ebd8f92bf5 100644 --- a/drivers/gpu/drm/vc4/vc4_validate_shaders.c +++ b/drivers/gpu/drm/vc4/vc4_validate_shaders.c @@ -779,7 +779,7 @@ vc4_handle_branch_target(struct vc4_shader_validation_state *validation_state) } struct vc4_validated_shader_info * -vc4_validate_shader(struct drm_gem_dma_object *shader_obj) +vc4_validate_shader(struct drm_gem_dma_object *shader_obj, u32 offset) { struct vc4_dev *vc4 = to_vc4_dev(shader_obj->base.dev); bool found_shader_end = false; @@ -793,8 +793,9 @@ vc4_validate_shader(struct drm_gem_dma_object *shader_obj) return NULL; memset(&validation_state, 0, sizeof(validation_state)); - validation_state.shader = shader_obj->vaddr; - validation_state.max_ip = shader_obj->base.size / sizeof(uint64_t); + validation_state.shader = shader_obj->vaddr + offset; + validation_state.max_ip = (shader_obj->base.size - offset) / + sizeof(uint64_t); reset_validation_state(&validation_state); diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_bo.c b/drivers/gpu/drm/vmwgfx/vmwgfx_bo.c index 9c7a73c0b0dc..a6d7156e4281 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_bo.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_bo.c @@ -55,6 +55,8 @@ static void vmw_bo_free(struct ttm_buffer_object *bo) /* Reserve and switch the backing mob. */ mutex_lock(&res->dev_priv->cmdbuf_mutex); (void)vmw_resource_reserve(res, false, true); + /* TTM drops the reservation before calling the destructor. */ + dma_resv_lock(bo->base.resv, NULL); vmw_resource_mob_detach(res); if (res->dirty) res->func->dirty_free(res); @@ -62,6 +64,7 @@ static void vmw_bo_free(struct ttm_buffer_object *bo) vmw_bo_dirty_release(res->guest_memory_bo); res->guest_memory_bo = NULL; res->guest_memory_offset = 0; + dma_resv_unlock(bo->base.resv); vmw_resource_unreserve(res, true, false, false, NULL, 0); mutex_unlock(&res->dev_priv->cmdbuf_mutex); diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c b/drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c index 5a69606a0593..b678e5b68db7 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.c @@ -89,10 +89,26 @@ vmw_cursor_plane_update_legacy(struct vmw_private *vmw, } } +static struct vmw_user_object +vmw_cursor_plane_user_object(struct drm_framebuffer *fb) +{ + struct vmw_user_object uo = { 0 }; + + if (!fb) + return uo; + + if (vmw_framebuffer_to_vfb(fb)->bo) + uo.buffer = vmw_framebuffer_to_vfbd(fb)->buffer; + else + uo = vmw_framebuffer_to_vfbs(fb)->uo; + + return uo; +} + static enum vmw_cursor_update_type -vmw_cursor_update_type(struct vmw_private *vmw, struct vmw_plane_state *vps) +vmw_cursor_update_type(struct vmw_private *vmw, struct vmw_user_object *uo) { - struct vmw_surface *surface = vmw_user_object_surface(&vps->uo); + struct vmw_surface *surface = vmw_user_object_surface(uo); if (surface && surface->snooper.image) return VMW_CURSOR_UPDATE_LEGACY; @@ -112,8 +128,7 @@ static void vmw_cursor_update_mob(struct vmw_private *vmw, { SVGAGBCursorHeader *header; SVGAGBAlphaCursorHeader *alpha_header; - struct vmw_bo *bo = vmw_user_object_buffer(&vps->uo); - u32 *image = vmw_bo_map_and_cache(bo); + u32 *image = vps->cursor.map.virtual; const u32 image_size = vps->base.crtc_w * vps->base.crtc_h * sizeof(*image); header = vmw_bo_map_and_cache(vps->cursor.mob); @@ -132,7 +147,6 @@ static void vmw_cursor_update_mob(struct vmw_private *vmw, memcpy(header + 1, image, image_size); vmw_write(vmw, SVGA_REG_CURSOR_MOBID, vmw_bo_mobid(vps->cursor.mob)); - vmw_bo_unmap(bo); vmw_bo_unmap(vps->cursor.mob); } @@ -152,10 +166,17 @@ static u32 vmw_cursor_mob_size(enum vmw_cursor_update_type update_type, static void vmw_cursor_mob_destroy(struct vmw_bo **vbo) { + int ret; + if (!(*vbo)) return; + ret = ttm_bo_reserve(&(*vbo)->tbo, false, false, NULL); + if (WARN_ON_ONCE(ret)) + return; + ttm_bo_unpin(&(*vbo)->tbo); + ttm_bo_unreserve(&(*vbo)->tbo); vmw_bo_unreference(vbo); } @@ -490,9 +511,21 @@ vmw_cursor_plane_cleanup_fb(struct drm_plane *plane, { struct vmw_cursor_plane *vcp = vmw_plane_to_vcp(plane); struct vmw_plane_state *vps = vmw_plane_state_to_vps(old_state); + struct vmw_bo *bo; + int ret; - if (!vmw_user_object_is_null(&vps->uo)) - vmw_user_object_unmap(&vps->uo); + if (vps->cursor.map.bo) { + bo = to_vmw_bo(&vps->cursor.map.bo->base); + ret = ttm_bo_reserve(&bo->tbo, false, false, NULL); + if (WARN_ON_ONCE(ret)) + return; + + ttm_bo_kunmap(&vps->cursor.map); + vps->cursor.map.bo = NULL; + ttm_bo_unpin(&bo->tbo); + ttm_bo_unreserve(&bo->tbo); + vmw_bo_unreference(&bo); + } vmw_cursor_mob_unmap(vps); vmw_cursor_mob_put(vcp, vps); @@ -625,22 +658,17 @@ int vmw_cursor_plane_prepare_fb(struct drm_plane *plane, struct vmw_surface *surface; int ret = 0; - if (!vmw_user_object_is_null(&vps->uo)) { - vmw_user_object_unmap(&vps->uo); + /* + * A duplicated state only owns the user object reference. Its mappings + * and pins belong to the old state until cleanup_fb(). + */ + if (!vmw_user_object_is_null(&vps->uo)) vmw_user_object_unref(&vps->uo); - } - if (fb) { - if (vmw_framebuffer_to_vfb(fb)->bo) { - vps->uo.buffer = vmw_framebuffer_to_vfbd(fb)->buffer; - vps->uo.surface = NULL; - } else { - memcpy(&vps->uo, &vmw_framebuffer_to_vfbs(fb)->uo, sizeof(vps->uo)); - } - vmw_user_object_ref(&vps->uo); - } + vps->uo = vmw_cursor_plane_user_object(fb); + vmw_user_object_ref(&vps->uo); - vps->cursor.update_type = vmw_cursor_update_type(vmw, vps); + vps->cursor.update_type = vmw_cursor_update_type(vmw, &vps->uo); switch (vps->cursor.update_type) { case VMW_CURSOR_UPDATE_LEGACY: surface = vmw_user_object_surface(&vps->uo); @@ -650,33 +678,39 @@ int vmw_cursor_plane_prepare_fb(struct drm_plane *plane, case VMW_CURSOR_UPDATE_GB_ONLY: case VMW_CURSOR_UPDATE_MOB: { bo = vmw_user_object_buffer(&vps->uo); + if (fb && !bo) + return -EINVAL; + if (bo) { struct ttm_operation_ctx ctx = { false, false }; + size_t size = (size_t)new_state->crtc_w * + new_state->crtc_h * sizeof(u32); ret = ttm_bo_reserve(&bo->tbo, true, false, NULL); if (ret != 0) - return -ENOMEM; + return ret; ret = ttm_bo_validate(&bo->tbo, &bo->placement, &ctx); if (ret != 0) - return -ENOMEM; + goto out_unreserve; /* - * vmw_bo_pin_reserved also validates, so to skip - * the extra validation use ttm_bo_pin directly + * vmw_bo_pin_reserved() also validates, so to skip + * the extra validation use ttm_bo_pin directly. + * Every state takes its own pin, the buffer can + * still be in use by an older state whose commit + * hasn't been cleaned up yet. */ - if (!bo->tbo.pin_count) - ttm_bo_pin(&bo->tbo); - - if (vmw_framebuffer_to_vfb(fb)->bo) { - const u32 size = new_state->crtc_w * - new_state->crtc_h * - sizeof(u32); - - (void)vmw_bo_map_and_cache_size(bo, size); - } else { - vmw_bo_map_and_cache(bo); + ttm_bo_pin(&bo->tbo); + + ret = ttm_bo_kmap(&bo->tbo, 0, PFN_UP(size), + &vps->cursor.map); + if (ret) { + vps->cursor.map.bo = NULL; + ttm_bo_unpin(&bo->tbo); + goto out_unreserve; } + vmw_bo_reference(bo); ttm_bo_unreserve(&bo->tbo); } if (!vmw_user_object_is_null(&vps->uo)) { @@ -703,6 +737,10 @@ int vmw_cursor_plane_prepare_fb(struct drm_plane *plane, } return 0; + +out_unreserve: + ttm_bo_unreserve(&bo->tbo); + return ret; } /** @@ -725,7 +763,7 @@ int vmw_cursor_plane_atomic_check(struct drm_plane *plane, int ret = 0; struct drm_crtc_state *crtc_state = NULL; struct vmw_surface *surface = NULL; - struct vmw_plane_state *vps = vmw_plane_state_to_vps(new_state); + struct vmw_user_object uo; enum vmw_cursor_update_type update_type; struct drm_framebuffer *fb = new_state->fb; @@ -744,7 +782,21 @@ int vmw_cursor_plane_atomic_check(struct drm_plane *plane, if (!fb) return 0; - update_type = vmw_cursor_update_type(vmw, vps); + if (!new_state->crtc_w || !new_state->crtc_h) { + drm_dbg_kms(&vmw->drm, + "Cursor dimensions (%u, %u) must be nonzero\n", + new_state->crtc_w, new_state->crtc_h); + return -EINVAL; + } + + /* The duplicated plane state's user object still belongs to the old FB. */ + uo = vmw_cursor_plane_user_object(fb); + update_type = vmw_cursor_update_type(vmw, &uo); + if ((update_type == VMW_CURSOR_UPDATE_GB_ONLY || + update_type == VMW_CURSOR_UPDATE_MOB) && + !vmw_user_object_buffer(&uo)) + return -EINVAL; + if (update_type == VMW_CURSOR_UPDATE_LEGACY) { if (new_state->crtc_w != VMW_CURSOR_SNOOP_WIDTH || new_state->crtc_h != VMW_CURSOR_SNOOP_HEIGHT) { @@ -753,14 +805,32 @@ int vmw_cursor_plane_atomic_check(struct drm_plane *plane, new_state->crtc_w, new_state->crtc_h); return -EINVAL; } - surface = vmw_user_object_surface(&vps->uo); + surface = vmw_user_object_surface(&uo); if (!surface || !surface->snooper.image) { drm_warn(&vmw->drm, "surface not suitable for cursor\n"); return -EINVAL; } - } else if (update_type == VMW_CURSOR_UPDATE_GB_ONLY || - update_type == VMW_CURSOR_UPDATE_MOB) { + } else if (update_type == VMW_CURSOR_UPDATE_GB_ONLY) { + u64 image_size = (u64)new_state->crtc_w * + new_state->crtc_h * sizeof(u32); + u32 max_size = SVGA_MAX_CURSOR_CMD_BYTES; + + /* The command-buffer limit includes the define-cursor header. */ + if (vmw->cman) + max_size = min_t(u32, max_size, + SVGA_CB_MAX_COMMAND_SIZE - + sizeof(struct vmw_svga_fifo_cmd_define_cursor)); + + if (new_state->crtc_w > SVGA_MAX_CURSOR_CMD_DIMENSION || + new_state->crtc_h > SVGA_MAX_CURSOR_CMD_DIMENSION || + image_size > max_size) { + drm_dbg_kms(&vmw->drm, + "Cursor dimensions (%u, %u) violate command limits\n", + new_state->crtc_w, new_state->crtc_h); + return -EINVAL; + } + } else if (update_type == VMW_CURSOR_UPDATE_MOB) { u32 cursor_max_dim = vmw_read(vmw, SVGA_REG_CURSOR_MAX_DIMENSION); @@ -796,7 +866,6 @@ void vmw_cursor_plane_atomic_update(struct drm_plane *plane, struct drm_atomic_commit *state) { - struct vmw_bo *bo; struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state, plane); struct drm_plane_state *old_state = @@ -815,6 +884,10 @@ vmw_cursor_plane_atomic_update(struct drm_plane *plane, return; } + /* Include legacy Xorg cursor-bypass offsets in the image and position. */ + hotspot_x = vps->cursor.legacy.hotspot_x + new_state->hotspot_x; + hotspot_y = vps->cursor.legacy.hotspot_y + new_state->hotspot_y; + switch (vps->cursor.update_type) { case VMW_CURSOR_UPDATE_LEGACY: vmw_cursor_plane_update_legacy(dev_priv, vps); @@ -823,13 +896,11 @@ vmw_cursor_plane_atomic_update(struct drm_plane *plane, vmw_cursor_update_mob(dev_priv, vps); break; case VMW_CURSOR_UPDATE_GB_ONLY: - bo = vmw_user_object_buffer(&vps->uo); - if (bo) - vmw_send_define_cursor_cmd(dev_priv, bo->map.virtual, + if (vps->cursor.map.virtual) + vmw_send_define_cursor_cmd(dev_priv, vps->cursor.map.virtual, vps->base.crtc_w, vps->base.crtc_h, - vps->base.hotspot_x, - vps->base.hotspot_y); + hotspot_x, hotspot_y); break; case VMW_CURSOR_UPDATE_NONE: /* do nothing */ @@ -842,9 +913,6 @@ vmw_cursor_plane_atomic_update(struct drm_plane *plane, cursor_x = new_state->crtc_x + du->set_gui_x; cursor_y = new_state->crtc_y + du->set_gui_y; - hotspot_x = vps->cursor.legacy.hotspot_x + new_state->hotspot_x; - hotspot_y = vps->cursor.legacy.hotspot_y + new_state->hotspot_y; - vmw_cursor_update_position(dev_priv, true, cursor_x + hotspot_x, cursor_y + hotspot_y); } diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.h b/drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.h index d32cf17d013b..9b50f80f9635 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.h +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_cursor_plane.h @@ -14,6 +14,8 @@ #include "drm/drm_fourcc.h" #include "drm/drm_plane.h" +#include <drm/ttm/ttm_bo.h> + #include <linux/types.h> struct SVGA3dCmdHeader; @@ -41,6 +43,8 @@ struct vmw_cursor_plane_state { enum vmw_cursor_update_type update_type; bool changed; bool surface_changed; + /* The mapped buffer is referenced and pinned by this state. */ + struct ttm_bo_kmap_obj map; struct vmw_bo *mob; struct { s32 hotspot_x; diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c index a9136a6523cb..435425f1adfa 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c @@ -565,6 +565,29 @@ static int vmw_cmd_ok(struct vmw_private *dev_priv, } /** + * vmw_cmd_body_fits - Check that a command body covers what a handler reads + * + * @header: Pointer to the command header in the command stream. + * @size: Number of body bytes that the command handler interprets. + * + * vmw_cmd_check() only verifies that @header->size fits into the submitted + * command buffer. A handler that reads past the declared body reads the next + * command, which is verified separately. A relocation recorded there would + * rewrite the already verified command after verification has finished. + * + * Return: true if the body is at least @size bytes, false otherwise. + */ +static bool vmw_cmd_body_fits(const SVGA3dCmdHeader *header, size_t size) +{ + if (likely(header->size >= size)) + return true; + + VMW_DEBUG_USER("SVGA3D command %u: body size %u is smaller than %zu.\n", + header->id, header->size, size); + return false; +} + +/** * vmw_resources_reserve - Reserve all resources on the sw_context's resource * list. * @@ -810,6 +833,9 @@ static int vmw_cmd_cid_check(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, uint32_t) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_context, VMW_RES_DIRTY_SET, user_context_converter, &cmd->body, NULL); @@ -853,6 +879,8 @@ static int vmw_cmd_set_render_target_check(struct vmw_private *dev_priv, int ret; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; if (cmd->body.type >= SVGA3D_RT_MAX) { VMW_DEBUG_USER("Illegal render target type %u.\n", @@ -898,6 +926,8 @@ static int vmw_cmd_surface_copy_check(struct vmw_private *dev_priv, int ret; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, @@ -918,6 +948,9 @@ static int vmw_cmd_buffer_copy_check(struct vmw_private *dev_priv, int ret; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, &cmd->body.src, NULL); @@ -937,6 +970,9 @@ static int vmw_cmd_pred_copy_check(struct vmw_private *dev_priv, int ret; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, &cmd->body.srcSid, NULL); @@ -956,6 +992,9 @@ static int vmw_cmd_stretch_blt_check(struct vmw_private *dev_priv, int ret; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, &cmd->body.src.sid, NULL); @@ -974,6 +1013,9 @@ static int vmw_cmd_blt_surf_screen_check(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdBlitSurfaceToScreen) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, &cmd->body.srcImage.sid, NULL); @@ -986,6 +1028,9 @@ static int vmw_cmd_present_check(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdPresent) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, &cmd->body.sid, NULL); @@ -1243,6 +1288,8 @@ static int vmw_cmd_dx_define_query(struct vmw_private *dev_priv, return -EINVAL; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; if (cmd->body.type < SVGA3D_QUERYTYPE_MIN || cmd->body.type >= SVGA3D_QUERYTYPE_MAX) @@ -1280,6 +1327,8 @@ static int vmw_cmd_dx_bind_query(struct vmw_private *dev_priv, return -EINVAL; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; /* * Look up the buffer pointed to by q.mobid, put it on the relocation @@ -1310,6 +1359,9 @@ static int vmw_cmd_begin_gb_query(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdBeginGBQuery) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_context, VMW_RES_DIRTY_SET, user_context_converter, &cmd->body.cid, NULL); @@ -1329,6 +1381,9 @@ static int vmw_cmd_begin_query(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdBeginQuery) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (unlikely(dev_priv->has_mob)) { VMW_DECLARE_CMD_VAR(gb_cmd, SVGA3dCmdBeginGBQuery); @@ -1364,6 +1419,9 @@ static int vmw_cmd_end_gb_query(struct vmw_private *dev_priv, int ret; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + ret = vmw_cmd_cid_check(dev_priv, sw_context, header); if (unlikely(ret != 0)) return ret; @@ -1394,6 +1452,9 @@ static int vmw_cmd_end_query(struct vmw_private *dev_priv, int ret; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (dev_priv->has_mob) { VMW_DECLARE_CMD_VAR(gb_cmd, SVGA3dCmdEndGBQuery); @@ -1440,6 +1501,9 @@ static int vmw_cmd_wait_gb_query(struct vmw_private *dev_priv, int ret; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + ret = vmw_cmd_cid_check(dev_priv, sw_context, header); if (unlikely(ret != 0)) return ret; @@ -1468,6 +1532,9 @@ static int vmw_cmd_wait_query(struct vmw_private *dev_priv, int ret; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (dev_priv->has_mob) { VMW_DECLARE_CMD_VAR(gb_cmd, SVGA3dCmdWaitForGBQuery); @@ -1637,6 +1704,15 @@ static int vmw_cmd_tex_state(struct vmw_private *dev_priv, int ret; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + + /* The loop below must not read a truncated trailing state. */ + if ((header->size - sizeof(cmd->body)) % sizeof(*cur_state)) { + VMW_DEBUG_USER("Invalid texture state size %u.\n", + header->size); + return -EINVAL; + } ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_context, VMW_RES_DIRTY_SET, user_context_converter, @@ -1718,6 +1794,7 @@ static int vmw_cmd_res_switch_backup(struct vmw_private *dev_priv, { struct vmw_bo *vbo; void *info; + u64 end; int ret; info = vmw_execbuf_info_from_res(sw_context, res); @@ -1728,6 +1805,13 @@ static int vmw_cmd_res_switch_backup(struct vmw_private *dev_priv, if (ret) return ret; + if (check_add_overflow((u64)backup_offset, + (u64)res->guest_memory_size, &end) || + end > vbo->tbo.base.size) { + VMW_DEBUG_USER("Backup buffer too small for resource.\n"); + return -EINVAL; + } + vmw_validation_res_switch_backup(sw_context->ctx, info, vbo, backup_offset); return 0; @@ -1782,6 +1866,9 @@ static int vmw_cmd_bind_gb_surface(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdBindGBSurface) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + return vmw_cmd_switch_backup(dev_priv, sw_context, vmw_res_surface, user_surface_converter, &cmd->body.sid, &cmd->body.mobid, 0); @@ -1801,6 +1888,9 @@ static int vmw_cmd_update_gb_image(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdUpdateGBImage) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, &cmd->body.image.sid, NULL); @@ -1820,6 +1910,9 @@ static int vmw_cmd_update_gb_surface(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdUpdateGBSurface) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_CLEAR, user_surface_converter, &cmd->body.sid, NULL); @@ -1839,6 +1932,9 @@ static int vmw_cmd_readback_gb_image(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdReadbackGBImage) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, &cmd->body.image.sid, NULL); @@ -1859,6 +1955,9 @@ static int vmw_cmd_readback_gb_surface(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdReadbackGBSurface) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_CLEAR, user_surface_converter, &cmd->body.sid, NULL); @@ -1879,6 +1978,9 @@ static int vmw_cmd_invalidate_gb_image(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdInvalidateGBImage) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, &cmd->body.image.sid, NULL); @@ -1899,6 +2001,9 @@ static int vmw_cmd_invalidate_gb_surface(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdInvalidateGBSurface) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_CLEAR, user_surface_converter, &cmd->body.sid, NULL); @@ -1921,6 +2026,8 @@ static int vmw_cmd_shader_define(struct vmw_private *dev_priv, struct vmw_resource *ctx; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_context, VMW_RES_DIRTY_SET, user_context_converter, @@ -1960,6 +2067,8 @@ static int vmw_cmd_shader_destroy(struct vmw_private *dev_priv, struct vmw_resource *ctx; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_context, VMW_RES_DIRTY_SET, user_context_converter, @@ -1999,6 +2108,8 @@ static int vmw_cmd_set_shader(struct vmw_private *dev_priv, int ret; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; if (!vmw_shadertype_is_valid(VMW_SM_LEGACY, cmd->body.type)) { VMW_DEBUG_USER("Illegal shader type %u.\n", @@ -2077,6 +2188,8 @@ static int vmw_cmd_set_shader_const(struct vmw_private *dev_priv, int ret; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_context, VMW_RES_DIRTY_SET, user_context_converter, @@ -2104,6 +2217,9 @@ static int vmw_cmd_bind_gb_shader(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdBindGBShader) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + return vmw_cmd_switch_backup(dev_priv, sw_context, vmw_res_shader, user_shader_converter, &cmd->body.shid, &cmd->body.mobid, cmd->body.offsetInBytes); @@ -2133,6 +2249,9 @@ vmw_cmd_dx_set_single_constant_buffer(struct vmw_private *dev_priv, return -EINVAL; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, &cmd->body.sid, &res); @@ -2186,6 +2305,9 @@ vmw_cmd_dx_set_constant_buffer_offset(struct vmw_private *dev_priv, return -EINVAL; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (cmd->body.slot >= SVGA3D_DX_MAX_CONSTBUFFERS) { VMW_DEBUG_USER("Illegal const buffer slot %u.\n", (unsigned int) cmd->body.slot); @@ -2217,6 +2339,9 @@ static int vmw_cmd_dx_set_shader_res(struct vmw_private *dev_priv, u32 num_sr_view = (cmd->header.size - sizeof(cmd->body)) / sizeof(SVGA3dShaderResourceViewId); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if ((u64) cmd->body.startView + (u64) num_sr_view > (u64) SVGA3D_DX_MAX_SRVIEWS || !vmw_shadertype_is_valid(dev_priv->sm_type, cmd->body.type)) { @@ -2252,6 +2377,8 @@ static int vmw_cmd_dx_set_shader(struct vmw_private *dev_priv, return -EINVAL; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; if (!vmw_shadertype_is_valid(dev_priv->sm_type, cmd->body.type)) { VMW_DEBUG_USER("Illegal shader type %u.\n", @@ -2309,6 +2436,9 @@ static int vmw_cmd_dx_set_vertex_buffers(struct vmw_private *dev_priv, return -EINVAL; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + num = (cmd->header.size - sizeof(cmd->body)) / sizeof(SVGA3dVertexBuffer); if ((u64)num + (u64)cmd->body.startBuffer > @@ -2360,6 +2490,9 @@ static int vmw_cmd_dx_set_index_buffer(struct vmw_private *dev_priv, return -EINVAL; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, &cmd->body.sid, &res); @@ -2395,6 +2528,9 @@ static int vmw_cmd_dx_set_rendertargets(struct vmw_private *dev_priv, sizeof(SVGA3dRenderTargetViewId); int ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (num_rt_view > SVGA3D_DX_MAX_RENDER_TARGETS) { VMW_DEBUG_USER("Invalid DX Rendertarget binding.\n"); return -EINVAL; @@ -2426,6 +2562,9 @@ static int vmw_cmd_dx_clear_rendertarget_view(struct vmw_private *dev_priv, container_of(header, typeof(*cmd), header); struct vmw_resource *ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + ret = vmw_view_id_val_add(sw_context, vmw_view_rt, cmd->body.renderTargetViewId); @@ -2448,6 +2587,9 @@ static int vmw_cmd_dx_clear_depthstencil_view(struct vmw_private *dev_priv, container_of(header, typeof(*cmd), header); struct vmw_resource *ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + ret = vmw_view_id_val_add(sw_context, vmw_view_ds, cmd->body.depthStencilViewId); @@ -2481,6 +2623,9 @@ static int vmw_cmd_dx_view_define(struct vmw_private *dev_priv, return -EINVAL; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(*cmd) - sizeof(*header))) + return -EINVAL; + if (unlikely(cmd->sid == SVGA3D_INVALID_ID)) { VMW_DEBUG_USER("Invalid surface id.\n"); return -EINVAL; @@ -2529,6 +2674,9 @@ static int vmw_cmd_dx_set_so_targets(struct vmw_private *dev_priv, return -EINVAL; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + num = (cmd->header.size - sizeof(cmd->body)) / sizeof(SVGA3dSoTarget); if (num > SVGA3D_DX_MAX_SOTARGETS) { @@ -2582,6 +2730,9 @@ static int vmw_cmd_dx_so_define(struct vmw_private *dev_priv, if (IS_ERR_OR_NULL(res)) return res ? PTR_ERR(res) : -EINVAL; cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(*cmd) - sizeof(*header))) + return -EINVAL; + ret = vmw_cotable_notify(res, cmd->defined_id); return ret; @@ -2617,6 +2768,9 @@ static int vmw_cmd_dx_check_subresource(struct vmw_private *dev_priv, offsetof(typeof(*cmd), sid)); cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->sid))) + return -EINVAL; + return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, &cmd->sid, NULL); @@ -2658,6 +2812,9 @@ static int vmw_cmd_dx_view_remove(struct vmw_private *dev_priv, struct vmw_resource *view; int ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!ctx_node) return -EINVAL; @@ -2695,6 +2852,9 @@ static int vmw_cmd_dx_define_shader(struct vmw_private *dev_priv, container_of(header, typeof(*cmd), header); int ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!ctx_node) return -EINVAL; @@ -2726,6 +2886,9 @@ static int vmw_cmd_dx_destroy_shader(struct vmw_private *dev_priv, container_of(header, typeof(*cmd), header); int ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!ctx_node) return -EINVAL; @@ -2752,6 +2915,9 @@ static int vmw_cmd_dx_bind_shader(struct vmw_private *dev_priv, container_of(header, typeof(*cmd), header); int ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (cmd->body.cid != SVGA3D_INVALID_ID) { ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_context, VMW_RES_DIRTY_SET, @@ -2803,6 +2969,9 @@ static int vmw_cmd_dx_genmips(struct vmw_private *dev_priv, struct vmw_resource *view; struct vmw_res_cache_entry *rcache; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + view = vmw_view_id_val_add(sw_context, vmw_view_sr, cmd->body.shaderResourceViewId); if (IS_ERR(view)) @@ -2836,6 +3005,9 @@ static int vmw_cmd_dx_transfer_from_buffer(struct vmw_private *dev_priv, container_of(header, typeof(*cmd), header); int ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface, VMW_RES_DIRTY_NONE, user_surface_converter, &cmd->body.srcSid, NULL); @@ -2861,6 +3033,9 @@ static int vmw_cmd_intra_surface_copy(struct vmw_private *dev_priv, VMW_DECLARE_CMD_VAR(*cmd, SVGA3dCmdIntraSurfaceCopy) = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!(dev_priv->capabilities2 & SVGA_CAP2_INTRA_SURFACE_COPY)) return -EINVAL; @@ -2909,6 +3084,9 @@ static int vmw_cmd_clear_uav_uint(struct vmw_private *dev_priv, } *cmd = container_of(header, typeof(*cmd), header); struct vmw_resource *ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!has_sm5_context(dev_priv)) return -EINVAL; @@ -2928,6 +3106,9 @@ static int vmw_cmd_clear_uav_float(struct vmw_private *dev_priv, } *cmd = container_of(header, typeof(*cmd), header); struct vmw_resource *ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!has_sm5_context(dev_priv)) return -EINVAL; @@ -2949,6 +3130,9 @@ static int vmw_cmd_set_uav(struct vmw_private *dev_priv, sizeof(SVGA3dUAViewId); int ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!has_sm5_context(dev_priv)) return -EINVAL; @@ -2981,6 +3165,9 @@ static int vmw_cmd_set_cs_uav(struct vmw_private *dev_priv, sizeof(SVGA3dUAViewId); int ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!has_sm5_context(dev_priv)) return -EINVAL; @@ -3013,6 +3200,9 @@ static int vmw_cmd_dx_define_streamoutput(struct vmw_private *dev_priv, } *cmd = container_of(header, typeof(*cmd), header); int ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!has_sm5_context(dev_priv)) return -EINVAL; @@ -3044,6 +3234,9 @@ static int vmw_cmd_dx_destroy_streamoutput(struct vmw_private *dev_priv, SVGA3dCmdDXDestroyStreamOutput body; } *cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!ctx_node) { DRM_ERROR("DX Context not set.\n"); return -EINVAL; @@ -3081,6 +3274,9 @@ static int vmw_cmd_dx_bind_streamoutput(struct vmw_private *dev_priv, } *cmd = container_of(header, typeof(*cmd), header); int ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!has_sm5_context(dev_priv)) return -EINVAL; @@ -3123,6 +3319,9 @@ static int vmw_cmd_dx_set_streamoutput(struct vmw_private *dev_priv, } *cmd = container_of(header, typeof(*cmd), header); int ret; + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!ctx_node) { DRM_ERROR("DX Context not set.\n"); return -EINVAL; @@ -3175,6 +3374,9 @@ static int vmw_cmd_indexed_instanced_indirect(struct vmw_private *dev_priv, SVGA3dCmdDXDrawIndexedInstancedIndirect body; } *cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!has_sm5_context(dev_priv)) return -EINVAL; @@ -3192,6 +3394,9 @@ static int vmw_cmd_instanced_indirect(struct vmw_private *dev_priv, SVGA3dCmdDXDrawInstancedIndirect body; } *cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!has_sm5_context(dev_priv)) return -EINVAL; @@ -3209,6 +3414,9 @@ static int vmw_cmd_dispatch_indirect(struct vmw_private *dev_priv, SVGA3dCmdDXDispatchIndirect body; } *cmd = container_of(header, typeof(*cmd), header); + if (!vmw_cmd_body_fits(header, sizeof(cmd->body))) + return -EINVAL; + if (!has_sm5_context(dev_priv)) return -EINVAL; diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_gem.c b/drivers/gpu/drm/vmwgfx/vmwgfx_gem.c index 39f8c46550c2..2969b74fff17 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_gem.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_gem.c @@ -73,10 +73,13 @@ static struct sg_table *vmw_gem_object_get_sg_table(struct drm_gem_object *obj) struct vmw_ttm_tt *vmw_tt = container_of(bo->ttm, struct vmw_ttm_tt, dma_ttm); - if (vmw_tt->vsgt.sgt) - return vmw_tt->vsgt.sgt; - - return drm_prime_pages_to_sg(obj->dev, vmw_tt->dma_ttm.pages, vmw_tt->dma_ttm.num_pages); + /* + * Do not return &vmw_tt->sgt: the core owns what this returns and + * drm_gem_unmap_dma_buf() sg_free_table()s and kfree()s it, but that + * sg_table is embedded in the vmw_ttm_tt allocation. + */ + return drm_prime_pages_to_sg(obj->dev, vmw_tt->dma_ttm.pages, + vmw_tt->dma_ttm.num_pages); } static int vmw_gem_vmap(struct drm_gem_object *obj, struct iosys_map *map) @@ -184,7 +187,7 @@ struct drm_gem_object *vmw_prime_import_sg_table(struct drm_device *dev, { int ret; struct vmw_private *dev_priv = vmw_priv(dev); - struct drm_gem_object *gem = NULL; + struct drm_gem_object *gem; struct vmw_bo *vbo; struct vmw_bo_params params = { .domain = (dev_priv->has_mob) ? VMW_BO_DOMAIN_SYS : VMW_BO_DOMAIN_VRAM, @@ -201,8 +204,10 @@ struct drm_gem_object *vmw_prime_import_sg_table(struct drm_device *dev, dma_resv_lock(params.resv, NULL); ret = vmw_bo_create(dev_priv, ¶ms, &vbo); - if (ret != 0) + if (ret != 0) { + gem = ERR_PTR(ret); goto out_no_bo; + } vbo->tbo.base.funcs = &vmw_gem_object_funcs; diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_gmrid_manager.c b/drivers/gpu/drm/vmwgfx/vmwgfx_gmrid_manager.c index d607452dff6a..cc580ce57797 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_gmrid_manager.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_gmrid_manager.c @@ -54,8 +54,11 @@ static int vmw_gmrid_man_get_node(struct ttm_resource_manager *man, const struct ttm_place *place, struct ttm_resource **res) { + struct vmw_private *vmw = vmw_priv_from_ttm(bo->bdev); struct vmwgfx_gmrid_man *gman = to_gmrid_manager(man); - int id; + u32 max_gmr_pages = 0; + bool mob_overflow = false; + int id, ret = 0; *res = kmalloc_obj(**res); if (!*res) @@ -85,43 +88,53 @@ static int vmw_gmrid_man_get_node(struct ttm_resource_manager *man, const unsigned long max_graphics_pages = totalram_pages() / 2; uint32_t new_max_pages = 0; - DRM_WARN("vmwgfx: mob memory overflow. Consider increasing guest RAM and graphicsMemory.\n"); - vmw_host_printf("vmwgfx, warning: mob memory overflow. Consider increasing guest RAM and graphicsMemory.\n"); + mob_overflow = true; + drm_warn(&vmw->drm, + "vmwgfx: mob memory overflow. Consider increasing guest RAM and graphicsMemory.\n"); if (gman->max_gmr_pages > (max_graphics_pages / 2)) { - DRM_WARN("vmwgfx: guest requires more than half of RAM for graphics.\n"); + drm_warn(&vmw->drm, + "vmwgfx: guest requires more than half of RAM for graphics.\n"); new_max_pages = max_graphics_pages; } else new_max_pages = gman->max_gmr_pages * 2; if (new_max_pages > gman->max_gmr_pages && new_max_pages >= gman->used_gmr_pages) { - DRM_WARN("vmwgfx: increasing guest mob limits to %u KiB.\n", - ((new_max_pages) << (PAGE_SHIFT - 10))); + drm_warn(&vmw->drm, + "vmwgfx: increasing guest mob limits to %u KiB.\n", + new_max_pages << (PAGE_SHIFT - 10)); gman->max_gmr_pages = new_max_pages; } else { - char buf[256]; - snprintf(buf, sizeof(buf), - "vmwgfx, error: guest graphics is out of memory (mob limit at: %u KiB).\n", - ((gman->max_gmr_pages) << (PAGE_SHIFT - 10))); - vmw_host_printf(buf); - DRM_WARN("%s", buf); - goto nospace; + max_gmr_pages = gman->max_gmr_pages; + gman->used_gmr_pages -= PFN_UP((*res)->size); + ret = -ENOSPC; + goto out_unlock; } } } (*res)->start = id; +out_unlock: spin_unlock(&gman->lock); - return 0; -nospace: - gman->used_gmr_pages -= PFN_UP((*res)->size); - spin_unlock(&gman->lock); - ida_free(&gman->gmr_ida, id); - ttm_resource_fini(man, *res); - kfree(*res); - return -ENOSPC; + /* Host logging allocates with GFP_KERNEL and must run unlocked. */ + if (mob_overflow) + vmw_host_printf("%s", + "vmwgfx, warning: mob memory overflow. Consider increasing guest RAM and graphicsMemory.\n"); + if (ret) { + char buf[256]; + + snprintf(buf, sizeof(buf), + "vmwgfx, error: guest graphics is out of memory (mob limit at: %u KiB).\n", + max_gmr_pages << (PAGE_SHIFT - 10)); + vmw_host_printf("%s", buf); + drm_warn(&vmw->drm, "%s", buf); + ida_free(&gman->gmr_ida, id); + ttm_resource_fini(man, *res); + kfree(*res); + } + return ret; } static void vmw_gmrid_man_put_node(struct ttm_resource_manager *man, diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c index a6c3304e1a67..fed844ccd789 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_kms.c @@ -155,9 +155,8 @@ int vmw_du_crtc_atomic_check(struct drm_crtc *crtc, * some actual rendering so give a clue as why it's blank. */ if (new_state->enable && !has_primary) - drm_dbg_driver(&vmw->drm, - "CRTC without a primary plane will be blank.\n"); - + drm_info_once(&vmw->drm, + "CRTC without a primary plane will be blank.\n"); if (new_state->connector_mask != connector_mask && new_state->connector_mask != 0) { @@ -275,6 +274,7 @@ vmw_du_plane_duplicate_state(struct drm_plane *plane) vps->cpp = 0; vps->cursor.mob = NULL; + memset(&vps->cursor.map, 0, sizeof(vps->cursor.map)); /* Each ref counted resource needs to be acquired again */ vmw_user_object_ref(&vps->uo); diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c index b147f5db9df5..a7828b8ed68e 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_ldu.c @@ -33,7 +33,7 @@ #include <drm/drm_atomic.h> #include <drm/drm_atomic_helper.h> #include <drm/drm_fourcc.h> - +#include <drm/drm_vblank_helper.h> #define vmw_crtc_to_ldu(x) \ container_of(x, struct vmw_legacy_display_unit, base.crtc) @@ -256,6 +256,7 @@ static const struct drm_crtc_funcs vmw_legacy_crtc_funcs = { .page_flip = drm_atomic_helper_page_flip, .enable_vblank = vmw_vkms_enable_vblank, .disable_vblank = vmw_vkms_disable_vblank, + .sync_vblank = drm_crtc_vblank_helper_sync_vblank_timer, .get_vblank_timestamp = vmw_vkms_get_vblank_timestamp, }; diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_msg.c b/drivers/gpu/drm/vmwgfx/vmwgfx_msg.c index fd77ab6568cb..58da332486bd 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_msg.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_msg.c @@ -431,7 +431,7 @@ int vmw_host_get_guestinfo(const char *guest_info_param, /* Remove reply code, which are the first 2 characters of * the reply */ - reply_len = max(reply_len - 2, (size_t) 0); + reply_len = reply_len > 2 ? reply_len - 2 : 0; reply_len = min(reply_len, *length); if (reply_len > 0) @@ -939,9 +939,12 @@ int vmw_mksstat_add_ioctl(struct drm_device *dev, void *data, struct vmw_private *const dev_priv = vmw_priv(dev); - const size_t num_pages_stat = PFN_UP(arg->stat_len); - const size_t num_pages_info = PFN_UP(arg->info_len); - const size_t num_pages_strs = PFN_UP(arg->strs_len); + const u64 max_stat_len = (u64)MKS_GUEST_STAT_INSTANCE_MAX_STAT_PPNS * PAGE_SIZE; + const u64 max_info_len = (u64)MKS_GUEST_STAT_INSTANCE_MAX_INFO_PPNS * PAGE_SIZE; + const u64 max_strs_len = (u64)MKS_GUEST_STAT_INSTANCE_MAX_STRS_PPNS * PAGE_SIZE; + size_t num_pages_stat; + size_t num_pages_info; + size_t num_pages_strs; long desc_len; long nr_pinned_stat; long nr_pinned_info; @@ -965,11 +968,15 @@ int vmw_mksstat_add_ioctl(struct drm_device *dev, void *data, if (!arg->description) return -EINVAL; - if (num_pages_stat > ARRAY_SIZE(pdesc->statPPNs) || - num_pages_info > ARRAY_SIZE(pdesc->infoPPNs) || - num_pages_strs > ARRAY_SIZE(pdesc->strsPPNs)) + if (arg->stat_len > max_stat_len || + arg->info_len > max_info_len || + arg->strs_len > max_strs_len) return -EINVAL; + num_pages_stat = PFN_UP(arg->stat_len); + num_pages_info = PFN_UP(arg->info_len); + num_pages_strs = PFN_UP(arg->strs_len); + /* Find an available slot in the mksGuestStats user array and reserve it */ for (slot = 0; slot < ARRAY_SIZE(dev_priv->mksstat_user_pids); ++slot) if (!atomic_cmpxchg(&dev_priv->mksstat_user_pids[slot], 0, MKSSTAT_PID_RESERVED)) diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c b/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c index e3a187a2c7a1..ad13688bd7da 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_resource.c @@ -138,6 +138,7 @@ static void vmw_resource_release(struct kref *kref) } res->guest_memory_dirty = false; vmw_resource_mob_detach(res); + vmw_bo_del_detached_resource(res->guest_memory_bo, res); if (res->dirty) res->func->dirty_free(res); if (res->coherent) diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c b/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c index 89714d5c235b..bc6c200f5129 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_scrn.c @@ -35,6 +35,7 @@ #include <drm/drm_damage_helper.h> #include <drm/drm_fourcc.h> #include <drm/drm_vblank.h> +#include <drm/drm_vblank_helper.h> #define vmw_crtc_to_sou(x) \ container_of(x, struct vmw_screen_object_unit, base.crtc) @@ -312,6 +313,7 @@ static const struct drm_crtc_funcs vmw_screen_object_crtc_funcs = { .page_flip = drm_atomic_helper_page_flip, .enable_vblank = vmw_vkms_enable_vblank, .disable_vblank = vmw_vkms_disable_vblank, + .sync_vblank = drm_crtc_vblank_helper_sync_vblank_timer, .get_vblank_timestamp = vmw_vkms_get_vblank_timestamp, }; diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_shader.c b/drivers/gpu/drm/vmwgfx/vmwgfx_shader.c index 39811cf19db1..033157efb1fc 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_shader.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_shader.c @@ -597,7 +597,7 @@ int vmw_dx_shader_add(struct vmw_cmdbuf_res_manager *man, if (!vmw_shader_id_ok(user_key, shader_type)) return -EINVAL; - shader = kmalloc_obj(*shader); + shader = kzalloc_obj(*shader); if (!shader) { return -ENOMEM; } diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c b/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c index cbf55084110a..08b32babc1cd 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_stdu.c @@ -37,6 +37,7 @@ #include <drm/drm_damage_helper.h> #include <drm/drm_fourcc.h> #include <drm/drm_vblank.h> +#include <drm/drm_vblank_helper.h> #define vmw_crtc_to_stdu(x) \ container_of(x, struct vmw_screen_target_display_unit, base.crtc) @@ -44,6 +45,8 @@ container_of(x, struct vmw_screen_target_display_unit, base.encoder) #define vmw_connector_to_stdu(x) \ container_of(x, struct vmw_screen_target_display_unit, base.connector) +#define vmw_primary_to_stdu(x) \ + container_of(x, struct vmw_screen_target_display_unit, base.primary) /* * Some renderers such as llvmpipe will align the width and height of their @@ -448,6 +451,13 @@ static void vmw_stdu_crtc_atomic_disable(struct drm_crtc *crtc, !new_crtc_state->mode_changed) return; + /* Never destroy DU 0's ST so that the VM client always has a + * window to accept input from. Otherwise we may never receive + * input to wake the VM when the CRTC is disabled during idle. + */ + if (stdu->base.unit == 0) + return; + ret = vmw_stdu_destroy_st(dev_priv, stdu); if (ret) DRM_ERROR("Failed to destroy Screen Target\n"); @@ -785,6 +795,7 @@ static const struct drm_crtc_funcs vmw_stdu_crtc_funcs = { .page_flip = drm_atomic_helper_page_flip, .enable_vblank = vmw_vkms_enable_vblank, .disable_vblank = vmw_vkms_disable_vblank, + .sync_vblank = drm_crtc_vblank_helper_sync_vblank_timer, .get_vblank_timestamp = vmw_vkms_get_vblank_timestamp, .get_crc_sources = vmw_vkms_get_crc_sources, .set_crc_source = vmw_vkms_set_crc_source, @@ -1411,7 +1422,8 @@ vmw_stdu_primary_plane_atomic_update(struct drm_plane *plane, int ret; /* If case of device error, maintain consistent atomic state */ - if (crtc && new_state->fb) { + if (crtc && new_state->fb && + drm_atomic_get_new_crtc_state(state, crtc)->active) { struct vmw_framebuffer *vfb = vmw_framebuffer_to_vfb(new_state->fb); stdu = vmw_crtc_to_stdu(crtc); @@ -1435,9 +1447,8 @@ vmw_stdu_primary_plane_atomic_update(struct drm_plane *plane, if (ret) DRM_ERROR("Failed to update STDU.\n"); } else { - crtc = old_state->crtc; - stdu = vmw_crtc_to_stdu(crtc); - dev_priv = vmw_priv(crtc->dev); + stdu = vmw_primary_to_stdu(plane); + dev_priv = vmw_priv(plane->dev); /* Blank STDU when fb and crtc are NULL */ if (!stdu->defined) diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_streamoutput.c b/drivers/gpu/drm/vmwgfx/vmwgfx_streamoutput.c index 52c6cfa163da..34d5b71fa42f 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_streamoutput.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_streamoutput.c @@ -284,7 +284,7 @@ int vmw_dx_streamoutput_add(struct vmw_cmdbuf_res_manager *man, struct vmw_private *dev_priv = ctx->dev_priv; int ret; - so = kmalloc_obj(*so); + so = kzalloc_obj(*so); if (!so) { return -ENOMEM; } diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_surface.c b/drivers/gpu/drm/vmwgfx/vmwgfx_surface.c index bd0563741e89..3064a2a960e1 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_surface.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_surface.c @@ -1718,22 +1718,32 @@ vmw_gb_surface_reference_internal(struct drm_device *dev, user_srf = container_of(base, struct vmw_user_surface, prime.base); srf = &user_srf->srf; + metadata = &srf->metadata; + + mutex_lock(&dev_priv->cmdbuf_mutex); + if (!srf->res.guest_memory_bo) { + mutex_unlock(&dev_priv->cmdbuf_mutex); DRM_ERROR("Shared GB surface is missing a backup buffer.\n"); + ret = -EINVAL; goto out_bad_resource; } - metadata = &srf->metadata; - mutex_lock(&dev_priv->cmdbuf_mutex); /* Protect res->backup */ ret = drm_gem_handle_create(file_priv, &srf->res.guest_memory_bo->tbo.base, &backup_handle); - mutex_unlock(&dev_priv->cmdbuf_mutex); if (ret != 0) { + mutex_unlock(&dev_priv->cmdbuf_mutex); drm_err(dev, "Wasn't able to create a backing handle for surface sid = %u.\n", req->sid); goto out_bad_resource; } + rep->crep.buffer_map_handle = + drm_vma_node_offset_addr(&srf->res.guest_memory_bo->tbo.base.vma_node); + rep->crep.buffer_size = srf->res.guest_memory_bo->tbo.base.size; + + mutex_unlock(&dev_priv->cmdbuf_mutex); + rep->creq.base.svga3d_flags = SVGA3D_FLAGS_LOWER_32(metadata->flags); rep->creq.base.format = metadata->format; rep->creq.base.mip_levels = metadata->mip_levels[0]; @@ -1746,9 +1756,6 @@ vmw_gb_surface_reference_internal(struct drm_device *dev, rep->crep.handle = user_srf->prime.base.handle; rep->crep.backup_size = srf->res.guest_memory_size; rep->crep.buffer_handle = backup_handle; - rep->crep.buffer_map_handle = - drm_vma_node_offset_addr(&srf->res.guest_memory_bo->tbo.base.vma_node); - rep->crep.buffer_size = srf->res.guest_memory_bo->tbo.base.size; rep->creq.version = drm_vmw_gb_surface_v1; rep->creq.svga3d_flags_upper_32_bits = @@ -1758,6 +1765,9 @@ vmw_gb_surface_reference_internal(struct drm_device *dev, rep->creq.must_be_zero = 0; out_bad_resource: + if (ret) + ttm_ref_object_base_unref(vmw_fpriv(file_priv)->tfile, + base->handle); ttm_base_object_unref(&base); return ret; diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_validation.h b/drivers/gpu/drm/vmwgfx/vmwgfx_validation.h index 353d837907d8..fc04555ca505 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_validation.h +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_validation.h @@ -127,16 +127,23 @@ vmw_validation_bo_reserve(struct vmw_validation_context *ctx, * vmw_validation_bo_fence - Unreserve and fence buffer objects registered * with a validation context * @ctx: The validation context + * @fence: Fence with which to fence all buffer objects taking part in the + * command submission. * * This function unreserves the buffer objects previously reserved using - * vmw_validation_bo_reserve, and fences them with a fence object. + * vmw_validation_bo_reserve, and fences them with a fence object if the + * given fence object is not NULL. */ static inline void vmw_validation_bo_fence(struct vmw_validation_context *ctx, struct vmw_fence_obj *fence) { - ttm_eu_fence_buffer_objects(&ctx->ticket, &ctx->bo_list, - (void *) fence); + /* fence is able to be NULL if vmw_execbuf_fence_commands() fails */ + if (fence) + ttm_eu_fence_buffer_objects(&ctx->ticket, &ctx->bo_list, + (void *)fence); + else + ttm_eu_backoff_reservation(&ctx->ticket, &ctx->bo_list); } /** diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_vkms.c b/drivers/gpu/drm/vmwgfx/vmwgfx_vkms.c index 3d0d5dfa869f..8ce10cf9c19e 100644 --- a/drivers/gpu/drm/vmwgfx/vmwgfx_vkms.c +++ b/drivers/gpu/drm/vmwgfx/vmwgfx_vkms.c @@ -299,7 +299,7 @@ vmw_vkms_crtc_cleanup(struct drm_crtc *crtc) struct vmw_display_unit *du = vmw_crtc_to_du(crtc); if (vmw->vkms_enabled) - drm_crtc_vblank_cancel_timer(crtc); + drm_crtc_vblank_stop_timer(crtc); if (du->vkms.surface) vmw_surface_unreference(&du->vkms.surface); diff --git a/drivers/gpu/drm/xe/abi/xe_log_abi.h b/drivers/gpu/drm/xe/abi/xe_log_abi.h index 526aadf85fe9..d7bd85ea9673 100644 --- a/drivers/gpu/drm/xe/abi/xe_log_abi.h +++ b/drivers/gpu/drm/xe/abi/xe_log_abi.h @@ -151,6 +151,9 @@ enum xe_log_location_bits { define(DRIVER_HARDWARE, 3, GT, GT_TDR, "Graphics Technology") \ define(DRIVER_HARDWARE, 4, LMTT, IO_BUS, "LMEM Translation Table") \ define(DRIVER_HARDWARE, 5, MEMIRQ, IO_BUS, "Memory Based IRQ") \ + define(DRIVER_HARDWARE, 6, VRAM, IO_BUS, "Video Memory/Local Memory") \ + define(DRIVER_HARDWARE, 7, PAT, IO_BUS, "Page Attribute Table") \ + define(DRIVER_HARDWARE, 8, HWMON, IO_BUS, "Hardware Monitoring") \ /* */ \ define(DRIVER_FEATURE, 1, PF, SW, "SR-IOV Physical Function") \ define(DRIVER_FEATURE, 2, VF, SW, "SR-IOV Virtual Function") \ diff --git a/drivers/gpu/drm/xe/xe_dma_buf.c b/drivers/gpu/drm/xe/xe_dma_buf.c index 6a85b292dee7..97299ca8f831 100644 --- a/drivers/gpu/drm/xe/xe_dma_buf.c +++ b/drivers/gpu/drm/xe/xe_dma_buf.c @@ -242,60 +242,62 @@ static const struct dma_buf_ops xe_dmabuf_ops = { struct dma_buf *xe_gem_prime_export(struct drm_gem_object *obj, int flags) { struct xe_bo *bo = gem_to_xe_bo(obj); + struct xe_validation_ctx ctx; + struct drm_exec exec; struct dma_buf *buf; - struct ttm_operation_ctx ctx = { - .interruptible = true, - .no_wait_gpu = true, - /* We opt to avoid OOM on system pages allocations */ - .gfp_retry_mayfail = true, - .allow_res_evict = false, - }; - int ret; + int ret = 0; if (bo->vm) return ERR_PTR(-EPERM); - /* - * Reject exporting purgeable BOs. DONTNEED BOs can be purged - * at any time, making the exported dma-buf unusable. Purged BOs - * have no backing store and are permanently invalid. - */ - ret = xe_bo_lock(bo, true); - if (ret) - return ERR_PTR(ret); + xe_validation_guard(&ctx, &xe_bo_device(bo)->val, &exec, + (struct xe_val_flags) {.interruptible = true}, ret) { + ret = drm_exec_lock_obj(&exec, &bo->ttm.base); + drm_exec_retry_on_contention(&exec); + if (ret) + break; - if (xe_bo_madv_is_dontneed(bo)) { - ret = -EBUSY; - goto out_unlock; - } + /* + * Reject exporting purgeable BOs. DONTNEED BOs can be purged + * at any time, making the exported dma-buf unusable. Purged BOs + * have no backing store and are permanently invalid. + */ + if (xe_bo_madv_is_dontneed(bo)) { + ret = -EBUSY; + break; + } - if (xe_bo_is_purged(bo)) { - ret = -EINVAL; - goto out_unlock; - } + if (xe_bo_is_purged(bo)) { + ret = -EINVAL; + break; + } - xe_bo_willneed_get_locked(bo); - xe_bo_unlock(bo); + /* + * Make sure the BO is backed in its preferred placement so that + * the exporter, rather than the importer, is charged for the + * memory allocation. + */ + ret = xe_bo_validate(bo, NULL, false, &exec); + drm_exec_retry_on_contention(&exec); + xe_validation_retry_on_oom(&ctx, &ret); + if (ret) + break; - ret = ttm_bo_setup_export(&bo->ttm, &ctx); + xe_bo_willneed_get_locked(bo); + } if (ret) - goto out_put; + return ERR_PTR(ret); buf = drm_gem_prime_export(obj, flags); if (IS_ERR(buf)) { - ret = PTR_ERR(buf); - goto out_put; + xe_bo_lock(bo, false); + xe_bo_willneed_put_locked(bo); + xe_bo_unlock(bo); + return buf; } buf->ops = &xe_dmabuf_ops; return buf; - -out_put: - xe_bo_lock(bo, false); - xe_bo_willneed_put_locked(bo); -out_unlock: - xe_bo_unlock(bo); - return ERR_PTR(ret); } static struct drm_gem_object * diff --git a/drivers/gpu/drm/xe/xe_guc_submit.c b/drivers/gpu/drm/xe/xe_guc_submit.c index 01f79f8883ba..dd970e6b1b9d 100644 --- a/drivers/gpu/drm/xe/xe_guc_submit.c +++ b/drivers/gpu/drm/xe/xe_guc_submit.c @@ -47,6 +47,7 @@ #include "xe_ring_ops_types.h" #include "xe_sched_job.h" #include "xe_sleep.h" +#include "xe_tlb_inval.h" #include "xe_trace.h" #include "xe_uc_fw.h" #include "xe_vm.h" @@ -264,6 +265,7 @@ static void guc_submit_fini(void *arg) /* Forcefully kill any remaining exec queues */ xe_guc_ct_stop(&guc->ct); + xe_tlb_inval_reset(&guc_to_gt(guc)->tlb_inval); guc_submit_reset_prepare(guc); xe_guc_softreset(guc); xe_guc_submit_stop(guc); diff --git a/drivers/gpu/drm/xe/xe_guc_tlb_inval.c b/drivers/gpu/drm/xe/xe_guc_tlb_inval.c index 111fef781b2a..0945d9711e17 100644 --- a/drivers/gpu/drm/xe/xe_guc_tlb_inval.c +++ b/drivers/gpu/drm/xe/xe_guc_tlb_inval.c @@ -31,12 +31,22 @@ static int send_tlb_inval(struct xe_guc *guc, const u32 *action, int len) { struct xe_gt *gt = guc_to_gt(guc); + int ret; xe_gt_assert(gt, action[1]); /* Seqno */ xe_gt_stats_incr(gt, XE_GT_STATS_ID_TLB_INVAL, 1); - return xe_guc_ct_send(&guc->ct, action, len, - G2H_LEN_DW_TLB_INVALIDATE, 1); + ret = xe_guc_ct_send(&guc->ct, action, len, G2H_LEN_DW_TLB_INVALIDATE, 1); + + /* + * A disabled CT can't deliver the request, and the GuC is reloaded + * with all TLBs invalid before the CT is enabled again, so there is + * nothing left to invalidate. Report it as cancelled, like a stopped CT. + */ + if (ret == -ENODEV) + return -ECANCELED; + + return ret; } #define MAKE_INVAL_OP_FLUSH(type, flush_cache) ((type << XE_GUC_TLB_INVAL_TYPE_SHIFT) | \ diff --git a/drivers/gpu/drm/xe/xe_hwmon.c b/drivers/gpu/drm/xe/xe_hwmon.c index 20c1cfffc5a0..daa3f61617a0 100644 --- a/drivers/gpu/drm/xe/xe_hwmon.c +++ b/drivers/gpu/drm/xe/xe_hwmon.c @@ -15,6 +15,7 @@ #include "regs/xe_pcode_regs.h" #include "xe_device.h" #include "xe_hwmon.h" +#include "xe_log.h" #include "xe_mmio.h" #include "xe_pcode.h" #include "xe_pcode_api.h" @@ -375,17 +376,20 @@ static struct xe_reg xe_hwmon_get_reg(struct xe_hwmon *hwmon, enum xe_hwmon_reg * same pattern for sysfs, allow arbitrary PL1 limits to be set but display * clamped values when read. */ -static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, u32 attr, int channel, long *value) +static int xe_hwmon_power_max_read(struct xe_hwmon *hwmon, u32 attr, int channel, long *value) { u32 reg_val = 0; struct xe_device *xe = hwmon->xe; struct xe_reg rapl_limit, pkg_power_sku; struct xe_mmio *mmio = xe_root_tile_mmio(xe); + int ret = 0; mutex_lock(&hwmon->hwmon_lock); if (hwmon->xe->info.has_mbx_power_limits) { - xe_hwmon_pcode_read_power_limit(hwmon, attr, channel, ®_val); + ret = xe_hwmon_pcode_read_power_limit(hwmon, attr, channel, ®_val); + if (ret) + goto unlock; } else { rapl_limit = xe_hwmon_get_reg(hwmon, REG_PKG_RAPL_LIMIT, channel); pkg_power_sku = xe_hwmon_get_reg(hwmon, REG_PKG_POWER_SKU, channel); @@ -417,6 +421,7 @@ static void xe_hwmon_power_max_read(struct xe_hwmon *hwmon, u32 attr, int channe } unlock: mutex_unlock(&hwmon->hwmon_lock); + return ret; } static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, u32 attr, int channel, long value) @@ -439,7 +444,9 @@ static int xe_hwmon_power_max_write(struct xe_hwmon *hwmon, u32 attr, int channe ret = xe_hwmon_pcode_rmw_power_limit(hwmon, attr, channel, PWR_LIM_EN, 0); if (ret) goto unlock; - xe_hwmon_pcode_read_power_limit(hwmon, attr, channel, ®_val); + ret = xe_hwmon_pcode_read_power_limit(hwmon, attr, channel, ®_val); + if (ret) + goto unlock; } else { reg_val = xe_mmio_rmw32(mmio, rapl_limit, PWR_LIM_EN, 0); reg_val = xe_mmio_read32(mmio, rapl_limit); @@ -496,15 +503,18 @@ unlock: return ret; } -static void xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon, u32 attr, int channel, - long *value) +static int xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon, u32 attr, int channel, + long *value) { struct xe_mmio *mmio = xe_root_tile_mmio(hwmon->xe); u32 reg_val; + int ret = 0; if (hwmon->xe->info.has_mbx_power_limits) { /* PL1 is rated max if supported. */ - xe_hwmon_pcode_read_power_limit(hwmon, PL1_HWMON_ATTR, channel, ®_val); + ret = xe_hwmon_pcode_read_power_limit(hwmon, PL1_HWMON_ATTR, channel, ®_val); + if (ret) + return ret; } else { /* * This sysfs file won't be visible if REG_PKG_POWER_SKU is invalid, so valid check @@ -518,6 +528,7 @@ static void xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon, u32 attr, int reg_val = REG_FIELD_GET(PKG_TDP, reg_val); *value = mul_u64_u32_shr(reg_val, SF_POWER, hwmon->scl_shift_power); + return ret; } /* @@ -540,7 +551,7 @@ static void xe_hwmon_power_rated_max_read(struct xe_hwmon *hwmon, u32 attr, int * hwmon->scl_shift_energy of 14 bits we have 57 (63 - 20 + 14) bits before * energyN_input overflows. This at 1000 W is an overflow duration of 278 years. */ -static void +static int xe_hwmon_energy_get(struct xe_hwmon *hwmon, int channel, long *energy) { struct xe_mmio *mmio = xe_root_tile_mmio(hwmon->xe); @@ -551,7 +562,7 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon, int channel, long *energy) /* Energy is supported only for card and pkg */ if (channel > CHANNEL_PKG) { *energy = 0; - return; + return 0; } if (hwmon->xe->info.platform == XE_BATTLEMAGE) { @@ -563,7 +574,7 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon, int channel, long *energy) if (ret != sizeof(pmt_val)) { drm_warn(&hwmon->xe->drm, "energy read from pmt failed, ret %d\n", ret); *energy = 0; - return; + return ret < 0 ? ret : -EIO; } if (channel == CHANNEL_PKG) @@ -580,6 +591,7 @@ xe_hwmon_energy_get(struct xe_hwmon *hwmon, int channel, long *energy) *energy = mul_u64_u32_shr(ei->accum_energy, SF_ENERGY, hwmon->scl_shift_energy); + return 0; } static ssize_t @@ -602,10 +614,11 @@ xe_hwmon_power_max_interval_show(struct device *dev, struct device_attribute *at if (hwmon->xe->info.has_mbx_power_limits) { ret = xe_hwmon_pcode_read_power_limit(hwmon, power_attr, channel, ®_val); if (ret) { - drm_err(&hwmon->xe->drm, - "power interval read fail, ch %d, attr %d, val 0x%08x, ret %d\n", - channel, power_attr, reg_val, ret); - reg_val = 0; + xe_log_err(hwmon->xe, HWMON, ret, + "Power interval read fail, ch %d, attr %d, val 0x%08x\n", + channel, power_attr, reg_val); + mutex_unlock(&hwmon->hwmon_lock); + return ret; } } else { reg_val = xe_mmio_read32(mmio, xe_hwmon_get_reg(hwmon, REG_PKG_RAPL_LIMIT, @@ -1229,7 +1242,8 @@ xe_hwmon_power_is_visible(struct xe_hwmon *hwmon, u32 attr, int channel) } case hwmon_power_crit: if (channel == CHANNEL_CARD) { - xe_hwmon_pcode_read_i1(hwmon, &uval); + if (xe_hwmon_pcode_read_i1(hwmon, &uval)) + return 0; return (uval & POWER_SETUP_I1_WATTS) ? 0644 : 0; } break; @@ -1248,7 +1262,8 @@ xe_hwmon_power_is_visible(struct xe_hwmon *hwmon, u32 attr, int channel) } } if ((!(uval & PWR_LIM_EN)) && channel == CHANNEL_CARD) { - xe_hwmon_pcode_read_i1(hwmon, &uval); + if (xe_hwmon_pcode_read_i1(hwmon, &uval)) + return 0; return (uval & POWER_SETUP_I1_WATTS) ? 0444 : 0; } return (uval) ? 0444 : 0; @@ -1264,11 +1279,9 @@ xe_hwmon_power_read(struct xe_hwmon *hwmon, u32 attr, int channel, long *val) switch (attr) { case hwmon_power_max: case hwmon_power_cap: - xe_hwmon_power_max_read(hwmon, attr, channel, val); - return 0; + return xe_hwmon_power_max_read(hwmon, attr, channel, val); case hwmon_power_rated_max: - xe_hwmon_power_rated_max_read(hwmon, attr, channel, val); - return 0; + return xe_hwmon_power_rated_max_read(hwmon, attr, channel, val); case hwmon_power_crit: return xe_hwmon_power_curr_crit_read(hwmon, channel, val, SF_POWER); default: @@ -1385,8 +1398,7 @@ xe_hwmon_energy_read(struct xe_hwmon *hwmon, u32 attr, int channel, long *val) { switch (attr) { case hwmon_energy_input: - xe_hwmon_energy_get(hwmon, channel, val); - return 0; + return xe_hwmon_energy_get(hwmon, channel, val); default: return -EOPNOTSUPP; } @@ -1649,7 +1661,7 @@ int xe_hwmon_register(struct xe_device *xe) { struct device *dev = xe->drm.dev; struct xe_hwmon *hwmon; - int ret; + int ret, err; /* hwmon is available only for dGfx */ if (!IS_DGFX(xe)) @@ -1680,9 +1692,11 @@ int xe_hwmon_register(struct xe_device *xe) &hwmon_chip_info, hwmon_groups); if (IS_ERR(hwmon->hwmon_dev)) { - drm_err(&xe->drm, "Failed to register xe hwmon (%pe)\n", hwmon->hwmon_dev); + err = PTR_ERR(hwmon->hwmon_dev); + xe_log_err(xe, HWMON, err, + "Failed to register xe hwmon\n"); xe->hwmon = NULL; - return PTR_ERR(hwmon->hwmon_dev); + return err; } return 0; diff --git a/drivers/gpu/drm/xe/xe_irq.c b/drivers/gpu/drm/xe/xe_irq.c index b394c8edf89c..f3964c6eca17 100644 --- a/drivers/gpu/drm/xe/xe_irq.c +++ b/drivers/gpu/drm/xe/xe_irq.c @@ -786,10 +786,8 @@ static void irq_uninstall(void *arg) { struct xe_device *xe = arg; - if (!atomic_xchg(&xe->irq.enabled, 0)) - return; - - xe_irq_reset(xe); + if (atomic_xchg(&xe->irq.enabled, 0)) + xe_irq_reset(xe); if (xe_device_has_msix(xe)) xe_irq_msix_free(xe); diff --git a/drivers/gpu/drm/xe/xe_query.c b/drivers/gpu/drm/xe/xe_query.c index dc975f595368..9cc35fc83954 100644 --- a/drivers/gpu/drm/xe/xe_query.c +++ b/drivers/gpu/drm/xe/xe_query.c @@ -6,7 +6,6 @@ #include "xe_query.h" #include <linux/nospec.h> -#include <linux/sched/clock.h> #include <drm/ttm/ttm_placement.h> #include <generated/xe_wa_oob.h> @@ -97,13 +96,14 @@ hwe_read_timestamp(struct xe_hw_engine *hwe, u64 *engine_ts, u64 *cpu_ts, u32 upper, lower, old_upper, loop = 0; struct xe_reg upper_reg = RING_TIMESTAMP_UDW(hwe->mmio_base), lower_reg = RING_TIMESTAMP(hwe->mmio_base); + u64 delta_start; upper = xe_mmio_read32(mmio, upper_reg); do { - *cpu_delta = local_clock(); + delta_start = ktime_get_raw_ns(); *cpu_ts = cpu_clock(); lower = xe_mmio_read32(mmio, lower_reg); - *cpu_delta = local_clock() - *cpu_delta; + *cpu_delta = ktime_get_raw_ns() - delta_start; old_upper = upper; upper = xe_mmio_read32(mmio, upper_reg); } while (upper != old_upper && loop++ < 2); diff --git a/drivers/gpu/drm/xe/xe_ras.c b/drivers/gpu/drm/xe/xe_ras.c index fe16a4106060..53cfbb9a3bac 100644 --- a/drivers/gpu/drm/xe/xe_ras.c +++ b/drivers/gpu/drm/xe/xe_ras.c @@ -496,7 +496,7 @@ enum xe_ras_recovery_action xe_ras_process_errors(struct xe_device *xe) } if (!xe->info.has_sysctrl) - return XE_RAS_RECOVERY_ACTION_RESET; + return XE_RAS_RECOVERY_ACTION_RECOVERED; BUILD_BUG_ON(BITS_PER_TYPE(sent) < XE_RAS_COMP_MAX); /* Default action */ |
