[PATCH 139/437] drm: amd: convert to read/write iterators

[Jens Axboe <axboe@kernel.dk>]

Signed-off-by: Jens Axboe <axboe@kernel.dk>
---
 drivers/gpu/drm/amd/amdgpu/amdgpu_aca.c       |   4 +-
 drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c   |  71 +++++++----
 .../drm/amd/amdgpu/amdgpu_fw_attestation.c    |  23 ++--
 drivers/gpu/drm/amd/amdgpu/amdgpu_mca.c       |   4 +-
 drivers/gpu/drm/amd/amdgpu/amdgpu_psp_ta.c    |  18 +--
 drivers/gpu/drm/amd/amdgpu/amdgpu_rap.c       |  14 +--
 drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c       |  34 +++---
 .../gpu/drm/amd/amdgpu/amdgpu_ras_eeprom.c    |  22 ++--
 drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c      |   6 +-
 .../gpu/drm/amd/amdgpu/amdgpu_securedisplay.c |  14 +--
 drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c       |  56 ++++-----
 drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c       |   3 +-
 drivers/gpu/drm/amd/amdkfd/kfd_debugfs.c      |  13 +-
 drivers/gpu/drm/amd/amdkfd/kfd_smi_events.c   |  19 ++-
 .../amd/display/amdgpu_dm/amdgpu_dm_debugfs.c | 111 ++++++++++--------
 drivers/gpu/drm/amd/pm/amdgpu_pm.c            |  11 +-
 drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c     |  17 +--
 17 files changed, 231 insertions(+), 209 deletions(-)

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_aca.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_aca.c
index 493982f94649..8fd471e72ae9 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_aca.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_aca.c
@@ -840,7 +840,7 @@ static int aca_dump_ce_open(struct inode *inode, struct file *file)
 static const struct file_operations aca_ce_dump_debug_fops = {
 	.owner = THIS_MODULE,
 	.open = aca_dump_ce_open,
-	.read = seq_read,
+	.read_iter = seq_read_iter,
 	.llseek = seq_lseek,
 	.release = single_release,
 };
