mirror of
https://github.com/torvalds/linux.git
synced 2026-11-20 13:03:48 +00:00
Merge tag 'drm-fixes-2026-11-07' of https://gitlab.freedesktop.org/drm/kernel
Pull drm fixes from Dave Airlie: "This is the weekly drm fixes, amdgpu leading the way with some i915, nouveau and other fixes. There should be a bunch of xe fixes, but their tree got screwed up so I guess I'll send those next week once they cleanup whatever happened. atomic: - Fix CRTC dma-fence handling drm: - Add parsing for additional HDMI 2.2 FRL rates bridge: - nwl-dsi: Fix LCDIF handling dma-buf: - Fix IOVA offset - Restore the scatter-list entry count before freeing dp: - Keep MOT set between messages when no_zero_sized is set panel: - visionox-r66451: Set brightness MSB first; Increase reset waiting time panic: - Fix display loop - Fix line parsing sched: - Fix out of bounds entity priority check - Adjust run-queue when changing priority at runtime amdgpu: - UALink fixes - RAS fixes - GEM_OP fix - Parse IB fixes - CS user fence fix - GPU reset fixes - Multi-media idle work handler cleanup fixes - UserQ fixes - CRC fix - SR-IOV fixes - IP discovery fix - HDMI 2.2 FRL fixes - DDC pin fix - HUBP fix - SPM fix - DCN 3.2 fixes - VRR/freesync fix - Seamless boot fix - SMU 13.0.7 fix - Backlight fix - dma-buf fixes - GPUVM fixes - Move DMCUB back to VRAM - Non-DC audio fix - BACO fix amdkfd: - Fix WPTR BO eviction fence handling - GPUVM locking fix i915: - Fix GitLab #8991 where tiled displays (LG UltraFine 5K) broken on PTL - Limit NVL TRANS_VTOTAL.Vtotal skip display workaround to A-step - Single scaler per pipe number to 1 and disable pipe joiner on WCL - Add quirk to force backlight type on some TUXEDO devices - Fix "CMTG: A disable timeout" splat - Fix intel_vrr_dcb_vmin_vblank_start - Bunch of PSR fixes - Static checker fixes etnaviv: - Fix NULL dereference in etnaviv_unbind() - Flush the tile status cache through both the PE and BLT imagination: - Align rogue_fwif_hwrtdata to 64 bytes loongson: - Fix BO handling in several places nouveau: - Map Kepler video engine contexts non-privileged - Clear use.enabled when subdev init fails - Avoid running VBIOS twice - Fix CE channel creation on pre-Kepler GPUs v3d: - Initialize job timedout_batches - Fix cache_clean_lock vc4: - Move output fence and BO unreserve out of job_lock - Power down PYH when output is disabled - hdmi: Fix scrambling" * tag 'drm-fixes-2026-11-07' of https://gitlab.freedesktop.org/drm/kernel: (91 commits) drm/sched: Adjust run-queue when changing priority at runtime drm/sched: Fix out of bounds entity priority check drm/etnaviv: Flush the tile status cache through both the PE and BLT drm/etnaviv: Fix NULL dereference on unbind without PPU flop reset drm/nouveau: Fix CE channel creation on pre-Kepler GPUs drm/nouveau/devinit/gf100-: try to avoid double-running vbios scripts drm/dp: keep MOT set between messages when no_zero_sized is set drm/nouveau/nvkm: clear use.enabled when subdev init fails drm/nouveau/fifo: map Kepler video engine contexts non-privileged drm/amdgpu: don't drop the gang dependency fence twice drm/amdgpu: stop GPU recovery wait for the JPEG/VCN idle work drm/amd/pm: track BACO state in the SMU v11 ArmD3 sequence drm/amdgpu: Only enable HDMI audio if display supports it Revert "drm/amd/display: Allocate DCN32/1 dmub memory to GTT" drm/amdgpu: don't walk the CS chunks when allocating them failed drm/amdgpu/vce: don't allocate a scheduler fence in the direct IB test drm/amdgpu: rewrite all PTEs of the BOs after a VM reset drm/amdgpu: unlock the VM and BO when attaching a KFD BO fails drm/amdgpu: drop the dma-buf reference when a KFD import fails drm/amdgpu: Clamp the ATIF backlight curve to its 99 points ...
This commit is contained in:
@@ -524,10 +524,12 @@ Kiran Gunda <[email protected]> <[email protected]>
|
||||
Kirill Tkhai <[email protected]> <[email protected]>
|
||||
Kiryl Shutsemau <[email protected]> <[email protected]>
|
||||
Kishon Vijay Abraham I <[email protected]> <[email protected]>
|
||||
Koby Elbaz <[email protected]> <[email protected]>
|
||||
Konrad Dybcio <[email protected]> <[email protected]>
|
||||
Konrad Dybcio <[email protected]> <[email protected]>
|
||||
Konstantin Khlebnikov <[email protected]> <[email protected]>
|
||||
Konstantin Khlebnikov <[email protected]> <[email protected]>
|
||||
Konstantin Sinyuk <[email protected]> <[email protected]>
|
||||
Koushik <[email protected]>
|
||||
Krishna Manikandan <[email protected]> <[email protected]>
|
||||
Krzysztof Kozlowski <[email protected]> <[email protected]>
|
||||
|
||||
+3
-3
@@ -11695,10 +11695,10 @@ S: Maintained
|
||||
F: block/partitions/efi.*
|
||||
|
||||
HABANALABS PCI DRIVER
|
||||
M: Koby Elbaz <[email protected]>
|
||||
M: Konstantin Sinyuk <konstantin.sinyuk@intel.com>
|
||||
M: Konstantin Sinyuk <[email protected]>
|
||||
M: Koby Elbaz <elbaz.koby@gmail.com>
|
||||
L: [email protected]
|
||||
S: Supported
|
||||
S: Maintained
|
||||
C: irc://irc.oftc.net/dri-devel
|
||||
T: git https://github.com/HabanaAI/drivers.accel.habanalabs.kernel.git
|
||||
F: Documentation/ABI/testing/debugfs-driver-habanalabs
|
||||
|
||||
@@ -111,12 +111,12 @@ struct sg_table *dma_buf_phys_vec_to_sgt(struct dma_buf_attachment *attach,
|
||||
size_t i;
|
||||
int ret;
|
||||
|
||||
dma_resv_assert_held(attach->dmabuf->resv);
|
||||
|
||||
if (WARN_ON(!attach || !attach->dmabuf || !provider))
|
||||
/* This function is supposed to work on MMIO memory only */
|
||||
return ERR_PTR(-EINVAL);
|
||||
|
||||
dma_resv_assert_held(attach->dmabuf->resv);
|
||||
|
||||
dma = kzalloc_obj(*dma);
|
||||
if (!dma)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
@@ -156,7 +156,7 @@ struct sg_table *dma_buf_phys_vec_to_sgt(struct dma_buf_attachment *attach,
|
||||
phys_vec[i].paddr);
|
||||
} else if (dma_use_iova(dma->state)) {
|
||||
ret = dma_iova_link(attach->dev, dma->state,
|
||||
phys_vec[i].paddr, 0,
|
||||
phys_vec[i].paddr, mapped_len,
|
||||
phys_vec[i].len, dir,
|
||||
DMA_ATTR_MMIO);
|
||||
if (ret)
|
||||
@@ -251,6 +251,8 @@ void dma_buf_free_sgt(struct dma_buf_attachment *attach, struct sg_table *sgt,
|
||||
sg_dma_len(sgl), dir, DMA_ATTR_MMIO);
|
||||
}
|
||||
|
||||
/* Restore the allocation count cleared for the DMA-only table. */
|
||||
sgt->orig_nents = sgt->nents;
|
||||
sg_free_table(sgt);
|
||||
kfree(dma->state);
|
||||
kfree(dma);
|
||||
|
||||
@@ -904,6 +904,10 @@ static int dma_buf_wrap_sg_table(struct sg_table **sg_table)
|
||||
sg_assign_page(to_sg, NULL);
|
||||
sg_dma_address(to_sg) = sg_dma_address(from_sg);
|
||||
sg_dma_len(to_sg) = sg_dma_len(from_sg);
|
||||
#ifdef CONFIG_NEED_SG_DMA_FLAGS
|
||||
/* the flags describe the DMA side, e.g. SG_DMA_BUS_ADDRESS */
|
||||
to_sg->dma_flags = from_sg->dma_flags;
|
||||
#endif
|
||||
to_sg = sg_next(to_sg);
|
||||
}
|
||||
|
||||
|
||||
@@ -406,7 +406,11 @@ int amdgpu_atif_query_backlight_caps(struct amdgpu_atif *atif)
|
||||
characteristics.max_input_signal;
|
||||
atif->backlight_caps.ac_level = characteristics.ac_level;
|
||||
atif->backlight_caps.dc_level = characteristics.dc_level;
|
||||
atif->backlight_caps.data_points = characteristics.number_of_points;
|
||||
if (characteristics.number_of_points > ATIF_QBTC_MAX_DATA_POINTS)
|
||||
pr_warn(FW_BUG "ATIF: backlight curve has %u points, using the first %u\n",
|
||||
characteristics.number_of_points, ATIF_QBTC_MAX_DATA_POINTS);
|
||||
atif->backlight_caps.data_points = min_t(u8, characteristics.number_of_points,
|
||||
ATIF_QBTC_MAX_DATA_POINTS);
|
||||
memcpy(atif->backlight_caps.luminance_data,
|
||||
characteristics.data_points,
|
||||
sizeof(atif->backlight_caps.luminance_data));
|
||||
|
||||
@@ -344,7 +344,8 @@ int amdgpu_amdkfd_gpuvm_map_bo_to_kernel(struct kgd_mem *mem, void **kptr,
|
||||
u64 *size, u32 domain);
|
||||
void amdgpu_amdkfd_gpuvm_unmap_bo_from_kernel(struct kgd_mem *mem);
|
||||
|
||||
int amdgpu_amdkfd_map_gtt_bo_to_gart(struct amdgpu_bo *bo, struct amdgpu_bo **bo_gart);
|
||||
int amdgpu_amdkfd_map_gtt_bo_to_gart(struct amdgpu_bo *bo, struct amdgpu_bo **bo_gart,
|
||||
struct amdkfd_process_info *process_info);
|
||||
|
||||
int amdgpu_amdkfd_gpuvm_restore_process_bos(void *process_info,
|
||||
struct dma_fence __rcu **ef);
|
||||
|
||||
@@ -975,11 +975,11 @@ static int kfd_mem_attach(struct amdgpu_device *adev, struct kgd_mem *mem,
|
||||
ret = amdgpu_vm_lock_pd(vm, &exec, 0);
|
||||
drm_exec_retry_on_contention(&exec);
|
||||
if (unlikely(ret))
|
||||
goto unwind;
|
||||
goto unlock;
|
||||
ret = drm_exec_lock_obj(&exec, &bo[i]->tbo.base);
|
||||
drm_exec_retry_on_contention(&exec);
|
||||
if (unlikely(ret))
|
||||
goto unwind;
|
||||
goto unlock;
|
||||
}
|
||||
|
||||
bo_va = amdgpu_vm_bo_find(vm, bo[i]);
|
||||
@@ -1005,6 +1005,8 @@ static int kfd_mem_attach(struct amdgpu_device *adev, struct kgd_mem *mem,
|
||||
|
||||
return 0;
|
||||
|
||||
unlock:
|
||||
drm_exec_fini(&exec);
|
||||
unwind:
|
||||
for (; i >= 0; i--) {
|
||||
if (!attachment[i])
|
||||
@@ -2261,11 +2263,13 @@ int amdgpu_amdkfd_gpuvm_sync_memory(
|
||||
* amdgpu_amdkfd_map_gtt_bo_to_gart - Map BO to GART and increment reference count
|
||||
* @bo: Buffer object to be mapped
|
||||
* @bo_gart: Return bo reference
|
||||
* @process_info: KFD process info of the queue the BO is for
|
||||
*
|
||||
* Before return, bo reference count is incremented. To release the reference and unpin/
|
||||
* unmap the BO, call amdgpu_amdkfd_free_kernel_mem.
|
||||
*/
|
||||
int amdgpu_amdkfd_map_gtt_bo_to_gart(struct amdgpu_bo *bo, struct amdgpu_bo **bo_gart)
|
||||
int amdgpu_amdkfd_map_gtt_bo_to_gart(struct amdgpu_bo *bo, struct amdgpu_bo **bo_gart,
|
||||
struct amdkfd_process_info *process_info)
|
||||
{
|
||||
int ret;
|
||||
|
||||
@@ -2287,8 +2291,8 @@ int amdgpu_amdkfd_map_gtt_bo_to_gart(struct amdgpu_bo *bo, struct amdgpu_bo **bo
|
||||
goto err_map_bo_gart_failed;
|
||||
}
|
||||
|
||||
amdgpu_amdkfd_remove_eviction_fence(
|
||||
bo, bo->vm_bo->vm->process_info->eviction_fence);
|
||||
/* bo->vm_bo can be the VM of any file which opened the BO */
|
||||
amdgpu_amdkfd_remove_eviction_fence(bo, process_info->eviction_fence);
|
||||
|
||||
amdgpu_bo_unreserve(bo);
|
||||
|
||||
@@ -2473,6 +2477,9 @@ static int import_obj_create(struct amdgpu_device *adev,
|
||||
|
||||
err_remove_mem:
|
||||
remove_kgd_mem_from_kfd_bo_list(*mem, avm->process_info);
|
||||
amdgpu_sync_free(&(*mem)->sync);
|
||||
mutex_destroy(&(*mem)->lock);
|
||||
dma_buf_put(dma_buf);
|
||||
drm_vma_node_revoke(&obj->vma_node, drm_priv);
|
||||
err_free_mem:
|
||||
kfree(*mem);
|
||||
|
||||
@@ -150,7 +150,12 @@ static int amdgpu_cs_p1_user_fence(struct amdgpu_cs_parser *p,
|
||||
if (size != PAGE_SIZE || data->offset > (size - 8))
|
||||
return -EINVAL;
|
||||
|
||||
if (amdgpu_ttm_tt_get_usermm(p->uf_bo->tbo.ttm))
|
||||
if (amdgpu_ttm_tt_is_userptr(p->uf_bo->tbo.ttm))
|
||||
return -EINVAL;
|
||||
|
||||
/* The GPU writes the user fence through the GART */
|
||||
if (p->uf_bo->preferred_domains != AMDGPU_GEM_DOMAIN_GTT &&
|
||||
p->uf_bo->allowed_domains != AMDGPU_GEM_DOMAIN_GTT)
|
||||
return -EINVAL;
|
||||
|
||||
*offset = data->offset;
|
||||
@@ -189,18 +194,22 @@ static int amdgpu_cs_pass1(struct amdgpu_cs_parser *p,
|
||||
int ret;
|
||||
int i;
|
||||
|
||||
if (cs->in.flags)
|
||||
return -EINVAL;
|
||||
|
||||
chunk_array = memdup_array_user(u64_to_user_ptr(cs->in.chunks),
|
||||
cs->in.num_chunks,
|
||||
sizeof(uint64_t));
|
||||
if (IS_ERR(chunk_array))
|
||||
return PTR_ERR(chunk_array);
|
||||
|
||||
p->nchunks = cs->in.num_chunks;
|
||||
p->chunks = kvmalloc_objs(struct amdgpu_cs_chunk, p->nchunks);
|
||||
/* parser_fini() walks nchunks chunks, set it once they exist */
|
||||
p->chunks = kvmalloc_objs(struct amdgpu_cs_chunk, cs->in.num_chunks);
|
||||
if (!p->chunks) {
|
||||
ret = -ENOMEM;
|
||||
goto free_chunk;
|
||||
}
|
||||
p->nchunks = cs->in.num_chunks;
|
||||
|
||||
for (i = 0; i < p->nchunks; i++) {
|
||||
struct drm_amdgpu_cs_chunk __user *chunk_ptr = NULL;
|
||||
@@ -1072,7 +1081,7 @@ static int amdgpu_cs_patch_ibs(struct amdgpu_cs_parser *p,
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
kptr += va_start - (m->start * AMDGPU_GPU_PAGE_SIZE);
|
||||
kptr += va_start - (m->start * AMDGPU_GPU_PAGE_SIZE) + m->offset;
|
||||
|
||||
if (ring->funcs->parse_cs) {
|
||||
memcpy(ib->ptr, kptr, ib->length_dw * 4);
|
||||
@@ -1308,10 +1317,8 @@ static int amdgpu_cs_submit(struct amdgpu_cs_parser *p,
|
||||
fence = &p->jobs[i]->base.s_fence->scheduled;
|
||||
dma_fence_get(fence);
|
||||
r = drm_sched_job_add_dependency(&leader->base, fence);
|
||||
if (r) {
|
||||
dma_fence_put(fence);
|
||||
if (r)
|
||||
return r;
|
||||
}
|
||||
}
|
||||
|
||||
if (p->gang_size > 1) {
|
||||
|
||||
@@ -5527,7 +5527,21 @@ static void amdgpu_device_halt_activities(struct amdgpu_device *adev,
|
||||
struct amdgpu_device *tmp_adev = NULL;
|
||||
int i;
|
||||
|
||||
/* block all schedulers and reset given job's ring */
|
||||
/* Stop job submission first, the preparation below can take seconds */
|
||||
list_for_each_entry(tmp_adev, device_list, reset_list) {
|
||||
for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
|
||||
struct amdgpu_ring *ring = tmp_adev->rings[i];
|
||||
|
||||
if (!amdgpu_ring_sched_ready(ring))
|
||||
continue;
|
||||
|
||||
drm_sched_wqueue_stop(&ring->sched);
|
||||
|
||||
if (need_emergency_restart)
|
||||
amdgpu_job_stop_all_jobs_on_sched(&ring->sched);
|
||||
}
|
||||
}
|
||||
|
||||
list_for_each_entry(tmp_adev, device_list, reset_list) {
|
||||
amdgpu_device_set_mp1_state(tmp_adev);
|
||||
|
||||
@@ -5563,18 +5577,6 @@ static void amdgpu_device_halt_activities(struct amdgpu_device *adev,
|
||||
amdgpu_ras_suspend(tmp_adev);
|
||||
|
||||
amdgpu_userq_pre_reset(tmp_adev);
|
||||
|
||||
for (i = 0; i < AMDGPU_MAX_RINGS; ++i) {
|
||||
struct amdgpu_ring *ring = tmp_adev->rings[i];
|
||||
|
||||
if (!amdgpu_ring_sched_ready(ring))
|
||||
continue;
|
||||
|
||||
drm_sched_wqueue_stop(&ring->sched);
|
||||
|
||||
if (need_emergency_restart)
|
||||
amdgpu_job_stop_all_jobs_on_sched(&ring->sched);
|
||||
}
|
||||
atomic_inc(&tmp_adev->gpu_reset_counter);
|
||||
}
|
||||
}
|
||||
@@ -5809,8 +5811,10 @@ int amdgpu_device_gpu_recover(struct amdgpu_device *adev,
|
||||
|
||||
amdgpu_device_halt_activities(adev, job, reset_context, &device_list,
|
||||
hive, need_emergency_restart);
|
||||
if (need_emergency_restart)
|
||||
goto skip_sched_resume;
|
||||
if (need_emergency_restart) {
|
||||
amdgpu_device_gpu_resume(adev, &device_list, need_emergency_restart);
|
||||
goto reset_unlock;
|
||||
}
|
||||
/*
|
||||
* Must check guilty signal here since after this point all old
|
||||
* HW fences are force signaled.
|
||||
@@ -5820,18 +5824,17 @@ int amdgpu_device_gpu_recover(struct amdgpu_device *adev,
|
||||
if (job && (dma_fence_get_status(&job->hw_fence->base) > 0)) {
|
||||
job_signaled = true;
|
||||
dev_info(adev->dev, "Guilty job already signaled, skipping HW reset");
|
||||
goto skip_hw_reset;
|
||||
goto post_resume;
|
||||
}
|
||||
|
||||
r = amdgpu_device_asic_reset(adev, &device_list, reset_context);
|
||||
if (r)
|
||||
goto reset_unlock;
|
||||
skip_hw_reset:
|
||||
post_resume:
|
||||
amdgpu_device_gpu_resume(adev, &device_list, need_emergency_restart);
|
||||
r = amdgpu_device_sched_resume(&device_list, reset_context, job_signaled);
|
||||
if (r)
|
||||
goto reset_unlock;
|
||||
skip_sched_resume:
|
||||
amdgpu_device_gpu_resume(adev, &device_list, need_emergency_restart);
|
||||
reset_unlock:
|
||||
amdgpu_device_recovery_put_reset_lock(adev, &device_list);
|
||||
amdgpu_ras_post_reset(adev, &device_list);
|
||||
|
||||
@@ -1468,6 +1468,40 @@ static int amdgpu_discovery_sysfs_recurse(struct amdgpu_device *adev,
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define list_to_kobj(el) container_of(el, struct kobject, entry)
|
||||
|
||||
static void amdgpu_discovery_sysfs_update_harvest(struct amdgpu_device *adev)
|
||||
{
|
||||
struct ip_discovery_top *ip_top = adev->discovery.ip_top;
|
||||
struct ip_die_entry *ip_die_entry;
|
||||
struct list_head *el_die, *el_hw_id, *el_hw_inst;
|
||||
struct ip_hw_id *hw_id;
|
||||
struct kset *die_kset;
|
||||
struct ip_hw_instance *ip_inst;
|
||||
|
||||
if (!ip_top)
|
||||
return;
|
||||
|
||||
die_kset = &ip_top->die_kset;
|
||||
|
||||
guard(spinlock)(&die_kset->list_lock);
|
||||
list_for_each(el_die, &die_kset->list) {
|
||||
ip_die_entry = to_ip_die_entry(list_to_kobj(el_die));
|
||||
|
||||
list_for_each(el_hw_id, &ip_die_entry->ip_kset.list) {
|
||||
hw_id = to_ip_hw_id(list_to_kobj(el_hw_id));
|
||||
|
||||
list_for_each(el_hw_inst, &hw_id->hw_id_kset.list) {
|
||||
ip_inst = to_ip_hw_instance(list_to_kobj(el_hw_inst));
|
||||
ip_inst->harvest =
|
||||
amdgpu_discovery_get_harvest_info(
|
||||
adev, ip_inst->hw_id,
|
||||
ip_inst->num_instance);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static int amdgpu_discovery_sysfs_init(struct amdgpu_device *adev)
|
||||
{
|
||||
uint8_t *discovery_bin = adev->discovery.bin;
|
||||
@@ -1478,9 +1512,13 @@ static int amdgpu_discovery_sysfs_init(struct amdgpu_device *adev)
|
||||
if (!discovery_bin)
|
||||
return -EINVAL;
|
||||
|
||||
/* If early init already created sysfs in standalone mode, skip normal init */
|
||||
if (adev->discovery.ip_top && adev->discovery.ip_top->standalone_mode)
|
||||
/* If early init already created sysfs in standalone mode, update harvest info
|
||||
* now that adev is fully initialized, then skip the rest of normal init.
|
||||
*/
|
||||
if (adev->discovery.ip_top && adev->discovery.ip_top->standalone_mode) {
|
||||
amdgpu_discovery_sysfs_update_harvest(adev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ip_top = kzalloc_obj(*ip_top);
|
||||
if (!ip_top)
|
||||
@@ -1535,8 +1573,6 @@ Err:
|
||||
|
||||
/* -------------------------------------------------- */
|
||||
|
||||
#define list_to_kobj(el) container_of(el, struct kobject, entry)
|
||||
|
||||
static void amdgpu_discovery_sysfs_ip_hw_free(struct ip_hw_id *ip_hw_id)
|
||||
{
|
||||
struct list_head *el, *tmp;
|
||||
|
||||
@@ -556,6 +556,11 @@ amdgpu_dma_buf_move_notify(struct dma_buf_attachment *attach)
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!amdgpu_vm_ready(vm)) {
|
||||
dma_resv_unlock(resv);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Reserve fences for two SDMA page table updates */
|
||||
r = dma_resv_reserve_fences(resv, 2);
|
||||
if (!r)
|
||||
|
||||
@@ -1064,6 +1064,7 @@ error_put_gobj:
|
||||
int amdgpu_gem_op_ioctl(struct drm_device *dev, void *data,
|
||||
struct drm_file *filp)
|
||||
{
|
||||
struct amdgpu_device *adev = drm_to_adev(dev);
|
||||
struct drm_amdgpu_gem_op *args = data;
|
||||
struct drm_gem_object *gobj;
|
||||
struct amdgpu_vm_bo_base *base;
|
||||
@@ -1170,7 +1171,8 @@ int amdgpu_gem_op_ioctl(struct drm_device *dev, void *data,
|
||||
|
||||
amdgpu_vm_bo_va_for_each_valid_mapping(bo_va, mapping) {
|
||||
if (num_mappings < args->num_entries) {
|
||||
vm_entries[num_mappings].addr = mapping->start * AMDGPU_GPU_PAGE_SIZE;
|
||||
vm_entries[num_mappings].addr =
|
||||
amdgpu_gmc_sign_extend(mapping->start * AMDGPU_GPU_PAGE_SIZE);
|
||||
vm_entries[num_mappings].size = (mapping->last - mapping->start + 1) * AMDGPU_GPU_PAGE_SIZE;
|
||||
vm_entries[num_mappings].offset = mapping->offset;
|
||||
vm_entries[num_mappings].flags = mapping->flags;
|
||||
@@ -1180,7 +1182,8 @@ int amdgpu_gem_op_ioctl(struct drm_device *dev, void *data,
|
||||
|
||||
amdgpu_vm_bo_va_for_each_invalid_mapping(bo_va, mapping) {
|
||||
if (num_mappings < args->num_entries) {
|
||||
vm_entries[num_mappings].addr = mapping->start * AMDGPU_GPU_PAGE_SIZE;
|
||||
vm_entries[num_mappings].addr =
|
||||
amdgpu_gmc_sign_extend(mapping->start * AMDGPU_GPU_PAGE_SIZE);
|
||||
vm_entries[num_mappings].size = (mapping->last - mapping->start + 1) * AMDGPU_GPU_PAGE_SIZE;
|
||||
vm_entries[num_mappings].offset = mapping->offset;
|
||||
vm_entries[num_mappings].flags = mapping->flags;
|
||||
|
||||
@@ -95,13 +95,27 @@ int amdgpu_jpeg_sw_fini(struct amdgpu_device *adev)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int amdgpu_jpeg_suspend(struct amdgpu_device *adev)
|
||||
int amdgpu_jpeg_early_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
/* Called on teardown even if sw_init never ran */
|
||||
if (!ip_block->status.sw)
|
||||
return 0;
|
||||
|
||||
/* hw_fini may not wait while a peer in the reset domain resets */
|
||||
cancel_delayed_work_sync(&ip_block->adev->jpeg.idle_work);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void amdgpu_jpeg_cancel_idle_work(struct amdgpu_device *adev)
|
||||
{
|
||||
/* The reset mustn't wait for the idle work, which waits for the reset */
|
||||
if (amdgpu_in_reset(adev))
|
||||
cancel_delayed_work(&adev->jpeg.idle_work);
|
||||
else
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
}
|
||||
|
||||
int amdgpu_jpeg_resume(struct amdgpu_device *adev)
|
||||
{
|
||||
return 0;
|
||||
@@ -114,6 +128,9 @@ static void amdgpu_jpeg_idle_work_handler(struct work_struct *work)
|
||||
unsigned int fences = 0;
|
||||
unsigned int i, j;
|
||||
|
||||
/* Nothing holding the reset semaphore waits for this work */
|
||||
down_read(&adev->reset_domain->sem);
|
||||
|
||||
for (i = 0; i < adev->jpeg.num_jpeg_inst; ++i) {
|
||||
if (adev->jpeg.harvest_config & (1U << i))
|
||||
continue;
|
||||
@@ -129,6 +146,8 @@ static void amdgpu_jpeg_idle_work_handler(struct work_struct *work)
|
||||
mutex_unlock(&adev->jpeg.jpeg_pg_lock);
|
||||
} else
|
||||
schedule_delayed_work(&adev->jpeg.idle_work, JPEG_IDLE_TIMEOUT);
|
||||
|
||||
up_read(&adev->reset_domain->sem);
|
||||
}
|
||||
|
||||
void amdgpu_jpeg_ring_begin_use(struct amdgpu_ring *ring)
|
||||
@@ -136,7 +155,7 @@ void amdgpu_jpeg_ring_begin_use(struct amdgpu_ring *ring)
|
||||
struct amdgpu_device *adev = ring->adev;
|
||||
|
||||
if (!atomic_fetch_inc(&adev->jpeg.total_submission_cnt))
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
|
||||
mutex_lock(&adev->jpeg.jpeg_pg_lock);
|
||||
amdgpu_device_ip_set_powergating_state(adev, AMD_IP_BLOCK_TYPE_JPEG,
|
||||
|
||||
@@ -156,11 +156,12 @@ struct amdgpu_jpeg {
|
||||
|
||||
int amdgpu_jpeg_sw_init(struct amdgpu_device *adev);
|
||||
int amdgpu_jpeg_sw_fini(struct amdgpu_device *adev);
|
||||
int amdgpu_jpeg_suspend(struct amdgpu_device *adev);
|
||||
int amdgpu_jpeg_early_fini(struct amdgpu_ip_block *ip_block);
|
||||
int amdgpu_jpeg_resume(struct amdgpu_device *adev);
|
||||
|
||||
void amdgpu_jpeg_ring_begin_use(struct amdgpu_ring *ring);
|
||||
void amdgpu_jpeg_ring_end_use(struct amdgpu_ring *ring);
|
||||
void amdgpu_jpeg_cancel_idle_work(struct amdgpu_device *adev);
|
||||
|
||||
int amdgpu_jpeg_dec_ring_test_ring(struct amdgpu_ring *ring);
|
||||
int amdgpu_jpeg_dec_ring_test_ib(struct amdgpu_ring *ring, long timeout);
|
||||
|
||||
@@ -1191,7 +1191,11 @@ static void amdgpu_mes_userq_notify_unmap_work_handler(struct work_struct *work)
|
||||
userq_notify_unmap_work.work);
|
||||
struct amdgpu_device *adev = mes->adev;
|
||||
|
||||
amdgpu_mes_notify_unmap_queue(adev);
|
||||
/* MES is unusable during GPU recovery; the re-arm below retries later */
|
||||
if (down_read_trylock(&adev->reset_domain->sem)) {
|
||||
amdgpu_mes_notify_unmap_queue(adev);
|
||||
up_read(&adev->reset_domain->sem);
|
||||
}
|
||||
|
||||
/* Re-arm if still oversubscribed */
|
||||
if (atomic_read(&mes->userq_hw_queue_count) >
|
||||
|
||||
@@ -1506,7 +1506,8 @@ int amdgpu_ras_reset_error_count(struct amdgpu_device *adev,
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
if (!amdgpu_ras_is_supported(adev, block))
|
||||
if (!amdgpu_ras_is_supported(adev, block) ||
|
||||
!amdgpu_ras_mgr_get_debug_mode(adev))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
if (amdgpu_sriov_vf(adev))
|
||||
|
||||
@@ -447,10 +447,8 @@ int amdgpu_sync_push_to_job(struct amdgpu_sync *sync, struct amdgpu_job *job)
|
||||
|
||||
dma_fence_get(f);
|
||||
r = drm_sched_job_add_dependency(&job->base, f);
|
||||
if (r) {
|
||||
dma_fence_put(f);
|
||||
if (r)
|
||||
return r;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -1085,7 +1085,7 @@ static void activate_accelerator(struct amdgpu_device *adev)
|
||||
|
||||
static void deactivate_accelerator(struct amdgpu_device *adev)
|
||||
{
|
||||
if (adev->ualink.info->accel_state < AMDGPU_UALINK_ACCEL_STATE_ACTIVE)
|
||||
if (adev->ualink.info->accel_state != AMDGPU_UALINK_ACCEL_STATE_ACTIVE)
|
||||
return;
|
||||
|
||||
dev_info(adev->dev,
|
||||
|
||||
@@ -362,6 +362,8 @@ static int amdgpu_userq_unmap_helper(struct amdgpu_usermode_queue *queue)
|
||||
adev->userq_funcs[queue->queue_type];
|
||||
int r;
|
||||
|
||||
/* The reset changes the queue state and the MES is unusable meanwhile */
|
||||
guard(rwsem_read)(&adev->reset_domain->sem);
|
||||
if ((queue->state == AMDGPU_USERQ_STATE_MAPPED) ||
|
||||
(queue->state == AMDGPU_USERQ_STATE_PREEMPTED)) {
|
||||
trace_amdgpu_userq_state_start(queue);
|
||||
@@ -388,6 +390,8 @@ static int amdgpu_userq_map_helper(struct amdgpu_usermode_queue *queue)
|
||||
adev->userq_funcs[queue->queue_type];
|
||||
int r;
|
||||
|
||||
/* The reset changes the queue state and the MES is unusable meanwhile */
|
||||
guard(rwsem_read)(&adev->reset_domain->sem);
|
||||
if (queue->state == AMDGPU_USERQ_STATE_UNMAPPED) {
|
||||
trace_amdgpu_userq_state_start(queue);
|
||||
|
||||
@@ -769,12 +773,7 @@ amdgpu_userq_create(struct drm_file *filp, union drm_amdgpu_userq *args)
|
||||
if (!adev->userq_halt_for_enforce_isolation ||
|
||||
((queue->queue_type != AMDGPU_HW_IP_GFX) &&
|
||||
(queue->queue_type != AMDGPU_HW_IP_COMPUTE))) {
|
||||
/* Serialize the map against an in-progress GPU reset (MES is
|
||||
* unresponsive during recovery), matching amdgpu_userq_detach_doorbell().
|
||||
*/
|
||||
down_read(&adev->reset_domain->sem);
|
||||
r = amdgpu_userq_map_helper(queue);
|
||||
up_read(&adev->reset_domain->sem);
|
||||
if (r) {
|
||||
drm_file_err(uq_mgr->file, "Failed to map Queue\n");
|
||||
trace_amdgpu_userq_create_end(queue, r);
|
||||
@@ -991,7 +990,11 @@ static int amdgpu_userq_validate_vm(void *param, struct amdgpu_bo *bo)
|
||||
return ttm_bo_validate(&bo->tbo, &bo->placement, &ctx);
|
||||
}
|
||||
|
||||
/* Handle all BOs on the invalidated list, validate them and update the PTs */
|
||||
/*
|
||||
* Handle all individual BOs which were moved, lock and validate them and
|
||||
* update the PTs. An evicted individual BO lands on the needs_update list,
|
||||
* the evicted one only holds imported DMA-bufs of compute VMs.
|
||||
*/
|
||||
static int
|
||||
amdgpu_userq_bo_validate(struct amdgpu_device *adev, struct drm_exec *exec,
|
||||
struct amdgpu_vm *vm)
|
||||
@@ -1002,8 +1005,8 @@ amdgpu_userq_bo_validate(struct amdgpu_device *adev, struct drm_exec *exec,
|
||||
int ret;
|
||||
|
||||
spin_lock(&vm->individual_lock);
|
||||
while (!list_empty(&vm->individual.evicted)) {
|
||||
bo_va = list_first_entry(&vm->individual.evicted,
|
||||
while (!list_empty(&vm->individual.needs_update)) {
|
||||
bo_va = list_first_entry(&vm->individual.needs_update,
|
||||
struct amdgpu_bo_va,
|
||||
base.vm_status);
|
||||
bo = bo_va->base.bo;
|
||||
|
||||
@@ -1115,7 +1115,8 @@ static int amdgpu_uvd_send_msg(struct amdgpu_ring *ring, struct amdgpu_bo *bo,
|
||||
uint64_t addr;
|
||||
int i, r;
|
||||
|
||||
r = amdgpu_job_alloc_with_ib(ring->adev, &adev->uvd.entity,
|
||||
r = amdgpu_job_alloc_with_ib(ring->adev,
|
||||
direct ? NULL : &adev->uvd.entity,
|
||||
AMDGPU_FENCE_OWNER_UNDEFINED,
|
||||
64, direct ? AMDGPU_IB_POOL_DIRECT :
|
||||
AMDGPU_IB_POOL_DELAYED,
|
||||
@@ -1160,11 +1161,11 @@ static int amdgpu_uvd_send_msg(struct amdgpu_ring *ring, struct amdgpu_bo *bo,
|
||||
goto err_free;
|
||||
|
||||
f = amdgpu_job_submit(job);
|
||||
}
|
||||
|
||||
amdgpu_bo_reserve(bo, true);
|
||||
amdgpu_bo_fence(bo, f, false);
|
||||
amdgpu_bo_unreserve(bo);
|
||||
amdgpu_bo_reserve(bo, true);
|
||||
amdgpu_bo_fence(bo, f, false);
|
||||
amdgpu_bo_unreserve(bo);
|
||||
}
|
||||
|
||||
if (fence)
|
||||
*fence = dma_fence_get(f);
|
||||
|
||||
@@ -471,7 +471,7 @@ static int amdgpu_vce_get_create_msg(struct amdgpu_ring *ring, uint32_t handle,
|
||||
uint64_t addr;
|
||||
int i, r;
|
||||
|
||||
r = amdgpu_job_alloc_with_ib(ring->adev, &ring->adev->vce.entity,
|
||||
r = amdgpu_job_alloc_with_ib(ring->adev, NULL,
|
||||
AMDGPU_FENCE_OWNER_UNDEFINED,
|
||||
ib_size_dw * 4, AMDGPU_IB_POOL_DIRECT,
|
||||
AMDGPU_KERNEL_JOB_ID_VCN_RING_TEST,
|
||||
@@ -562,7 +562,8 @@ static int amdgpu_vce_get_destroy_msg(struct amdgpu_ring *ring, uint32_t handle,
|
||||
struct dma_fence *f = NULL;
|
||||
int i, r;
|
||||
|
||||
r = amdgpu_job_alloc_with_ib(ring->adev, &ring->adev->vce.entity,
|
||||
r = amdgpu_job_alloc_with_ib(ring->adev,
|
||||
direct ? NULL : &ring->adev->vce.entity,
|
||||
AMDGPU_FENCE_OWNER_UNDEFINED,
|
||||
ib_size_dw * 4,
|
||||
direct ? AMDGPU_IB_POOL_DIRECT :
|
||||
|
||||
@@ -299,6 +299,26 @@ void amdgpu_vcn_sw_fini(struct amdgpu_device *adev, int i)
|
||||
mutex_destroy(&adev->vcn.inst[i].vcn1_jpeg1_workaround);
|
||||
}
|
||||
|
||||
int amdgpu_vcn_early_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int i;
|
||||
|
||||
/* Called on teardown even if sw_init never ran */
|
||||
if (!ip_block->status.sw)
|
||||
return 0;
|
||||
|
||||
/* hw_fini may not wait while a peer in the reset domain resets */
|
||||
for (i = 0; i < adev->vcn.num_vcn_inst; ++i) {
|
||||
if (adev->vcn.harvest_config & (1 << i))
|
||||
continue;
|
||||
|
||||
cancel_delayed_work_sync(&adev->vcn.inst[i].idle_work);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool amdgpu_vcn_is_disabled_vcn(struct amdgpu_device *adev, enum vcn_ring_type type, uint32_t vcn_instance)
|
||||
{
|
||||
bool ret = false;
|
||||
@@ -459,6 +479,15 @@ void amdgpu_vcn_put_profile(struct amdgpu_device *adev)
|
||||
mutex_unlock(&adev->vcn.workload_profile_mutex);
|
||||
}
|
||||
|
||||
void amdgpu_vcn_cancel_idle_work(struct amdgpu_vcn_inst *vcn_inst)
|
||||
{
|
||||
/* The reset mustn't wait for the idle work, which waits for the reset */
|
||||
if (amdgpu_in_reset(vcn_inst->adev))
|
||||
cancel_delayed_work(&vcn_inst->idle_work);
|
||||
else
|
||||
cancel_delayed_work_sync(&vcn_inst->idle_work);
|
||||
}
|
||||
|
||||
static void amdgpu_vcn_idle_work_handler(struct work_struct *work)
|
||||
{
|
||||
struct amdgpu_vcn_inst *vcn_inst =
|
||||
@@ -470,6 +499,9 @@ static void amdgpu_vcn_idle_work_handler(struct work_struct *work)
|
||||
if (adev->vcn.harvest_config & (1 << i))
|
||||
return;
|
||||
|
||||
/* Nothing holding the reset semaphore waits for this work */
|
||||
down_read(&adev->reset_domain->sem);
|
||||
|
||||
for (j = 0; j < adev->vcn.inst[i].num_enc_rings; ++j)
|
||||
fence[i] += amdgpu_fence_count_emitted(&vcn_inst->ring_enc[j]);
|
||||
|
||||
@@ -499,6 +531,8 @@ static void amdgpu_vcn_idle_work_handler(struct work_struct *work)
|
||||
} else {
|
||||
schedule_delayed_work(&vcn_inst->idle_work, VCN_IDLE_TIMEOUT);
|
||||
}
|
||||
|
||||
up_read(&adev->reset_domain->sem);
|
||||
}
|
||||
|
||||
void amdgpu_vcn_ring_begin_use(struct amdgpu_ring *ring)
|
||||
@@ -507,7 +541,7 @@ void amdgpu_vcn_ring_begin_use(struct amdgpu_ring *ring)
|
||||
struct amdgpu_vcn_inst *vcn_inst = &adev->vcn.inst[ring->me];
|
||||
|
||||
if (!atomic_fetch_inc(&vcn_inst->total_submission_cnt))
|
||||
cancel_delayed_work_sync(&vcn_inst->idle_work);
|
||||
amdgpu_vcn_cancel_idle_work(vcn_inst);
|
||||
|
||||
mutex_lock(&vcn_inst->vcn_pg_lock);
|
||||
vcn_inst->set_pg_state(vcn_inst, AMD_PG_STATE_UNGATE);
|
||||
|
||||
@@ -522,10 +522,12 @@ enum vcn_ring_type {
|
||||
int amdgpu_vcn_early_init(struct amdgpu_device *adev, int i);
|
||||
int amdgpu_vcn_sw_init(struct amdgpu_device *adev, int i);
|
||||
void amdgpu_vcn_sw_fini(struct amdgpu_device *adev, int i);
|
||||
int amdgpu_vcn_early_fini(struct amdgpu_ip_block *ip_block);
|
||||
int amdgpu_vcn_suspend(struct amdgpu_device *adev, int i);
|
||||
int amdgpu_vcn_resume(struct amdgpu_device *adev, int i);
|
||||
void amdgpu_vcn_ring_begin_use(struct amdgpu_ring *ring);
|
||||
void amdgpu_vcn_ring_end_use(struct amdgpu_ring *ring);
|
||||
void amdgpu_vcn_cancel_idle_work(struct amdgpu_vcn_inst *vcn_inst);
|
||||
|
||||
bool amdgpu_vcn_is_disabled_vcn(struct amdgpu_device *adev,
|
||||
enum vcn_ring_type type, uint32_t vcn_instance);
|
||||
|
||||
@@ -271,19 +271,27 @@ static void amdgpu_vm_bo_reset_state_machine(struct amdgpu_vm *vm)
|
||||
|
||||
/*
|
||||
* Don't use list splice here, we need the special handling for the root
|
||||
* PD and set the moved flag appropriately.
|
||||
* PD. All mappings must be written again, also of the vm_bos which are
|
||||
* already waiting for an update of some of them, e.g. after a map with
|
||||
* a delayed update, so set the moved flag for everything that needs an
|
||||
* update.
|
||||
*/
|
||||
amdgpu_vm_assert_locked(vm);
|
||||
list_for_each_entry_safe(vm_bo, tmp, &vm->kernel.idle, vm_status)
|
||||
amdgpu_vm_bo_needs_update(vm_bo);
|
||||
list_for_each_entry(vm_bo, &vm->kernel.needs_update, vm_status)
|
||||
vm_bo->moved = true;
|
||||
|
||||
list_for_each_entry_safe(vm_bo, tmp, &vm->always_valid.idle, vm_status)
|
||||
amdgpu_vm_bo_needs_update(vm_bo);
|
||||
list_for_each_entry(vm_bo, &vm->always_valid.needs_update, vm_status)
|
||||
vm_bo->moved = true;
|
||||
|
||||
spin_lock(&vm->individual_lock);
|
||||
list_for_each_entry_safe(vm_bo, tmp, &vm->individual.idle, vm_status) {
|
||||
vm_bo->moved = true;
|
||||
list_for_each_entry_safe(vm_bo, tmp, &vm->individual.idle, vm_status)
|
||||
list_move(&vm_bo->vm_status, &vm->individual.needs_update);
|
||||
}
|
||||
list_for_each_entry(vm_bo, &vm->individual.needs_update, vm_status)
|
||||
vm_bo->moved = true;
|
||||
spin_unlock(&vm->individual_lock);
|
||||
}
|
||||
|
||||
|
||||
@@ -235,7 +235,6 @@ static int amdgpu_vm_sdma_update(struct amdgpu_vm_update_params *p,
|
||||
dma_fence_get(fence);
|
||||
r = drm_sched_job_add_dependency(&p->job->base, fence);
|
||||
if (r) {
|
||||
dma_fence_put(fence);
|
||||
dma_resv_iter_end(&cursor);
|
||||
return r;
|
||||
}
|
||||
|
||||
@@ -1705,8 +1705,9 @@ static void dce_v10_0_afmt_setmode(struct drm_encoder *encoder,
|
||||
WREG32(mmAFMT_RAMP_CONTROL2 + dig->afmt->offset, 0x00000001);
|
||||
WREG32(mmAFMT_RAMP_CONTROL3 + dig->afmt->offset, 0x00000001);
|
||||
|
||||
/* enable audio after to setting up hw */
|
||||
dce_v10_0_audio_enable(adev, dig->afmt->pin, true);
|
||||
/* Only enable audio if the display supports it */
|
||||
if (connector->display_info.has_audio)
|
||||
dce_v10_0_audio_enable(adev, dig->afmt->pin, true);
|
||||
}
|
||||
|
||||
static void dce_v10_0_afmt_enable(struct drm_encoder *encoder, bool enable)
|
||||
|
||||
@@ -1748,8 +1748,9 @@ static void dce_v6_0_afmt_setmode(struct drm_encoder *encoder,
|
||||
dce_v6_0_audio_dp_enable(encoder, 1);
|
||||
}
|
||||
|
||||
/* enable audio after setting up hw */
|
||||
dce_v6_0_audio_enable(adev, dig->afmt->pin, true);
|
||||
/* Only enable audio if the display supports it */
|
||||
if (connector->display_info.has_audio)
|
||||
dce_v6_0_audio_enable(adev, dig->afmt->pin, true);
|
||||
}
|
||||
|
||||
static void dce_v6_0_afmt_enable(struct drm_encoder *encoder, bool enable)
|
||||
|
||||
@@ -1653,8 +1653,9 @@ static void dce_v8_0_afmt_setmode(struct drm_encoder *encoder,
|
||||
WREG32(mmAFMT_RAMP_CONTROL2 + offset, 0x00000001);
|
||||
WREG32(mmAFMT_RAMP_CONTROL3 + offset, 0x00000001);
|
||||
|
||||
/* enable audio after setting up hw */
|
||||
dce_v8_0_audio_enable(adev, dig->afmt->pin, true);
|
||||
/* Only enable audio if the display supports it */
|
||||
if (connector->display_info.has_audio)
|
||||
dce_v8_0_audio_enable(adev, dig->afmt->pin, true);
|
||||
}
|
||||
|
||||
static void dce_v8_0_afmt_enable(struct drm_encoder *encoder, bool enable)
|
||||
|
||||
@@ -4080,6 +4080,7 @@ static void gfx_v12_0_update_spm_vmid(struct amdgpu_device *adev,
|
||||
{
|
||||
u32 reg, data;
|
||||
|
||||
amdgpu_gfx_off_ctrl(adev, false);
|
||||
reg = SOC15_REG_OFFSET(GC, 0, regRLC_SPM_MC_CNTL);
|
||||
if (amdgpu_sriov_is_pp_one_vf(adev))
|
||||
data = RREG32_NO_KIQ(reg);
|
||||
@@ -4093,6 +4094,7 @@ static void gfx_v12_0_update_spm_vmid(struct amdgpu_device *adev,
|
||||
WREG32_SOC15_NO_KIQ(GC, 0, regRLC_SPM_MC_CNTL, data);
|
||||
else
|
||||
WREG32_SOC15(GC, 0, regRLC_SPM_MC_CNTL, data);
|
||||
amdgpu_gfx_off_ctrl(adev, true);
|
||||
|
||||
if (ring
|
||||
&& amdgpu_sriov_is_pp_one_vf(adev)
|
||||
|
||||
@@ -168,8 +168,19 @@ static int ih_v6_0_toggle_ring_interrupts(struct amdgpu_device *adev,
|
||||
tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, ENABLE_INTR, (enable ? 1 : 0));
|
||||
|
||||
if (amdgpu_sriov_vf(adev) && amdgpu_sriov_reg_indirect_ih(adev)) {
|
||||
if (psp_reg_program(&adev->psp, ih_regs->psp_reg_id, tmp))
|
||||
/*
|
||||
* PSP programming of IH_RB_CNTL is slow enough for MSI to
|
||||
* arrive before this call returns. Publish ih->enabled first
|
||||
* so amdgpu_ih_process() consumes that IV and rearms.
|
||||
*/
|
||||
if (enable) {
|
||||
ih->enabled = true;
|
||||
smp_wmb();
|
||||
}
|
||||
if (psp_reg_program(&adev->psp, ih_regs->psp_reg_id, tmp)) {
|
||||
ih->enabled = false;
|
||||
return -ETIMEDOUT;
|
||||
}
|
||||
} else {
|
||||
WREG32(ih_regs->ih_rb_cntl, tmp);
|
||||
}
|
||||
|
||||
@@ -131,17 +131,13 @@ static int jpeg_v2_0_sw_init(struct amdgpu_ip_block *ip_block)
|
||||
*
|
||||
* @ip_block: Pointer to the amdgpu_ip_block for this hw instance.
|
||||
*
|
||||
* JPEG suspend and free up sw allocation
|
||||
* Free up JPEG sw allocation
|
||||
*/
|
||||
static int jpeg_v2_0_sw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
int r;
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
|
||||
r = amdgpu_jpeg_suspend(adev);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
amdgpu_jpeg_sysfs_reset_mask_fini(adev);
|
||||
|
||||
r = amdgpu_jpeg_sw_fini(adev);
|
||||
@@ -159,11 +155,15 @@ static int jpeg_v2_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
struct amdgpu_ring *ring = adev->jpeg.inst->ring_dec;
|
||||
int r;
|
||||
|
||||
adev->nbio.funcs->vcn_doorbell_range(adev, ring->use_doorbell,
|
||||
(adev->doorbell_index.vcn.vcn_ring0_1 << 1), 0);
|
||||
|
||||
return amdgpu_ring_test_helper(ring);
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -177,7 +177,9 @@ static int jpeg_v2_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
|
||||
if (adev->jpeg.cur_state != AMD_PG_STATE_GATE &&
|
||||
RREG32_SOC15(JPEG, 0, mmUVD_JRBC_STATUS))
|
||||
@@ -195,15 +197,7 @@ static int jpeg_v2_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
*/
|
||||
static int jpeg_v2_0_suspend(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
int r;
|
||||
|
||||
r = jpeg_v2_0_hw_fini(ip_block);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(ip_block->adev);
|
||||
|
||||
return r;
|
||||
return jpeg_v2_0_hw_fini(ip_block);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -787,6 +781,7 @@ static const struct amd_ip_funcs jpeg_v2_0_ip_funcs = {
|
||||
.early_init = jpeg_v2_0_early_init,
|
||||
.sw_init = jpeg_v2_0_sw_init,
|
||||
.sw_fini = jpeg_v2_0_sw_fini,
|
||||
.early_fini = amdgpu_jpeg_early_fini,
|
||||
.hw_init = jpeg_v2_0_hw_init,
|
||||
.hw_fini = jpeg_v2_0_hw_fini,
|
||||
.suspend = jpeg_v2_0_suspend,
|
||||
|
||||
@@ -181,17 +181,13 @@ static int jpeg_v2_5_sw_init(struct amdgpu_ip_block *ip_block)
|
||||
*
|
||||
* @ip_block: Pointer to the amdgpu_ip_block for this hw instance.
|
||||
*
|
||||
* JPEG suspend and free up sw allocation
|
||||
* Free up JPEG sw allocation
|
||||
*/
|
||||
static int jpeg_v2_5_sw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
int r;
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
|
||||
r = amdgpu_jpeg_suspend(adev);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
amdgpu_jpeg_sysfs_reset_mask_fini(adev);
|
||||
|
||||
r = amdgpu_jpeg_sw_fini(adev);
|
||||
@@ -221,10 +217,14 @@ static int jpeg_v2_5_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -239,7 +239,9 @@ static int jpeg_v2_5_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int i;
|
||||
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
|
||||
for (i = 0; i < adev->jpeg.num_jpeg_inst; ++i) {
|
||||
if (adev->jpeg.harvest_config & (1 << i))
|
||||
@@ -265,15 +267,7 @@ static int jpeg_v2_5_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
*/
|
||||
static int jpeg_v2_5_suspend(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
int r;
|
||||
|
||||
r = jpeg_v2_5_hw_fini(ip_block);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(ip_block->adev);
|
||||
|
||||
return r;
|
||||
return jpeg_v2_5_hw_fini(ip_block);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -661,6 +655,7 @@ static const struct amd_ip_funcs jpeg_v2_5_ip_funcs = {
|
||||
.early_init = jpeg_v2_5_early_init,
|
||||
.sw_init = jpeg_v2_5_sw_init,
|
||||
.sw_fini = jpeg_v2_5_sw_fini,
|
||||
.early_fini = amdgpu_jpeg_early_fini,
|
||||
.hw_init = jpeg_v2_5_hw_init,
|
||||
.hw_fini = jpeg_v2_5_hw_fini,
|
||||
.suspend = jpeg_v2_5_suspend,
|
||||
@@ -677,6 +672,7 @@ static const struct amd_ip_funcs jpeg_v2_6_ip_funcs = {
|
||||
.early_init = jpeg_v2_5_early_init,
|
||||
.sw_init = jpeg_v2_5_sw_init,
|
||||
.sw_fini = jpeg_v2_5_sw_fini,
|
||||
.early_fini = amdgpu_jpeg_early_fini,
|
||||
.hw_init = jpeg_v2_5_hw_init,
|
||||
.hw_fini = jpeg_v2_5_hw_fini,
|
||||
.suspend = jpeg_v2_5_suspend,
|
||||
|
||||
@@ -146,17 +146,13 @@ static int jpeg_v3_0_sw_init(struct amdgpu_ip_block *ip_block)
|
||||
*
|
||||
* @ip_block: Pointer to the amdgpu_ip_block for this hw instance.
|
||||
*
|
||||
* JPEG suspend and free up sw allocation
|
||||
* Free up JPEG sw allocation
|
||||
*/
|
||||
static int jpeg_v3_0_sw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(adev);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
amdgpu_jpeg_sysfs_reset_mask_fini(adev);
|
||||
|
||||
r = amdgpu_jpeg_sw_fini(adev);
|
||||
@@ -174,11 +170,15 @@ static int jpeg_v3_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
struct amdgpu_ring *ring = adev->jpeg.inst->ring_dec;
|
||||
int r;
|
||||
|
||||
adev->nbio.funcs->vcn_doorbell_range(adev, ring->use_doorbell,
|
||||
(adev->doorbell_index.vcn.vcn_ring0_1 << 1), 0);
|
||||
|
||||
return amdgpu_ring_test_helper(ring);
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -192,7 +192,9 @@ static int jpeg_v3_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
|
||||
if (adev->jpeg.cur_state != AMD_PG_STATE_GATE &&
|
||||
RREG32_SOC15(JPEG, 0, mmUVD_JRBC_STATUS))
|
||||
@@ -210,15 +212,7 @@ static int jpeg_v3_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
*/
|
||||
static int jpeg_v3_0_suspend(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
int r;
|
||||
|
||||
r = jpeg_v3_0_hw_fini(ip_block);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(ip_block->adev);
|
||||
|
||||
return r;
|
||||
return jpeg_v3_0_hw_fini(ip_block);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -560,6 +554,7 @@ static const struct amd_ip_funcs jpeg_v3_0_ip_funcs = {
|
||||
.early_init = jpeg_v3_0_early_init,
|
||||
.sw_init = jpeg_v3_0_sw_init,
|
||||
.sw_fini = jpeg_v3_0_sw_fini,
|
||||
.early_fini = amdgpu_jpeg_early_fini,
|
||||
.hw_init = jpeg_v3_0_hw_init,
|
||||
.hw_fini = jpeg_v3_0_hw_fini,
|
||||
.suspend = jpeg_v3_0_suspend,
|
||||
|
||||
@@ -157,17 +157,13 @@ static int jpeg_v4_0_sw_init(struct amdgpu_ip_block *ip_block)
|
||||
*
|
||||
* @ip_block: Pointer to the amdgpu_ip_block for this hw instance.
|
||||
*
|
||||
* JPEG suspend and free up sw allocation
|
||||
* Free up JPEG sw allocation
|
||||
*/
|
||||
static int jpeg_v4_0_sw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(adev);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
amdgpu_jpeg_sysfs_reset_mask_fini(adev);
|
||||
r = amdgpu_jpeg_sw_fini(adev);
|
||||
|
||||
@@ -204,10 +200,14 @@ static int jpeg_v4_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -221,7 +221,10 @@ static int jpeg_v4_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
|
||||
if (!amdgpu_sriov_vf(adev)) {
|
||||
if (adev->jpeg.cur_state != AMD_PG_STATE_GATE &&
|
||||
RREG32_SOC15(JPEG, 0, regUVD_JRBC_STATUS))
|
||||
@@ -242,15 +245,7 @@ static int jpeg_v4_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
*/
|
||||
static int jpeg_v4_0_suspend(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
int r;
|
||||
|
||||
r = jpeg_v4_0_hw_fini(ip_block);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(ip_block->adev);
|
||||
|
||||
return r;
|
||||
return jpeg_v4_0_hw_fini(ip_block);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -744,6 +739,7 @@ static const struct amd_ip_funcs jpeg_v4_0_ip_funcs = {
|
||||
.early_init = jpeg_v4_0_early_init,
|
||||
.sw_init = jpeg_v4_0_sw_init,
|
||||
.sw_fini = jpeg_v4_0_sw_fini,
|
||||
.early_fini = amdgpu_jpeg_early_fini,
|
||||
.hw_init = jpeg_v4_0_hw_init,
|
||||
.hw_fini = jpeg_v4_0_hw_fini,
|
||||
.suspend = jpeg_v4_0_suspend,
|
||||
|
||||
@@ -248,17 +248,13 @@ static int jpeg_v4_0_3_sw_init(struct amdgpu_ip_block *ip_block)
|
||||
*
|
||||
* @ip_block: Pointer to the amdgpu_ip_block for this hw instance.
|
||||
*
|
||||
* JPEG suspend and free up sw allocation
|
||||
* Free up JPEG sw allocation
|
||||
*/
|
||||
static int jpeg_v4_0_3_sw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(adev);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
amdgpu_jpeg_sysfs_reset_mask_fini(adev);
|
||||
|
||||
r = amdgpu_jpeg_sw_fini(adev);
|
||||
@@ -435,12 +431,16 @@ static int jpeg_v4_0_3_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
VCN_JPEG_DB_CTRL__EN_MASK);
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -455,7 +455,9 @@ static int jpeg_v4_0_3_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int ret = 0;
|
||||
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
|
||||
if (!amdgpu_sriov_vf(adev)) {
|
||||
if (adev->jpeg.cur_state != AMD_PG_STATE_GATE)
|
||||
@@ -477,15 +479,7 @@ static int jpeg_v4_0_3_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
*/
|
||||
static int jpeg_v4_0_3_suspend(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
int r;
|
||||
|
||||
r = jpeg_v4_0_3_hw_fini(ip_block);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(ip_block->adev);
|
||||
|
||||
return r;
|
||||
return jpeg_v4_0_3_hw_fini(ip_block);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -1222,6 +1216,7 @@ static const struct amd_ip_funcs jpeg_v4_0_3_ip_funcs = {
|
||||
.early_init = jpeg_v4_0_3_early_init,
|
||||
.sw_init = jpeg_v4_0_3_sw_init,
|
||||
.sw_fini = jpeg_v4_0_3_sw_fini,
|
||||
.early_fini = amdgpu_jpeg_early_fini,
|
||||
.hw_init = jpeg_v4_0_3_hw_init,
|
||||
.hw_fini = jpeg_v4_0_3_hw_fini,
|
||||
.suspend = jpeg_v4_0_3_suspend,
|
||||
|
||||
@@ -191,17 +191,13 @@ static int jpeg_v4_0_5_sw_init(struct amdgpu_ip_block *ip_block)
|
||||
*
|
||||
* @ip_block: Pointer to the amdgpu_ip_block for this hw instance.
|
||||
*
|
||||
* JPEG suspend and free up sw allocation
|
||||
* Free up JPEG sw allocation
|
||||
*/
|
||||
static int jpeg_v4_0_5_sw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(adev);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
amdgpu_jpeg_sysfs_reset_mask_fini(adev);
|
||||
r = amdgpu_jpeg_sw_fini(adev);
|
||||
|
||||
@@ -232,10 +228,14 @@ static int jpeg_v4_0_5_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
ring = adev->jpeg.inst[i].ring_dec;
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -250,7 +250,9 @@ static int jpeg_v4_0_5_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int i;
|
||||
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
|
||||
for (i = 0; i < adev->jpeg.num_jpeg_inst; ++i) {
|
||||
if (adev->jpeg.harvest_config & (1 << i))
|
||||
@@ -274,15 +276,7 @@ static int jpeg_v4_0_5_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
*/
|
||||
static int jpeg_v4_0_5_suspend(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
int r;
|
||||
|
||||
r = jpeg_v4_0_5_hw_fini(ip_block);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(ip_block->adev);
|
||||
|
||||
return r;
|
||||
return jpeg_v4_0_5_hw_fini(ip_block);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -803,6 +797,7 @@ static const struct amd_ip_funcs jpeg_v4_0_5_ip_funcs = {
|
||||
.early_init = jpeg_v4_0_5_early_init,
|
||||
.sw_init = jpeg_v4_0_5_sw_init,
|
||||
.sw_fini = jpeg_v4_0_5_sw_fini,
|
||||
.early_fini = amdgpu_jpeg_early_fini,
|
||||
.hw_init = jpeg_v4_0_5_hw_init,
|
||||
.hw_fini = jpeg_v4_0_5_hw_fini,
|
||||
.suspend = jpeg_v4_0_5_suspend,
|
||||
|
||||
@@ -135,17 +135,13 @@ static int jpeg_v5_0_0_sw_init(struct amdgpu_ip_block *ip_block)
|
||||
*
|
||||
* @ip_block: Pointer to the amdgpu_ip_block for this hw instance.
|
||||
*
|
||||
* JPEG suspend and free up sw allocation
|
||||
* Free up JPEG sw allocation
|
||||
*/
|
||||
static int jpeg_v5_0_0_sw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(adev);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
amdgpu_jpeg_sysfs_reset_mask_fini(adev);
|
||||
r = amdgpu_jpeg_sw_fini(adev);
|
||||
|
||||
@@ -173,9 +169,13 @@ static int jpeg_v5_0_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -189,7 +189,9 @@ static int jpeg_v5_0_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
|
||||
if (adev->jpeg.cur_state != AMD_PG_STATE_GATE &&
|
||||
RREG32_SOC15(JPEG, 0, regUVD_JRBC_STATUS))
|
||||
@@ -207,15 +209,7 @@ static int jpeg_v5_0_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
*/
|
||||
static int jpeg_v5_0_0_suspend(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
int r;
|
||||
|
||||
r = jpeg_v5_0_0_hw_fini(ip_block);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(ip_block->adev);
|
||||
|
||||
return r;
|
||||
return jpeg_v5_0_0_hw_fini(ip_block);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -679,6 +673,7 @@ static const struct amd_ip_funcs jpeg_v5_0_0_ip_funcs = {
|
||||
.early_init = jpeg_v5_0_0_early_init,
|
||||
.sw_init = jpeg_v5_0_0_sw_init,
|
||||
.sw_fini = jpeg_v5_0_0_sw_fini,
|
||||
.early_fini = amdgpu_jpeg_early_fini,
|
||||
.hw_init = jpeg_v5_0_0_hw_init,
|
||||
.hw_fini = jpeg_v5_0_0_hw_fini,
|
||||
.suspend = jpeg_v5_0_0_suspend,
|
||||
|
||||
@@ -240,17 +240,13 @@ static int jpeg_v5_0_1_sw_init(struct amdgpu_ip_block *ip_block)
|
||||
*
|
||||
* @ip_block: Pointer to the amdgpu_ip_block for this hw instance.
|
||||
*
|
||||
* JPEG suspend and free up sw allocation
|
||||
* Free up JPEG sw allocation
|
||||
*/
|
||||
static int jpeg_v5_0_1_sw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(adev);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
amdgpu_jpeg_sysfs_reset_mask_fini(adev);
|
||||
|
||||
r = amdgpu_jpeg_sw_fini(adev);
|
||||
@@ -307,11 +303,15 @@ static int jpeg_v5_0_1_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
VCN_JPEG_DB_CTRL__EN_MASK);
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -326,7 +326,9 @@ static int jpeg_v5_0_1_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int ret = 0;
|
||||
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
|
||||
if (!amdgpu_sriov_vf(adev)) {
|
||||
if (adev->jpeg.cur_state != AMD_PG_STATE_GATE)
|
||||
@@ -348,16 +350,7 @@ static int jpeg_v5_0_1_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
*/
|
||||
static int jpeg_v5_0_1_suspend(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int r;
|
||||
|
||||
r = jpeg_v5_0_1_hw_fini(ip_block);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(adev);
|
||||
|
||||
return r;
|
||||
return jpeg_v5_0_1_hw_fini(ip_block);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -883,6 +876,7 @@ static const struct amd_ip_funcs jpeg_v5_0_1_ip_funcs = {
|
||||
.late_init = NULL,
|
||||
.sw_init = jpeg_v5_0_1_sw_init,
|
||||
.sw_fini = jpeg_v5_0_1_sw_fini,
|
||||
.early_fini = amdgpu_jpeg_early_fini,
|
||||
.hw_init = jpeg_v5_0_1_hw_init,
|
||||
.hw_fini = jpeg_v5_0_1_hw_fini,
|
||||
.suspend = jpeg_v5_0_1_suspend,
|
||||
|
||||
@@ -206,17 +206,13 @@ static int jpeg_v5_0_2_sw_init(struct amdgpu_ip_block *ip_block)
|
||||
*
|
||||
* @ip_block: Pointer to the amdgpu_ip_block for this hw instance.
|
||||
*
|
||||
* JPEG suspend and free up sw allocation
|
||||
* Free up JPEG sw allocation
|
||||
*/
|
||||
static int jpeg_v5_0_2_sw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(adev);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
amdgpu_jpeg_sysfs_reset_mask_fini(adev);
|
||||
|
||||
r = amdgpu_jpeg_sw_fini(adev);
|
||||
@@ -280,11 +276,15 @@ static int jpeg_v5_0_2_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
VCN_JPEG_DB_CTRL__EN_MASK);
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -299,7 +299,9 @@ static int jpeg_v5_0_2_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int ret = 0;
|
||||
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
|
||||
if (!amdgpu_sriov_vf(adev)) {
|
||||
if (adev->jpeg.cur_state != AMD_PG_STATE_GATE)
|
||||
@@ -318,16 +320,7 @@ static int jpeg_v5_0_2_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
*/
|
||||
static int jpeg_v5_0_2_suspend(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int r;
|
||||
|
||||
r = jpeg_v5_0_2_hw_fini(ip_block);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(adev);
|
||||
|
||||
return r;
|
||||
return jpeg_v5_0_2_hw_fini(ip_block);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -867,6 +860,7 @@ static const struct amd_ip_funcs jpeg_v5_0_2_ip_funcs = {
|
||||
.late_init = NULL,
|
||||
.sw_init = jpeg_v5_0_2_sw_init,
|
||||
.sw_fini = jpeg_v5_0_2_sw_fini,
|
||||
.early_fini = amdgpu_jpeg_early_fini,
|
||||
.hw_init = jpeg_v5_0_2_hw_init,
|
||||
.hw_fini = jpeg_v5_0_2_hw_fini,
|
||||
.suspend = jpeg_v5_0_2_suspend,
|
||||
|
||||
@@ -118,17 +118,13 @@ static int jpeg_v5_3_0_sw_init(struct amdgpu_ip_block *ip_block)
|
||||
*
|
||||
* @ip_block: Pointer to the amdgpu_ip_block for this hw instance.
|
||||
*
|
||||
* JPEG suspend and free up sw allocation
|
||||
* Free up JPEG sw allocation
|
||||
*/
|
||||
static int jpeg_v5_3_0_sw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
int r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(adev);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
amdgpu_jpeg_sysfs_reset_mask_fini(adev);
|
||||
r = amdgpu_jpeg_sw_fini(adev);
|
||||
|
||||
@@ -156,9 +152,13 @@ static int jpeg_v5_3_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -172,7 +172,9 @@ static int jpeg_v5_3_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_jpeg_cancel_idle_work(adev);
|
||||
|
||||
if (adev->jpeg.cur_state != AMD_PG_STATE_GATE &&
|
||||
RREG32_SOC15(JPEG, 0, regUVD_JRBC0_UVD_JRBC_STATUS))
|
||||
@@ -190,15 +192,7 @@ static int jpeg_v5_3_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
*/
|
||||
static int jpeg_v5_3_0_suspend(struct amdgpu_ip_block *ip_block)
|
||||
{
|
||||
int r;
|
||||
|
||||
r = jpeg_v5_3_0_hw_fini(ip_block);
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
r = amdgpu_jpeg_suspend(ip_block->adev);
|
||||
|
||||
return r;
|
||||
return jpeg_v5_3_0_hw_fini(ip_block);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -667,6 +661,7 @@ static const struct amd_ip_funcs jpeg_v5_3_0_ip_funcs = {
|
||||
.early_init = jpeg_v5_3_0_early_init,
|
||||
.sw_init = jpeg_v5_3_0_sw_init,
|
||||
.sw_fini = jpeg_v5_3_0_sw_fini,
|
||||
.early_fini = amdgpu_jpeg_early_fini,
|
||||
.hw_init = jpeg_v5_3_0_hw_init,
|
||||
.hw_fini = jpeg_v5_3_0_hw_fini,
|
||||
.suspend = jpeg_v5_3_0_suspend,
|
||||
|
||||
@@ -218,8 +218,10 @@ static int mes_v11_0_submit_pkt_and_poll_completion(struct amdgpu_mes *mes,
|
||||
r = amdgpu_fence_wait_polling(ring,
|
||||
seq - ring->fence_drv.num_fences_mask,
|
||||
timeout);
|
||||
if (r < 1)
|
||||
if (r < 1) {
|
||||
r = -ETIMEDOUT;
|
||||
goto error_undo;
|
||||
}
|
||||
|
||||
api_status = (struct MES_API_STATUS *)((char *)pkt + api_status_off);
|
||||
api_status->api_completion_fence_addr = status_gpu_addr;
|
||||
|
||||
@@ -195,8 +195,10 @@ static int mes_v12_0_submit_pkt_and_poll_completion(struct amdgpu_mes *mes,
|
||||
r = amdgpu_fence_wait_polling(ring,
|
||||
seq - ring->fence_drv.num_fences_mask,
|
||||
timeout);
|
||||
if (r < 1)
|
||||
if (r < 1) {
|
||||
r = -ETIMEDOUT;
|
||||
goto error_undo;
|
||||
}
|
||||
|
||||
api_status = (struct MES_API_STATUS *)((char *)pkt + api_status_off);
|
||||
api_status->api_completion_fence_addr = status_gpu_addr;
|
||||
|
||||
@@ -161,13 +161,52 @@ static int navi10_ih_toggle_ring_interrupts(struct amdgpu_device *adev,
|
||||
tmp = RREG32(ih_regs->ih_rb_cntl);
|
||||
tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, RB_ENABLE, (enable ? 1 : 0));
|
||||
tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, RB_GPU_TS_ENABLE, 1);
|
||||
|
||||
if (enable) {
|
||||
/* Unset the CLEAR_OVERFLOW bit to make sure the next step
|
||||
* is switching the bit from 0 to 1
|
||||
*/
|
||||
tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, WPTR_OVERFLOW_CLEAR, 0);
|
||||
if (amdgpu_sriov_vf(adev) && amdgpu_sriov_reg_indirect_ih(adev)) {
|
||||
if (psp_reg_program(&adev->psp, ih_regs->psp_reg_id, tmp))
|
||||
return -ETIMEDOUT;
|
||||
} else {
|
||||
WREG32_NO_KIQ(ih_regs->ih_rb_cntl, tmp);
|
||||
}
|
||||
|
||||
/* Clear RB_OVERFLOW bit */
|
||||
tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, WPTR_OVERFLOW_CLEAR, 1);
|
||||
if (amdgpu_sriov_vf(adev) && amdgpu_sriov_reg_indirect_ih(adev)) {
|
||||
if (psp_reg_program(&adev->psp, ih_regs->psp_reg_id, tmp))
|
||||
return -ETIMEDOUT;
|
||||
} else {
|
||||
WREG32_NO_KIQ(ih_regs->ih_rb_cntl, tmp);
|
||||
}
|
||||
|
||||
/* Unset the CLEAR_OVERFLOW bit immediately so new overflows
|
||||
* can be detected.
|
||||
*/
|
||||
tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, WPTR_OVERFLOW_CLEAR, 0);
|
||||
}
|
||||
|
||||
/* enable_intr field is only valid in ring0 */
|
||||
if (ih == &adev->irq.ih)
|
||||
tmp = REG_SET_FIELD(tmp, IH_RB_CNTL, ENABLE_INTR, (enable ? 1 : 0));
|
||||
|
||||
if (amdgpu_sriov_vf(adev) && amdgpu_sriov_reg_indirect_ih(adev)) {
|
||||
if (psp_reg_program(&adev->psp, ih_regs->psp_reg_id, tmp))
|
||||
/*
|
||||
* PSP programming of IH_RB_CNTL is slow enough for MSI to
|
||||
* arrive before this call returns. Publish ih->enabled first
|
||||
* so amdgpu_ih_process() consumes that IV and rearms.
|
||||
*/
|
||||
if (enable) {
|
||||
ih->enabled = true;
|
||||
smp_wmb();
|
||||
}
|
||||
if (psp_reg_program(&adev->psp, ih_regs->psp_reg_id, tmp)) {
|
||||
ih->enabled = false;
|
||||
return -ETIMEDOUT;
|
||||
}
|
||||
} else {
|
||||
WREG32(ih_regs->ih_rb_cntl, tmp);
|
||||
}
|
||||
|
||||
@@ -710,7 +710,9 @@ static int uvd_v3_1_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
amdgpu_ring_commit(ring);
|
||||
|
||||
done:
|
||||
if (!r)
|
||||
if (r)
|
||||
cancel_delayed_work_sync(&adev->uvd.idle_work);
|
||||
else
|
||||
drm_info(adev_to_drm(adev), "UVD initialized successfully.\n");
|
||||
|
||||
return r;
|
||||
|
||||
@@ -198,7 +198,9 @@ static int uvd_v4_2_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
amdgpu_ring_commit(ring);
|
||||
|
||||
done:
|
||||
if (!r)
|
||||
if (r)
|
||||
cancel_delayed_work_sync(&adev->uvd.idle_work);
|
||||
else
|
||||
drm_info(adev_to_drm(adev), "UVD initialized successfully.\n");
|
||||
|
||||
return r;
|
||||
|
||||
@@ -190,7 +190,9 @@ static int uvd_v5_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
amdgpu_ring_commit(ring);
|
||||
|
||||
done:
|
||||
if (!r)
|
||||
if (r)
|
||||
cancel_delayed_work_sync(&adev->uvd.idle_work);
|
||||
else
|
||||
drm_info(adev_to_drm(adev), "UVD initialized successfully.\n");
|
||||
|
||||
return r;
|
||||
|
||||
@@ -515,7 +515,9 @@ static int uvd_v6_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
}
|
||||
|
||||
done:
|
||||
if (!r) {
|
||||
if (r) {
|
||||
cancel_delayed_work_sync(&adev->uvd.idle_work);
|
||||
} else {
|
||||
if (uvd_v6_0_enc_support(adev))
|
||||
drm_info(adev_to_drm(adev), "UVD and UVD ENC initialized successfully.\n");
|
||||
else
|
||||
|
||||
@@ -583,7 +583,9 @@ static int uvd_v7_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
}
|
||||
}
|
||||
done:
|
||||
if (!r)
|
||||
if (r)
|
||||
cancel_delayed_work_sync(&adev->uvd.idle_work);
|
||||
else
|
||||
drm_info(adev_to_drm(adev), "UVD and UVD ENC initialized successfully.\n");
|
||||
|
||||
return r;
|
||||
|
||||
@@ -651,12 +651,16 @@ static int vce_v1_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
for (i = 0; i < adev->vce.num_rings; i++) {
|
||||
r = amdgpu_ring_test_helper(&adev->vce.ring[i]);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
|
||||
dev_info(adev->dev, "VCE initialized successfully.\n");
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
cancel_delayed_work_sync(&adev->vce.idle_work);
|
||||
return r;
|
||||
}
|
||||
|
||||
static int vce_v1_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
@@ -483,12 +483,16 @@ static int vce_v2_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
for (i = 0; i < adev->vce.num_rings; i++) {
|
||||
r = amdgpu_ring_test_helper(&adev->vce.ring[i]);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
|
||||
drm_info(adev_to_drm(adev), "VCE initialized successfully.\n");
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
cancel_delayed_work_sync(&adev->vce.idle_work);
|
||||
return r;
|
||||
}
|
||||
|
||||
static int vce_v2_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
@@ -482,12 +482,16 @@ static int vce_v3_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
for (i = 0; i < adev->vce.num_rings; i++) {
|
||||
r = amdgpu_ring_test_helper(&adev->vce.ring[i]);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
|
||||
drm_info(adev_to_drm(adev), "VCE initialized successfully.\n");
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
cancel_delayed_work_sync(&adev->vce.idle_work);
|
||||
return r;
|
||||
}
|
||||
|
||||
static int vce_v3_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
@@ -533,12 +533,16 @@ static int vce_v4_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
for (i = 0; i < adev->vce.num_rings; i++) {
|
||||
r = amdgpu_ring_test_helper(&adev->vce.ring[i]);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
|
||||
drm_info(adev_to_drm(adev), "VCE initialized successfully.\n");
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
cancel_delayed_work_sync(&adev->vce.idle_work);
|
||||
return r;
|
||||
}
|
||||
|
||||
static int vce_v4_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
@@ -150,8 +150,8 @@ static int vcn_v1_0_sw_init(struct amdgpu_ip_block *ip_block)
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
/* Override the work func */
|
||||
adev->vcn.inst[0].idle_work.work.func = vcn_v1_0_idle_work_handler;
|
||||
/* Own lockdep class, this work is still cancelled synchronously */
|
||||
INIT_DELAYED_WORK(&adev->vcn.inst[0].idle_work, vcn_v1_0_idle_work_handler);
|
||||
|
||||
amdgpu_vcn_setup_ucode(adev, 0);
|
||||
|
||||
@@ -252,18 +252,25 @@ static int vcn_v1_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error_vcn;
|
||||
|
||||
for (i = 0; i < adev->vcn.inst[0].num_enc_rings; ++i) {
|
||||
ring = &adev->vcn.inst->ring_enc[i];
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error_vcn;
|
||||
}
|
||||
|
||||
ring = adev->jpeg.inst->ring_dec;
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
goto error_both;
|
||||
return 0;
|
||||
|
||||
error_both:
|
||||
cancel_delayed_work_sync(&adev->jpeg.idle_work);
|
||||
error_vcn:
|
||||
cancel_delayed_work_sync(&adev->vcn.inst[0].idle_work);
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
@@ -294,7 +294,7 @@ static int vcn_v2_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
|
||||
//Disable vcn decode for sriov
|
||||
if (amdgpu_sriov_vf(adev))
|
||||
@@ -304,10 +304,14 @@ static int vcn_v2_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
ring = &adev->vcn.inst->ring_enc[i];
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
amdgpu_vcn_cancel_idle_work(adev->vcn.inst);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -322,7 +326,9 @@ static int vcn_v2_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
struct amdgpu_device *adev = ip_block->adev;
|
||||
struct amdgpu_vcn_inst *vinst = adev->vcn.inst;
|
||||
|
||||
cancel_delayed_work_sync(&vinst->idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_vcn_cancel_idle_work(vinst);
|
||||
|
||||
if ((adev->pg_flags & AMD_PG_SUPPORT_VCN_DPG) ||
|
||||
(vinst->cur_state != AMD_PG_STATE_GATE &&
|
||||
@@ -2099,6 +2105,7 @@ static const struct amd_ip_funcs vcn_v2_0_ip_funcs = {
|
||||
.early_init = vcn_v2_0_early_init,
|
||||
.sw_init = vcn_v2_0_sw_init,
|
||||
.sw_fini = vcn_v2_0_sw_fini,
|
||||
.early_fini = amdgpu_vcn_early_fini,
|
||||
.hw_init = vcn_v2_0_hw_init,
|
||||
.hw_fini = vcn_v2_0_hw_fini,
|
||||
.suspend = vcn_v2_0_suspend,
|
||||
|
||||
@@ -304,8 +304,8 @@ static int vcn_v2_5_sw_init(struct amdgpu_ip_block *ip_block)
|
||||
if (r)
|
||||
return r;
|
||||
|
||||
/* Override the work func */
|
||||
adev->vcn.inst[j].idle_work.work.func = vcn_v2_5_idle_work_handler;
|
||||
/* Own lockdep class, this work is still cancelled synchronously */
|
||||
INIT_DELAYED_WORK(&adev->vcn.inst[j].idle_work, vcn_v2_5_idle_work_handler);
|
||||
|
||||
amdgpu_vcn_setup_ucode(adev, j);
|
||||
|
||||
@@ -481,18 +481,26 @@ static int vcn_v2_5_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
|
||||
for (i = 0; i < adev->vcn.inst[j].num_enc_rings; ++i) {
|
||||
ring = &adev->vcn.inst[j].ring_enc[i];
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return r;
|
||||
|
||||
error:
|
||||
for (i = 0; i <= j; i++) {
|
||||
if (adev->vcn.harvest_config & (1 << i))
|
||||
continue;
|
||||
cancel_delayed_work_sync(&adev->vcn.inst[i].idle_work);
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -417,18 +417,26 @@ static int vcn_v3_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
|
||||
for (j = 0; j < adev->vcn.inst[i].num_enc_rings; ++j) {
|
||||
ring = &adev->vcn.inst[i].ring_enc[j];
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
while (i >= 0) {
|
||||
if (!(adev->vcn.harvest_config & (1 << i)))
|
||||
amdgpu_vcn_cancel_idle_work(&adev->vcn.inst[i]);
|
||||
i--;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -449,7 +457,9 @@ static int vcn_v3_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
if (adev->vcn.harvest_config & (1 << i))
|
||||
continue;
|
||||
|
||||
cancel_delayed_work_sync(&vinst->idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_vcn_cancel_idle_work(vinst);
|
||||
|
||||
if (!amdgpu_sriov_vf(adev)) {
|
||||
if ((adev->pg_flags & AMD_PG_SUPPORT_VCN_DPG) ||
|
||||
@@ -2358,6 +2368,7 @@ static const struct amd_ip_funcs vcn_v3_0_ip_funcs = {
|
||||
.early_init = vcn_v3_0_early_init,
|
||||
.sw_init = vcn_v3_0_sw_init,
|
||||
.sw_fini = vcn_v3_0_sw_fini,
|
||||
.early_fini = amdgpu_vcn_early_fini,
|
||||
.hw_init = vcn_v3_0_hw_init,
|
||||
.hw_fini = vcn_v3_0_hw_fini,
|
||||
.suspend = vcn_v3_0_suspend,
|
||||
|
||||
@@ -349,11 +349,19 @@ static int vcn_v4_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
while (i >= 0) {
|
||||
if (!(adev->vcn.harvest_config & (1 << i)))
|
||||
amdgpu_vcn_cancel_idle_work(&adev->vcn.inst[i]);
|
||||
i--;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -374,7 +382,9 @@ static int vcn_v4_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
if (adev->vcn.harvest_config & (1 << i))
|
||||
continue;
|
||||
|
||||
cancel_delayed_work_sync(&vinst->idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_vcn_cancel_idle_work(vinst);
|
||||
|
||||
if (!amdgpu_sriov_vf(adev)) {
|
||||
if ((adev->pg_flags & AMD_PG_SUPPORT_VCN_DPG) ||
|
||||
@@ -2279,6 +2289,7 @@ static const struct amd_ip_funcs vcn_v4_0_ip_funcs = {
|
||||
.early_init = vcn_v4_0_early_init,
|
||||
.sw_init = vcn_v4_0_sw_init,
|
||||
.sw_fini = vcn_v4_0_sw_fini,
|
||||
.early_fini = amdgpu_vcn_early_fini,
|
||||
.hw_init = vcn_v4_0_hw_init,
|
||||
.hw_fini = vcn_v4_0_hw_fini,
|
||||
.suspend = vcn_v4_0_suspend,
|
||||
|
||||
@@ -395,11 +395,19 @@ static int vcn_v4_0_3_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
|
||||
return r;
|
||||
|
||||
error:
|
||||
while (i >= 0) {
|
||||
if (!(adev->vcn.harvest_config & (1 << i)))
|
||||
amdgpu_vcn_cancel_idle_work(&adev->vcn.inst[i]);
|
||||
i--;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -417,7 +425,9 @@ static int vcn_v4_0_3_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
for (i = 0; i < adev->vcn.num_vcn_inst; ++i) {
|
||||
struct amdgpu_vcn_inst *vinst = &adev->vcn.inst[i];
|
||||
|
||||
cancel_delayed_work_sync(&vinst->idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_vcn_cancel_idle_work(vinst);
|
||||
|
||||
if (vinst->cur_state != AMD_PG_STATE_GATE)
|
||||
vinst->set_pg_state(vinst, AMD_PG_STATE_GATE);
|
||||
@@ -2027,6 +2037,7 @@ static const struct amd_ip_funcs vcn_v4_0_3_ip_funcs = {
|
||||
.late_init = vcn_v4_0_3_late_init,
|
||||
.sw_init = vcn_v4_0_3_sw_init,
|
||||
.sw_fini = vcn_v4_0_3_sw_fini,
|
||||
.early_fini = amdgpu_vcn_early_fini,
|
||||
.hw_init = vcn_v4_0_3_hw_init,
|
||||
.hw_fini = vcn_v4_0_3_hw_fini,
|
||||
.suspend = vcn_v4_0_3_suspend,
|
||||
|
||||
@@ -303,10 +303,18 @@ static int vcn_v4_0_5_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
while (i >= 0) {
|
||||
if (!(adev->vcn.harvest_config & (1 << i)))
|
||||
amdgpu_vcn_cancel_idle_work(&adev->vcn.inst[i]);
|
||||
i--;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -327,7 +335,9 @@ static int vcn_v4_0_5_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
if (adev->vcn.harvest_config & (1 << i))
|
||||
continue;
|
||||
|
||||
cancel_delayed_work_sync(&vinst->idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_vcn_cancel_idle_work(vinst);
|
||||
|
||||
if (!amdgpu_sriov_vf(adev)) {
|
||||
if ((adev->pg_flags & AMD_PG_SUPPORT_VCN_DPG) ||
|
||||
@@ -1682,6 +1692,7 @@ static const struct amd_ip_funcs vcn_v4_0_5_ip_funcs = {
|
||||
.early_init = vcn_v4_0_5_early_init,
|
||||
.sw_init = vcn_v4_0_5_sw_init,
|
||||
.sw_fini = vcn_v4_0_5_sw_fini,
|
||||
.early_fini = amdgpu_vcn_early_fini,
|
||||
.hw_init = vcn_v4_0_5_hw_init,
|
||||
.hw_fini = vcn_v4_0_5_hw_fini,
|
||||
.suspend = vcn_v4_0_5_suspend,
|
||||
|
||||
@@ -267,10 +267,18 @@ static int vcn_v5_0_0_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
while (i >= 0) {
|
||||
if (!(adev->vcn.harvest_config & (1 << i)))
|
||||
amdgpu_vcn_cancel_idle_work(&adev->vcn.inst[i]);
|
||||
i--;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -291,7 +299,9 @@ static int vcn_v5_0_0_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
if (adev->vcn.harvest_config & (1 << i))
|
||||
continue;
|
||||
|
||||
cancel_delayed_work_sync(&vinst->idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_vcn_cancel_idle_work(vinst);
|
||||
|
||||
if (!amdgpu_sriov_vf(adev)) {
|
||||
if ((adev->pg_flags & AMD_PG_SUPPORT_VCN_DPG) ||
|
||||
@@ -1468,6 +1478,7 @@ static const struct amd_ip_funcs vcn_v5_0_0_ip_funcs = {
|
||||
.early_init = vcn_v5_0_0_early_init,
|
||||
.sw_init = vcn_v5_0_0_sw_init,
|
||||
.sw_fini = vcn_v5_0_0_sw_fini,
|
||||
.early_fini = amdgpu_vcn_early_fini,
|
||||
.hw_init = vcn_v5_0_0_hw_init,
|
||||
.hw_fini = vcn_v5_0_0_hw_fini,
|
||||
.suspend = vcn_v5_0_0_suspend,
|
||||
|
||||
@@ -342,11 +342,19 @@ static int vcn_v5_0_1_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
while (i >= 0) {
|
||||
if (!(adev->vcn.harvest_config & (1 << i)))
|
||||
amdgpu_vcn_cancel_idle_work(&adev->vcn.inst[i]);
|
||||
i--;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -364,7 +372,10 @@ static int vcn_v5_0_1_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
for (i = 0; i < adev->vcn.num_vcn_inst; ++i) {
|
||||
struct amdgpu_vcn_inst *vinst = &adev->vcn.inst[i];
|
||||
|
||||
cancel_delayed_work_sync(&adev->vcn.inst[i].idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_vcn_cancel_idle_work(&adev->vcn.inst[i]);
|
||||
|
||||
if (vinst->cur_state != AMD_PG_STATE_GATE)
|
||||
vinst->set_pg_state(vinst, AMD_PG_STATE_GATE);
|
||||
}
|
||||
@@ -1652,6 +1663,7 @@ static const struct amd_ip_funcs vcn_v5_0_1_ip_funcs = {
|
||||
.late_init = vcn_v5_0_1_late_init,
|
||||
.sw_init = vcn_v5_0_1_sw_init,
|
||||
.sw_fini = vcn_v5_0_1_sw_fini,
|
||||
.early_fini = amdgpu_vcn_early_fini,
|
||||
.hw_init = vcn_v5_0_1_hw_init,
|
||||
.hw_fini = vcn_v5_0_1_hw_fini,
|
||||
.suspend = vcn_v5_0_1_suspend,
|
||||
|
||||
@@ -257,11 +257,19 @@ static int vcn_v5_0_2_hw_init(struct amdgpu_ip_block *ip_block)
|
||||
|
||||
r = amdgpu_ring_test_helper(ring);
|
||||
if (r)
|
||||
return r;
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
error:
|
||||
while (i >= 0) {
|
||||
if (!(adev->vcn.harvest_config & (1 << i)))
|
||||
amdgpu_vcn_cancel_idle_work(&adev->vcn.inst[i]);
|
||||
i--;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -279,7 +287,10 @@ static int vcn_v5_0_2_hw_fini(struct amdgpu_ip_block *ip_block)
|
||||
for (i = 0; i < adev->vcn.num_vcn_inst; ++i) {
|
||||
struct amdgpu_vcn_inst *vinst = &adev->vcn.inst[i];
|
||||
|
||||
cancel_delayed_work_sync(&adev->vcn.inst[i].idle_work);
|
||||
/* Teardown cancelled it synchronously in early_fini */
|
||||
if (!adev->shutdown)
|
||||
amdgpu_vcn_cancel_idle_work(&adev->vcn.inst[i]);
|
||||
|
||||
if (vinst->cur_state != AMD_PG_STATE_GATE)
|
||||
vinst->set_pg_state(vinst, AMD_PG_STATE_GATE);
|
||||
}
|
||||
@@ -1443,6 +1454,7 @@ static const struct amd_ip_funcs vcn_v5_0_2_ip_funcs = {
|
||||
.late_init = NULL,
|
||||
.sw_init = vcn_v5_0_2_sw_init,
|
||||
.sw_fini = vcn_v5_0_2_sw_fini,
|
||||
.early_fini = amdgpu_vcn_early_fini,
|
||||
.hw_init = vcn_v5_0_2_hw_init,
|
||||
.hw_fini = vcn_v5_0_2_hw_fini,
|
||||
.suspend = vcn_v5_0_2_suspend,
|
||||
|
||||
@@ -303,7 +303,8 @@ static int init_user_queue(struct process_queue_manager *pqm,
|
||||
}
|
||||
|
||||
retval = amdgpu_amdkfd_map_gtt_bo_to_gart(q_properties->wptr_bo,
|
||||
&(*q)->wptr_bo_gart);
|
||||
&(*q)->wptr_bo_gart,
|
||||
pqm->process->kgd_process_info);
|
||||
if (retval) {
|
||||
pr_err("Failed to map wptr bo to GART\n");
|
||||
goto free_gang_ctx_bo;
|
||||
|
||||
@@ -538,7 +538,6 @@ int dm_dmub_sw_init(struct amdgpu_device *adev)
|
||||
DMUB_WINDOW_MEMORY_TYPE_FB, /* DMUB_WINDOW_CURSOR_OFFLOAD */
|
||||
};
|
||||
int r;
|
||||
int mem_domain = AMDGPU_GEM_DOMAIN_GTT;
|
||||
|
||||
switch (amdgpu_ip_version(adev, DCE_HWIP, 0)) {
|
||||
case IP_VERSION(2, 1, 0):
|
||||
@@ -675,19 +674,13 @@ int dm_dmub_sw_init(struct amdgpu_device *adev)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Limit to allocate dmub to GTT on DCN32/1
|
||||
* TODO: Other asics with GDDR7 may have worse latency
|
||||
*/
|
||||
if (dmub_asic != DMUB_ASIC_DCN32 &&
|
||||
dmub_asic != DMUB_ASIC_DCN321)
|
||||
mem_domain |= AMDGPU_GEM_DOMAIN_VRAM;
|
||||
|
||||
/*
|
||||
* Allocate a framebuffer based on the total size of all the regions.
|
||||
* TODO: Move this into GART.
|
||||
*/
|
||||
r = dmub_bo_create_kernel(adev, region_info.fb_size, PAGE_SIZE,
|
||||
mem_domain,
|
||||
AMDGPU_GEM_DOMAIN_VRAM |
|
||||
AMDGPU_GEM_DOMAIN_GTT,
|
||||
&adev->dm.dmub_bo,
|
||||
&adev->dm.dmub_bo_gpu_addr,
|
||||
&adev->dm.dmub_bo_cpu_addr);
|
||||
|
||||
@@ -131,6 +131,14 @@ void amdgpu_dm_get_freesync_config_for_crtc(
|
||||
vrefresh >= aconnector->min_vfreq &&
|
||||
vrefresh <= aconnector->max_vfreq;
|
||||
|
||||
/*
|
||||
* DC reads allow_freesync while validating the new state, for example
|
||||
* to keep SubVP off a single FreeSync display, but it is otherwise set
|
||||
* only on the first flip after the commit. Set it here, so that a
|
||||
* stream created by this commit is not validated without it.
|
||||
*/
|
||||
new_crtc_state->stream->allow_freesync = new_crtc_state->vrr_supported;
|
||||
|
||||
if (new_crtc_state->vrr_supported) {
|
||||
new_crtc_state->stream->ignore_msa_timing_param = true;
|
||||
fs_vid_mode = new_crtc_state->freesync_config.state == VRR_STATE_ACTIVE_FIXED;
|
||||
@@ -165,6 +173,18 @@ out:
|
||||
}
|
||||
EXPORT_IF_KUNIT(amdgpu_dm_get_freesync_config_for_crtc);
|
||||
|
||||
#define DP_HDR_SDP_EOTF_IDX 2
|
||||
|
||||
static bool dm_dp_in_hdr_mode(const struct dc_stream_state *stream)
|
||||
{
|
||||
const struct dc_info_packet *hdr = &stream->hdr_static_metadata;
|
||||
|
||||
if (!dc_is_dp_signal(stream->signal) || !hdr->valid)
|
||||
return false;
|
||||
|
||||
return hdr->sb[DP_HDR_SDP_EOTF_IDX] == HDMI_EOTF_SMPTE_ST2084;
|
||||
}
|
||||
|
||||
void amdgpu_dm_update_freesync_state_on_stream(
|
||||
struct amdgpu_display_manager *dm,
|
||||
struct dm_crtc_state *new_crtc_state,
|
||||
@@ -181,6 +201,7 @@ void amdgpu_dm_update_freesync_state_on_stream(
|
||||
bool pack_sdp_v1_3 = false;
|
||||
struct amdgpu_dm_connector *aconn;
|
||||
enum vrr_packet_type packet_type = PACKET_TYPE_VRR;
|
||||
enum color_transfer_func app_tf;
|
||||
|
||||
if (!new_stream)
|
||||
return;
|
||||
@@ -232,12 +253,16 @@ void amdgpu_dm_update_freesync_state_on_stream(
|
||||
&new_stream->adaptive_sync_infopacket);
|
||||
}
|
||||
|
||||
app_tf = dm_dp_in_hdr_mode(new_stream) ?
|
||||
TRANSFER_FUNC_PQ2084 :
|
||||
TRANSFER_FUNC_UNKNOWN;
|
||||
|
||||
mod_freesync_build_vrr_infopacket(
|
||||
dm->freesync_module,
|
||||
new_stream,
|
||||
&vrr_params,
|
||||
packet_type,
|
||||
TRANSFER_FUNC_UNKNOWN,
|
||||
app_tf,
|
||||
&vrr_infopacket,
|
||||
pack_sdp_v1_3);
|
||||
|
||||
|
||||
@@ -1190,6 +1190,12 @@ STATIC_IFN_KUNIT uint8_t get_max_frl_rate(uint8_t max_lanes, uint8_t max_rate_pe
|
||||
max_frl_rate = 5;
|
||||
else if ((max_lanes == 4) && (max_rate_per_lane == 12))
|
||||
max_frl_rate = 6;
|
||||
else if ((max_lanes == 4) && (max_rate_per_lane == 16))
|
||||
max_frl_rate = 7;
|
||||
else if ((max_lanes == 4) && (max_rate_per_lane == 20))
|
||||
max_frl_rate = 8;
|
||||
else if ((max_lanes == 4) && (max_rate_per_lane == 24))
|
||||
max_frl_rate = 9;
|
||||
else
|
||||
max_frl_rate = 0;
|
||||
|
||||
|
||||
@@ -1267,6 +1267,33 @@ static void dm_test_get_max_frl_rate_4lanes_12gbps(struct kunit *test)
|
||||
KUNIT_EXPECT_EQ(test, get_max_frl_rate(4, 12), 6);
|
||||
}
|
||||
|
||||
/**
|
||||
* dm_test_get_max_frl_rate_4lanes_16gbps - Test Get max frl rate 4lanes 16gbps
|
||||
* @test: The KUnit test context
|
||||
*/
|
||||
static void dm_test_get_max_frl_rate_4lanes_16gbps(struct kunit *test)
|
||||
{
|
||||
KUNIT_EXPECT_EQ(test, get_max_frl_rate(4, 16), 7);
|
||||
}
|
||||
|
||||
/**
|
||||
* dm_test_get_max_frl_rate_4lanes_20gbps - Test Get max frl rate 4lanes 20gbps
|
||||
* @test: The KUnit test context
|
||||
*/
|
||||
static void dm_test_get_max_frl_rate_4lanes_20gbps(struct kunit *test)
|
||||
{
|
||||
KUNIT_EXPECT_EQ(test, get_max_frl_rate(4, 20), 8);
|
||||
}
|
||||
|
||||
/**
|
||||
* dm_test_get_max_frl_rate_4lanes_24gbps - Test Get max frl rate 4lanes 24gbps
|
||||
* @test: The KUnit test context
|
||||
*/
|
||||
static void dm_test_get_max_frl_rate_4lanes_24gbps(struct kunit *test)
|
||||
{
|
||||
KUNIT_EXPECT_EQ(test, get_max_frl_rate(4, 24), 9);
|
||||
}
|
||||
|
||||
/**
|
||||
* dm_test_get_max_frl_rate_unknown - Test Get max frl rate unknown
|
||||
* @test: The KUnit test context
|
||||
@@ -4875,6 +4902,9 @@ static struct kunit_case amdgpu_dm_helpers_test_cases[] = {
|
||||
KUNIT_CASE(dm_test_get_max_frl_rate_4lanes_8gbps),
|
||||
KUNIT_CASE(dm_test_get_max_frl_rate_4lanes_10gbps),
|
||||
KUNIT_CASE(dm_test_get_max_frl_rate_4lanes_12gbps),
|
||||
KUNIT_CASE(dm_test_get_max_frl_rate_4lanes_16gbps),
|
||||
KUNIT_CASE(dm_test_get_max_frl_rate_4lanes_20gbps),
|
||||
KUNIT_CASE(dm_test_get_max_frl_rate_4lanes_24gbps),
|
||||
KUNIT_CASE(dm_test_get_max_frl_rate_unknown),
|
||||
/* dm_dtn_log_begin / dm_dtn_log_append_v / dm_dtn_log_end */
|
||||
KUNIT_CASE(dm_test_dtn_log_buffer_accumulates),
|
||||
|
||||
@@ -538,6 +538,9 @@ static void dcn401_update_clocks_update_dtb_dto(struct clk_mgr_internal *clk_mgr
|
||||
otg_master = resource_get_otg_master_for_stream(
|
||||
&context->res_ctx, context->streams[i]);
|
||||
ASSERT(otg_master);
|
||||
if (!otg_master)
|
||||
continue;
|
||||
|
||||
ASSERT(otg_master->clock_source);
|
||||
ASSERT(otg_master->clock_source->funcs->program_pix_clk);
|
||||
ASSERT(otg_master->stream_res.pix_clk_params.controller_id >= CONTROLLER_ID_D0);
|
||||
|
||||
@@ -2484,6 +2484,8 @@ static enum dc_status dc_commit_state_no_check(struct dc *dc, struct dc_state *c
|
||||
* update pending complete before optimizing bandwidth.
|
||||
*/
|
||||
hwss_wait_for_odm_update_pending_complete(dc, context);
|
||||
/* No DET may stay allocated to a HUBP without a plane (e.g. left over from VBIOS) */
|
||||
hwss_reset_unused_det(dc, context);
|
||||
/* pplib is notified if disp_num changed */
|
||||
dc->hwss.optimize_bandwidth(dc, context);
|
||||
/* Need to do otg sync again as otg could be out of sync due to otg
|
||||
@@ -4870,8 +4872,10 @@ static void commit_planes_for_stream(struct dc *dc,
|
||||
dc_exit_ips_for_hw_access(dc);
|
||||
|
||||
dc_z10_restore(dc);
|
||||
if (update_type == UPDATE_TYPE_FULL && dc->optimized_required)
|
||||
if (update_type == UPDATE_TYPE_FULL && dc->optimized_required) {
|
||||
hwss_reset_unused_det(dc, dc->current_state);
|
||||
hwss_process_outstanding_hw_updates(dc, dc->current_state);
|
||||
}
|
||||
|
||||
if (update_type != UPDATE_TYPE_FAST && dc->res_pool->funcs->prepare_mcache_programming)
|
||||
dc->res_pool->funcs->prepare_mcache_programming(dc, context);
|
||||
|
||||
@@ -3147,6 +3147,37 @@ void hwss_wait_for_odm_update_pending_complete(struct dc *dc, struct dc_state *c
|
||||
hwss_wait_for_all_blank_complete(dc, context);
|
||||
}
|
||||
|
||||
void hwss_reset_unused_det(struct dc *dc, struct dc_state *context)
|
||||
{
|
||||
struct hubbub *hubbub = dc->res_pool->hubbub;
|
||||
unsigned int i, j;
|
||||
|
||||
if (!hubbub || !hubbub->funcs->program_det_segments)
|
||||
return;
|
||||
|
||||
for (i = 0; i < dc->res_pool->pipe_count; i++) {
|
||||
struct hubp *hubp = dc->res_pool->hubps[i];
|
||||
bool hubp_in_use = false;
|
||||
|
||||
if (!hubp)
|
||||
continue;
|
||||
|
||||
for (j = 0; j < dc->res_pool->pipe_count; j++) {
|
||||
const struct pipe_ctx *pipe = &context->res_ctx.pipe_ctx[j];
|
||||
|
||||
/* A plane-less pipe renders from the DPG, its HUBP (assigned with the stream) needs no DET */
|
||||
if (pipe->plane_state && pipe->plane_res.hubp &&
|
||||
pipe->plane_res.hubp->inst == hubp->inst) {
|
||||
hubp_in_use = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!hubp_in_use)
|
||||
hubbub->funcs->program_det_segments(hubbub, hubp->inst, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void hwss_wait_for_no_pipes_pending(struct dc *dc, struct dc_state *context)
|
||||
{
|
||||
int i;
|
||||
|
||||
@@ -1829,6 +1829,9 @@ void hwss_wait_for_odm_update_pending_complete(struct dc *dc,
|
||||
void hwss_wait_for_no_pipes_pending(struct dc *dc,
|
||||
struct dc_state *context);
|
||||
|
||||
void hwss_reset_unused_det(struct dc *dc,
|
||||
struct dc_state *context);
|
||||
|
||||
void hwss_wait_for_outstanding_hw_updates(struct dc *dc,
|
||||
struct dc_state *dc_context);
|
||||
|
||||
|
||||
@@ -2602,12 +2602,8 @@ bool dp_is_sink_present(struct dc_link *link)
|
||||
* which indicates we need additional delay
|
||||
*/
|
||||
|
||||
if (dal_ddc_open(ddc, GPIO_MODE_INPUT,
|
||||
GPIO_DDC_CONFIG_TYPE_MODE_I2C) != GPIO_RESULT_OK) {
|
||||
dal_ddc_close(ddc);
|
||||
|
||||
if (dal_ddc_open(ddc, GPIO_MODE_INPUT, GPIO_DDC_CONFIG_TYPE_MODE_I2C) != GPIO_RESULT_OK)
|
||||
return present;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read GPIO: DP sink is present if both clock and data pins are zero
|
||||
|
||||
@@ -449,6 +449,13 @@ void optc2_lock_doublebuffer_disable(struct timing_generator *optc)
|
||||
void optc2_setup_manual_trigger(struct timing_generator *optc)
|
||||
{
|
||||
struct optc *optc1 = DCN10TG_FROM_TG(optc);
|
||||
uint32_t v_total, v_total_max;
|
||||
|
||||
REG_GET(OTG_V_TOTAL_MAX, OTG_V_TOTAL_MAX, &v_total_max);
|
||||
if (!v_total_max) {
|
||||
REG_GET(OTG_V_TOTAL, OTG_V_TOTAL, &v_total);
|
||||
optc->funcs->set_vtotal_min_max(optc, v_total, v_total);
|
||||
}
|
||||
|
||||
/* Set the min/max selectors unconditionally so that
|
||||
* DMCUB fw may change OTG timings when necessary
|
||||
|
||||
@@ -91,6 +91,12 @@
|
||||
SRI(OTG_CRC0_WINDOWA_Y_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC0_WINDOWB_X_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC0_WINDOWB_Y_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC1_DATA_RG, OTG, inst),\
|
||||
SRI(OTG_CRC1_DATA_B, OTG, inst),\
|
||||
SRI(OTG_CRC1_WINDOWA_X_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC1_WINDOWA_Y_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC1_WINDOWB_X_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC1_WINDOWB_Y_CONTROL, OTG, inst),\
|
||||
SR(GSL_SOURCE_SELECT),\
|
||||
SRI(OTG_TRIGA_MANUAL_TRIG, OTG, inst),\
|
||||
SRI(OTG_DRR_CONTROL, OTG, inst)
|
||||
@@ -229,6 +235,7 @@
|
||||
SF(OTG0_OTG_GSL_CONTROL, OTG_GSL_CHECK_ALL_FIELDS, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_CONT_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC0_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL2, OTG_CRC_DSC_MODE, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL2, OTG_CRC_DATA_STREAM_COMBINE_MODE, mask_sh),\
|
||||
@@ -245,6 +252,17 @@
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_X_CONTROL, OTG_CRC0_WINDOWB_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_Y_CONTROL, OTG_CRC0_WINDOWB_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_Y_CONTROL, OTG_CRC0_WINDOWB_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_RG, CRC1_R_CR, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_RG, CRC1_G_Y, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_B, CRC1_B_CB, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_X_CONTROL, OTG_CRC1_WINDOWA_X_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_X_CONTROL, OTG_CRC1_WINDOWA_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_Y_CONTROL, OTG_CRC1_WINDOWA_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_Y_CONTROL, OTG_CRC1_WINDOWA_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_X_CONTROL, OTG_CRC1_WINDOWB_X_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_X_CONTROL, OTG_CRC1_WINDOWB_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_Y_CONTROL, OTG_CRC1_WINDOWB_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_Y_CONTROL, OTG_CRC1_WINDOWB_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_TRIGA_MANUAL_TRIG, OTG_TRIGA_MANUAL_TRIG, mask_sh),\
|
||||
SF(GSL_SOURCE_SELECT, GSL0_READY_SOURCE_SEL, mask_sh),\
|
||||
SF(GSL_SOURCE_SELECT, GSL1_READY_SOURCE_SEL, mask_sh),\
|
||||
|
||||
@@ -83,6 +83,12 @@
|
||||
SRI(OTG_CRC0_WINDOWA_Y_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC0_WINDOWB_X_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC0_WINDOWB_Y_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC1_DATA_RG, OTG, inst),\
|
||||
SRI(OTG_CRC1_DATA_B, OTG, inst),\
|
||||
SRI(OTG_CRC1_WINDOWA_X_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC1_WINDOWA_Y_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC1_WINDOWB_X_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC1_WINDOWB_Y_CONTROL, OTG, inst),\
|
||||
SR(GSL_SOURCE_SELECT),\
|
||||
SRI(OTG_TRIGA_MANUAL_TRIG, OTG, inst),\
|
||||
SRI(OTG_GLOBAL_CONTROL1, OTG, inst),\
|
||||
@@ -205,7 +211,9 @@
|
||||
SF(OTG0_OTG_GSL_CONTROL, OTG_GSL_CHECK_ALL_FIELDS, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_CONT_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC0_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_DATA_RG, CRC0_R_CR, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_DATA_RG, CRC0_G_Y, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_DATA_B, CRC0_B_CB, mask_sh),\
|
||||
@@ -217,6 +225,17 @@
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_X_CONTROL, OTG_CRC0_WINDOWB_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_Y_CONTROL, OTG_CRC0_WINDOWB_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_Y_CONTROL, OTG_CRC0_WINDOWB_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_RG, CRC1_R_CR, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_RG, CRC1_G_Y, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_B, CRC1_B_CB, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_X_CONTROL, OTG_CRC1_WINDOWA_X_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_X_CONTROL, OTG_CRC1_WINDOWA_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_Y_CONTROL, OTG_CRC1_WINDOWA_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_Y_CONTROL, OTG_CRC1_WINDOWA_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_X_CONTROL, OTG_CRC1_WINDOWB_X_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_X_CONTROL, OTG_CRC1_WINDOWB_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_Y_CONTROL, OTG_CRC1_WINDOWB_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_Y_CONTROL, OTG_CRC1_WINDOWB_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_TRIGA_MANUAL_TRIG, OTG_TRIGA_MANUAL_TRIG, mask_sh),\
|
||||
SF(GSL_SOURCE_SELECT, GSL0_READY_SOURCE_SEL, mask_sh),\
|
||||
SF(GSL_SOURCE_SELECT, GSL1_READY_SOURCE_SEL, mask_sh),\
|
||||
@@ -264,8 +283,7 @@
|
||||
SF(OTG0_INTERRUPT_DEST, OTG0_IHC_OTG_VERTICAL_INTERRUPT2_DEST, mask_sh)
|
||||
|
||||
#define OPTC_COMMON_MASK_SH_LIST_DCN31X(mask_sh)\
|
||||
OPTC_COMMON_MASK_SH_LIST_DCN3_1(mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_EN, mask_sh)
|
||||
OPTC_COMMON_MASK_SH_LIST_DCN3_1(mask_sh)
|
||||
|
||||
void dcn31_timing_generator_init(struct optc *optc1);
|
||||
|
||||
|
||||
@@ -84,6 +84,12 @@
|
||||
SRI(OTG_CRC0_WINDOWA_Y_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC0_WINDOWB_X_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC0_WINDOWB_Y_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC1_DATA_RG, OTG, inst),\
|
||||
SRI(OTG_CRC1_DATA_B, OTG, inst),\
|
||||
SRI(OTG_CRC1_WINDOWA_X_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC1_WINDOWA_Y_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC1_WINDOWB_X_CONTROL, OTG, inst),\
|
||||
SRI(OTG_CRC1_WINDOWB_Y_CONTROL, OTG, inst),\
|
||||
SR(GSL_SOURCE_SELECT),\
|
||||
SRI(OTG_TRIGA_MANUAL_TRIG, OTG, inst),\
|
||||
SRI(OTG_GLOBAL_CONTROL1, OTG, inst),\
|
||||
@@ -204,6 +210,7 @@
|
||||
SF(OTG0_OTG_GSL_CONTROL, OTG_GSL_CHECK_ALL_FIELDS, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_CONT_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC0_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_DATA_RG, CRC0_R_CR, mask_sh),\
|
||||
@@ -217,6 +224,17 @@
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_X_CONTROL, OTG_CRC0_WINDOWB_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_Y_CONTROL, OTG_CRC0_WINDOWB_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_Y_CONTROL, OTG_CRC0_WINDOWB_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_RG, CRC1_R_CR, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_RG, CRC1_G_Y, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_B, CRC1_B_CB, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_X_CONTROL, OTG_CRC1_WINDOWA_X_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_X_CONTROL, OTG_CRC1_WINDOWA_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_Y_CONTROL, OTG_CRC1_WINDOWA_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_Y_CONTROL, OTG_CRC1_WINDOWA_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_X_CONTROL, OTG_CRC1_WINDOWB_X_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_X_CONTROL, OTG_CRC1_WINDOWB_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_Y_CONTROL, OTG_CRC1_WINDOWB_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_Y_CONTROL, OTG_CRC1_WINDOWB_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_TRIGA_MANUAL_TRIG, OTG_TRIGA_MANUAL_TRIG, mask_sh),\
|
||||
SF(GSL_SOURCE_SELECT, GSL0_READY_SOURCE_SEL, mask_sh),\
|
||||
SF(GSL_SOURCE_SELECT, GSL1_READY_SOURCE_SEL, mask_sh),\
|
||||
|
||||
@@ -146,6 +146,17 @@
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_X_CONTROL, OTG_CRC0_WINDOWB_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_Y_CONTROL, OTG_CRC0_WINDOWB_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_Y_CONTROL, OTG_CRC0_WINDOWB_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_RG, CRC1_R_CR, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_RG, CRC1_G_Y, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_B, CRC1_B_CB, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_X_CONTROL, OTG_CRC1_WINDOWA_X_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_X_CONTROL, OTG_CRC1_WINDOWA_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_Y_CONTROL, OTG_CRC1_WINDOWA_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_Y_CONTROL, OTG_CRC1_WINDOWA_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_X_CONTROL, OTG_CRC1_WINDOWB_X_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_X_CONTROL, OTG_CRC1_WINDOWB_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_Y_CONTROL, OTG_CRC1_WINDOWB_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_Y_CONTROL, OTG_CRC1_WINDOWB_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_TRIGA_MANUAL_TRIG, OTG_TRIGA_MANUAL_TRIG, mask_sh),\
|
||||
SF(GSL_SOURCE_SELECT, GSL0_READY_SOURCE_SEL, mask_sh),\
|
||||
SF(GSL_SOURCE_SELECT, GSL1_READY_SOURCE_SEL, mask_sh),\
|
||||
|
||||
@@ -32,23 +32,12 @@
|
||||
#define OPTC_COMMON_MASK_SH_LIST_DCN3_5(mask_sh)\
|
||||
OPTC_COMMON_MASK_SH_LIST_DCN3_2(mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_WINDOW_DB_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_RG, CRC1_R_CR, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_RG, CRC1_G_Y, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_B, CRC1_B_CB, mask_sh),\
|
||||
SF(OTG0_OTG_CRC2_DATA_RG, CRC2_R_CR, mask_sh),\
|
||||
SF(OTG0_OTG_CRC2_DATA_RG, CRC2_G_Y, mask_sh),\
|
||||
SF(OTG0_OTG_CRC2_DATA_B, CRC2_B_CB, mask_sh),\
|
||||
SF(OTG0_OTG_CRC3_DATA_RG, CRC3_R_CR, mask_sh),\
|
||||
SF(OTG0_OTG_CRC3_DATA_RG, CRC3_G_Y, mask_sh),\
|
||||
SF(OTG0_OTG_CRC3_DATA_B, CRC3_B_CB, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_X_CONTROL, OTG_CRC1_WINDOWA_X_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_X_CONTROL, OTG_CRC1_WINDOWA_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_Y_CONTROL, OTG_CRC1_WINDOWA_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_Y_CONTROL, OTG_CRC1_WINDOWA_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_X_CONTROL, OTG_CRC1_WINDOWB_X_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_X_CONTROL, OTG_CRC1_WINDOWB_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_Y_CONTROL, OTG_CRC1_WINDOWB_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_Y_CONTROL, OTG_CRC1_WINDOWB_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWA_X_CONTROL_READBACK, OTG_CRC0_WINDOWA_X_START_READBACK, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWA_X_CONTROL_READBACK, OTG_CRC0_WINDOWA_X_END_READBACK, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWA_Y_CONTROL_READBACK, OTG_CRC0_WINDOWA_Y_START_READBACK, mask_sh),\
|
||||
|
||||
@@ -110,6 +110,7 @@
|
||||
SF(OTG0_OTG_GSL_CONTROL, OTG_GSL_CHECK_ALL_FIELDS, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_CONT_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC0_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_DATA_RG, CRC0_R_CR, mask_sh),\
|
||||
@@ -123,6 +124,17 @@
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_X_CONTROL, OTG_CRC0_WINDOWB_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_Y_CONTROL, OTG_CRC0_WINDOWB_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_WINDOWB_Y_CONTROL, OTG_CRC0_WINDOWB_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_RG, CRC1_R_CR, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_RG, CRC1_G_Y, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_DATA_B, CRC1_B_CB, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_X_CONTROL, OTG_CRC1_WINDOWA_X_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_X_CONTROL, OTG_CRC1_WINDOWA_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_Y_CONTROL, OTG_CRC1_WINDOWA_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWA_Y_CONTROL, OTG_CRC1_WINDOWA_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_X_CONTROL, OTG_CRC1_WINDOWB_X_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_X_CONTROL, OTG_CRC1_WINDOWB_X_END, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_Y_CONTROL, OTG_CRC1_WINDOWB_Y_START, mask_sh),\
|
||||
SF(OTG0_OTG_CRC1_WINDOWB_Y_CONTROL, OTG_CRC1_WINDOWB_Y_END, mask_sh),\
|
||||
SF(OTG0_OTG_TRIGA_MANUAL_TRIG, OTG_TRIGA_MANUAL_TRIG, mask_sh),\
|
||||
SF(GSL_SOURCE_SELECT, GSL0_READY_SOURCE_SEL, mask_sh),\
|
||||
SF(GSL_SOURCE_SELECT, GSL1_READY_SOURCE_SEL, mask_sh),\
|
||||
|
||||
@@ -137,6 +137,7 @@
|
||||
SF(OTG0_OTG_GSL_CONTROL, OTG_GSL_CHECK_ALL_FIELDS, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_CONT_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC0_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_DATA_R, CRC0_R_CR, mask_sh),\
|
||||
@@ -316,6 +317,7 @@
|
||||
SF(OTG0_OTG_GSL_CONTROL, OTG_GSL_CHECK_ALL_FIELDS, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_CONT_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC0_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_DATA_R, CRC0_R_CR, mask_sh),\
|
||||
|
||||
@@ -109,7 +109,9 @@
|
||||
SF(OTG0_OTG_GSL_CONTROL, OTG_GSL_FORCE_DELAY, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_CONT_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC0_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_SELECT, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC_CNTL, OTG_CRC1_EN, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_DATA_R, CRC0_R_CR, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_DATA_G, CRC0_G_Y, mask_sh),\
|
||||
SF(OTG0_OTG_CRC0_DATA_B, CRC0_B_CB, mask_sh),\
|
||||
|
||||
@@ -1941,8 +1941,21 @@ static bool dml1_validate(struct dc *dc, struct dc_state *context, enum dc_valid
|
||||
out = dcn32_internal_validate_bw(dc, context, pipes, &pipe_cnt, &vlevel, validate_mode);
|
||||
DC_FP_END();
|
||||
|
||||
if (pipe_cnt == 0)
|
||||
if (pipe_cnt == 0) {
|
||||
/* The context is a copy of the previous state, so without this the
|
||||
* clocks the last display needed stay applied with all displays off.
|
||||
*/
|
||||
context->bw_ctx.bw.dcn.clk.socclk_khz = 0;
|
||||
context->bw_ctx.bw.dcn.clk.dppclk_khz = 0;
|
||||
context->bw_ctx.bw.dcn.clk.dcfclk_khz = 0;
|
||||
context->bw_ctx.bw.dcn.clk.dcfclk_deep_sleep_khz = 0;
|
||||
context->bw_ctx.bw.dcn.clk.dramclk_khz = 0;
|
||||
context->bw_ctx.bw.dcn.clk.fclk_khz = 0;
|
||||
context->bw_ctx.bw.dcn.clk.p_state_change_support = true;
|
||||
context->bw_ctx.bw.dcn.clk.fclk_p_state_change_support = true;
|
||||
context->bw_ctx.bw.dcn.clk.num_ways = 0;
|
||||
goto validate_out;
|
||||
}
|
||||
|
||||
if (!out)
|
||||
goto validate_fail;
|
||||
|
||||
@@ -1054,6 +1054,12 @@ unsigned int dcn32_get_max_hw_cursor_size(const struct dc *dc,
|
||||
SRI_ARR(OTG_CRC0_WINDOWA_Y_CONTROL, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC0_WINDOWB_X_CONTROL, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC0_WINDOWB_Y_CONTROL, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC1_DATA_RG, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC1_DATA_B, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC1_WINDOWA_X_CONTROL, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC1_WINDOWA_Y_CONTROL, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC1_WINDOWB_X_CONTROL, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC1_WINDOWB_Y_CONTROL, OTG, inst), \
|
||||
SR_ARR(GSL_SOURCE_SELECT, inst), \
|
||||
SRI_ARR(OTG_TRIGA_MANUAL_TRIG, OTG, inst), \
|
||||
SRI_ARR(OTG_GLOBAL_CONTROL1, OTG, inst), \
|
||||
|
||||
@@ -535,6 +535,12 @@ int dcn401_get_power_profile(const struct dc_state *context);
|
||||
SRI_ARR(OTG_CRC0_WINDOWA_Y_CONTROL, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC0_WINDOWB_X_CONTROL, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC0_WINDOWB_Y_CONTROL, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC1_DATA_RG, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC1_DATA_B, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC1_WINDOWA_X_CONTROL, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC1_WINDOWA_Y_CONTROL, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC1_WINDOWB_X_CONTROL, OTG, inst), \
|
||||
SRI_ARR(OTG_CRC1_WINDOWB_Y_CONTROL, OTG, inst), \
|
||||
SR_ARR(GSL_SOURCE_SELECT, inst), \
|
||||
SRI_ARR(OTG_TRIGA_MANUAL_TRIG, OTG, inst), \
|
||||
SRI_ARR(OTG_GLOBAL_CONTROL1, OTG, inst), \
|
||||
|
||||
@@ -1281,10 +1281,8 @@ void mod_freesync_handle_v_update(struct mod_freesync *mod_freesync,
|
||||
* If VRR is inactive, set vtotal min and max to nominal vtotal
|
||||
*/
|
||||
if (in_out_vrr->state == VRR_STATE_INACTIVE) {
|
||||
in_out_vrr->adjust.v_total_min =
|
||||
mod_freesync_calc_v_total_from_refresh(stream,
|
||||
in_out_vrr->max_refresh_in_uhz);
|
||||
in_out_vrr->adjust.v_total_max = in_out_vrr->adjust.v_total_min;
|
||||
in_out_vrr->adjust.v_total_min = stream->timing.v_total;
|
||||
in_out_vrr->adjust.v_total_max = stream->timing.v_total;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1419,7 +1419,25 @@ int smu_v11_0_get_max_sustainable_clocks_by_dc(struct smu_context *smu,
|
||||
int smu_v11_0_baco_set_armd3_sequence(struct smu_context *smu,
|
||||
enum smu_baco_seq baco_seq)
|
||||
{
|
||||
return smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_ArmD3, baco_seq, NULL);
|
||||
struct smu_baco_context *smu_baco = &smu->smu_baco;
|
||||
int ret;
|
||||
|
||||
ret = smu_cmn_send_smc_msg_with_param(smu, SMU_MSG_ArmD3, baco_seq, NULL);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/*
|
||||
* PMFW owns the BACO transition once armed, so keep the driver's view
|
||||
* in sync. Otherwise smu_v11_0_get_bamaco_support() falls back to the
|
||||
* live BACO feature bit, which PMFW clears when armed, and the runtime
|
||||
* resume wrongly concludes BACO is unsupported and skips the exit.
|
||||
*/
|
||||
if (baco_seq == BACO_SEQ_BAMACO || baco_seq == BACO_SEQ_BACO)
|
||||
smu_baco->state = SMU_BACO_STATE_ENTER;
|
||||
else
|
||||
smu_baco->state = SMU_BACO_STATE_EXIT;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int smu_v11_0_get_bamaco_support(struct smu_context *smu)
|
||||
|
||||
@@ -2912,6 +2912,25 @@ static int smu_v13_0_7_mode1_reset(struct smu_context *smu)
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void smu_v13_0_7_get_unique_id(struct smu_context *smu)
|
||||
{
|
||||
SmuMetricsExternal_t metrics_external;
|
||||
SmuMetrics_t *metrics = &metrics_external.SmuMetrics;
|
||||
struct amdgpu_device *adev = smu->adev;
|
||||
u32 upper32 = 0, lower32 = 0;
|
||||
int ret;
|
||||
|
||||
ret = smu_cmn_get_metrics_table(smu, &metrics_external, false);
|
||||
if (ret)
|
||||
goto out;
|
||||
|
||||
upper32 = metrics->PublicSerialNumberUpper;
|
||||
lower32 = metrics->PublicSerialNumberLower;
|
||||
|
||||
out:
|
||||
adev->unique_id = ((u64)upper32 << 32) | lower32;
|
||||
}
|
||||
|
||||
static void smu_v13_0_7_init_msg_ctl(struct smu_context *smu)
|
||||
{
|
||||
struct amdgpu_device *adev = smu->adev;
|
||||
@@ -2995,6 +3014,7 @@ static const struct pptable_funcs smu_v13_0_7_ppt_funcs = {
|
||||
.enable_uclk_shadow = smu_v13_0_enable_uclk_shadow,
|
||||
.set_wbrf_exclusion_ranges = smu_v13_0_set_wbrf_exclusion_ranges,
|
||||
.interrupt_work = smu_v13_0_interrupt_work,
|
||||
.get_unique_id = smu_v13_0_7_get_unique_id,
|
||||
};
|
||||
|
||||
void smu_v13_0_7_set_ppt_funcs(struct smu_context *smu)
|
||||
|
||||
@@ -110,6 +110,8 @@ struct nwl_dsi {
|
||||
int error;
|
||||
|
||||
struct nwl_dsi_transfer *xfer;
|
||||
|
||||
unsigned int endpoint;
|
||||
};
|
||||
|
||||
static const struct regmap_config nwl_dsi_regmap_config = {
|
||||
@@ -821,10 +823,13 @@ static int nwl_dsi_bridge_atomic_check(struct drm_bridge *bridge,
|
||||
struct drm_connector_state *conn_state)
|
||||
{
|
||||
struct drm_display_mode *adjusted_mode = &crtc_state->adjusted_mode;
|
||||
struct nwl_dsi *dsi = bridge_to_dsi(bridge);
|
||||
|
||||
/* At least LCDIF + NWL needs active high sync */
|
||||
adjusted_mode->flags |= (DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC);
|
||||
adjusted_mode->flags &= ~(DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC);
|
||||
if (dsi->endpoint == NWL_DSI_ENDPOINT_LCDIF) {
|
||||
adjusted_mode->flags |= (DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC);
|
||||
adjusted_mode->flags &= ~(DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC);
|
||||
}
|
||||
|
||||
/*
|
||||
* Do a full modeset if crtc_state->active is changed to be true.
|
||||
@@ -1088,13 +1093,12 @@ static int nwl_dsi_parse_dt(struct nwl_dsi *dsi)
|
||||
static int nwl_dsi_select_input(struct nwl_dsi *dsi)
|
||||
{
|
||||
struct device_node *remote;
|
||||
u32 use_dcss = 1;
|
||||
int ret;
|
||||
|
||||
remote = of_graph_get_remote_node(dsi->dev->of_node, 0,
|
||||
NWL_DSI_ENDPOINT_LCDIF);
|
||||
if (remote) {
|
||||
use_dcss = 0;
|
||||
dsi->endpoint = NWL_DSI_ENDPOINT_LCDIF;
|
||||
} else {
|
||||
remote = of_graph_get_remote_node(dsi->dev->of_node, 0,
|
||||
NWL_DSI_ENDPOINT_DCSS);
|
||||
@@ -1103,11 +1107,12 @@ static int nwl_dsi_select_input(struct nwl_dsi *dsi)
|
||||
"No valid input endpoint found\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
dsi->endpoint = NWL_DSI_ENDPOINT_DCSS;
|
||||
}
|
||||
|
||||
DRM_DEV_INFO(dsi->dev, "Using %s as input source\n",
|
||||
(use_dcss) ? "DCSS" : "LCDIF");
|
||||
ret = mux_control_try_select(dsi->mux, use_dcss);
|
||||
(dsi->endpoint == NWL_DSI_ENDPOINT_DCSS) ? "DCSS" : "LCDIF");
|
||||
ret = mux_control_try_select(dsi->mux, dsi->endpoint);
|
||||
if (ret < 0)
|
||||
DRM_DEV_ERROR(dsi->dev, "Failed to select input: %d\n", ret);
|
||||
|
||||
|
||||
@@ -2192,7 +2192,8 @@ static int drm_dp_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs,
|
||||
msg.buffer = msgs[i].buf + j;
|
||||
msg.size = min(transfer_size, msgs[i].len - j);
|
||||
|
||||
if (j + msg.size == msgs[i].len && aux->no_zero_sized)
|
||||
if (aux->no_zero_sized && i == num - 1 &&
|
||||
j + msg.size == msgs[i].len)
|
||||
msg.request &= ~DP_AUX_I2C_MOT;
|
||||
err = drm_dp_i2c_drain_msg(aux, &msg);
|
||||
|
||||
|
||||
@@ -154,11 +154,8 @@ static void drm_crtc_crc_fini(struct drm_crtc *crtc)
|
||||
#endif
|
||||
}
|
||||
|
||||
static const struct dma_fence_ops drm_crtc_fence_ops;
|
||||
|
||||
static struct drm_crtc *fence_to_crtc(struct dma_fence *fence)
|
||||
{
|
||||
BUG_ON(rcu_access_pointer(fence->ops) != &drm_crtc_fence_ops);
|
||||
return container_of(fence->extern_lock, struct drm_crtc, fence_lock);
|
||||
}
|
||||
|
||||
@@ -493,14 +490,23 @@ EXPORT_SYMBOL(__drmm_crtc_alloc_with_planes);
|
||||
* drm_crtc_cleanup - Clean up the core crtc usage
|
||||
* @crtc: CRTC to cleanup
|
||||
*
|
||||
* This function cleans up @crtc and removes it from the DRM mode setting
|
||||
* core. Note that the function does *not* free the crtc structure itself,
|
||||
* this is the responsibility of the caller.
|
||||
* This function cleans up @crtc and removes it from the DRM mode setting core,
|
||||
* after first waiting an RCU grace period to ensure @crtc->dev can safely be
|
||||
* dereferenced by our dma_fence_ops.
|
||||
*
|
||||
* Note that the function does *not* free the crtc structure itself, this is the
|
||||
* responsibility of the caller.
|
||||
*/
|
||||
void drm_crtc_cleanup(struct drm_crtc *crtc)
|
||||
{
|
||||
struct drm_device *dev = crtc->dev;
|
||||
|
||||
/* Ensure our dma_fence_ops remain valid for an RCU grace period after
|
||||
* the fence is signaled. This is necessary because our dma_fence_ops
|
||||
* dereference crtc->dev.
|
||||
*/
|
||||
synchronize_rcu();
|
||||
|
||||
/* Note that the crtc_list is considered to be static; should we
|
||||
* remove the drm_crtc at runtime we would have to decrement all
|
||||
* the indices on the drm_crtc after us in the crtc_list.
|
||||
|
||||
@@ -6194,6 +6194,18 @@ void drm_get_max_frl_rate(int max_frl_rate, u8 *max_lanes, u8 *max_rate_per_lane
|
||||
*max_lanes = 4;
|
||||
*max_rate_per_lane = 12;
|
||||
break;
|
||||
case 7:
|
||||
*max_lanes = 4;
|
||||
*max_rate_per_lane = 16;
|
||||
break;
|
||||
case 8:
|
||||
*max_lanes = 4;
|
||||
*max_rate_per_lane = 20;
|
||||
break;
|
||||
case 9:
|
||||
*max_lanes = 4;
|
||||
*max_rate_per_lane = 24;
|
||||
break;
|
||||
case 0:
|
||||
default:
|
||||
*max_lanes = 0;
|
||||
|
||||
@@ -66,7 +66,7 @@ static int drm_panic_type_set(const char *val, const struct kernel_param *kp)
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(drm_panic_type_map); i++) {
|
||||
if (!strcmp(val, drm_panic_type_map[i])) {
|
||||
if (sysfs_streq(val, drm_panic_type_map[i])) {
|
||||
drm_panic_type = i;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -168,6 +168,17 @@ u16 etnaviv_buffer_config_pta(struct etnaviv_gpu *gpu, unsigned short id)
|
||||
return buffer->user_size / 8;
|
||||
}
|
||||
|
||||
static void etnaviv_cmd_flush_ts(struct etnaviv_cmdbuf *buffer, bool has_blt)
|
||||
{
|
||||
CMD_LOAD_STATE(buffer, VIVS_TS_FLUSH_CACHE, VIVS_TS_FLUSH_CACHE_FLUSH);
|
||||
|
||||
if (has_blt) {
|
||||
CMD_LOAD_STATE(buffer, VIVS_BLT_ENABLE, 0x1);
|
||||
CMD_LOAD_STATE(buffer, VIVS_BLT_SET_COMMAND, 0x1);
|
||||
CMD_LOAD_STATE(buffer, VIVS_BLT_ENABLE, 0x0);
|
||||
}
|
||||
}
|
||||
|
||||
void etnaviv_buffer_end(struct etnaviv_gpu *gpu)
|
||||
{
|
||||
struct etnaviv_cmdbuf *buffer = &gpu->buffer;
|
||||
@@ -191,7 +202,7 @@ void etnaviv_buffer_end(struct etnaviv_gpu *gpu)
|
||||
unsigned int dwords = 7;
|
||||
|
||||
if (has_blt)
|
||||
dwords += 10;
|
||||
dwords += 11;
|
||||
|
||||
link_target = etnaviv_buffer_reserve(gpu, buffer, dwords);
|
||||
|
||||
@@ -204,16 +215,8 @@ void etnaviv_buffer_end(struct etnaviv_gpu *gpu)
|
||||
CMD_LOAD_STATE(buffer, VIVS_BLT_ENABLE, 0x0);
|
||||
}
|
||||
CMD_LOAD_STATE(buffer, VIVS_GL_FLUSH_CACHE, flush);
|
||||
if (gpu->exec_state == ETNA_PIPE_3D) {
|
||||
if (has_blt) {
|
||||
CMD_LOAD_STATE(buffer, VIVS_BLT_ENABLE, 0x1);
|
||||
CMD_LOAD_STATE(buffer, VIVS_BLT_SET_COMMAND, 0x1);
|
||||
CMD_LOAD_STATE(buffer, VIVS_BLT_ENABLE, 0x0);
|
||||
} else {
|
||||
CMD_LOAD_STATE(buffer, VIVS_TS_FLUSH_CACHE,
|
||||
VIVS_TS_FLUSH_CACHE_FLUSH);
|
||||
}
|
||||
}
|
||||
if (gpu->exec_state == ETNA_PIPE_3D)
|
||||
etnaviv_cmd_flush_ts(buffer, has_blt);
|
||||
CMD_SEM(buffer, SYNC_RECIPIENT_FE, SYNC_RECIPIENT_PE);
|
||||
CMD_STALL(buffer, SYNC_RECIPIENT_FE, SYNC_RECIPIENT_PE);
|
||||
if (has_blt) {
|
||||
@@ -400,12 +403,12 @@ void etnaviv_buffer_queue(struct etnaviv_gpu *gpu, u32 exec_state,
|
||||
return_dwords = 7;
|
||||
|
||||
/*
|
||||
* When the BLT engine is present we need 6 more dwords in the return
|
||||
* When the BLT engine is present we need 7 more dwords in the return
|
||||
* target: 3 enable/flush/disable + 4 enable/semaphore stall/disable,
|
||||
* but we don't need the normal TS flush state.
|
||||
* on top of the normal TS flush state.
|
||||
*/
|
||||
if (has_blt)
|
||||
return_dwords += 6;
|
||||
return_dwords += 7;
|
||||
|
||||
return_target = etnaviv_buffer_reserve(gpu, buffer, return_dwords);
|
||||
CMD_LINK(cmdbuf, return_dwords, return_target);
|
||||
@@ -422,14 +425,7 @@ void etnaviv_buffer_queue(struct etnaviv_gpu *gpu, u32 exec_state,
|
||||
VIVS_GL_FLUSH_CACHE_DEPTH |
|
||||
VIVS_GL_FLUSH_CACHE_COLOR |
|
||||
VIVS_GL_FLUSH_CACHE_SHADER_L1);
|
||||
if (has_blt) {
|
||||
CMD_LOAD_STATE(buffer, VIVS_BLT_ENABLE, 0x1);
|
||||
CMD_LOAD_STATE(buffer, VIVS_BLT_SET_COMMAND, 0x1);
|
||||
CMD_LOAD_STATE(buffer, VIVS_BLT_ENABLE, 0x0);
|
||||
} else {
|
||||
CMD_LOAD_STATE(buffer, VIVS_TS_FLUSH_CACHE,
|
||||
VIVS_TS_FLUSH_CACHE_FLUSH);
|
||||
}
|
||||
etnaviv_cmd_flush_ts(buffer, has_blt);
|
||||
}
|
||||
CMD_SEM(buffer, SYNC_RECIPIENT_FE, SYNC_RECIPIENT_PE);
|
||||
CMD_STALL(buffer, SYNC_RECIPIENT_FE, SYNC_RECIPIENT_PE);
|
||||
|
||||
@@ -601,8 +601,10 @@ static void etnaviv_unbind(struct device *dev)
|
||||
|
||||
component_unbind_all(dev, drm);
|
||||
|
||||
etnaviv_cmdbuf_free(priv->flop_reset_data_ppu);
|
||||
kfree(priv->flop_reset_data_ppu);
|
||||
if (priv->flop_reset_data_ppu) {
|
||||
etnaviv_cmdbuf_free(priv->flop_reset_data_ppu);
|
||||
kfree(priv->flop_reset_data_ppu);
|
||||
}
|
||||
|
||||
etnaviv_cmdbuf_suballoc_destroy(priv->cmdbuf_suballoc);
|
||||
|
||||
|
||||
@@ -4629,7 +4629,7 @@ intel_ddi_port_sync_transcoders(const struct intel_crtc_state *ref_crtc_state,
|
||||
* From, xe3lpd onwards we have defeatured this with reference to
|
||||
* Wa_16024710867
|
||||
*/
|
||||
if (!IS_DISPLAY_VER(display, 9, 20))
|
||||
if (!IS_DISPLAY_VER(display, 9, 30))
|
||||
return 0;
|
||||
|
||||
if (!intel_crtc_has_type(ref_crtc_state, INTEL_OUTPUT_DP))
|
||||
|
||||
@@ -1854,15 +1854,22 @@ static void hsw_crtc_disable(struct intel_atomic_state *state,
|
||||
intel_atomic_get_old_crtc_state(state, crtc);
|
||||
struct intel_crtc *pipe_crtc;
|
||||
|
||||
if (crtc->cmtg.enabled && intel_cmtg_is_allowed(old_crtc_state)) {
|
||||
intel_cmtg_set_clk_select(old_crtc_state);
|
||||
intel_cmtg_disable(old_crtc_state);
|
||||
}
|
||||
/*
|
||||
* FIXME collapse everything to one hook.
|
||||
* Need care with mst->ddi interactions.
|
||||
*/
|
||||
intel_encoders_disable(state, crtc);
|
||||
|
||||
/*
|
||||
* Disable CMTG after the encoders are disabled, but before the
|
||||
* transcoder and port PLL are torn down in
|
||||
* intel_encoders_post_disable()/intel_dpll_disable().
|
||||
*/
|
||||
if (crtc->cmtg.enabled && intel_cmtg_is_allowed(old_crtc_state)) {
|
||||
intel_cmtg_set_clk_select(old_crtc_state);
|
||||
intel_cmtg_disable(old_crtc_state);
|
||||
}
|
||||
|
||||
intel_encoders_post_disable(state, crtc);
|
||||
|
||||
intel_dpll_disable(old_crtc_state);
|
||||
@@ -2844,7 +2851,7 @@ void intel_set_transcoder_timings(const struct intel_crtc_state *crtc_state,
|
||||
HSYNC_END(adjusted_mode->crtc_hsync_end - 1));
|
||||
|
||||
if (display->platform.novalake &&
|
||||
IS_DISPLAY_STEP(display, STEP_A0, STEP_C0))
|
||||
IS_DISPLAY_STEP(display, STEP_A0, STEP_B0))
|
||||
crtc_vtotal = 1;
|
||||
|
||||
intel_de_write(display, TRANS_VTOTAL(display, transcoder),
|
||||
@@ -2941,7 +2948,7 @@ void intel_set_transcoder_timings_lrr(const struct intel_crtc_state *crtc_state,
|
||||
* is the transcoder's undelayed vblank.
|
||||
*/
|
||||
if (display->platform.novalake &&
|
||||
IS_DISPLAY_STEP(display, STEP_A0, STEP_C0))
|
||||
IS_DISPLAY_STEP(display, STEP_A0, STEP_B0))
|
||||
crtc_vtotal = 1;
|
||||
|
||||
intel_de_write(display, TRANS_VTOTAL(display, transcoder),
|
||||
|
||||
@@ -1813,7 +1813,10 @@ static void __intel_display_device_info_runtime_init(struct intel_display *displ
|
||||
if (intel_display_wa(display, INTEL_DISPLAY_WA_14011765242))
|
||||
for_each_pipe(display, pipe)
|
||||
display_runtime->num_scalers[pipe] = 0;
|
||||
else if (DISPLAY_VER(display) >= 11) {
|
||||
else if (DISPLAY_VERx100(display) == 3002) {
|
||||
for_each_pipe(display, pipe)
|
||||
display_runtime->num_scalers[pipe] = 1;
|
||||
} else if (DISPLAY_VER(display) >= 11) {
|
||||
for_each_pipe(display, pipe)
|
||||
display_runtime->num_scalers[pipe] = 2;
|
||||
} else if (DISPLAY_VER(display) >= 9) {
|
||||
|
||||
@@ -477,9 +477,9 @@ bool intel_dp_has_joiner(struct intel_dp *intel_dp)
|
||||
!connector->panel.vbt.edp.pipe_joiner_enable)
|
||||
return false;
|
||||
|
||||
return DISPLAY_VER(display) >= 12 ||
|
||||
return ((DISPLAY_VER(display) >= 12 && DISPLAY_VERx100(display) != 3002) ||
|
||||
(DISPLAY_VER(display) == 11 &&
|
||||
encoder->port != PORT_A);
|
||||
encoder->port != PORT_A));
|
||||
}
|
||||
|
||||
static int dg2_max_source_rate(struct intel_dp *intel_dp)
|
||||
|
||||
@@ -41,6 +41,7 @@
|
||||
#include "intel_display_types.h"
|
||||
#include "intel_dp.h"
|
||||
#include "intel_dp_aux_backlight.h"
|
||||
#include "intel_quirks.h"
|
||||
|
||||
/*
|
||||
* DP AUX registers for Intel's proprietary HDR backlight interface. We define
|
||||
@@ -693,11 +694,30 @@ int intel_dp_aux_init_backlight_funcs(struct intel_connector *connector)
|
||||
struct drm_device *dev = connector->base.dev;
|
||||
struct intel_panel *panel = &connector->panel;
|
||||
bool try_intel_interface = false, try_vesa_interface = false;
|
||||
int enable_dpcd_backlight;
|
||||
|
||||
/*
|
||||
* Some devices have a broken VBT in some Panels, but not others,
|
||||
* advertising INTEL_BACKLIGHT_DISPLAY_DDI, but actually failing to use
|
||||
* the Intel interface. Adding a fallback to the Vesa interface gives
|
||||
* these devices a working backlight for both the broken and non broken
|
||||
* panel VBTs.
|
||||
*
|
||||
* This fallback can not be made the general default as this has broken
|
||||
* other devices in the past whose VBT correctly reports
|
||||
* INTEL_BACKLIGHT_DISPLAY_DDI and whose PWM path is the actual
|
||||
* backlight control, but whose DPCD optimistically advertises
|
||||
* DP_EDP_BACKLIGHT_AUX_ENABLE_CAP / _BRIGHTNESS_AUX_SET_CAP.
|
||||
*/
|
||||
enable_dpcd_backlight = display->params.enable_dpcd_backlight;
|
||||
if (enable_dpcd_backlight == INTEL_DP_AUX_BACKLIGHT_AUTO &&
|
||||
intel_has_dpcd_quirk(intel_dp, QUIRK_ENABLE_DPCD_BACKLIGHT))
|
||||
enable_dpcd_backlight = INTEL_DP_AUX_BACKLIGHT_ON;
|
||||
|
||||
/* Check the VBT and user's module parameters to figure out which
|
||||
* interfaces to probe
|
||||
*/
|
||||
switch (display->params.enable_dpcd_backlight) {
|
||||
switch (enable_dpcd_backlight) {
|
||||
case INTEL_DP_AUX_BACKLIGHT_OFF:
|
||||
return -ENODEV;
|
||||
case INTEL_DP_AUX_BACKLIGHT_AUTO:
|
||||
|
||||
@@ -140,6 +140,7 @@ intel_plane_duplicate_state(struct drm_plane *plane)
|
||||
intel_state->dpt_vma = NULL;
|
||||
intel_state->fence_id = -1;
|
||||
intel_state->damage = DRM_RECT_INIT(0, 0, 0, 0);
|
||||
intel_state->psr2_sel_fetch_area = DRM_RECT_INIT(0, 0, 0, 0);
|
||||
|
||||
/* add reference to fb */
|
||||
if (intel_state->hw.fb)
|
||||
@@ -1979,6 +1980,16 @@ static int intel_add_affected_planes(struct intel_atomic_state *state)
|
||||
ret = intel_joiner_add_affected_planes(state, intel_crtc_joined_pipe_mask(crtc_state));
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
/*
|
||||
* Add affected plane here to ensure UV and Y plane linking is
|
||||
* in place if UV plane is added as a part of selective update.
|
||||
*/
|
||||
if (crtc_state->enable_psr2_sel_fetch) {
|
||||
ret = intel_plane_add_affected(state, crtc);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user