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:
Linus Torvalds
2026-11-07 10:20:51 -08:00
122 changed files with 1123 additions and 470 deletions
+2
View File
@@ -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
View File
@@ -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
+5 -3
View File
@@ -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);
+4
View File
@@ -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);
}
+5 -1
View File
@@ -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));
+2 -1
View File
@@ -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);
+14 -7
View File
@@ -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) {
+22 -19
View File
@@ -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);
+40 -4
View File
@@ -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)
+5 -2
View File
@@ -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;
+22 -3
View File
@@ -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,
+2 -1
View File
@@ -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);
+5 -1
View File
@@ -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) >
+2 -1
View File
@@ -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))
+1 -3
View File
@@ -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;
}
+1 -1
View File
@@ -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,
+11 -8
View File
@@ -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;
+6 -5
View File
@@ -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);
+3 -2
View File
@@ -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 :
+35 -1
View File
@@ -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);
+2
View File
@@ -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);
+12 -4
View File
@@ -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;
}
+3 -2
View File
@@ -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)
+3 -2
View File
@@ -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)
+3 -2
View File
@@ -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)
+2
View File
@@ -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)
+12 -1
View File
@@ -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);
}
+11 -16
View File
@@ -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,
+12 -16
View File
@@ -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,
+11 -16
View File
@@ -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,
+12 -16
View File
@@ -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,
+11 -16
View File
@@ -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,
+11 -16
View File
@@ -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,
+11 -16
View File
@@ -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,
+11 -17
View File
@@ -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,
+11 -17
View File
@@ -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,
+11 -16
View File
@@ -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,
+3 -1
View File
@@ -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;
+3 -1
View File
@@ -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;
+40 -1
View File
@@ -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);
}
+3 -1
View File
@@ -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;
+3 -1
View File
@@ -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;
+3 -1
View File
@@ -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;
+3 -1
View File
@@ -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
+3 -1
View File
@@ -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;
+5 -1
View File
@@ -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)
+5 -1
View File
@@ -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)
+5 -1
View File
@@ -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)
+5 -1
View File
@@ -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)
+11 -4
View File
@@ -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;
}
+10 -3
View File
@@ -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,
+12 -4
View File
@@ -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;
}
/**
+14 -3
View File
@@ -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,
+13 -2
View File
@@ -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,
+13 -2
View File
@@ -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,
+13 -2
View File
@@ -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,
+13 -2
View File
@@ -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,
+14 -2
View File
@@ -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,
+14 -2
View File
@@ -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);
+5 -1
View File
@@ -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;
}
}
+19 -1
View File
@@ -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)
+11 -6
View File
@@ -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);
+2 -1
View File
@@ -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);
+12 -6
View File
@@ -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.
+12
View File
@@ -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;
+1 -1
View File
@@ -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;
}
+18 -22
View File
@@ -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);
+4 -2
View File
@@ -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);
+1 -1
View File
@@ -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))
+13 -6
View File
@@ -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) {
+2 -2
View File
@@ -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