@@ -858,7 +858,7 @@ static int aca_dump_ue_open(struct inode *inode, struct file *file)
 static const struct file_operations aca_ue_dump_debug_fops = {
 	.owner = THIS_MODULE,
 	.open = aca_dump_ue_open,
-	.read = seq_read,
+	.read_iter = seq_read_iter,
 	.llseek = seq_lseek,
 	.release = single_release,
 };
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c
index f5d0fa207a88..f816d92430ff 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_debugfs.c
@@ -194,6 +194,7 @@ static ssize_t amdgpu_debugfs_regs_read(struct file *f, char __user *buf,
 {
 	return amdgpu_debugfs_process_reg_op(true, f, buf, size, pos);
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_regs_read);
 
 /*
  * amdgpu_debugfs_regs_write - Callback for writing MMIO registers
@@ -203,6 +204,7 @@ static ssize_t amdgpu_debugfs_regs_write(struct file *f, const char __user *buf,
 {
 	return amdgpu_debugfs_process_reg_op(false, f, (char __user *)buf, size, pos);
 }
+FOPS_WRITE_ITER_HELPER(amdgpu_debugfs_regs_write);
 
 static int amdgpu_debugfs_regs2_open(struct inode *inode, struct file *file)
 {
@@ -365,11 +367,13 @@ static ssize_t amdgpu_debugfs_regs2_read(struct file *f, char __user *buf, size_
 {
 	return amdgpu_debugfs_regs2_op(f, buf, *pos, size, 0);
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_regs2_read);
 
 static ssize_t amdgpu_debugfs_regs2_write(struct file *f, const char __user *buf, size_t size, loff_t *pos)
 {
 	return amdgpu_debugfs_regs2_op(f, (char __user *)buf, *pos, size, 1);
 }
+FOPS_WRITE_ITER_HELPER(amdgpu_debugfs_regs2_write);
 
 static int amdgpu_debugfs_gprwave_open(struct inode *inode, struct file *file)
 {
@@ -475,6 +479,7 @@ static ssize_t amdgpu_debugfs_gprwave_read(struct file *f, char __user *buf, siz
 	kfree(data);
 	return result;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_gprwave_read);
 
 static long amdgpu_debugfs_gprwave_ioctl(struct file *f, unsigned int cmd, unsigned long data)
 {
@@ -562,6 +567,7 @@ static ssize_t amdgpu_debugfs_regs_pcie_read(struct file *f, char __user *buf,
 	amdgpu_virt_disable_access_debugfs(adev);
 	return r;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_regs_pcie_read);
 
 /**
  * amdgpu_debugfs_regs_pcie_write - Write to a PCIE register
@@ -622,6 +628,7 @@ static ssize_t amdgpu_debugfs_regs_pcie_write(struct file *f, const char __user
 	amdgpu_virt_disable_access_debugfs(adev);
 	return r;
 }
+FOPS_WRITE_ITER_HELPER(amdgpu_debugfs_regs_pcie_write);
 
 /**
  * amdgpu_debugfs_regs_didt_read - Read from a DIDT register
@@ -681,6 +688,7 @@ static ssize_t amdgpu_debugfs_regs_didt_read(struct file *f, char __user *buf,
 	amdgpu_virt_disable_access_debugfs(adev);
 	return r;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_regs_didt_read);
 
 /**
  * amdgpu_debugfs_regs_didt_write - Write to a DIDT register
@@ -741,6 +749,7 @@ static ssize_t amdgpu_debugfs_regs_didt_write(struct file *f, const char __user
 	amdgpu_virt_disable_access_debugfs(adev);
 	return r;
 }
+FOPS_WRITE_ITER_HELPER(amdgpu_debugfs_regs_didt_write);
 
 /**
  * amdgpu_debugfs_regs_smc_read - Read from a SMC register
@@ -800,6 +809,7 @@ static ssize_t amdgpu_debugfs_regs_smc_read(struct file *f, char __user *buf,
 	amdgpu_virt_disable_access_debugfs(adev);
 	return r;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_regs_smc_read);
 
 /**
  * amdgpu_debugfs_regs_smc_write - Write to a SMC register
@@ -860,6 +870,7 @@ static ssize_t amdgpu_debugfs_regs_smc_write(struct file *f, const char __user *
 	amdgpu_virt_disable_access_debugfs(adev);
 	return r;
 }
+FOPS_WRITE_ITER_HELPER(amdgpu_debugfs_regs_smc_write);
 
 /**
  * amdgpu_debugfs_gca_config_read - Read from gfx config data
@@ -957,6 +968,7 @@ static ssize_t amdgpu_debugfs_gca_config_read(struct file *f, char __user *buf,
 	kfree(config);
 	return result;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_gca_config_read);
 
 /**
  * amdgpu_debugfs_sensor_read - Read from the powerplay sensors
@@ -1030,6 +1042,7 @@ static ssize_t amdgpu_debugfs_sensor_read(struct file *f, char __user *buf,
 	amdgpu_virt_disable_access_debugfs(adev);
 	return !r ? outsize : r;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_sensor_read);
 
 /** amdgpu_debugfs_wave_read - Read WAVE STATUS data
  *
@@ -1121,6 +1134,7 @@ static ssize_t amdgpu_debugfs_wave_read(struct file *f, char __user *buf,
 	amdgpu_virt_disable_access_debugfs(adev);
 	return result;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_wave_read);
 
 /** amdgpu_debugfs_gpr_read - Read wave gprs
  *
@@ -1219,6 +1233,7 @@ static ssize_t amdgpu_debugfs_gpr_read(struct file *f, char __user *buf,
 	kfree(data);
 	return r;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_gpr_read);
 
 /**
  * amdgpu_debugfs_gfxoff_residency_read - Read GFXOFF residency
@@ -1271,6 +1286,7 @@ static ssize_t amdgpu_debugfs_gfxoff_residency_read(struct file *f, char __user
 
 	return r;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_gfxoff_residency_read);
 
 /**
  * amdgpu_debugfs_gfxoff_residency_write - Log GFXOFF Residency
@@ -1320,7 +1336,7 @@ static ssize_t amdgpu_debugfs_gfxoff_residency_write(struct file *f, const char
 
 	return r;
 }
-
+FOPS_WRITE_ITER_HELPER(amdgpu_debugfs_gfxoff_residency_write);
 
 /**
  * amdgpu_debugfs_gfxoff_count_read - Read GFXOFF entry count
@@ -1370,6 +1386,7 @@ static ssize_t amdgpu_debugfs_gfxoff_count_read(struct file *f, char __user *buf
 
 	return r;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_gfxoff_count_read);
 
 /**
  * amdgpu_debugfs_gfxoff_write - Enable/disable GFXOFF
@@ -1419,7 +1436,7 @@ static ssize_t amdgpu_debugfs_gfxoff_write(struct file *f, const char __user *bu
 
 	return r;
 }
-
+FOPS_WRITE_ITER_HELPER(amdgpu_debugfs_gfxoff_write);
 
 /**
  * amdgpu_debugfs_gfxoff_read - read gfxoff status
@@ -1465,6 +1482,7 @@ static ssize_t amdgpu_debugfs_gfxoff_read(struct file *f, char __user *buf,
 
 	return r;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_gfxoff_read);
 
 static ssize_t amdgpu_debugfs_gfxoff_status_read(struct file *f, char __user *buf,
 						 size_t size, loff_t *pos)
@@ -1506,12 +1524,13 @@ static ssize_t amdgpu_debugfs_gfxoff_status_read(struct file *f, char __user *bu
 
 	return r;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_gfxoff_status_read);
 
 static const struct file_operations amdgpu_debugfs_regs2_fops = {
 	.owner = THIS_MODULE,
 	.unlocked_ioctl = amdgpu_debugfs_regs2_ioctl,
-	.read = amdgpu_debugfs_regs2_read,
-	.write = amdgpu_debugfs_regs2_write,
+	.read_iter = amdgpu_debugfs_regs2_read_iter,
+	.write_iter = amdgpu_debugfs_regs2_write_iter,
 	.open = amdgpu_debugfs_regs2_open,
 	.release = amdgpu_debugfs_regs2_release,
 	.llseek = default_llseek
@@ -1520,7 +1539,7 @@ static const struct file_operations amdgpu_debugfs_regs2_fops = {
 static const struct file_operations amdgpu_debugfs_gprwave_fops = {
 	.owner = THIS_MODULE,
 	.unlocked_ioctl = amdgpu_debugfs_gprwave_ioctl,
-	.read = amdgpu_debugfs_gprwave_read,
+	.read_iter = amdgpu_debugfs_gprwave_read_iter,
 	.open = amdgpu_debugfs_gprwave_open,
 	.release = amdgpu_debugfs_gprwave_release,
 	.llseek = default_llseek
@@ -1528,75 +1547,75 @@ static const struct file_operations amdgpu_debugfs_gprwave_fops = {
 
 static const struct file_operations amdgpu_debugfs_regs_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_regs_read,
-	.write = amdgpu_debugfs_regs_write,
+	.read_iter = amdgpu_debugfs_regs_read_iter,
+	.write_iter = amdgpu_debugfs_regs_write_iter,
 	.llseek = default_llseek
 };
 static const struct file_operations amdgpu_debugfs_regs_didt_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_regs_didt_read,
-	.write = amdgpu_debugfs_regs_didt_write,
+	.read_iter = amdgpu_debugfs_regs_didt_read_iter,
+	.write_iter = amdgpu_debugfs_regs_didt_write_iter,
 	.llseek = default_llseek
 };
 static const struct file_operations amdgpu_debugfs_regs_pcie_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_regs_pcie_read,
-	.write = amdgpu_debugfs_regs_pcie_write,
+	.read_iter = amdgpu_debugfs_regs_pcie_read_iter,
+	.write_iter = amdgpu_debugfs_regs_pcie_write_iter,
 	.llseek = default_llseek
 };
 static const struct file_operations amdgpu_debugfs_regs_smc_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_regs_smc_read,
-	.write = amdgpu_debugfs_regs_smc_write,
+	.read_iter = amdgpu_debugfs_regs_smc_read_iter,
+	.write_iter = amdgpu_debugfs_regs_smc_write_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations amdgpu_debugfs_gca_config_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_gca_config_read,
+	.read_iter = amdgpu_debugfs_gca_config_read_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations amdgpu_debugfs_sensors_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_sensor_read,
+	.read_iter = amdgpu_debugfs_sensor_read_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations amdgpu_debugfs_wave_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_wave_read,
+	.read_iter = amdgpu_debugfs_wave_read_iter,
 	.llseek = default_llseek
 };
 static const struct file_operations amdgpu_debugfs_gpr_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_gpr_read,
+	.read_iter = amdgpu_debugfs_gpr_read_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations amdgpu_debugfs_gfxoff_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_gfxoff_read,
-	.write = amdgpu_debugfs_gfxoff_write,
+	.read_iter = amdgpu_debugfs_gfxoff_read_iter,
+	.write_iter = amdgpu_debugfs_gfxoff_write_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations amdgpu_debugfs_gfxoff_status_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_gfxoff_status_read,
+	.read_iter = amdgpu_debugfs_gfxoff_status_read_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations amdgpu_debugfs_gfxoff_count_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_gfxoff_count_read,
+	.read_iter = amdgpu_debugfs_gfxoff_count_read_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations amdgpu_debugfs_gfxoff_residency_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_gfxoff_residency_read,
-	.write = amdgpu_debugfs_gfxoff_residency_write,
+	.read_iter = amdgpu_debugfs_gfxoff_residency_read_iter,
+	.write_iter = amdgpu_debugfs_gfxoff_residency_write_iter,
 	.llseek = default_llseek
 };
 
@@ -2058,6 +2077,7 @@ static ssize_t amdgpu_reset_dump_register_list_read(struct file *f,
 
 	return len;
 }
+FOPS_READ_ITER_HELPER(amdgpu_reset_dump_register_list_read);
 
 static ssize_t amdgpu_reset_dump_register_list_write(struct file *f,
 			const char __user *buf, size_t size, loff_t *pos)
@@ -2111,11 +2131,12 @@ static ssize_t amdgpu_reset_dump_register_list_write(struct file *f,
 	kfree(new);
 	return ret;
 }
+FOPS_WRITE_ITER_HELPER(amdgpu_reset_dump_register_list_write);
 
 static const struct file_operations amdgpu_reset_dump_register_list = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_reset_dump_register_list_read,
-	.write = amdgpu_reset_dump_register_list_write,
+	.read_iter = amdgpu_reset_dump_register_list_read_iter,
+	.write_iter = amdgpu_reset_dump_register_list_write_iter,
 	.llseek = default_llseek
 };
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_fw_attestation.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_fw_attestation.c
index 2d4b67175b55..a5edb6de1c10 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_fw_attestation.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_fw_attestation.c
@@ -50,23 +50,22 @@ struct FW_ATT_RECORD {
 	uint32_t AttFwTaId;              /* Ta ID (only in TA Attestation Table) */
 };
 
-static ssize_t amdgpu_fw_attestation_debugfs_read(struct file *f,
-						  char __user *buf,
-						  size_t size,
-						  loff_t *pos)
+static ssize_t amdgpu_fw_attestation_debugfs_read(struct kiocb *iocb,
+						  struct iov_iter *to)
 {
-	struct amdgpu_device *adev = (struct amdgpu_device *)file_inode(f)->i_private;
+	struct amdgpu_device *adev = file_inode(iocb->ki_filp)->i_private;
 	uint64_t records_addr = 0;
 	uint64_t vram_pos = 0;
 	struct FW_ATT_DB_HEADER fw_att_hdr = {0};
 	struct FW_ATT_RECORD fw_att_record = {0};
+	size_t size = iov_iter_count(to);
 
 	if (size < sizeof(struct FW_ATT_RECORD)) {
 		DRM_WARN("FW attestation input buffer not enough memory");
 		return -EINVAL;
 	}
 
-	if ((*pos + sizeof(struct FW_ATT_DB_HEADER)) >= FW_ATTESTATION_MAX_SIZE) {
+	if ((iocb->ki_pos + sizeof(struct FW_ATT_DB_HEADER)) >= FW_ATTESTATION_MAX_SIZE) {
 		DRM_WARN("FW attestation out of bounds");
 		return 0;
 	}
@@ -78,7 +77,7 @@ static ssize_t amdgpu_fw_attestation_debugfs_read(struct file *f,
 
 	vram_pos =  records_addr - adev->gmc.vram_start;
 
-	if (*pos == 0) {
+	if (iocb->ki_pos == 0) {
 		amdgpu_device_vram_access(adev,
 					  vram_pos,
 					  (uint32_t *)&fw_att_hdr,
@@ -94,7 +93,7 @@ static ssize_t amdgpu_fw_attestation_debugfs_read(struct file *f,
 	}
 
 	amdgpu_device_vram_access(adev,
-				  vram_pos + sizeof(struct FW_ATT_DB_HEADER) + *pos,
+				  vram_pos + sizeof(struct FW_ATT_DB_HEADER) + iocb->ki_pos,
 				  (uint32_t *)&fw_att_record,
 				  sizeof(struct FW_ATT_RECORD),
 				  false);
@@ -102,18 +101,16 @@ static ssize_t amdgpu_fw_attestation_debugfs_read(struct file *f,
 	if (fw_att_record.RecordValid != FW_ATTESTATION_RECORD_VALID)
 		return 0;
 
-	if (copy_to_user(buf, (void *)&fw_att_record, sizeof(struct FW_ATT_RECORD)))
+	if (!copy_to_iter_full((void *)&fw_att_record, sizeof(struct FW_ATT_RECORD), to))
 		return -EINVAL;
 
-	*pos += sizeof(struct FW_ATT_RECORD);
-
+	iocb->ki_pos += sizeof(struct FW_ATT_RECORD);
 	return sizeof(struct FW_ATT_RECORD);
 }
 
 static const struct file_operations amdgpu_fw_attestation_debugfs_ops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_fw_attestation_debugfs_read,
-	.write = NULL,
+	.read_iter = amdgpu_fw_attestation_debugfs_read,
 	.llseek = default_llseek
 };
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mca.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_mca.c
index 24ad4b97177b..c6a971a260df 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mca.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mca.c
@@ -480,7 +480,7 @@ static int mca_dump_ce_open(struct inode *inode, struct file *file)
 static const struct file_operations mca_ce_dump_debug_fops = {
 	.owner = THIS_MODULE,
 	.open = mca_dump_ce_open,
-	.read = seq_read,
+	.read_iter = seq_read_iter,
 	.llseek = seq_lseek,
 	.release = single_release,
 };
@@ -498,7 +498,7 @@ static int mca_dump_ue_open(struct inode *inode, struct file *file)
 static const struct file_operations mca_ue_dump_debug_fops = {
 	.owner = THIS_MODULE,
 	.open = mca_dump_ue_open,
-	.read = seq_read,
+	.read_iter = seq_read_iter,
 	.llseek = seq_lseek,
 	.release = single_release,
 };
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_psp_ta.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_psp_ta.c
index ca5c86e5f7cd..f96fde084fc6 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_psp_ta.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_psp_ta.c
@@ -26,12 +26,9 @@
 
 #if defined(CONFIG_DEBUG_FS)
 
-static ssize_t ta_if_load_debugfs_write(struct file *fp, const char *buf,
-					    size_t len, loff_t *off);
-static ssize_t ta_if_unload_debugfs_write(struct file *fp, const char *buf,
-					    size_t len, loff_t *off);
-static ssize_t ta_if_invoke_debugfs_write(struct file *fp, const char *buf,
-					    size_t len, loff_t *off);
+static ssize_t ta_if_load_debugfs_write_iter(struct kiocb *, struct iov_iter *);
+static ssize_t ta_if_unload_debugfs_write_iter(struct kiocb *, struct iov_iter *);
+static ssize_t ta_if_invoke_debugfs_write_iter(struct kiocb *, struct iov_iter *);
 
 static uint32_t get_bin_version(const uint8_t *bin)
 {
@@ -84,19 +81,19 @@ static void set_ta_context_funcs(struct psp_context *psp,
 }
 
 static const struct file_operations ta_load_debugfs_fops = {
-	.write  = ta_if_load_debugfs_write,
+	.write_iter  = ta_if_load_debugfs_write_iter,
 	.llseek = default_llseek,
 	.owner  = THIS_MODULE
 };
 
 static const struct file_operations ta_unload_debugfs_fops = {
-	.write  = ta_if_unload_debugfs_write,
+	.write_iter  = ta_if_unload_debugfs_write_iter,
 	.llseek = default_llseek,
 	.owner  = THIS_MODULE
 };
 
 static const struct file_operations ta_invoke_debugfs_fops = {
-	.write  = ta_if_invoke_debugfs_write,
+	.write_iter  = ta_if_invoke_debugfs_write_iter,
 	.llseek = default_llseek,
 	.owner  = THIS_MODULE
 };
@@ -240,6 +237,7 @@ static ssize_t ta_if_load_debugfs_write(struct file *fp, const char *buf, size_t
 
 	return ret;
 }
+FOPS_WRITE_ITER_HELPER(ta_if_load_debugfs_write);
 
 static ssize_t ta_if_unload_debugfs_write(struct file *fp, const char *buf, size_t len, loff_t *off)
 {
@@ -286,6 +284,7 @@ static ssize_t ta_if_unload_debugfs_write(struct file *fp, const char *buf, size
 
 	return ret;
 }
+FOPS_WRITE_ITER_HELPER(ta_if_unload_debugfs_write);
 
 static ssize_t ta_if_invoke_debugfs_write(struct file *fp, const char *buf, size_t len, loff_t *off)
 {
@@ -370,6 +369,7 @@ static ssize_t ta_if_invoke_debugfs_write(struct file *fp, const char *buf, size
 
 	return ret;
 }
+FOPS_WRITE_ITER_HELPER(ta_if_invoke_debugfs_write);
 
 void amdgpu_ta_if_debugfs_init(struct amdgpu_device *adev)
 {
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_rap.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_rap.c
index 123bcf5c2bb1..b946c94972b2 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_rap.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_rap.c
@@ -40,21 +40,22 @@
  * from header file ta_rap_if.h
  *
  */
-static ssize_t amdgpu_rap_debugfs_write(struct file *f, const char __user *buf,
-		size_t size, loff_t *pos)
+static ssize_t amdgpu_rap_debugfs_write(struct kiocb *iocb,
+					struct iov_iter *from)
 {
-	struct amdgpu_device *adev = (struct amdgpu_device *)file_inode(f)->i_private;
+	struct amdgpu_device *adev = file_inode(iocb->ki_filp)->i_private;
 	struct ta_rap_shared_memory *rap_shared_mem;
 	struct ta_rap_cmd_output_data *rap_cmd_output;
 	struct drm_device *dev = adev_to_drm(adev);
+	size_t size = iov_iter_count(from);
 	uint32_t op;
 	enum ta_rap_status status;
 	int ret;
 
-	if (*pos || size != 2)
+	if (iocb->ki_pos || size != 2)
 		return -EINVAL;
 
-	ret = kstrtouint_from_user(buf, size, *pos, &op);
+	ret = kstrtouint_from_iter(from, size, iocb->ki_pos, &op);
 	if (ret)
 		return ret;
 
@@ -109,8 +110,7 @@ static ssize_t amdgpu_rap_debugfs_write(struct file *f, const char __user *buf,
 
 static const struct file_operations amdgpu_rap_debugfs_ops = {
 	.owner = THIS_MODULE,
-	.read = NULL,
-	.write = amdgpu_rap_debugfs_write,
+	.write_iter = amdgpu_rap_debugfs_write,
 	.llseek = default_llseek
 };
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c
index 8ebab6f22e5a..f8daf833f0c4 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ras.c
@@ -201,13 +201,13 @@ static int amdgpu_reserve_page_direct(struct amdgpu_device *adev, uint64_t addre
 	return 0;
 }
 
-static ssize_t amdgpu_ras_debugfs_read(struct file *f, char __user *buf,
-					size_t size, loff_t *pos)
+static ssize_t amdgpu_ras_debugfs_read(struct kiocb *iocb, struct iov_iter *to)
 {
-	struct ras_manager *obj = (struct ras_manager *)file_inode(f)->i_private;
+	struct ras_manager *obj = file_inode(iocb->ki_filp)->i_private;
 	struct ras_query_if info = {
 		.head = obj->head,
 	};
+	size_t size = iov_iter_count(to);
 	ssize_t s;
 	char val[128];
 
@@ -224,25 +224,23 @@ static ssize_t amdgpu_ras_debugfs_read(struct file *f, char __user *buf,
 	s = snprintf(val, sizeof(val), "%s: %lu\n%s: %lu\n",
 			"ue", info.ue_count,
 			"ce", info.ce_count);
-	if (*pos >= s)
+	if (iocb->ki_pos >= s)
 		return 0;
 
-	s -= *pos;
+	s -= iocb->ki_pos;
 	s = min_t(u64, s, size);
 
 
-	if (copy_to_user(buf, &val[*pos], s))
+	if (!copy_to_iter_full(&val[iocb->ki_pos], s, to))
 		return -EINVAL;
 
-	*pos += s;
-
+	iocb->ki_pos += s;
 	return s;
 }
 
 static const struct file_operations amdgpu_ras_debugfs_ops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_ras_debugfs_read,
-	.write = NULL,
+	.read_iter = amdgpu_ras_debugfs_read,
 	.llseek = default_llseek
 };
 
@@ -541,6 +539,7 @@ static ssize_t amdgpu_ras_debugfs_ctrl_write(struct file *f,
 
 	return size;
 }
+FOPS_WRITE_ITER_HELPER(amdgpu_ras_debugfs_ctrl_write);
 
 /**
  * DOC: AMDGPU RAS debugfs EEPROM table reset interface
@@ -558,12 +557,11 @@ static ssize_t amdgpu_ras_debugfs_ctrl_write(struct file *f,
  * will reset EEPROM table to 0 entries.
  *
  */
-static ssize_t amdgpu_ras_debugfs_eeprom_write(struct file *f,
-					       const char __user *buf,
-					       size_t size, loff_t *pos)
+static ssize_t amdgpu_ras_debugfs_eeprom_write(struct kiocb *iocb,
+					       struct iov_iter *from)
 {
-	struct amdgpu_device *adev =
-		(struct amdgpu_device *)file_inode(f)->i_private;
+	struct amdgpu_device *adev = file_inode(iocb->ki_filp)->i_private;
+	size_t size = iov_iter_count(from);
 	int ret;
 
 	ret = amdgpu_ras_eeprom_reset_table(
@@ -581,15 +579,13 @@ static ssize_t amdgpu_ras_debugfs_eeprom_write(struct file *f,
 
 static const struct file_operations amdgpu_ras_debugfs_ctrl_ops = {
 	.owner = THIS_MODULE,
-	.read = NULL,
-	.write = amdgpu_ras_debugfs_ctrl_write,
+	.write_iter = amdgpu_ras_debugfs_ctrl_write_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations amdgpu_ras_debugfs_eeprom_ops = {
 	.owner = THIS_MODULE,
-	.read = NULL,
-	.write = amdgpu_ras_debugfs_eeprom_write,
+	.write_iter = amdgpu_ras_debugfs_eeprom_write,
 	.llseek = default_llseek
 };
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ras_eeprom.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ras_eeprom.c
index b12808c0c331..4d62691e3804 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ras_eeprom.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ras_eeprom.c
@@ -1001,12 +1001,12 @@ uint32_t amdgpu_ras_eeprom_max_record_count(struct amdgpu_ras_eeprom_control *co
 }
 
 static ssize_t
-amdgpu_ras_debugfs_eeprom_size_read(struct file *f, char __user *buf,
-				    size_t size, loff_t *pos)
+amdgpu_ras_debugfs_eeprom_size_read(struct kiocb *iocb, struct iov_iter *to)
 {
-	struct amdgpu_device *adev = (struct amdgpu_device *)file_inode(f)->i_private;
+	struct amdgpu_device *adev = file_inode(iocb->ki_filp)->i_private;
 	struct amdgpu_ras *ras = amdgpu_ras_get_context(adev);
 	struct amdgpu_ras_eeprom_control *control = ras ? &ras->eeprom_control : NULL;
+	size_t size = iov_iter_count(to);
 	u8 data[50];
 	int res;
 
@@ -1020,24 +1020,22 @@ amdgpu_ras_debugfs_eeprom_size_read(struct file *f, char __user *buf,
 			       RAS_TBL_SIZE_BYTES, control->ras_max_record_count);
 	}
 
-	if (*pos >= res)
+	if (iocb->ki_pos >= res)
 		return 0;
 
-	res -= *pos;
+	res -= iocb->ki_pos;
 	res = min_t(size_t, res, size);
 
-	if (copy_to_user(buf, &data[*pos], res))
+	if (!copy_to_iter_full(&data[iocb->ki_pos], res, to))
 		return -EFAULT;
 
-	*pos += res;
-
+	iocb->ki_pos += res;
 	return res;
 }
 
 const struct file_operations amdgpu_ras_debugfs_eeprom_size_ops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_ras_debugfs_eeprom_size_read,
-	.write = NULL,
+	.read_iter = amdgpu_ras_debugfs_eeprom_size_read,
 	.llseek = default_llseek,
 };
 
@@ -1215,11 +1213,11 @@ amdgpu_ras_debugfs_eeprom_table_read(struct file *f, char __user *buf,
 		return amdgpu_ras_debugfs_table_read(f, buf, size, pos);
 	}
 }
+FOPS_READ_ITER_HELPER(amdgpu_ras_debugfs_eeprom_table_read);
 
 const struct file_operations amdgpu_ras_debugfs_eeprom_table_ops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_ras_debugfs_eeprom_table_read,
-	.write = NULL,
+	.read_iter = amdgpu_ras_debugfs_eeprom_table_read_iter,
 	.llseek = default_llseek,
 };
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c
index 06f0a6534a94..a03bc2765b88 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ring.c
@@ -512,10 +512,11 @@ static ssize_t amdgpu_debugfs_ring_read(struct file *f, char __user *buf,
 
 	return result;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_ring_read);
 
 static const struct file_operations amdgpu_debugfs_ring_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_ring_read,
+	.read_iter = amdgpu_debugfs_ring_read_iter,
 	.llseek = default_llseek
 };
 
@@ -577,10 +578,11 @@ static ssize_t amdgpu_debugfs_mqd_read(struct file *f, char __user *buf,
 	kfree(kbuf);
 	return r;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_mqd_read);
 
 static const struct file_operations amdgpu_debugfs_mqd_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_mqd_read,
+	.read_iter = amdgpu_debugfs_mqd_read_iter,
 	.llseek = default_llseek
 };
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_securedisplay.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_securedisplay.c
index 8ed0e073656f..f7bfa470979f 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_securedisplay.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_securedisplay.c
@@ -88,23 +88,24 @@ void psp_prep_securedisplay_cmd_buf(struct psp_context *psp, struct ta_securedis
 
 #if defined(CONFIG_DEBUG_FS)
 
-static ssize_t amdgpu_securedisplay_debugfs_write(struct file *f, const char __user *buf,
-		size_t size, loff_t *pos)
+static ssize_t amdgpu_securedisplay_debugfs_write(struct kiocb *iocb,
+						  struct iov_iter *from)
 {
-	struct amdgpu_device *adev = (struct amdgpu_device *)file_inode(f)->i_private;
+	struct amdgpu_device *adev = file_inode(iocb->ki_filp)->i_private;
 	struct psp_context *psp = &adev->psp;
 	struct ta_securedisplay_cmd *securedisplay_cmd;
 	struct drm_device *dev = adev_to_drm(adev);
+	size_t size = iov_iter_count(from);
 	uint32_t phy_id;
 	uint32_t op;
 	char str[64];
 	int ret;
 
-	if (*pos || size > sizeof(str) - 1)
+	if (iocb->ki_pos || size > sizeof(str) - 1)
 		return -EINVAL;
 
 	memset(str,  0, sizeof(str));
-	ret = copy_from_user(str, buf, size);
+	ret = !copy_from_iter_full(str, size, from);
 	if (ret)
 		return -EFAULT;
 
@@ -163,8 +164,7 @@ static ssize_t amdgpu_securedisplay_debugfs_write(struct file *f, const char __u
 
 static const struct file_operations amdgpu_securedisplay_debugfs_ops = {
 	.owner = THIS_MODULE,
-	.read = NULL,
-	.write = amdgpu_securedisplay_debugfs_write,
+	.write_iter = amdgpu_securedisplay_debugfs_write,
 	.llseek = default_llseek
 };
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
index fc418e670fda..dd5a73291d85 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
@@ -2311,30 +2311,29 @@ DEFINE_SHOW_ATTRIBUTE(amdgpu_ttm_page_pool);
  *
  * Accesses VRAM via MMIO for debugging purposes.
  */
-static ssize_t amdgpu_ttm_vram_read(struct file *f, char __user *buf,
-				    size_t size, loff_t *pos)
+static ssize_t amdgpu_ttm_vram_read(struct kiocb *iocb, struct iov_iter *to)
 {
-	struct amdgpu_device *adev = file_inode(f)->i_private;
+	struct amdgpu_device *adev = file_inode(iocb->ki_filp)->i_private;
+	size_t size = iov_iter_count(to);
 	ssize_t result = 0;
 
-	if (size & 0x3 || *pos & 0x3)
+	if (size & 0x3 || iocb->ki_pos & 0x3)
 		return -EINVAL;
 
-	if (*pos >= adev->gmc.mc_vram_size)
+	if (iocb->ki_pos >= adev->gmc.mc_vram_size)
 		return -ENXIO;
 
-	size = min(size, (size_t)(adev->gmc.mc_vram_size - *pos));
+	size = min(size, (size_t)(adev->gmc.mc_vram_size - iocb->ki_pos));
 	while (size) {
 		size_t bytes = min(size, AMDGPU_TTM_VRAM_MAX_DW_READ * 4);
 		uint32_t value[AMDGPU_TTM_VRAM_MAX_DW_READ];
 
-		amdgpu_device_vram_access(adev, *pos, value, bytes, false);
-		if (copy_to_user(buf, value, bytes))
+		amdgpu_device_vram_access(adev, iocb->ki_pos, value, bytes, false);
+		if (!copy_to_iter_full(value, bytes, to))
 			return -EFAULT;
 
 		result += bytes;
-		buf += bytes;
-		*pos += bytes;
+		iocb->ki_pos += bytes;
 		size -= bytes;
 	}
 
@@ -2379,11 +2378,12 @@ static ssize_t amdgpu_ttm_vram_write(struct file *f, const char __user *buf,
 
 	return result;
 }
+FOPS_WRITE_ITER_HELPER(amdgpu_ttm_vram_write);
 
 static const struct file_operations amdgpu_ttm_vram_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_ttm_vram_read,
-	.write = amdgpu_ttm_vram_write,
+	.read_iter = amdgpu_ttm_vram_read,
+	.write_iter = amdgpu_ttm_vram_write_iter,
 	.llseek = default_llseek,
 };
 
@@ -2394,10 +2394,10 @@ static const struct file_operations amdgpu_ttm_vram_fops = {
  * GPU and the known addresses are not physical addresses but instead
  * bus addresses (e.g., what you'd put in an IB or ring buffer).
  */
-static ssize_t amdgpu_iomem_read(struct file *f, char __user *buf,
-				 size_t size, loff_t *pos)
+static ssize_t amdgpu_iomem_read(struct kiocb *iocb, struct iov_iter *to)
 {
-	struct amdgpu_device *adev = file_inode(f)->i_private;
+	struct amdgpu_device *adev = file_inode(iocb->ki_filp)->i_private;
+	size_t size = iov_iter_count(to);
 	struct iommu_domain *dom;
 	ssize_t result = 0;
 	int r;
@@ -2406,8 +2406,8 @@ static ssize_t amdgpu_iomem_read(struct file *f, char __user *buf,
 	dom = iommu_get_domain_for_dev(adev->dev);
 
 	while (size) {
-		phys_addr_t addr = *pos & PAGE_MASK;
-		loff_t off = *pos & ~PAGE_MASK;
+		phys_addr_t addr = iocb->ki_pos & PAGE_MASK;
+		loff_t off = iocb->ki_pos & ~PAGE_MASK;
 		size_t bytes = PAGE_SIZE - off;
 		unsigned long pfn;
 		struct page *p;
@@ -2430,13 +2430,13 @@ static ssize_t amdgpu_iomem_read(struct file *f, char __user *buf,
 			return -EPERM;
 
 		ptr = kmap_local_page(p);
-		r = copy_to_user(buf, ptr + off, bytes);
+		r = !copy_to_iter_full(ptr + off, bytes, to);
 		kunmap_local(ptr);
 		if (r)
 			return -EFAULT;
 
 		size -= bytes;
-		*pos += bytes;
+		iocb->ki_pos += bytes;
 		result += bytes;
 	}
 
@@ -2450,10 +2450,10 @@ static ssize_t amdgpu_iomem_read(struct file *f, char __user *buf,
  * GPU and the known addresses are not physical addresses but instead
  * bus addresses (e.g., what you'd put in an IB or ring buffer).
  */
-static ssize_t amdgpu_iomem_write(struct file *f, const char __user *buf,
-				 size_t size, loff_t *pos)
+static ssize_t amdgpu_iomem_write(struct kiocb *iocb, struct iov_iter *from)
 {
-	struct amdgpu_device *adev = file_inode(f)->i_private;
+	struct amdgpu_device *adev = file_inode(iocb->ki_filp)->i_private;
+	size_t size = iov_iter_count(from);
 	struct iommu_domain *dom;
 	ssize_t result = 0;
 	int r;
@@ -2461,8 +2461,8 @@ static ssize_t amdgpu_iomem_write(struct file *f, const char __user *buf,
 	dom = iommu_get_domain_for_dev(adev->dev);
 
 	while (size) {
-		phys_addr_t addr = *pos & PAGE_MASK;
-		loff_t off = *pos & ~PAGE_MASK;
+		phys_addr_t addr = iocb->ki_pos & PAGE_MASK;
+		loff_t off = iocb->ki_pos & ~PAGE_MASK;
 		size_t bytes = PAGE_SIZE - off;
 		unsigned long pfn;
 		struct page *p;
@@ -2481,13 +2481,13 @@ static ssize_t amdgpu_iomem_write(struct file *f, const char __user *buf,
 			return -EPERM;
 
 		ptr = kmap_local_page(p);
-		r = copy_from_user(ptr + off, buf, bytes);
+		r = !copy_from_iter_full(ptr + off, bytes, from);
 		kunmap_local(ptr);
 		if (r)
 			return -EFAULT;
 
 		size -= bytes;
-		*pos += bytes;
+		iocb->ki_pos += bytes;
 		result += bytes;
 	}
 
@@ -2496,8 +2496,8 @@ static ssize_t amdgpu_iomem_write(struct file *f, const char __user *buf,
 
 static const struct file_operations amdgpu_ttm_iomem_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_iomem_read,
-	.write = amdgpu_iomem_write,
+	.read_iter = amdgpu_iomem_read,
+	.write_iter = amdgpu_iomem_write,
 	.llseek = default_llseek
 };
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c
index 9c514a606a2f..e2596f9fe6f0 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vcn.c
@@ -1142,10 +1142,11 @@ static ssize_t amdgpu_debugfs_vcn_fwlog_read(struct file *f, char __user *buf,
 	*pos += read_bytes;
 	return read_bytes;
 }
+FOPS_READ_ITER_HELPER(amdgpu_debugfs_vcn_fwlog_read);
 
 static const struct file_operations amdgpu_debugfs_vcnfwlog_fops = {
 	.owner = THIS_MODULE,
-	.read = amdgpu_debugfs_vcn_fwlog_read,
+	.read_iter = amdgpu_debugfs_vcn_fwlog_read_iter,
 	.llseek = default_llseek
 };
 #endif
diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_debugfs.c b/drivers/gpu/drm/amd/amdkfd/kfd_debugfs.c
index 4a5a0a4e00f2..1f03e7915b99 100644
--- a/drivers/gpu/drm/amd/amdkfd/kfd_debugfs.c
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_debugfs.c
@@ -40,9 +40,10 @@ static int kfd_debugfs_hang_hws_read(struct seq_file *m, void *data)
 	return 0;
 }
 
-static ssize_t kfd_debugfs_hang_hws_write(struct file *file,
-	const char __user *user_buf, size_t size, loff_t *ppos)
+static ssize_t kfd_debugfs_hang_hws_write(struct kiocb *iocb,
+					  struct iov_iter *from)
 {
+	size_t size = iov_iter_count(from);
 	struct kfd_node *dev;
 	char tmp[16];
 	uint32_t gpu_id;
@@ -53,7 +54,7 @@ static ssize_t kfd_debugfs_hang_hws_write(struct file *file,
 		pr_err("Invalid input for gpu id.\n");
 		goto out;
 	}
-	if (copy_from_user(tmp, user_buf, size)) {
+	if (!copy_from_iter_full(tmp, size, from)) {
 		ret = -EFAULT;
 		goto out;
 	}
@@ -75,7 +76,7 @@ static ssize_t kfd_debugfs_hang_hws_write(struct file *file,
 static const struct file_operations kfd_debugfs_fops = {
 	.owner = THIS_MODULE,
 	.open = kfd_debugfs_open,
-	.read = seq_read,
+	.read_iter = seq_read_iter,
 	.llseek = seq_lseek,
 	.release = single_release,
 };
@@ -83,8 +84,8 @@ static const struct file_operations kfd_debugfs_fops = {
 static const struct file_operations kfd_debugfs_hang_hws_fops = {
 	.owner = THIS_MODULE,
 	.open = kfd_debugfs_open,
-	.read = seq_read,
-	.write = kfd_debugfs_hang_hws_write,
+	.read_iter = seq_read_iter,
+	.write_iter = kfd_debugfs_hang_hws_write,
 	.llseek = seq_lseek,
 	.release = single_release,
 };
diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_smi_events.c b/drivers/gpu/drm/amd/amdkfd/kfd_smi_events.c
index 06ac835190f9..04eba7e9dfae 100644
--- a/drivers/gpu/drm/amd/amdkfd/kfd_smi_events.c
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_smi_events.c
@@ -46,9 +46,8 @@ struct kfd_smi_client {
 #define MAX_KFIFO_SIZE	1024
 
 static __poll_t kfd_smi_ev_poll(struct file *, struct poll_table_struct *);
-static ssize_t kfd_smi_ev_read(struct file *, char __user *, size_t, loff_t *);
-static ssize_t kfd_smi_ev_write(struct file *, const char __user *, size_t,
-				loff_t *);
+static ssize_t kfd_smi_ev_read_iter(struct kiocb *, struct iov_iter *);
+static ssize_t kfd_smi_ev_write(struct kiocb *, struct iov_iter *);
 static int kfd_smi_ev_release(struct inode *, struct file *);
 
 static const char kfd_smi_name[] = "kfd_smi_ev";
@@ -56,8 +55,8 @@ static const char kfd_smi_name[] = "kfd_smi_ev";
 static const struct file_operations kfd_smi_ev_fops = {
 	.owner = THIS_MODULE,
 	.poll = kfd_smi_ev_poll,
-	.read = kfd_smi_ev_read,
-	.write = kfd_smi_ev_write,
+	.read_iter = kfd_smi_ev_read_iter,
+	.write_iter = kfd_smi_ev_write,
 	.release = kfd_smi_ev_release
 };
 
@@ -121,16 +120,14 @@ static ssize_t kfd_smi_ev_read(struct file *filep, char __user *user,
 	kfree(buf);
 	return ret;
 }
+FOPS_READ_ITER_HELPER(kfd_smi_ev_read);
 
-static ssize_t kfd_smi_ev_write(struct file *filep, const char __user *user,
-				size_t size, loff_t *offset)
+static ssize_t kfd_smi_ev_write(struct kiocb *iocb, struct iov_iter *from)
 {
-	struct kfd_smi_client *client = filep->private_data;
+	struct kfd_smi_client *client = iocb->ki_filp->private_data;
 	uint64_t events;
 
-	if (!access_ok(user, size) || size < sizeof(events))
-		return -EFAULT;
-	if (copy_from_user(&events, user, sizeof(events)))
+	if (!copy_from_iter_full(&events, sizeof(events), from))
 		return -EFAULT;
 
 	WRITE_ONCE(client->events, events);
diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_debugfs.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_debugfs.c
index eee4945653e2..ee1bd4372074 100644
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_debugfs.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_debugfs.c
@@ -249,6 +249,7 @@ static ssize_t dp_link_settings_read(struct file *f, char __user *buf,
 	kfree(rd_buf);
 	return result;
 }
+FOPS_READ_ITER_HELPER(dp_link_settings_read);
 
 static ssize_t dp_link_settings_write(struct file *f, const char __user *buf,
 				 size_t size, loff_t *pos)
@@ -336,6 +337,7 @@ static ssize_t dp_link_settings_write(struct file *f, const char __user *buf,
 	kfree(wr_buf);
 	return size;
 }
+FOPS_WRITE_ITER_HELPER(dp_link_settings_write);
 
 static bool dp_mst_is_end_device(struct amdgpu_dm_connector *aconnector)
 {
@@ -483,6 +485,7 @@ static ssize_t dp_mst_link_setting(struct file *f, const char __user *buf,
 	kfree(wr_buf);
 	return size;
 }
+FOPS_WRITE_ITER_HELPER(dp_mst_link_setting);
 
 /* function: get current DP PHY settings: voltage swing, pre-emphasis,
  * post-cursor2 (defined by VESA DP specification)
@@ -566,6 +569,7 @@ static ssize_t dp_phy_settings_read(struct file *f, char __user *buf,
 	kfree(rd_buf);
 	return result;
 }
+FOPS_READ_ITER_HELPER(dp_phy_settings_read);
 
 static int dp_lttpr_status_show(struct seq_file *m, void *unused)
 {
@@ -686,6 +690,7 @@ static ssize_t dp_phy_settings_write(struct file *f, const char __user *buf,
 	kfree(wr_buf);
 	return size;
 }
+FOPS_WRITE_ITER_HELPER(dp_phy_settings_write);
 
 /* function description
  *
@@ -892,6 +897,7 @@ static ssize_t dp_phy_test_pattern_debugfs_write(struct file *f, const char __us
 
 	return size;
 }
+FOPS_WRITE_ITER_HELPER(dp_phy_test_pattern_debugfs_write);
 
 /*
  * Returns the DMCUB tracebuffer contents.
@@ -1149,6 +1155,7 @@ static ssize_t dp_dsc_passthrough_set(struct file *f, const char __user *buf,
 	kfree(wr_buf);
 	return 0;
 }
+FOPS_WRITE_ITER_HELPER(dp_dsc_passthrough_set);
 
 /*
  * Returns the HDCP capability of the Display (1.4 for now).
@@ -1270,6 +1277,7 @@ static ssize_t dp_sdp_message_debugfs_write(struct file *f, const char __user *b
 
 	return write_size;
 }
+FOPS_WRITE_ITER_HELPER(dp_sdp_message_debugfs_write);
 
 /* function: Read link's DSC & FEC capabilities
  *
@@ -1456,6 +1464,7 @@ static ssize_t trigger_hotplug(struct file *f, const char __user *buf,
 
 	return size;
 }
+FOPS_WRITE_ITER_HELPER(trigger_hotplug);
 
 /* function: read DSC status on the connector
  *
@@ -1527,6 +1536,7 @@ static ssize_t dp_dsc_clock_en_read(struct file *f, char __user *buf,
 	kfree(rd_buf);
 	return result;
 }
+FOPS_READ_ITER_HELPER(dp_dsc_clock_en_read);
 
 /* function: write force DSC on the connector
  *
@@ -1641,6 +1651,7 @@ static ssize_t dp_dsc_clock_en_write(struct file *f, const char __user *buf,
 	kfree(wr_buf);
 	return size;
 }
+FOPS_WRITE_ITER_HELPER(dp_dsc_clock_en_write);
 
 /* function: read DSC slice width parameter on the connector
  *
@@ -1713,6 +1724,7 @@ static ssize_t dp_dsc_slice_width_read(struct file *f, char __user *buf,
 	kfree(rd_buf);
 	return result;
 }
+FOPS_READ_ITER_HELPER(dp_dsc_slice_width_read);
 
 /* function: write DSC slice width parameter
  *
@@ -1825,6 +1837,7 @@ static ssize_t dp_dsc_slice_width_write(struct file *f, const char __user *buf,
 	kfree(wr_buf);
 	return size;
 }
+FOPS_WRITE_ITER_HELPER(dp_dsc_slice_width_write);
 
 /* function: read DSC slice height parameter on the connector
  *
@@ -1897,6 +1910,7 @@ static ssize_t dp_dsc_slice_height_read(struct file *f, char __user *buf,
 	kfree(rd_buf);
 	return result;
 }
+FOPS_READ_ITER_HELPER(dp_dsc_slice_height_read);
 
 /* function: write DSC slice height parameter
  *
@@ -2009,6 +2023,7 @@ static ssize_t dp_dsc_slice_height_write(struct file *f, const char __user *buf,
 	kfree(wr_buf);
 	return size;
 }
+FOPS_WRITE_ITER_HELPER(dp_dsc_slice_height_write);
 
 /* function: read DSC target rate on the connector in bits per pixel
  *
@@ -2077,6 +2092,7 @@ static ssize_t dp_dsc_bits_per_pixel_read(struct file *f, char __user *buf,
 	kfree(rd_buf);
 	return result;
 }
+FOPS_READ_ITER_HELPER(dp_dsc_bits_per_pixel_read);
 
 /* function: write DSC target rate in bits per pixel
  *
@@ -2181,6 +2197,7 @@ static ssize_t dp_dsc_bits_per_pixel_write(struct file *f, const char __user *bu
 	kfree(wr_buf);
 	return size;
 }
+FOPS_WRITE_ITER_HELPER(dp_dsc_bits_per_pixel_write);
 
 /* function: read DSC picture width parameter on the connector
  *
@@ -2252,6 +2269,7 @@ static ssize_t dp_dsc_pic_width_read(struct file *f, char __user *buf,
 	kfree(rd_buf);
 	return result;
 }
+FOPS_READ_ITER_HELPER(dp_dsc_pic_width_read);
 
 static ssize_t dp_dsc_pic_height_read(struct file *f, char __user *buf,
 				    size_t size, loff_t *pos)
@@ -2308,6 +2326,7 @@ static ssize_t dp_dsc_pic_height_read(struct file *f, char __user *buf,
 	kfree(rd_buf);
 	return result;
 }
+FOPS_READ_ITER_HELPER(dp_dsc_pic_height_read);
 
 /* function: read DSC chunk size parameter on the connector
  *
@@ -2379,6 +2398,7 @@ static ssize_t dp_dsc_chunk_size_read(struct file *f, char __user *buf,
 	kfree(rd_buf);
 	return result;
 }
+FOPS_READ_ITER_HELPER(dp_dsc_chunk_size_read);
 
 /* function: read DSC slice bpg offset on the connector
  *
@@ -2450,7 +2470,7 @@ static ssize_t dp_dsc_slice_bpg_offset_read(struct file *f, char __user *buf,
 	kfree(rd_buf);
 	return result;
 }
-
+FOPS_READ_ITER_HELPER(dp_dsc_slice_bpg_offset_read);
 
 /*
  * function description: Read max_requested_bpc property from the connector
@@ -2511,7 +2531,7 @@ static ssize_t dp_max_bpc_read(struct file *f, char __user *buf,
 	kfree(rd_buf);
 	return result;
 }
-
+FOPS_READ_ITER_HELPER(dp_max_bpc_read);
 
 /*
  * function description: Set max_requested_bpc property on the connector
@@ -2593,6 +2613,7 @@ static ssize_t dp_max_bpc_write(struct file *f, const char __user *buf,
 	kfree(wr_buf);
 	return size;
 }
+FOPS_WRITE_ITER_HELPER(dp_max_bpc_write);
 
 /*
  * Backlight at this moment.  Read only.
@@ -2751,104 +2772,104 @@ DEFINE_SHOW_ATTRIBUTE(is_dpia_link);
 
 static const struct file_operations dp_dsc_clock_en_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.read = dp_dsc_clock_en_read,
-	.write = dp_dsc_clock_en_write,
+	.read_iter = dp_dsc_clock_en_read_iter,
+	.write_iter = dp_dsc_clock_en_write_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_dsc_slice_width_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.read = dp_dsc_slice_width_read,
-	.write = dp_dsc_slice_width_write,
+	.read_iter = dp_dsc_slice_width_read_iter,
+	.write_iter = dp_dsc_slice_width_write_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_dsc_slice_height_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.read = dp_dsc_slice_height_read,
-	.write = dp_dsc_slice_height_write,
+	.read_iter = dp_dsc_slice_height_read_iter,
+	.write_iter = dp_dsc_slice_height_write_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_dsc_bits_per_pixel_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.read = dp_dsc_bits_per_pixel_read,
-	.write = dp_dsc_bits_per_pixel_write,
+	.read_iter = dp_dsc_bits_per_pixel_read_iter,
+	.write_iter = dp_dsc_bits_per_pixel_write_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_dsc_pic_width_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.read = dp_dsc_pic_width_read,
+	.read_iter = dp_dsc_pic_width_read_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_dsc_pic_height_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.read = dp_dsc_pic_height_read,
+	.read_iter = dp_dsc_pic_height_read_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_dsc_chunk_size_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.read = dp_dsc_chunk_size_read,
+	.read_iter = dp_dsc_chunk_size_read_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_dsc_slice_bpg_offset_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.read = dp_dsc_slice_bpg_offset_read,
+	.read_iter = dp_dsc_slice_bpg_offset_read_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations trigger_hotplug_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.write = trigger_hotplug,
+	.write_iter = trigger_hotplug_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_link_settings_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.read = dp_link_settings_read,
-	.write = dp_link_settings_write,
+	.read_iter = dp_link_settings_read_iter,
+	.write_iter = dp_link_settings_write_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_phy_settings_debugfs_fop = {
 	.owner = THIS_MODULE,
-	.read = dp_phy_settings_read,
-	.write = dp_phy_settings_write,
+	.read_iter = dp_phy_settings_read_iter,
+	.write_iter = dp_phy_settings_write_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_phy_test_pattern_fops = {
 	.owner = THIS_MODULE,
-	.write = dp_phy_test_pattern_debugfs_write,
+	.write_iter = dp_phy_test_pattern_debugfs_write_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations sdp_message_fops = {
 	.owner = THIS_MODULE,
-	.write = dp_sdp_message_debugfs_write,
+	.write_iter = dp_sdp_message_debugfs_write_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_max_bpc_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.read = dp_max_bpc_read,
-	.write = dp_max_bpc_write,
+	.read_iter = dp_max_bpc_read_iter,
+	.write_iter = dp_max_bpc_write_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_dsc_disable_passthrough_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.write = dp_dsc_passthrough_set,
+	.write_iter = dp_dsc_passthrough_set_iter,
 	.llseek = default_llseek
 };
 
 static const struct file_operations dp_mst_link_settings_debugfs_fops = {
 	.owner = THIS_MODULE,
-	.write = dp_mst_link_setting,
+	.write_iter = dp_mst_link_setting_iter,
 	.llseek = default_llseek
 };
 
@@ -3275,6 +3296,7 @@ static ssize_t edp_ilr_write(struct file *f, const char __user *buf,
 	kfree(wr_buf);
 	return size;
 }
+FOPS_WRITE_ITER_HELPER(edp_ilr_write);
 
 static int edp_ilr_open(struct inode *inode, struct file *file)
 {
@@ -3284,10 +3306,10 @@ static int edp_ilr_open(struct inode *inode, struct file *file)
 static const struct file_operations edp_ilr_debugfs_fops = {
 	.owner = THIS_MODULE,
 	.open = edp_ilr_open,
-	.read = seq_read,
+	.read_iter = seq_read_iter,
 	.llseek = seq_lseek,
 	.release = single_release,
-	.write = edp_ilr_write
+	.write_iter = edp_ilr_write_iter
 };
 
 void connector_debugfs_init(struct amdgpu_dm_connector *connector)
@@ -3552,18 +3574,15 @@ void crtc_debugfs_init(struct drm_crtc *crtc)
  * Writes DTN log state to the user supplied buffer.
  * Example usage: cat /sys/kernel/debug/dri/0/amdgpu_dm_dtn_log
  */
-static ssize_t dtn_log_read(
-	struct file *f,
-	char __user *buf,
-	size_t size,
-	loff_t *pos)
+static ssize_t dtn_log_read(struct kiocb *iocb, struct iov_iter *to)
 {
-	struct amdgpu_device *adev = file_inode(f)->i_private;
+	struct amdgpu_device *adev = file_inode(iocb->ki_filp)->i_private;
 	struct dc *dc = adev->dm.dc;
 	struct dc_log_buffer_ctx log_ctx = { 0 };
+	size_t size = iov_iter_count(to);
 	ssize_t result = 0;
 
-	if (!buf || !size)
+	if (!size)
 		return -EINVAL;
 
 	if (!dc->hwss.log_hw_state)
@@ -3571,13 +3590,13 @@ static ssize_t dtn_log_read(
 
 	dc->hwss.log_hw_state(dc, &log_ctx);
 
-	if (*pos < log_ctx.pos) {
-		size_t to_copy = log_ctx.pos - *pos;
+	if (iocb->ki_pos < log_ctx.pos) {
+		size_t to_copy = log_ctx.pos - iocb->ki_pos;
 
 		to_copy = min(to_copy, size);
 
-		if (!copy_to_user(buf, log_ctx.buf + *pos, to_copy)) {
-			*pos += to_copy;
+		if (copy_to_iter_full(log_ctx.buf + iocb->ki_pos, to_copy, to)) {
+			iocb->ki_pos += to_copy;
 			result = to_copy;
 		}
 	}
@@ -3591,13 +3610,10 @@ static ssize_t dtn_log_read(
  * Writes DTN log state to dmesg when triggered via a write.
  * Example usage: echo 1 > /sys/kernel/debug/dri/0/amdgpu_dm_dtn_log
  */
-static ssize_t dtn_log_write(
-	struct file *f,
-	const char __user *buf,
-	size_t size,
-	loff_t *pos)
+static ssize_t dtn_log_write(struct kiocb *iocb, struct iov_iter *from)
 {
-	struct amdgpu_device *adev = file_inode(f)->i_private;
+	struct amdgpu_device *adev = file_inode(iocb->ki_filp)->i_private;
+	size_t size = iov_iter_count(from);
 	struct dc *dc = adev->dm.dc;
 
 	/* Write triggers log output via dmesg. */
@@ -3972,18 +3988,19 @@ static ssize_t dcc_en_bits_read(
 	kfree(rd_buf);
 	return result;
 }
+FOPS_READ_ITER_HELPER(dcc_en_bits_read);
 
 void dtn_debugfs_init(struct amdgpu_device *adev)
 {
 	static const struct file_operations dtn_log_fops = {
 		.owner = THIS_MODULE,
-		.read = dtn_log_read,
-		.write = dtn_log_write,
+		.read_iter = dtn_log_read,
+		.write_iter = dtn_log_write,
 		.llseek = default_llseek
 	};
 	static const struct file_operations dcc_en_bits_fops = {
 		.owner = THIS_MODULE,
-		.read = dcc_en_bits_read,
+		.read_iter = dcc_en_bits_read_iter,
 		.llseek = default_llseek
 	};
 
diff --git a/drivers/gpu/drm/amd/pm/amdgpu_pm.c b/drivers/gpu/drm/amd/pm/amdgpu_pm.c
index f09b9d49297e..d78f7b351f7d 100644
--- a/drivers/gpu/drm/amd/pm/amdgpu_pm.c
+++ b/drivers/gpu/drm/amd/pm/amdgpu_pm.c
@@ -4572,10 +4572,9 @@ DEFINE_SHOW_ATTRIBUTE(amdgpu_debugfs_pm_info);
  *
  * Reads debug memory region allocated to PMFW
  */
-static ssize_t amdgpu_pm_prv_buffer_read(struct file *f, char __user *buf,
-					 size_t size, loff_t *pos)
+static ssize_t amdgpu_pm_prv_buffer_read(struct kiocb *iocb, struct iov_iter *to)
 {
-	struct amdgpu_device *adev = file_inode(f)->i_private;
+	struct amdgpu_device *adev = file_inode(iocb->ki_filp)->i_private;
 	size_t smu_prv_buf_size;
 	void *smu_prv_buf;
 	int ret = 0;
@@ -4592,14 +4591,14 @@ static ssize_t amdgpu_pm_prv_buffer_read(struct file *f, char __user *buf,
 	if (!smu_prv_buf || !smu_prv_buf_size)
 		return -EINVAL;
 
-	return simple_read_from_buffer(buf, size, pos, smu_prv_buf,
-				       smu_prv_buf_size);
+	return simple_copy_to_iter(smu_prv_buf, &iocb->ki_pos,
+					smu_prv_buf_size, to);
 }
 
 static const struct file_operations amdgpu_debugfs_pm_prv_buffer_fops = {
 	.owner = THIS_MODULE,
 	.open = simple_open,
-	.read = amdgpu_pm_prv_buffer_read,
+	.read_iter = amdgpu_pm_prv_buffer_read,
 	.llseek = default_llseek,
 };
 
diff --git a/drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c b/drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c
index 246b211b1e85..04332432e57f 100644
--- a/drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c
+++ b/drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c
@@ -3603,20 +3603,13 @@ static int smu_stb_debugfs_open(struct inode *inode, struct file *filp)
 	return r;
 }
 
-static ssize_t smu_stb_debugfs_read(struct file *filp, char __user *buf, size_t size,
-				loff_t *pos)
+static ssize_t smu_stb_debugfs_read(struct kiocb *iocb, struct iov_iter *to)
 {
-	struct amdgpu_device *adev = filp->f_inode->i_private;
+	struct amdgpu_device *adev = iocb->ki_filp->f_inode->i_private;
 	struct smu_context *smu = adev->powerplay.pp_handle;
 
-
-	if (!filp->private_data)
-		return -EINVAL;
-
-	return simple_read_from_buffer(buf,
-				       size,
-				       pos, filp->private_data,
-				       smu->stb_context.stb_buf_size);
+	return simple_copy_to_iter(adev, &iocb->ki_pos,
+				       smu->stb_context.stb_buf_size, to);
 }
 
 static int smu_stb_debugfs_release(struct inode *inode, struct file *filp)
@@ -3637,7 +3630,7 @@ static int smu_stb_debugfs_release(struct inode *inode, struct file *filp)
 static const struct file_operations smu_stb_debugfs_fops = {
 	.owner = THIS_MODULE,
 	.open = smu_stb_debugfs_open,
-	.read = smu_stb_debugfs_read,
+	.read_iter = smu_stb_debugfs_read,
 	.release = smu_stb_debugfs_release,
 	.llseek = default_llseek,
 };
-- 
2.43.0