73 files changed, 426 insertions, 449 deletions

diff --git a/sys/amd64/acpica/acpi_wakeup.c b/sys/amd64/acpica/acpi_wakeup.c
index 1200d20f14c2..ace559236de5 100644
--- a/sys/amd64/acpica/acpi_wakeup.c
+++ b/sys/amd64/acpica/acpi_wakeup.c
@@ -344,8 +344,7 @@ acpi_alloc_wakeup_handler(void **wakeaddr,
 
 	for (i = 0; i < ACPI_WAKEPT_PAGES - (la57 ? 0 : 1); i++) {
 		wakept_m[i] = pmap_page_alloc_below_4g(true);
-		wakept_pages[i] = (void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(
-		    wakept_m[i]));
+		wakept_pages[i] = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(wakept_m[i]));
 	}
 	if (EVENTHANDLER_REGISTER(power_resume, acpi_stop_beep, NULL,
 	    EVENTHANDLER_PRI_LAST) == NULL) {
diff --git a/sys/amd64/amd64/efirt_machdep.c b/sys/amd64/amd64/efirt_machdep.c
index 203b2b264587..17088f69887d 100644
--- a/sys/amd64/amd64/efirt_machdep.c
+++ b/sys/amd64/amd64/efirt_machdep.c
@@ -95,7 +95,7 @@ efi_destroy_1t1_map(void)
  * Map a physical address from EFI runtime space into KVA space.  Returns 0 to
  * indicate a failed mapping so that the caller may handle error.
  */
-vm_offset_t
+void *
 efi_phys_to_kva(vm_paddr_t paddr)
 {
 
@@ -135,7 +135,7 @@ efi_1t1_pte(vm_offset_t va)
 		} else {
 			mphys = *pml5e & PG_FRAME;
 		}
-		pml4e = (pml4_entry_t *)PHYS_TO_DMAP(mphys);
+		pml4e = PHYS_TO_DMAP(mphys);
 		pml4e = &pml4e[pml4_idx];
 	} else {
 		pml4e = &efi_pml4[pml4_idx];
@@ -149,7 +149,7 @@ efi_1t1_pte(vm_offset_t va)
 		mphys = *pml4e & PG_FRAME;
 	}
 
-	pdpe = (pdp_entry_t *)PHYS_TO_DMAP(mphys);
+	pdpe = PHYS_TO_DMAP(mphys);
 	pdp_idx = pmap_pdpe_index(va);
 	pdpe += pdp_idx;
 	if (*pdpe == 0) {
@@ -160,7 +160,7 @@ efi_1t1_pte(vm_offset_t va)
 		mphys = *pdpe & PG_FRAME;
 	}
 
-	pde = (pd_entry_t *)PHYS_TO_DMAP(mphys);
+	pde = PHYS_TO_DMAP(mphys);
 	pd_idx = pmap_pde_index(va);
 	pde += pd_idx;
 	if (*pde == 0) {
@@ -171,7 +171,7 @@ efi_1t1_pte(vm_offset_t va)
 		mphys = *pde & PG_FRAME;
 	}
 
-	pte = (pt_entry_t *)PHYS_TO_DMAP(mphys);
+	pte = PHYS_TO_DMAP(mphys);
 	pte += pmap_pte_index(va);
 	KASSERT(*pte == 0, ("va %#jx *pt %#jx", va, *pte));
 
@@ -197,7 +197,7 @@ efi_create_1t1_map(struct efi_md *map, int ndesc, int descsz)
 	VM_OBJECT_WLOCK(obj_1t1_pt);
 	efi_pmltop_page = efi_1t1_page();
 	VM_OBJECT_WUNLOCK(obj_1t1_pt);
-	pml = (void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(efi_pmltop_page));
+	pml = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(efi_pmltop_page));
 	if (la57) {
 		efi_pml5 = pml;
 		pmap_pinit_pml5(efi_pmltop_page);
diff --git a/sys/amd64/amd64/kexec_support.c b/sys/amd64/amd64/kexec_support.c
index 8189a48e9ae9..e299e9d3661c 100644
--- a/sys/amd64/amd64/kexec_support.c
+++ b/sys/amd64/amd64/kexec_support.c
@@ -88,16 +88,14 @@ kexec_generate_page_tables(pml4_entry_t *root, vm_offset_t start,
 			mpa = VM_PAGE_TO_PHYS(m);
 			root[i] = mpa | PG_RW | PG_V;
 		}
-		pdp_entry_t *pdp =
-			(pdp_entry_t *)(PHYS_TO_DMAP(root[i] & PG_FRAME));
+		pdp_entry_t *pdp = PHYS_TO_DMAP(root[i] & PG_FRAME);
 		for (; j < NPDPEPG && pg < start + size; j++, k = 0, l = 0) {
 			if (pdp[j] == 0) {
 				m = vm_radix_iter_next(pages);
 				mpa = VM_PAGE_TO_PHYS(m);
 				pdp[j] = mpa | PG_RW | PG_V;
 			}
-			pd_entry_t *pde =
-			    (pd_entry_t *)(PHYS_TO_DMAP(pdp[j] & PG_FRAME));
+			pd_entry_t *pde = PHYS_TO_DMAP(pdp[j] & PG_FRAME);
 			for (; k < NPDEPG && pg < start + size; k++, l = 0) {
 				if (pde[k] == 0) {
 					if (!do_pte) {
@@ -118,7 +116,7 @@ kexec_generate_page_tables(pml4_entry_t *root, vm_offset_t start,
 				for (; l < NPTEPG && pg < start + size;
 				    l++, pg += PAGE_SIZE) {
 					pt_entry_t *pte =
-					    (pt_entry_t *)PHYS_TO_DMAP(pde[pmap_pde_index(pg)] & PG_FRAME);
+					    PHYS_TO_DMAP(pde[pmap_pde_index(pg)] & PG_FRAME);
 					pte[pmap_pte_index(pg)] =
 					    pmap_kextract(pg) | PG_RW | PG_V;
 				}
diff --git a/sys/amd64/amd64/machdep.c b/sys/amd64/amd64/machdep.c
index 21217ebdb9df..e338db372df3 100644
--- a/sys/amd64/amd64/machdep.c
+++ b/sys/amd64/amd64/machdep.c
@@ -1132,7 +1132,7 @@ do_next:
 	phys_avail[pa_indx] -= round_page(msgbufsize);
 
 	/* Map the message buffer. */
-	msgbufp = (struct msgbuf *)PHYS_TO_DMAP(phys_avail[pa_indx]);
+	msgbufp = PHYS_TO_DMAP(phys_avail[pa_indx]);
 	TSEXIT();
 }
 
diff --git a/sys/amd64/amd64/mem.c b/sys/amd64/amd64/mem.c
index 851f2df0e6e1..ab1e6cde6cd5 100644
--- a/sys/amd64/amd64/mem.c
+++ b/sys/amd64/amd64/mem.c
@@ -77,10 +77,10 @@ int
 memrw(struct cdev *dev, struct uio *uio, int flags)
 {
 	struct iovec *iov;
-	void *p;
+	void *p, *vd;
 	ssize_t orig_resid;
 	vm_prot_t prot;
-	u_long v, vd;
+	u_long v;
 	u_int c;
 	int error;
 
@@ -145,7 +145,7 @@ memrw(struct cdev *dev, struct uio *uio, int flags)
 		case CDEV_MINOR_MEM:
 			if (v < dmaplimit) {
 				vd = PHYS_TO_DMAP(v);
-				error = uiomove((void *)vd, c, uio);
+				error = uiomove(vd, c, uio);
 				break;
 			}
 			if (v > cpu_getmaxphyaddr()) {
diff --git a/sys/amd64/amd64/minidump_machdep.c b/sys/amd64/amd64/minidump_machdep.c
index 43bf81a991bf..41f713faf149 100644
--- a/sys/amd64/amd64/minidump_machdep.c
+++ b/sys/amd64/amd64/minidump_machdep.c
@@ -193,8 +193,8 @@ cpu_minidumpsys(struct dumperinfo *di, const struct minidumpstate *state)
 		 */
 		pmapsize += PAGE_SIZE;
 		ii = pmap_pml4e_index(va);
-		pml4 = (uint64_t *)PHYS_TO_DMAP(KPML4phys) + ii;
-		pdp = (uint64_t *)PHYS_TO_DMAP(*pml4 & PG_FRAME);
+		pml4 = PHYS_TO_DMAP(KPML4phys);
+		pdp = PHYS_TO_DMAP(pml4[ii] & PG_FRAME);
 		pdpe = atomic_load_64(&pdp[pmap_pdpe_index(va)]);
 		if ((pdpe & PG_V) == 0) {
 			va += NBPDP;
@@ -216,7 +216,7 @@ cpu_minidumpsys(struct dumperinfo *di, const struct minidumpstate *state)
 			continue;
 		}
 
-		pd = (uint64_t *)PHYS_TO_DMAP(pdpe & PG_FRAME);
+		pd = PHYS_TO_DMAP(pdpe & PG_FRAME);
 		for (n = 0; n < NPDEPG; n++, va += NBPDR) {
 			pde = atomic_load_64(&pd[pmap_pde_index(va)]);
 
@@ -240,7 +240,7 @@ cpu_minidumpsys(struct dumperinfo *di, const struct minidumpstate *state)
 			if (vm_phys_is_dumpable(pa))
 				vm_page_dump_add(state->dump_bitset, pa);
 			/* and for each valid page in this 2MB block */
-			pt = (uint64_t *)PHYS_TO_DMAP(pde & PG_FRAME);
+			pt = PHYS_TO_DMAP(pde & PG_FRAME);
 			for (k = 0; k < NPTEPG; k++) {
 				pte = atomic_load_64(&pt[k]);
 				if ((pte & PG_V) == 0)
@@ -325,8 +325,8 @@ cpu_minidumpsys(struct dumperinfo *di, const struct minidumpstate *state)
 	bzero(fakepd, sizeof(fakepd));
 	for (va = kva_layout.km_low; va < kva_end; va += NBPDP) {
 		ii = pmap_pml4e_index(va);
-		pml4 = (uint64_t *)PHYS_TO_DMAP(KPML4phys) + ii;
-		pdp = (uint64_t *)PHYS_TO_DMAP(*pml4 & PG_FRAME);
+		pml4 = PHYS_TO_DMAP(KPML4phys);
+		pdp = PHYS_TO_DMAP(pml4[ii] & PG_FRAME);
 		pdpe = atomic_load_64(&pdp[pmap_pdpe_index(va)]);
 
 		/* We always write a page, even if it is zero */
@@ -360,7 +360,7 @@ cpu_minidumpsys(struct dumperinfo *di, const struct minidumpstate *state)
 
 		pa = pdpe & PG_FRAME;
 		if (PHYS_IN_DMAP(pa) && vm_phys_is_dumpable(pa)) {
-			pd = (uint64_t *)PHYS_TO_DMAP(pa);
+			pd = PHYS_TO_DMAP(pa);
 			error = blk_write(di, (char *)pd, 0, PAGE_SIZE);
 		} else {
 			/* Malformed pa, write the zeroed fakepd. */
diff --git a/sys/amd64/amd64/mp_machdep.c b/sys/amd64/amd64/mp_machdep.c
index eef3c5573e15..172b0b9e544e 100644
--- a/sys/amd64/amd64/mp_machdep.c
+++ b/sys/amd64/amd64/mp_machdep.c
@@ -355,29 +355,29 @@ start_all_aps(void)
 	/* Create a transient 1:1 mapping of low 4G */
 	if (la57) {
 		m_pml4 = pmap_page_alloc_below_4g(true);
-		v_pml4 = (pml4_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m_pml4));
+		v_pml4 = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m_pml4));
 	} else {
 		v_pml4 = &kernel_pmap->pm_pmltop[0];
 	}
 	m_pdp = pmap_page_alloc_below_4g(true);
-	v_pdp = (pdp_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m_pdp));
+	v_pdp = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m_pdp));
 	m_pd[0] = pmap_page_alloc_below_4g(false);
-	v_pd = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m_pd[0]));
+	v_pd = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m_pd[0]));
 	for (i = 0; i < NPDEPG; i++)
 		v_pd[i] = (i << PDRSHIFT) | X86_PG_V | X86_PG_RW | X86_PG_A |
 		    X86_PG_M | PG_PS;
 	m_pd[1] = pmap_page_alloc_below_4g(false);
-	v_pd = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m_pd[1]));
+	v_pd = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m_pd[1]));
 	for (i = 0; i < NPDEPG; i++)
 		v_pd[i] = (NBPDP + (i << PDRSHIFT)) | X86_PG_V | X86_PG_RW |
 		    X86_PG_A | X86_PG_M | PG_PS;
 	m_pd[2] = pmap_page_alloc_below_4g(false);
-	v_pd = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m_pd[2]));
+	v_pd = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m_pd[2]));
 	for (i = 0; i < NPDEPG; i++)
 		v_pd[i] = (2UL * NBPDP + (i << PDRSHIFT)) | X86_PG_V |
 		    X86_PG_RW | X86_PG_A | X86_PG_M | PG_PS;
 	m_pd[3] = pmap_page_alloc_below_4g(false);
-	v_pd = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m_pd[3]));
+	v_pd = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m_pd[3]));
 	for (i = 0; i < NPDEPG; i++)
 		v_pd[i] = (3UL * NBPDP + (i << PDRSHIFT)) | X86_PG_V |
 		    X86_PG_RW | X86_PG_A | X86_PG_M | PG_PS;
@@ -399,7 +399,7 @@ start_all_aps(void)
 	pmap_invalidate_all(kernel_pmap);
 
 	/* copy the AP 1st level boot code */
-	bcopy(mptramp_start, (void *)PHYS_TO_DMAP(boot_address), bootMP_size);
+	bcopy(mptramp_start, PHYS_TO_DMAP(boot_address), bootMP_size);
 	if (bootverbose)
 		printf("AP boot address %#lx\n", boot_address);
 
diff --git a/sys/amd64/amd64/pmap.c b/sys/amd64/amd64/pmap.c
index e5f21d326cfc..b9ecc230495d 100644
--- a/sys/amd64/amd64/pmap.c
+++ b/sys/amd64/amd64/pmap.c
@@ -1340,7 +1340,7 @@ static pv_entry_t pmap_pvh_remove(struct md_page *pvh, pmap_t pmap,
 		    vm_offset_t va);
 
 static void	pmap_abort_ptp(pmap_t pmap, vm_offset_t va, vm_page_t mpte);
-static int pmap_change_props_locked(vm_offset_t va, vm_size_t size,
+static int pmap_change_props_locked(void *addr, vm_size_t size,
     vm_prot_t prot, int mode, int flags);
 static bool	pmap_demote_pde(pmap_t pmap, pd_entry_t *pde, vm_offset_t va);
 static bool	pmap_demote_pde_locked(pmap_t pmap, pd_entry_t *pde,
@@ -1465,7 +1465,7 @@ pmap_pml5e_to_pml4e(pml5_entry_t *pml5e, vm_offset_t va)
 	pml4_entry_t *pml4e;
 
 	/* XXX MPASS(pmap_is_la57(pmap); */
-	pml4e = (pml4_entry_t *)PHYS_TO_DMAP(*pml5e & PG_FRAME);
+	pml4e = PHYS_TO_DMAP(*pml5e & PG_FRAME);
 	return (&pml4e[pmap_pml4e_index(va)]);
 }
 
@@ -1482,7 +1482,7 @@ pmap_pml4e(pmap_t pmap, vm_offset_t va)
 		PG_V = pmap_valid_bit(pmap);
 		if ((*pml5e & PG_V) == 0)
 			return (NULL);
-		pml4e = (pml4_entry_t *)PHYS_TO_DMAP(*pml5e & PG_FRAME);
+		pml4e = PHYS_TO_DMAP(*pml5e & PG_FRAME);
 	} else {
 		pml4e = pmap->pm_pmltop;
 	}
@@ -1502,7 +1502,7 @@ pmap_pml4e_to_pdpe(pml4_entry_t *pml4e, vm_offset_t va)
 {
 	pdp_entry_t *pdpe;
 
-	pdpe = (pdp_entry_t *)PHYS_TO_DMAP(*pml4e & PG_FRAME);
+	pdpe = PHYS_TO_DMAP(*pml4e & PG_FRAME);
 	return (&pdpe[pmap_pdpe_index(va)]);
 }
 
@@ -1528,7 +1528,7 @@ pmap_pdpe_to_pde(pdp_entry_t *pdpe, vm_offset_t va)
 
 	KASSERT((*pdpe & PG_PS) == 0,
 	    ("%s: pdpe %#lx is a leaf", __func__, *pdpe));
-	pde = (pd_entry_t *)PHYS_TO_DMAP(*pdpe & PG_FRAME);
+	pde = PHYS_TO_DMAP(*pdpe & PG_FRAME);
 	return (&pde[pmap_pde_index(va)]);
 }
 
@@ -1556,7 +1556,7 @@ pmap_pde_to_pte(pd_entry_t *pde, vm_offset_t va)
 
 	KASSERT((*pde & PG_PS) == 0,
 	    ("%s: pde %#lx is a leaf", __func__, *pde));
-	pte = (pt_entry_t *)PHYS_TO_DMAP(*pde & PG_FRAME);
+	pte = PHYS_TO_DMAP(*pde & PG_FRAME);
 	return (&pte[pmap_pte_index(va)]);
 }
 
@@ -2136,11 +2136,11 @@ pmap_bootstrap(vm_paddr_t *firstaddr)
 		vtopdem = ((1ul << (NPDEPGSHIFT + NPDPEPGSHIFT +
 		    NPML4EPGSHIFT + NPML5EPGSHIFT)) - 1) << 3;
 		PDmap = (vm_offset_t)P5Dmap;
-		kernel_pmap->pm_pmltop = (void *)PHYS_TO_DMAP(KPML5phys);
+		kernel_pmap->pm_pmltop = PHYS_TO_DMAP(KPML5phys);
 		kernel_pmap->pm_cr3 = KPML5phys;
 		pmap_pt_page_count_adj(kernel_pmap, 1);	/* top-level page */
 	} else {
-		kernel_pml4 = (pml4_entry_t *)PHYS_TO_DMAP(KPML4phys);
+		kernel_pml4 = PHYS_TO_DMAP(KPML4phys);
 		kernel_pmap->pm_pmltop = kernel_pml4;
 		kernel_pmap->pm_cr3 = KPML4phys;
 	}
@@ -2612,7 +2612,7 @@ pmap_init(void)
 			continue;
 		/* Make the direct map consistent */
 		if (ppim->pa < dmaplimit && ppim->pa + ppim->sz <= dmaplimit) {
-			(void)pmap_change_attr((void *)PHYS_TO_DMAP(ppim->pa),
+			(void)pmap_change_attr(PHYS_TO_DMAP(ppim->pa),
 			    ppim->sz, ppim->mode);
 		}
 		if (!bootverbose)
@@ -3664,7 +3664,7 @@ pmap_invalidate_cache_pages(vm_page_t *pages, int count)
 		else if (cpu_vendor_id != CPU_VENDOR_INTEL)
 			mfence();
 		for (i = 0; i < count; i++) {
-			daddr = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pages[i]));
+			daddr = PHYS_TO_DMAP_ADDR(VM_PAGE_TO_PHYS(pages[i]));
 			eva = daddr + PAGE_SIZE;
 			for (; daddr < eva; daddr += cpu_clflush_line_size) {
 				if (useclflushopt)
@@ -3715,8 +3715,8 @@ pmap_flush_cache_phys_range(vm_paddr_t spa, vm_paddr_t epa, vm_memattr_t mattr)
 	    ("pmap_flush_cache_phys_range: epa not page-aligned"));
 
 	if (spa < dmaplimit) {
-		pmap_flush_cache_range(PHYS_TO_DMAP(spa), PHYS_TO_DMAP(MIN(
-		    dmaplimit, epa)));
+		pmap_flush_cache_range(PHYS_TO_DMAP_ADDR(spa),
+		    PHYS_TO_DMAP_ADDR(MIN(dmaplimit, epa)));
 		if (dmaplimit >= epa)
 			return;
 		spa = dmaplimit;
@@ -3926,7 +3926,7 @@ pmap_kremove(vm_offset_t va)
 void *
 pmap_map(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end, int prot)
 {
-	return ((void *)PHYS_TO_DMAP(start));
+	return (PHYS_TO_DMAP(start));
 }
 
 /*
@@ -4233,7 +4233,7 @@ pmap_pinit_pml4(vm_page_t pml4pg)
 	pml4_entry_t *pm_pml4;
 	int i;
 
-	pm_pml4 = (pml4_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pml4pg));
+	pm_pml4 = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pml4pg));
 
 	/* Wire in kernel global address entries. */
 	for (i = 0; i < NKPML4E; i++) {
@@ -4276,7 +4276,7 @@ pmap_pinit_pml5(vm_page_t pml5pg)
 	pml5_entry_t *pm_pml5;
 	int i;
 
-	pm_pml5 = (pml5_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pml5pg));
+	pm_pml5 = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pml5pg));
 	for (i = 0; i < NPML5EPG / 2; i++)
 		pm_pml5[i] = 0;
 	for (; i < NPML5EPG; i++)
@@ -4289,7 +4289,7 @@ pmap_pinit_pml4_pti(vm_page_t pml4pgu)
 	pml4_entry_t *pm_pml4u;
 	int i;
 
-	pm_pml4u = (pml4_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pml4pgu));
+	pm_pml4u = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pml4pgu));
 	for (i = 0; i < NPML4EPG; i++)
 		pm_pml4u[i] = pti_pml4[i];
 }
@@ -4299,7 +4299,7 @@ pmap_pinit_pml5_pti(vm_page_t pml5pgu)
 {
 	pml5_entry_t *pm_pml5u;
 
-	pm_pml5u = (pml5_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pml5pgu));
+	pm_pml5u = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pml5pgu));
 	pagezero(pm_pml5u);
 
 	/*
@@ -4378,7 +4378,7 @@ pmap_pinit_type(pmap_t pmap, enum pmap_type pm_type, int flags)
 	pmap_pt_page_count_pinit(pmap, 1);
 
 	pmltop_phys = VM_PAGE_TO_PHYS(pmltop_pg);
-	pmap->pm_pmltop = (pml5_entry_t *)PHYS_TO_DMAP(pmltop_phys);
+	pmap->pm_pmltop = PHYS_TO_DMAP(pmltop_phys);
 
 	if (pmap_pcid_enabled) {
 		if (pmap->pm_pcidp == NULL)
@@ -4414,7 +4414,7 @@ pmap_pinit_type(pmap_t pmap, enum pmap_type pm_type, int flags)
 			pmltop_pgu = pmap_alloc_pt_page(NULL, 0,
 			    VM_ALLOC_WIRED | VM_ALLOC_WAITOK);
 			pmap_pt_page_count_pinit(pmap, 1);
-			pmap->pm_pmltopu = (pml4_entry_t *)PHYS_TO_DMAP(
+			pmap->pm_pmltopu = PHYS_TO_DMAP(
 			    VM_PAGE_TO_PHYS(pmltop_pgu));
 			if (pmap_is_la57(pmap))
 				pmap_pinit_pml5_pti(pmltop_pgu);
@@ -4489,7 +4489,7 @@ pmap_allocpte_getpml4(pmap_t pmap, struct rwlock **lockp, vm_offset_t va,
 	} else {
 		allocated = false;
 	}
-	pml4 = (pml4_entry_t *)PHYS_TO_DMAP(*pml5 & PG_FRAME);
+	pml4 = PHYS_TO_DMAP(*pml5 & PG_FRAME);
 	pml4 = &pml4[pmap_pml4e_index(va)];
 	if ((*pml4 & PG_V) == 0) {
 		pml4pg = PHYS_TO_VM_PAGE(*pml5 & PG_FRAME);
@@ -4530,7 +4530,7 @@ pmap_allocpte_getpdp(pmap_t pmap, struct rwlock **lockp, vm_offset_t va,
 	} else {
 		allocated = false;
 	}
-	pdp = (pdp_entry_t *)PHYS_TO_DMAP(*pml4 & PG_FRAME);
+	pdp = PHYS_TO_DMAP(*pml4 & PG_FRAME);
 	pdp = &pdp[pmap_pdpe_index(va)];
 	if ((*pdp & PG_V) == 0) {
 		pdppg = PHYS_TO_VM_PAGE(*pml4 & PG_FRAME);
@@ -4683,7 +4683,7 @@ pmap_allocpte_nosleep(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp,
 			pdpg = PHYS_TO_VM_PAGE(*pdp & PG_FRAME);
 			pdpg->ref_count++;
 		}
-		pd = (pd_entry_t *)PHYS_TO_DMAP(*pdp & PG_FRAME);
+		pd = PHYS_TO_DMAP(*pdp & PG_FRAME);
 
 		/* Now we know where the page directory page is */
 		pd = &pd[pmap_pde_index(va)];
@@ -4752,7 +4752,7 @@ retry:
 			else
 				return (NULL);
 		}
-		pde = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pdpg));
+		pde = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pdpg));
 		pde = &pde[pmap_pde_index(va)];
 	} else
 		panic("pmap_alloc_pde: missing page table page for va %#lx",
@@ -4912,24 +4912,24 @@ pmap_kmsan_shadow_map_page_array(vm_paddr_t pdppa, vm_size_t size)
 	npde = size / NBPDR;
 
 	dummypa = vm_phys_early_alloc(-1, PAGE_SIZE);
-	pagezero((void *)PHYS_TO_DMAP(dummypa));
+	pagezero(PHYS_TO_DMAP(dummypa));
 
 	dummypt = vm_phys_early_alloc(-1, PAGE_SIZE);
-	pagezero((void *)PHYS_TO_DMAP(dummypt));
+	pagezero(PHYS_TO_DMAP(dummypt));
 	dummypd = vm_phys_early_alloc(-1, PAGE_SIZE * npdpg);
 	for (i = 0; i < npdpg; i++)
-		pagezero((void *)PHYS_TO_DMAP(dummypd + ptoa(i)));
+		pagezero(PHYS_TO_DMAP(dummypd + ptoa(i)));
 
-	pte = (pt_entry_t *)PHYS_TO_DMAP(dummypt);
+	pte = PHYS_TO_DMAP(dummypt);
 	for (i = 0; i < NPTEPG; i++)
 		pte[i] = (pt_entry_t)(dummypa | X86_PG_V | X86_PG_RW |
 		    X86_PG_A | X86_PG_M | pg_nx);
 
-	pde = (pd_entry_t *)PHYS_TO_DMAP(dummypd);
+	pde = PHYS_TO_DMAP(dummypd);
 	for (i = 0; i < npde; i++)
 		pde[i] = (pd_entry_t)(dummypt | X86_PG_V | X86_PG_RW | pg_nx);
 
-	pdpe = (pdp_entry_t *)PHYS_TO_DMAP(pdppa);
+	pdpe = PHYS_TO_DMAP(pdppa);
 	for (i = 0; i < npdpg; i++)
 		pdpe[i] = (pdp_entry_t)(dummypd + ptoa(i) | X86_PG_V |
 		    X86_PG_RW | pg_nx);
@@ -4977,7 +4977,7 @@ pmap_page_array_startup(long pages)
 		if ((*pdpe & X86_PG_V) == 0) {
 			pa = vm_phys_early_alloc(domain, PAGE_SIZE);
 			dump_add_page(pa);
-			pagezero((void *)PHYS_TO_DMAP(pa));
+			pagezero(PHYS_TO_DMAP(pa));
 			*pdpe = (pdp_entry_t)(pa | X86_PG_V | X86_PG_RW |
 			    X86_PG_A | X86_PG_M);
 		}
@@ -5549,7 +5549,7 @@ retry:
 	PV_STAT(counter_u64_add(pc_chunk_count, 1));
 	PV_STAT(counter_u64_add(pc_chunk_allocs, 1));
 	dump_add_page(m->phys_addr);
-	pc = (void *)PHYS_TO_DMAP(m->phys_addr);
+	pc = PHYS_TO_DMAP(m->phys_addr);
 	pc->pc_pmap = pmap;
 	pc->pc_map[0] = PC_FREEN & ~1ul;	/* preallocated bit 0 */
 	pc->pc_map[1] = PC_FREEN;
@@ -5649,7 +5649,7 @@ retry:
 		PV_STAT(counter_u64_add(pc_chunk_count, 1));
 		PV_STAT(counter_u64_add(pc_chunk_allocs, 1));
 		dump_add_page(m->phys_addr);
-		pc = (void *)PHYS_TO_DMAP(m->phys_addr);
+		pc = PHYS_TO_DMAP(m->phys_addr);
 		pc->pc_pmap = pmap;
 		pc->pc_map[0] = PC_FREEN;
 		pc->pc_map[1] = PC_FREEN;
@@ -6035,7 +6035,7 @@ pmap_demote_pde_mpte(pmap_t pmap, pd_entry_t *pde, vm_offset_t va,
 		}
 	}
 	mptepa = VM_PAGE_TO_PHYS(mpte);
-	firstpte = (pt_entry_t *)PHYS_TO_DMAP(mptepa);
+	firstpte = PHYS_TO_DMAP(mptepa);
 	newpde = mptepa | PG_M | PG_A | (oldpde & PG_U) | PG_RW | PG_V;
 	KASSERT((oldpde & (PG_M | PG_RW)) != PG_RW,
 	    ("pmap_demote_pde: oldpde is missing PG_M"));
@@ -6122,7 +6122,7 @@ pmap_remove_kernel_pde(pmap_t pmap, pd_entry_t *pde, vm_offset_t va)
 	 * contains valid mappings.  Zero it to invalidate those mappings.
 	 */
 	if (vm_page_any_valid(mpte))
-		pagezero((void *)PHYS_TO_DMAP(mptepa));
+		pagezero(PHYS_TO_DMAP(mptepa));
 
 	/*
 	 * Demote the mapping.
@@ -6851,7 +6851,7 @@ pmap_promote_pde(pmap_t pmap, pd_entry_t *pde, vm_offset_t va, vm_page_t mpte,
 	 * ineligible for promotion due to hardware errata, invalid, or does
 	 * not map the first 4KB physical page within a 2MB page.
 	 */
-	firstpte = (pt_entry_t *)PHYS_TO_DMAP(*pde & PG_FRAME);
+	firstpte = PHYS_TO_DMAP(*pde & PG_FRAME);
 	newpde = *firstpte;
 	if (!pmap_allow_2m_x_page(pmap, pmap_pde_ept_executable(pmap, newpde)))
 		return (false);
@@ -7027,7 +7027,7 @@ restart:
 			    NULL, va);
 			if (mp == NULL)
 				goto allocf;
-			pdpe = (pdp_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mp));
+			pdpe = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mp));
 			pdpe = &pdpe[pmap_pdpe_index(va)];
 			origpte = *pdpe;
 			MPASS(origpte == 0);
@@ -7048,7 +7048,7 @@ restart:
 			    NULL, va);
 			if (mp == NULL)
 				goto allocf;
-			pde = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mp));
+			pde = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mp));
 			pde = &pde[pmap_pde_index(va)];
 			origpte = *pde;
 			MPASS(origpte == 0);
@@ -7411,7 +7411,7 @@ pmap_every_pte_zero(vm_paddr_t pa)
 	pt_entry_t *pt_end, *pte;
 
 	KASSERT((pa & PAGE_MASK) == 0, ("pa is misaligned"));
-	pte = (pt_entry_t *)PHYS_TO_DMAP(pa);
+	pte = PHYS_TO_DMAP(pa);
 	for (pt_end = pte + NPTEPG; pte < pt_end; pte++) {
 		if (*pte != 0)
 			return (false);
@@ -7757,7 +7757,7 @@ pmap_enter_quick_locked(pmap_t pmap, vm_offset_t va, vm_page_t m,
 					return (NULL);
 			}
 		}
-		pte = (pt_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mpte));
+		pte = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mpte));
 		pte = &pte[pmap_pte_index(va)];
 	} else {
 		mpte = NULL;
@@ -8172,7 +8172,7 @@ pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr, vm_size_t len,
 		if (va_next > end_addr)
 			va_next = end_addr;
 
-		src_pte = (pt_entry_t *)PHYS_TO_DMAP(srcptepaddr);
+		src_pte = PHYS_TO_DMAP(srcptepaddr);
 		src_pte = &src_pte[pmap_pte_index(addr)];
 		dstmpte = NULL;
 		for (; addr < va_next; addr += PAGE_SIZE, src_pte++) {
@@ -8192,8 +8192,7 @@ pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr, vm_size_t len,
 			} else if ((dstmpte = pmap_allocpte(dst_pmap, addr,
 			    NULL)) == NULL)
 				goto out;
-			dst_pte = (pt_entry_t *)
-			    PHYS_TO_DMAP(VM_PAGE_TO_PHYS(dstmpte));
+			dst_pte = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(dstmpte));
 			dst_pte = &dst_pte[pmap_pte_index(addr)];
 			if (*dst_pte == 0 &&
 			    pmap_try_insert_pv_entry(dst_pmap, addr,
@@ -8256,13 +8255,13 @@ pmap_vmspace_copy(pmap_t dst_pmap, pmap_t src_pmap)
 void
 pmap_zero_page(vm_page_t m)
 {
-	vm_offset_t va;
+	void *va;
 
 #ifdef TSLOG_PAGEZERO
 	TSENTER();
 #endif
 	va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
-	pagezero((void *)va);
+	pagezero(va);
 #ifdef TSLOG_PAGEZERO
 	TSEXIT();
 #endif
@@ -8275,10 +8274,10 @@ pmap_zero_page(vm_page_t m)
 void
 pmap_zero_page_area(vm_page_t m, int off, int size)
 {
-	vm_offset_t va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
+	void *va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
 
 	if (off == 0 && size == PAGE_SIZE)
-		pagezero((void *)va);
+		pagezero(va);
 	else
 		bzero((char *)va + off, size);
 }
@@ -8289,10 +8288,10 @@ pmap_zero_page_area(vm_page_t m, int off, int size)
 void
 pmap_copy_page(vm_page_t msrc, vm_page_t mdst)
 {
-	vm_offset_t src = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(msrc));
-	vm_offset_t dst = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mdst));
+	void *src = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(msrc));
+	void *dst = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mdst));
 
-	pagecopy((void *)src, (void *)dst);
+	pagecopy(src, dst);
 }
 
 int unmapped_buf_allowed = 1;
@@ -8555,8 +8554,7 @@ pmap_remove_pages(pmap_t pmap)
 				if ((tpte & (PG_PS | PG_V)) == PG_V) {
 					superpage = false;
 					ptepde = tpte;
-					pte = (pt_entry_t *)PHYS_TO_DMAP(tpte &
-					    PG_FRAME);
+					pte = PHYS_TO_DMAP(tpte & PG_FRAME);
 					pte = &pte[pmap_pte_index(pv->pv_va)];
 					tpte = *pte;
 				} else {
@@ -9396,7 +9394,8 @@ static void *
 pmap_mapdev_internal(vm_paddr_t pa, vm_size_t size, int mode, int flags)
 {
 	struct pmap_preinit_mapping *ppim;
-	vm_offset_t va, offset;
+	char *va;
+	vm_offset_t offset;
 	vm_size_t tmpsize;
 	int i;
 
@@ -9405,7 +9404,7 @@ pmap_mapdev_internal(vm_paddr_t pa, vm_size_t size, int mode, int flags)
 	pa = trunc_page(pa);
 
 	if (!pmap_initialized) {
-		va = 0;
+		va = NULL;
 		for (i = 0; i < PMAP_PREINIT_MAPPING_COUNT; i++) {
 			ppim = pmap_preinit_mapping + i;
 			if (ppim->va == 0) {
@@ -9414,11 +9413,11 @@ pmap_mapdev_internal(vm_paddr_t pa, vm_size_t size, int mode, int flags)
 				ppim->mode = mode;
 				ppim->va = virtual_avail;
 				virtual_avail += size;
-				va = ppim->va;
+				va = (void *)ppim->va;
 				break;
 			}
 		}
-		if (va == 0)
+		if (va == NULL)
 			panic("%s: too many preinit mappings", __func__);
 	} else {
 		/*
@@ -9429,7 +9428,7 @@ pmap_mapdev_internal(vm_paddr_t pa, vm_size_t size, int mode, int flags)
 			if (ppim->pa == pa && ppim->sz == size &&
 			    (ppim->mode == mode ||
 			    (flags & MAPDEV_SETATTR) == 0))
-				return ((void *)(ppim->va + offset));
+				return ((char *)ppim->va + offset);
 		}
 		/*
 		 * If the specified range of physical addresses fits within
@@ -9445,18 +9444,20 @@ pmap_mapdev_internal(vm_paddr_t pa, vm_size_t size, int mode, int flags)
 			} else
 				i = 0;
 			if (!i)
-				return ((void *)(va + offset));
+				return (va + offset);
 		}
-		va = (vm_offset_t)kva_alloc(size);
-		if (va == 0)
+		va = kva_alloc(size);
+		if (va == NULL)
 			panic("%s: Couldn't allocate KVA", __func__);
 	}
 	for (tmpsize = 0; tmpsize < size; tmpsize += PAGE_SIZE)
-		pmap_kenter_attr(va + tmpsize, pa + tmpsize, mode);
-	pmap_invalidate_range(kernel_pmap, va, va + tmpsize);
+		pmap_kenter_attr((vm_offset_t)va + tmpsize, pa + tmpsize, mode);
+	pmap_invalidate_range(kernel_pmap, (vm_offset_t)va,
+	    (vm_offset_t)va + tmpsize);
 	if ((flags & MAPDEV_FLUSHCACHE) != 0)
-		pmap_invalidate_cache_range(va, va + tmpsize);
-	return ((void *)(va + offset));
+		pmap_invalidate_cache_range((vm_offset_t)va,
+		    (vm_offset_t)va + tmpsize);
+	return (va + offset);
 }
 
 void *
@@ -9561,7 +9562,7 @@ pmap_demote_pdpe(pmap_t pmap, pdp_entry_t *pdpe, vm_offset_t va, vm_page_t m)
 		pmap_pt_page_count_adj(pmap, 1);
 	}
 	pdpgpa = VM_PAGE_TO_PHYS(pdpg);
-	firstpde = (pd_entry_t *)PHYS_TO_DMAP(pdpgpa);
+	firstpde = PHYS_TO_DMAP(pdpgpa);
 	newpdpe = pdpgpa | PG_M | PG_A | (oldpdpe & PG_U) | PG_RW | PG_V;
 	KASSERT((oldpdpe & PG_A) != 0,
 	    ("pmap_demote_pdpe: oldpdpe is missing PG_A"));
@@ -9610,7 +9611,7 @@ pmap_page_set_memattr(vm_page_t m, vm_memattr_t ma)
 	 * required for data coherence.
 	 */
 	if ((m->flags & PG_FICTITIOUS) == 0 &&
-	    pmap_change_attr((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)), PAGE_SIZE,
+	    pmap_change_attr(PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)), PAGE_SIZE,
 	    m->md.pat_mode))
 		panic("memory attribute change on the direct map failed");
 }
@@ -9660,7 +9661,7 @@ pmap_change_attr(void *va, vm_size_t size, int mode)
 	int error;
 
 	PMAP_LOCK(kernel_pmap);
-	error = pmap_change_props_locked((vm_offset_t)va, size, PROT_NONE, mode,
+	error = pmap_change_props_locked(va, size, PROT_NONE, mode,
 	    MAPDEV_FLUSHCACHE);
 	PMAP_UNLOCK(kernel_pmap);
 	return (error);
@@ -9683,17 +9684,17 @@ pmap_change_prot(void *va, vm_size_t size, vm_prot_t prot)
 		return (EINVAL);
 
 	PMAP_LOCK(kernel_pmap);
-	error = pmap_change_props_locked((vm_offset_t)va, size, prot, -1,
+	error = pmap_change_props_locked(va, size, prot, -1,
 	    MAPDEV_ASSERTVALID);
 	PMAP_UNLOCK(kernel_pmap);
 	return (error);
 }
 
 static int
-pmap_change_props_locked(vm_offset_t va, vm_size_t size, vm_prot_t prot,
+pmap_change_props_locked(void *addr, vm_size_t size, vm_prot_t prot,
     int mode, int flags)
 {
-	vm_offset_t base, offset, tmpva;
+	vm_offset_t base, offset, tmpva, va;
 	vm_paddr_t pa_start, pa_end, pa_end1;
 	pdp_entry_t *pdpe;
 	pd_entry_t *pde, pde_bits, pde_mask;
@@ -9701,6 +9702,7 @@ pmap_change_props_locked(vm_offset_t va, vm_size_t size, vm_prot_t prot,
 	int error;
 	bool changed;
 
+	va = (vm_offset_t)addr;
 	PMAP_LOCK_ASSERT(kernel_pmap, MA_OWNED);
 	base = trunc_page(va);
 	offset = va & PAGE_MASK;
@@ -9956,7 +9958,7 @@ pmap_demote_DMAP(vm_paddr_t base, vm_size_t len, bool invalidate)
 	WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, "pmap_demote_DMAP");
 
 	if (len < NBPDP && base < dmaplimit) {
-		va = PHYS_TO_DMAP(base);
+		va = PHYS_TO_DMAP_ADDR(base);
 		changed = false;
 
 		/*
@@ -10517,7 +10519,7 @@ pmap_map_io_transient(vm_page_t page[], void *vaddr[], int count,
 			vaddr[i] = (void *)addr;
 			needs_mapping = true;
 		} else {
-			vaddr[i] = (void *)PHYS_TO_DMAP(paddr);
+			vaddr[i] = PHYS_TO_DMAP(paddr);
 		}
 	}
 
@@ -10584,7 +10586,7 @@ pmap_quick_enter_page(vm_page_t m)
 
 	paddr = VM_PAGE_TO_PHYS(m);
 	if (paddr < dmaplimit)
-		return ((void *)PHYS_TO_DMAP(paddr));
+		return (PHYS_TO_DMAP(paddr));
 	mtx_lock_spin(&qframe_mtx);
 	KASSERT(*vtopte(qframe) == 0, ("qframe busy"));
 
@@ -10779,9 +10781,8 @@ pmap_large_map(vm_paddr_t spa, vm_size_t len, void **addr,
 
 	/* See if DMAP can serve. */
 	if (spa + len <= dmaplimit) {
-		va = PHYS_TO_DMAP(spa);
-		*addr = (void *)va;
-		return (pmap_change_attr((void *)va, len, mattr));
+		*addr = PHYS_TO_DMAP(spa);
+		return (pmap_change_attr(*addr, len, mattr));
 	}
 
 	/*
@@ -11147,7 +11148,7 @@ pmap_pti_init(void)
 	pti_obj = vm_pager_allocate(OBJT_PHYS, NULL, 0, VM_PROT_ALL, 0, NULL);
 	VM_OBJECT_WLOCK(pti_obj);
 	pml4_pg = pmap_pti_alloc_page();
-	pti_pml4 = (pml4_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pml4_pg));
+	pti_pml4 = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pml4_pg));
 	for (va = kva_layout.km_low; va <= kva_layout.km_high &&
 	    va >= kva_layout.km_low && va > NBPML4; va += NBPML4) {
 		pdpe = pmap_pti_pdpe(va);
@@ -11282,7 +11283,7 @@ pmap_pti_pde(vm_offset_t va)
 		mphys = *pdpe & ~PAGE_MASK;
 	}
 
-	pde = (pd_entry_t *)PHYS_TO_DMAP(mphys);
+	pde = PHYS_TO_DMAP(mphys);
 	pd_idx = pmap_pde_index(va);
 	pde += pd_idx;
 	return (pde);
@@ -11320,7 +11321,7 @@ pmap_pti_pte(vm_offset_t va, bool *unwire_pde)
 		mphys = *pde & ~(PAGE_MASK | pg_nx);
 	}
 
-	pte = (pt_entry_t *)PHYS_TO_DMAP(mphys);
+	pte = PHYS_TO_DMAP(mphys);
 	pte += pmap_pte_index(va);
 
 	return (pte);
@@ -12100,7 +12101,7 @@ restart:
 			continue;
 		}
 		pa = pml4e & PG_FRAME;
-		pdp = (pdp_entry_t *)PHYS_TO_DMAP(pa);
+		pdp = PHYS_TO_DMAP(pa);
 
 		for (j = pmap_pdpe_index(sva); j < NPDPEPG; j++) {
 			pdpe = pdp[j];
@@ -12129,7 +12130,7 @@ restart:
 				sva += NBPDP;
 				goto restart;
 			}
-			pd = (pd_entry_t *)PHYS_TO_DMAP(pa);
+			pd = PHYS_TO_DMAP(pa);
 
 			for (k = pmap_pde_index(sva); k < NPDEPG; k++) {
 				pde = pd[k];
@@ -12158,7 +12159,7 @@ restart:
 					sva += NBPDR;
 					goto restart;
 				}
-				pt = (pt_entry_t *)PHYS_TO_DMAP(pa);
+				pt = PHYS_TO_DMAP(pa);
 
 				for (l = pmap_pte_index(sva); l < NPTEPG; l++,
 				    sva += PAGE_SIZE) {
@@ -12248,7 +12249,7 @@ DB_SHOW_COMMAND(phys2dmap, pmap_phys2dmap)
 
 	if (have_addr) {
 		a = (vm_paddr_t)addr;
-		db_printf("0x%jx\n", (uintmax_t)PHYS_TO_DMAP(a));
+		db_printf("%p\n", PHYS_TO_DMAP(a));
 	} else {
 		db_printf("show phys2dmap addr\n");
 	}
@@ -12276,7 +12277,7 @@ ptpages_show_pml4(vm_page_t pg4, int num_entries, uint64_t PG_V)
 	pd_entry_t *pd;
 	int i4, i3, i2;
 
-	pml4 = (pml4_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pg4));
+	pml4 = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pg4));
 	for (i4 = 0; i4 < num_entries; i4++) {
 		if ((pml4[i4] & PG_V) == 0)
 			continue;
@@ -12286,7 +12287,7 @@ ptpages_show_pml4(vm_page_t pg4, int num_entries, uint64_t PG_V)
 			continue;
 		}
 		ptpages_show_page(3, i4, pg3);
-		pdp = (pdp_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pg3));
+		pdp = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pg3));
 		for (i3 = 0; i3 < NPDPEPG; i3++) {
 			if ((pdp[i3] & PG_V) == 0)
 				continue;
@@ -12296,7 +12297,7 @@ ptpages_show_pml4(vm_page_t pg4, int num_entries, uint64_t PG_V)
 				continue;
 			}
 			ptpages_show_page(2, i3, pg2);
-			pd = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pg2));
+			pd = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pg2));
 			for (i2 = 0; i2 < NPDEPG; i2++) {
 				if ((pd[i2] & PG_V) == 0)
 					continue;
diff --git a/sys/amd64/include/sf_buf.h b/sys/amd64/include/sf_buf.h
index e5e23d47ae91..18f4b67a5a35 100644
--- a/sys/amd64/include/sf_buf.h
+++ b/sys/amd64/include/sf_buf.h
@@ -40,7 +40,7 @@ static inline void *
 sf_buf_kva(struct sf_buf *sf)
 {
 
-	return ((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS((vm_page_t)sf)));
+	return (PHYS_TO_DMAP(VM_PAGE_TO_PHYS((vm_page_t)sf)));
 }
 
 static inline vm_page_t
diff --git a/sys/amd64/include/vmparam.h b/sys/amd64/include/vmparam.h
index ed17922642c0..2914a204b2ef 100644
--- a/sys/amd64/include/vmparam.h
+++ b/sys/amd64/include/vmparam.h
@@ -253,11 +253,12 @@
 	    _va < kva_layout.dmap_low + dmaplimit); })
 
 #define	PMAP_HAS_DMAP	1
-#define	PHYS_TO_DMAP(x)	__extension__ ({				\
+#define	PHYS_TO_DMAP_ADDR(x)	__extension__ ({			\
 	KASSERT(PHYS_IN_DMAP(x),					\
 	    ("physical address %#jx not covered by the DMAP",		\
 	    (uintmax_t)x));						\
 	(x) + kva_layout.dmap_low; })
+#define	PHYS_TO_DMAP(x)		((void *)PHYS_TO_DMAP_ADDR(x))
 
 #define	DMAP_TO_PHYS(x)	__extension__ ({				\
 	uintptr_t _x = (uintptr_t)(x);					\
diff --git a/sys/amd64/vmm/amd/amdvi_hw.c b/sys/amd64/vmm/amd/amdvi_hw.c
index 4dd0339654a9..495ccfeb4cbe 100644
--- a/sys/amd64/vmm/amd/amdvi_hw.c
+++ b/sys/amd64/vmm/amd/amdvi_hw.c
@@ -649,7 +649,7 @@ amdvi_decode_evt(struct amdvi_event *evt)
 	case AMDVI_EVENT_CMD_HW_ERROR:
 		printf("\t[%s EVT]\n", (evt->opcode == AMDVI_EVENT_ILLEGAL_CMD) ?
 		    "ILLEGAL CMD" : "CMD HW ERR");
-		cmd = (struct amdvi_cmd *)PHYS_TO_DMAP(evt->addr);
+		cmd = PHYS_TO_DMAP(evt->addr);
 		printf("\tCMD opcode= 0x%x 0x%x 0x%x 0x%lx\n",
 		    cmd->opcode, cmd->word0, cmd->word1, cmd->addr);
 		break;
@@ -1036,8 +1036,7 @@ amdvi_free_ptp(uint64_t *ptp, int level)
 			continue;
 #endif
 
-		amdvi_free_ptp((uint64_t *)PHYS_TO_DMAP(ptp[i]
-		    & AMDVI_PT_MASK), level - 1);
+		amdvi_free_ptp(PHYS_TO_DMAP(ptp[i] & AMDVI_PT_MASK), level - 1);
 	}
 
 	free(ptp, M_AMDVI);
@@ -1098,7 +1097,7 @@ amdvi_set_pt(uint64_t *pt, int level, vm_paddr_t gpa,
 #endif
 #define PTE2PA(x)	((uint64_t)(x) & AMDVI_PT_MASK)
 		pa = PTE2PA(pt[index]);
-		pt = (uint64_t *)PHYS_TO_DMAP(pa);
+		pt = PHYS_TO_DMAP(pa);
 		shift -= PT_SHIFT;
 		level--;
 	}
diff --git a/sys/amd64/vmm/amd/ivrs_drv.c b/sys/amd64/vmm/amd/ivrs_drv.c
index c75e0fcc2d68..85171a5d51be 100644
--- a/sys/amd64/vmm/amd/ivrs_drv.c
+++ b/sys/amd64/vmm/amd/ivrs_drv.c
@@ -680,7 +680,7 @@ ivhd_attach(device_t dev)
 		break;
 	}
 
-	softc->ctrl = (struct amdvi_ctrl *) PHYS_TO_DMAP(ivhd->BaseAddress);
+	softc->ctrl = PHYS_TO_DMAP(ivhd->BaseAddress);
 	status = ivhd_dev_parse(ivhd, softc);
 	if (status != 0) {
 		device_printf(dev,
diff --git a/sys/amd64/vmm/intel/ept.c b/sys/amd64/vmm/intel/ept.c
index 5432c7da5df7..8b050b29bd1e 100644
--- a/sys/amd64/vmm/intel/ept.c
+++ b/sys/amd64/vmm/intel/ept.c
@@ -143,8 +143,7 @@ ept_dump(uint64_t *ptp, int nlevels)
 		printf("%3d 0x%016lx\n", i, ptpval);
 
 		if (nlevels != 0 && (ptpval & EPT_PG_SUPERPAGE) == 0) {
-			ptpnext = (uint64_t *)
-				  PHYS_TO_DMAP(ptpval & EPT_ADDR_MASK);
+			ptpnext = PHYS_TO_DMAP(ptpval & EPT_ADDR_MASK);
 			ept_dump(ptpnext, nlevels);
 		}
 	}
diff --git a/sys/amd64/vmm/intel/vtd.c b/sys/amd64/vmm/intel/vtd.c
index b56541290a9d..35c1a9fdfdab 100644
--- a/sys/amd64/vmm/intel/vtd.c
+++ b/sys/amd64/vmm/intel/vtd.c
@@ -324,7 +324,7 @@ vtd_init(void)
 		snprintf(envname, sizeof(envname), "vtd.regmap.%d.addr", units);
 		if (getenv_ulong(envname, &mapaddr) == 0)
 			break;
-		vtdmaps[units] = (struct vtdmap *)PHYS_TO_DMAP(mapaddr);
+		vtdmaps[units] = PHYS_TO_DMAP(mapaddr);
 	}
 
 	if (units > 0)
@@ -353,7 +353,7 @@ vtd_init(void)
 
 		drhd = (ACPI_DMAR_HARDWARE_UNIT *)hdr;
 		drhds[units] = drhd;
-		vtdmaps[units] = (struct vtdmap *)PHYS_TO_DMAP(drhd->Address);
+		vtdmaps[units] = PHYS_TO_DMAP(drhd->Address);
 		if (++units >= DRHD_MAX_UNITS)
 			break;
 		remaining -= hdr->Length;
@@ -581,7 +581,7 @@ vtd_update_mapping(void *arg, vm_paddr_t gpa, vm_paddr_t hpa, uint64_t len,
 			ptp[ptpindex] = vtophys(nlp)| VTD_PTE_RD | VTD_PTE_WR;
 		}
 
-		ptp = (uint64_t *)PHYS_TO_DMAP(ptp[ptpindex] & VTD_PTE_ADDR_M);
+		ptp = PHYS_TO_DMAP(ptp[ptpindex] & VTD_PTE_ADDR_M);
 	}
 
 	if ((gpa & ((1UL << ptpshift) - 1)) != 0)
@@ -743,7 +743,7 @@ vtd_free_ptp(uint64_t *ptp, int level)
 				continue;
 			if ((ptp[i] & VTD_PTE_SUPERPAGE) != 0)
 				continue;
-			nlp = (uint64_t *)PHYS_TO_DMAP(ptp[i] & VTD_PTE_ADDR_M);
+			nlp = PHYS_TO_DMAP(ptp[i] & VTD_PTE_ADDR_M);
 			vtd_free_ptp(nlp, level - 1);
 		}
 	}
diff --git a/sys/arm/include/vmparam.h b/sys/arm/include/vmparam.h
index 03145d7e322a..712b9124b795 100644
--- a/sys/arm/include/vmparam.h
+++ b/sys/arm/include/vmparam.h
@@ -183,7 +183,8 @@ extern vm_offset_t vm_max_kernel_address;
 #define	SFBUF_MAP
 
 #define	PMAP_HAS_DMAP	0
-#define	PHYS_TO_DMAP(x)	({ panic("No direct map exists"); 0; })
+#define	PHYS_TO_DMAP_ADDR(x)	({ panic("No direct map exists"); 0; })
+#define	PHYS_TO_DMAP(x)		((void *)PHYS_TO_DMAP_ADDR(x))
 #define	DMAP_TO_PHYS(x)	({ panic("No direct map exists"); 0; })
 
 #define	DEVMAP_MAX_VADDR	ARM_VECTORS_HIGH
diff --git a/sys/arm64/arm64/efirt_machdep.c b/sys/arm64/arm64/efirt_machdep.c
index bde0d4f784dc..c8d23199583e 100644
--- a/sys/arm64/arm64/efirt_machdep.c
+++ b/sys/arm64/arm64/efirt_machdep.c
@@ -112,7 +112,7 @@ efi_1t1_l3(vm_offset_t va)
 		mphys = PTE_TO_PHYS(*l0);
 	}
 
-	l1 = (pd_entry_t *)PHYS_TO_DMAP(mphys);
+	l1 = PHYS_TO_DMAP(mphys);
 	l1_idx = pmap_l1_index(va);
 	l1 += l1_idx;
 	if (*l1 == 0) {
@@ -124,7 +124,7 @@ efi_1t1_l3(vm_offset_t va)
 		mphys = PTE_TO_PHYS(*l1);
 	}
 
-	l2 = (pd_entry_t *)PHYS_TO_DMAP(mphys);
+	l2 = PHYS_TO_DMAP(mphys);
 	l2_idx = pmap_l2_index(va);
 	l2 += l2_idx;
 	if (*l2 == 0) {
@@ -136,7 +136,7 @@ efi_1t1_l3(vm_offset_t va)
 		mphys = PTE_TO_PHYS(*l2);
 	}
 
-	l3 = (pt_entry_t *)PHYS_TO_DMAP(mphys);
+	l3 = PHYS_TO_DMAP(mphys);
 	l3 += pmap_l3_index(va);
 	KASSERT(*l3 == 0, ("%s: Already mapped: va %#jx *pt %#jx", __func__,
 	    va, *l3));
@@ -148,7 +148,7 @@ efi_1t1_l3(vm_offset_t va)
  * Map a physical address from EFI runtime space into KVA space.  Returns 0 to
  * indicate a failed mapping so that the caller may handle error.
  */
-vm_offset_t
+void *
 efi_phys_to_kva(vm_paddr_t paddr)
 {
 	if (PHYS_IN_DMAP(paddr))
@@ -156,7 +156,7 @@ efi_phys_to_kva(vm_paddr_t paddr)
 
 	/* TODO: Map memory not in the DMAP */
 
-	return (0);
+	return (NULL);
 }
 
 /*
@@ -179,7 +179,7 @@ efi_create_1t1_map(struct efi_md *map, int ndesc, int descsz)
 	VM_OBJECT_WLOCK(obj_1t1_pt);
 	efi_l0_page = efi_1t1_page();
 	VM_OBJECT_WUNLOCK(obj_1t1_pt);
-	efi_l0 = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(efi_l0_page));
+	efi_l0 = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(efi_l0_page));
 	efi_ttbr0 = ASID_TO_OPERAND(ASID_RESERVED_FOR_EFI) |
 	    VM_PAGE_TO_PHYS(efi_l0_page);
 
diff --git a/sys/arm64/arm64/gicv3_its.c b/sys/arm64/arm64/gicv3_its.c
index 06491f6ffe05..42f0fdb2697d 100644
--- a/sys/arm64/arm64/gicv3_its.c
+++ b/sys/arm64/arm64/gicv3_its.c
@@ -735,7 +735,6 @@ gicv3_its_conftable_init(struct gicv3_its_softc *sc)
 	device_t gicv3;
 	uint32_t ctlr;
 	vm_paddr_t conf_pa;
-	vm_offset_t conf_va;
 
 	/*
 	 * The PROPBASER is a singleton in our parent. We only set it up the
@@ -767,15 +766,14 @@ gicv3_its_conftable_init(struct gicv3_its_softc *sc)
 		if (!physmem_excluded(conf_pa, LPI_CONFTAB_SIZE))
 			panic("gicv3 PROPBASER needs to reuse %#lx, but not reserved",
 			    conf_pa);
-		conf_va = PHYS_TO_DMAP(conf_pa);
-		if (!pmap_klookup(conf_va, NULL))
+		conf_table = PHYS_TO_DMAP(conf_pa);
+		if (!pmap_klookup((vm_offset_t)conf_table, NULL))
 			panic("Cannot map prior LPI mapping into KVA");
-		conf_table = (void *)conf_va;
 		extra_flags = ITS_FLAGS_LPI_PREALLOC | ITS_FLAGS_LPI_CONF_FLUSH;
 		if (bootverbose)
 			device_printf(sc->dev,
-			    "LPI enabled, conf table using pa %#lx va %lx\n",
-			    conf_pa, conf_va);
+			    "LPI enabled, conf table using pa %#lx va %p\n",
+			    conf_pa, conf_table);
 	} else {
 		/*
 		 * Otherwise just allocate contiguous pages. We'll configure the
@@ -918,7 +916,7 @@ its_init_cpu_lpi(device_t dev, struct gicv3_its_softc *sc)
 		if (!physmem_excluded(tmp, LPI_PENDTAB_SIZE))
 			panic("gicv3 PENDBASER on cpu %d needs to reuse 0x%#lx, but not reserved\n",
 			    cpuid, tmp);
-		sc->sc_pend_base[cpuid] = (void *)PHYS_TO_DMAP(tmp);
+		sc->sc_pend_base[cpuid] = PHYS_TO_DMAP(tmp);
 	}
 
 
diff --git a/sys/arm64/arm64/kexec_support.c b/sys/arm64/arm64/kexec_support.c
index 8b9719c05b67..7ca6bf659d91 100644
--- a/sys/arm64/arm64/kexec_support.c
+++ b/sys/arm64/arm64/kexec_support.c
@@ -140,7 +140,7 @@ kexec_reboot_md(struct kexec_image *image)
 
 	for (int i = 0; i < KEXEC_SEGMENT_MAX; i++) {
 		if (image->segments[i].size > 0)
-			cpu_dcache_inv_range((void *)PHYS_TO_DMAP(image->segments[i].target),
+			cpu_dcache_inv_range(PHYS_TO_DMAP(image->segments[i].target),
 			    image->segments[i].size);
 	}
 	ptr = pmap_kextract((vm_offset_t)kexec_reboot_bottom);
diff --git a/sys/arm64/arm64/machdep.c b/sys/arm64/arm64/machdep.c
index 2ef5a32d7d54..adfb509d4924 100644
--- a/sys/arm64/arm64/machdep.c
+++ b/sys/arm64/arm64/machdep.c
@@ -484,7 +484,7 @@ arm64_get_writable_addr(void *addr, void **out)
 	 * If it is within the DMAP region and is writable use that.
 	 */
 	if (PHYS_IN_DMAP_RANGE(pa)) {
-		addr = (void *)PHYS_TO_DMAP(pa);
+		addr = PHYS_TO_DMAP(pa);
 		if (PAR_SUCCESS(arm64_address_translate_s1e1w(
 		    (vm_offset_t)addr))) {
 			*out = addr;
@@ -534,7 +534,7 @@ efi_early_map(vm_offset_t va)
 	efi_map_foreach_entry(efihdr, efi_early_map_entry, &emd);
 	if (emd.pa == 0)
 		return NULL;
-	return (void *)PHYS_TO_DMAP(emd.pa);
+	return PHYS_TO_DMAP(emd.pa);
 }
 
 
@@ -552,7 +552,7 @@ exclude_efi_memreserve(vm_paddr_t efi_systbl_phys)
 	struct efi_systbl *systbl;
 	efi_guid_t efi_memreserve = LINUX_EFI_MEMRESERVE_TABLE;
 
-	systbl = (struct efi_systbl *)PHYS_TO_DMAP(efi_systbl_phys);
+	systbl = PHYS_TO_DMAP(efi_systbl_phys);
 	if (systbl == NULL) {
 		printf("can't map systbl\n");
 		return;
@@ -588,8 +588,7 @@ exclude_efi_memreserve(vm_paddr_t efi_systbl_phys)
 		 * after a SetVirtualAddressMap(). The list's mr_next pointer
 		 * is also a PA.
 		 */
-		mr = (struct linux_efi_memreserve *)PHYS_TO_DMAP(
-			(vm_offset_t)cfgtbl->ct_data);
+		mr = PHYS_TO_DMAP((vm_offset_t)cfgtbl->ct_data);
 		while (true) {
 			for (int j = 0; j < mr->mr_count; j++) {
 				struct linux_efi_memreserve_entry *mre;
@@ -600,7 +599,7 @@ exclude_efi_memreserve(vm_paddr_t efi_systbl_phys)
 			}
 			if (mr->mr_next == 0)
 				break;
-			mr = (struct linux_efi_memreserve *)PHYS_TO_DMAP(mr->mr_next);
+			mr = PHYS_TO_DMAP(mr->mr_next);
 		};
 	}
 
diff --git a/sys/arm64/arm64/mem.c b/sys/arm64/arm64/mem.c
index 2a998ca1f845..16f8a8071799 100644
--- a/sys/arm64/arm64/mem.c
+++ b/sys/arm64/arm64/mem.c
@@ -104,8 +104,7 @@ memrw(struct cdev *dev, struct uio *uio, int flags)
 		case CDEV_MINOR_MEM:
 			/* If within the DMAP use this to copy from */
 			if (PHYS_IN_DMAP(v)) {
-				v = PHYS_TO_DMAP(v);
-				error = uiomove((void *)v, cnt, uio);
+				error = uiomove(PHYS_TO_DMAP(v), cnt, uio);
 				break;
 			}
 
diff --git a/sys/arm64/arm64/minidump_machdep.c b/sys/arm64/arm64/minidump_machdep.c
index 749c96545506..9ee48e23c604 100644
--- a/sys/arm64/arm64/minidump_machdep.c
+++ b/sys/arm64/arm64/minidump_machdep.c
@@ -125,7 +125,7 @@ blk_write(struct dumperinfo *di, char *ptr, vm_paddr_t pa, size_t sz)
 			ptr += len;
 			sz -= len;
 		} else {
-			dump_va = (void *)PHYS_TO_DMAP(pa);
+			dump_va = PHYS_TO_DMAP(pa);
 			fragsz += len;
 			pa += len;
 			sz -= len;
diff --git a/sys/arm64/arm64/pmap.c b/sys/arm64/arm64/pmap.c
index 8b41c4f48fb8..0ce4435e481d 100644
--- a/sys/arm64/arm64/pmap.c
+++ b/sys/arm64/arm64/pmap.c
@@ -479,7 +479,7 @@ static pv_entry_t pmap_pvh_remove(struct md_page *pvh, pmap_t pmap,
 static void pmap_abort_ptp(pmap_t pmap, vm_offset_t va, vm_page_t mpte);
 static bool pmap_activate_int(struct thread *td, pmap_t pmap);
 static void pmap_alloc_asid(pmap_t pmap);
-static int pmap_change_props_locked(vm_offset_t va, vm_size_t size,
+static int pmap_change_props_locked(void *addr, vm_size_t size,
     vm_prot_t prot, int mode, bool skip_unmapped);
 static bool pmap_copy_l3c(pmap_t pmap, pt_entry_t *l3p, vm_offset_t va,
     pt_entry_t l3e, vm_page_t ml3, struct rwlock **lockp);
@@ -573,7 +573,7 @@ pmap_l0_to_l1(pd_entry_t *l0, vm_offset_t va)
 {
 	pd_entry_t *l1;
 
-	l1 = (pd_entry_t *)PHYS_TO_DMAP(PTE_TO_PHYS(pmap_load(l0)));
+	l1 = PHYS_TO_DMAP(PTE_TO_PHYS(pmap_load(l0)));
 	return (&l1[pmap_l1_index(va)]);
 }
 
@@ -606,7 +606,7 @@ pmap_l1_to_l2(pd_entry_t *l1p, vm_offset_t va)
 	    ("%s: L1 entry %#lx for %#lx is invalid", __func__, l1, va));
 	KASSERT((l1 & ATTR_DESCR_TYPE_MASK) == ATTR_DESCR_TYPE_TABLE,
 	    ("%s: L1 entry %#lx for %#lx is a leaf", __func__, l1, va));
-	l2p = (pd_entry_t *)PHYS_TO_DMAP(PTE_TO_PHYS(l1));
+	l2p = PHYS_TO_DMAP(PTE_TO_PHYS(l1));
 	return (&l2p[pmap_l2_index(va)]);
 }
 
@@ -640,7 +640,7 @@ pmap_l2_to_l3(pd_entry_t *l2p, vm_offset_t va)
 	    ("%s: L2 entry %#lx for %#lx is invalid", __func__, l2, va));
 	KASSERT((l2 & ATTR_DESCR_TYPE_MASK) == ATTR_DESCR_TYPE_TABLE,
 	    ("%s: L2 entry %#lx for %#lx is a leaf", __func__, l2, va));
-	l3p = (pt_entry_t *)PHYS_TO_DMAP(PTE_TO_PHYS(l2));
+	l3p = PHYS_TO_DMAP(PTE_TO_PHYS(l2));
 	return (&l3p[pmap_l3_index(va)]);
 }
 
@@ -1026,7 +1026,7 @@ pmap_bootstrap_l0_table(struct pmap_bootstrap_state *state)
 			if ((l0e & ATTR_DESCR_VALID) != 0) {
 				MPASS((l0e & ATTR_DESCR_MASK) == L0_TABLE);
 				l1_pa = PTE_TO_PHYS(l0e);
-				state->l1 = (pt_entry_t *)PHYS_TO_DMAP(l1_pa);
+				state->l1 = PHYS_TO_DMAP(l1_pa);
 				return;
 			}
 		}
@@ -1074,7 +1074,7 @@ pmap_bootstrap_l1_table(struct pmap_bootstrap_state *state)
 			if ((l1e & ATTR_DESCR_VALID) != 0) {
 				MPASS((l1e & ATTR_DESCR_MASK) == L1_TABLE);
 				l2_pa = PTE_TO_PHYS(l1e);
-				state->l2 = (pt_entry_t *)PHYS_TO_DMAP(l2_pa);
+				state->l2 = PHYS_TO_DMAP(l2_pa);
 				return;
 			}
 		}
@@ -1118,7 +1118,7 @@ pmap_bootstrap_l2_table(struct pmap_bootstrap_state *state)
 			if ((l2e & ATTR_DESCR_VALID) != 0) {
 				MPASS((l2e & ATTR_DESCR_MASK) == L2_TABLE);
 				l3_pa = PTE_TO_PHYS(l2e);
-				state->l3 = (pt_entry_t *)PHYS_TO_DMAP(l3_pa);
+				state->l3 = PHYS_TO_DMAP(l3_pa);
 				return;
 			}
 		}
@@ -1404,7 +1404,7 @@ pmap_bootstrap(void)
 	for (int i = 0; i < physmap_idx; i += 2) {
 		if ((physmap[i + 1] - physmap[i]) > largest_phys_size) {
 			largest_phys_size = physmap[i + 1] - physmap[i];
-			bs_state.freemempos = PHYS_TO_DMAP(physmap[i]);
+			bs_state.freemempos = PHYS_TO_DMAP_ADDR(physmap[i]);
 		}
 	}
 
@@ -1475,7 +1475,7 @@ pmap_bootstrap_allocate_san_l2(vm_paddr_t start_pa, vm_paddr_t end_pa,
 			continue;
 		}
 
-		bzero_early((void *)PHYS_TO_DMAP(pa), L2_SIZE);
+		bzero_early(PHYS_TO_DMAP(pa), L2_SIZE);
 		physmem_exclude_region(pa, L2_SIZE, EXFLAG_NOALLOC);
 		pmap_store(l2, PHYS_TO_PTE(pa) | PMAP_SAN_PTE_BITS | L2_BLOCK);
 	}
@@ -2221,11 +2221,12 @@ pmap_extract_and_hold(pmap_t pmap, vm_offset_t va, vm_prot_t prot)
  * Returns true if the entire kernel virtual address range is mapped
  */
 static bool
-pmap_kmapped_range(vm_offset_t sva, vm_size_t size)
+pmap_kmapped_range(void *va, vm_size_t size)
 {
 	pt_entry_t *pte, tpte;
-	vm_offset_t eva;
+	vm_offset_t eva, sva;
 
+	sva = (vm_offset_t)va;
 	KASSERT(sva >= VM_MIN_KERNEL_ADDRESS,
 	    ("%s: Invalid virtual address: %lx", __func__, sva));
 	MPASS(size != 0);
@@ -2562,7 +2563,7 @@ pmap_kremove_device(vm_offset_t sva, vm_size_t size)
 void *
 pmap_map(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end, int prot)
 {
-	return ((void *)PHYS_TO_DMAP(start));
+	return (PHYS_TO_DMAP(start));
 }
 
 /*
@@ -2773,7 +2774,7 @@ pmap_pinit0(pmap_t pmap)
 	PMAP_LOCK_INIT(pmap);
 	bzero(&pmap->pm_stats, sizeof(pmap->pm_stats));
 	pmap->pm_l0_paddr = READ_SPECIALREG(ttbr0_el1);
-	pmap->pm_l0 = (pd_entry_t *)PHYS_TO_DMAP(pmap->pm_l0_paddr);
+	pmap->pm_l0 = PHYS_TO_DMAP(pmap->pm_l0_paddr);
 	TAILQ_INIT(&pmap->pm_pvchunk);
 	vm_radix_init(&pmap->pm_root);
 	pmap->pm_cookie = COOKIE_FROM(ASID_RESERVED_FOR_PID_0, INT_MIN);
@@ -2797,7 +2798,7 @@ pmap_pinit_stage(pmap_t pmap, enum pmap_stage stage, int levels)
 	m = vm_page_alloc_noobj(VM_ALLOC_WAITOK | VM_ALLOC_WIRED |
 	    VM_ALLOC_ZERO);
 	pmap->pm_l0_paddr = VM_PAGE_TO_PHYS(m);
-	pmap->pm_l0 = (pd_entry_t *)PHYS_TO_DMAP(pmap->pm_l0_paddr);
+	pmap->pm_l0 = PHYS_TO_DMAP(pmap->pm_l0_paddr);
 
 	TAILQ_INIT(&pmap->pm_pvchunk);
 	vm_radix_init(&pmap->pm_root);
@@ -2947,7 +2948,7 @@ _pmap_alloc_l3(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp)
 			l1pg->ref_count++;
 		}
 
-		l1 = (pd_entry_t *)PHYS_TO_DMAP(PTE_TO_PHYS(pmap_load(l0)));
+		l1 = PHYS_TO_DMAP(PTE_TO_PHYS(pmap_load(l0)));
 		l1 = &l1[ptepindex & Ln_ADDR_MASK];
 		KASSERT((pmap_load(l1) & ATTR_DESCR_VALID) == 0,
 		    ("%s: L1 entry %#lx is valid", __func__, pmap_load(l1)));
@@ -2971,10 +2972,10 @@ _pmap_alloc_l3(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp)
 				return (NULL);
 			}
 			tl0 = pmap_load(l0);
-			l1 = (pd_entry_t *)PHYS_TO_DMAP(PTE_TO_PHYS(tl0));
+			l1 = PHYS_TO_DMAP(PTE_TO_PHYS(tl0));
 			l1 = &l1[l1index & Ln_ADDR_MASK];
 		} else {
-			l1 = (pd_entry_t *)PHYS_TO_DMAP(PTE_TO_PHYS(tl0));
+			l1 = PHYS_TO_DMAP(PTE_TO_PHYS(tl0));
 			l1 = &l1[l1index & Ln_ADDR_MASK];
 			tl1 = pmap_load(l1);
 			if (tl1 == 0) {
@@ -2991,7 +2992,7 @@ _pmap_alloc_l3(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp)
 			}
 		}
 
-		l2 = (pd_entry_t *)PHYS_TO_DMAP(PTE_TO_PHYS(pmap_load(l1)));
+		l2 = PHYS_TO_DMAP(PTE_TO_PHYS(pmap_load(l1)));
 		l2 = &l2[ptepindex & Ln_ADDR_MASK];
 		KASSERT((pmap_load(l2) & ATTR_DESCR_VALID) == 0,
 		    ("%s: L2 entry %#lx is valid", __func__, pmap_load(l2)));
@@ -3034,7 +3035,7 @@ retry:
 			else
 				return (NULL);
 		}
-		l2 = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(l2pg));
+		l2 = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(l2pg));
 		l2 = &l2[pmap_l2_index(va)];
 	} else
 		panic("pmap_alloc_l2: missing page table page for va %#lx",
@@ -3659,7 +3660,7 @@ retry:
 	PV_STAT(atomic_add_int(&pc_chunk_count, 1));
 	PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
 	dump_add_page(m->phys_addr);
-	pc = (void *)PHYS_TO_DMAP(m->phys_addr);
+	pc = PHYS_TO_DMAP(m->phys_addr);
 	pc->pc_pmap = pmap;
 	memcpy(pc->pc_map, pc_freemask, sizeof(pc_freemask));
 	pc->pc_map[0] &= ~1ul;		/* preallocated bit 0 */
@@ -3723,7 +3724,7 @@ retry:
 		PV_STAT(atomic_add_int(&pc_chunk_count, 1));
 		PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
 		dump_add_page(m->phys_addr);
-		pc = (void *)PHYS_TO_DMAP(m->phys_addr);
+		pc = PHYS_TO_DMAP(m->phys_addr);
 		pc->pc_pmap = pmap;
 		memcpy(pc->pc_map, pc_freemask, sizeof(pc_freemask));
 		TAILQ_INSERT_HEAD(&pmap->pm_pvchunk, pc, pc_list);
@@ -3961,7 +3962,7 @@ pmap_remove_kernel_l2(pmap_t pmap, pt_entry_t *l2, vm_offset_t va)
 	 * contains valid mappings.  Zero it to invalidate those mappings.
 	 */
 	if (vm_page_any_valid(ml3))
-		pagezero((void *)PHYS_TO_DMAP(ml3pa));
+		pagezero(PHYS_TO_DMAP(ml3pa));
 
 	/*
 	 * Demote the mapping.  The caller must have already invalidated the
@@ -4994,7 +4995,7 @@ pmap_promote_l2(pmap_t pmap, pd_entry_t *l2, vm_offset_t va, vm_page_t mpte,
 	 * Examine the first L3E in the specified PTP.  Abort if this L3E is
 	 * ineligible for promotion...
 	 */
-	firstl3 = (pt_entry_t *)PHYS_TO_DMAP(PTE_TO_PHYS(pmap_load(l2)));
+	firstl3 = PHYS_TO_DMAP(PTE_TO_PHYS(pmap_load(l2)));
 	newl2 = pmap_load(firstl3);
 	if ((newl2 & ATTR_SW_NO_PROMOTE) != 0)
 		return (false);
@@ -5308,7 +5309,7 @@ restart:
 				PMAP_LOCK(pmap);
 				goto restart;
 			}
-			l2p = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mp));
+			l2p = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mp));
 			l2p = &l2p[pmap_l2_index(va)];
 			origpte = pmap_load(l2p);
 		} else {
@@ -5340,7 +5341,7 @@ restart:
 				goto restart;
 			}
 			mp->ref_count += L3C_ENTRIES - 1;
-			l3p = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mp));
+			l3p = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mp));
 			l3p = &l3p[pmap_l3_index(va)];
 		} else {
 			l3p = pmap_l2_to_l3(l2p, va);
@@ -5665,11 +5666,10 @@ validate:
 		    m->md.pv_memattr == VM_MEMATTR_WRITE_BACK &&
 		    (opa != pa || (orig_l3 & ATTR_S1_XN))) {
 			PMAP_ASSERT_STAGE1(pmap);
-			cpu_icache_sync_range((void *)PHYS_TO_DMAP(pa),
-			    PAGE_SIZE);
+			cpu_icache_sync_range(PHYS_TO_DMAP(pa), PAGE_SIZE);
 		}
 	} else {
-		cpu_dcache_wb_range((void *)PHYS_TO_DMAP(pa), PAGE_SIZE);
+		cpu_dcache_wb_range(PHYS_TO_DMAP(pa), PAGE_SIZE);
 	}
 
 	/*
@@ -5780,7 +5780,7 @@ pmap_every_pte_zero(vm_paddr_t pa)
 	pt_entry_t *pt_end, *pte;
 
 	KASSERT((pa & PAGE_MASK) == 0, ("pa is misaligned"));
-	pte = (pt_entry_t *)PHYS_TO_DMAP(pa);
+	pte = PHYS_TO_DMAP(pa);
 	for (pt_end = pte + Ln_ENTRIES; pte < pt_end; pte++) {
 		if (*pte != 0)
 			return (false);
@@ -5976,7 +5976,7 @@ pmap_enter_l2(pmap_t pmap, vm_offset_t va, pd_entry_t new_l2, u_int flags,
 	if ((new_l2 & ATTR_S1_XN) == 0 && (PTE_TO_PHYS(new_l2) !=
 	    PTE_TO_PHYS(old_l2) || (old_l2 & ATTR_S1_XN) != 0) &&
 	    pmap != kernel_pmap && m->md.pv_memattr == VM_MEMATTR_WRITE_BACK) {
-		cpu_icache_sync_range((void *)PHYS_TO_DMAP(PTE_TO_PHYS(new_l2)),
+		cpu_icache_sync_range(PHYS_TO_DMAP(PTE_TO_PHYS(new_l2)),
 		    L2_SIZE);
 	}
 
@@ -6112,7 +6112,7 @@ retry:
 				(*ml3p)->ref_count += L3C_ENTRIES - 1;
 			}
 		}
-		l3p = (pt_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(*ml3p));
+		l3p = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(*ml3p));
 	} else {
 		*ml3p = NULL;
 
@@ -6131,8 +6131,7 @@ retry:
 		} else {
 			KASSERT(lvl == 2,
 			    ("pmap_enter_l3c: Invalid level %d", lvl));
-			l3p = (pt_entry_t *)PHYS_TO_DMAP(PTE_TO_PHYS(
-			    pmap_load(pde)));
+			l3p = PHYS_TO_DMAP(PTE_TO_PHYS(pmap_load(pde)));
 		}
 	}
 have_l3p:
@@ -6204,7 +6203,7 @@ have_l3p:
 	 */
 	if ((l3e & ATTR_S1_XN) == 0 && pmap != kernel_pmap &&
 	    m->md.pv_memattr == VM_MEMATTR_WRITE_BACK)
-		cpu_icache_sync_range((void *)PHYS_TO_DMAP(pa), L3C_SIZE);
+		cpu_icache_sync_range(PHYS_TO_DMAP(pa), L3C_SIZE);
 
 	/*
 	 * Map the superpage.
@@ -6369,7 +6368,7 @@ pmap_enter_quick_locked(pmap_t pmap, vm_offset_t va, vm_page_t m,
 					return (mpte);
 			}
 		}
-		l3 = (pt_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mpte));
+		l3 = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mpte));
 		l3 = &l3[pmap_l3_index(va)];
 	} else {
 		mpte = NULL;
@@ -6431,7 +6430,7 @@ pmap_enter_quick_locked(pmap_t pmap, vm_offset_t va, vm_page_t m,
 	/* Sync icache before the mapping is stored to PTE */
 	if ((prot & VM_PROT_EXECUTE) && pmap != kernel_pmap &&
 	    m->md.pv_memattr == VM_MEMATTR_WRITE_BACK)
-		cpu_icache_sync_range((void *)PHYS_TO_DMAP(pa), PAGE_SIZE);
+		cpu_icache_sync_range(PHYS_TO_DMAP(pa), PAGE_SIZE);
 
 	pmap_store(l3, l3_val);
 	dsb(ishst);
@@ -6770,7 +6769,7 @@ pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr, vm_size_t len,
 		    ("pmap_copy: source page table page is unused"));
 		if (va_next > end_addr)
 			va_next = end_addr;
-		src_pte = (pt_entry_t *)PHYS_TO_DMAP(PTE_TO_PHYS(srcptepaddr));
+		src_pte = PHYS_TO_DMAP(PTE_TO_PHYS(srcptepaddr));
 		src_pte = &src_pte[pmap_l3_index(addr)];
 		dstmpte = NULL;
 		for (; addr < va_next; addr += PAGE_SIZE, src_pte++) {
@@ -6789,8 +6788,7 @@ pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr, vm_size_t len,
 			} else if ((dstmpte = pmap_alloc_l3(dst_pmap, addr,
 			    NULL)) == NULL)
 				goto out;
-			dst_pte = (pt_entry_t *)
-			    PHYS_TO_DMAP(VM_PAGE_TO_PHYS(dstmpte));
+			dst_pte = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(dstmpte));
 			dst_pte = &dst_pte[pmap_l3_index(addr)];
 			if ((ptetemp & ATTR_CONTIGUOUS) != 0 && (addr &
 			    L3C_OFFSET) == 0 && addr + L3C_OFFSET <=
@@ -6877,9 +6875,9 @@ pmap_vmspace_copy(pmap_t dst_pmap, pmap_t src_pmap)
 void
 pmap_zero_page(vm_page_t m)
 {
-	vm_offset_t va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
+	void *va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
 
-	pagezero((void *)va);
+	pagezero(va);
 }
 
 /*
@@ -6891,10 +6889,10 @@ pmap_zero_page(vm_page_t m)
 void
 pmap_zero_page_area(vm_page_t m, int off, int size)
 {
-	vm_offset_t va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
+	void *va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
 
 	if (off == 0 && size == PAGE_SIZE)
-		pagezero((void *)va);
+		pagezero(va);
 	else
 		bzero((char *)va + off, size);
 }
@@ -6908,10 +6906,10 @@ pmap_zero_page_area(vm_page_t m, int off, int size)
 void
 pmap_copy_page(vm_page_t msrc, vm_page_t mdst)
 {
-	vm_offset_t src = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(msrc));
-	vm_offset_t dst = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mdst));
+	void *src = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(msrc));
+	void *dst = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mdst));
 
-	pagecopy((void *)src, (void *)dst);
+	pagecopy(src, dst);
 }
 
 int unmapped_buf_allowed = 1;
@@ -6956,7 +6954,7 @@ void *
 pmap_quick_enter_page(vm_page_t m)
 {
 
-	return ((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)));
+	return (PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)));
 }
 
 void
@@ -7992,7 +7990,7 @@ pmap_mapbios(vm_paddr_t pa, vm_size_t size)
 	/* Use the DMAP region if we can */
 	if (PHYS_IN_DMAP(pa) && PHYS_IN_DMAP(pa + size - 1) &&
 	    pmap_kmapped_range(PHYS_TO_DMAP(pa), size))
-		return ((void *)PHYS_TO_DMAP(pa));
+		return (PHYS_TO_DMAP(pa));
 
 	if (!vm_initialized) {
 		/*
@@ -8119,7 +8117,7 @@ pmap_unmapbios(void *p, vm_size_t size)
 		    va + size - 1));
 		/* Ensure the attributes are as expected for the DMAP region */
 		PMAP_LOCK(kernel_pmap);
-		error = pmap_change_props_locked(va, size,
+		error = pmap_change_props_locked(p, size,
 		    PROT_READ | PROT_WRITE, VM_MEMATTR_DEFAULT, false);
 		PMAP_UNLOCK(kernel_pmap);
 		KASSERT(error == 0, ("%s: Failed to reset DMAP attributes: %d",
@@ -8195,7 +8193,7 @@ pmap_page_set_memattr(vm_page_t m, vm_memattr_t ma)
 	 * required for data coherence.
 	 */
 	if ((m->flags & PG_FICTITIOUS) == 0 &&
-	    pmap_change_attr((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)), PAGE_SIZE,
+	    pmap_change_attr(PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)), PAGE_SIZE,
 	    m->md.pv_memattr) != 0)
 		panic("memory attribute change on the direct map failed");
 }
@@ -8225,8 +8223,7 @@ pmap_change_attr(void *va, vm_size_t size, int mode)
 	int error;
 
 	PMAP_LOCK(kernel_pmap);
-	error = pmap_change_props_locked((vm_offset_t)va, size, PROT_NONE, mode,
-	    false);
+	error = pmap_change_props_locked(va, size, PROT_NONE, mode, false);
 	PMAP_UNLOCK(kernel_pmap);
 	return (error);
 }
@@ -8248,16 +8245,16 @@ pmap_change_prot(void *va, vm_size_t size, vm_prot_t prot)
 		return (EINVAL);
 
 	PMAP_LOCK(kernel_pmap);
-	error = pmap_change_props_locked((vm_offset_t)va, size, prot, -1, false);
+	error = pmap_change_props_locked(va, size, prot, -1, false);
 	PMAP_UNLOCK(kernel_pmap);
 	return (error);
 }
 
 static int
-pmap_change_props_locked(vm_offset_t va, vm_size_t size, vm_prot_t prot,
+pmap_change_props_locked(void *addr, vm_size_t size, vm_prot_t prot,
     int mode, bool skip_unmapped)
 {
-	vm_offset_t base, offset, tmpva;
+	vm_offset_t base, offset, tmpva, va;
 	vm_size_t pte_size;
 	vm_paddr_t pa;
 	pt_entry_t pte, *ptep, *newpte;
@@ -8266,6 +8263,7 @@ pmap_change_props_locked(vm_offset_t va, vm_size_t size, vm_prot_t prot,
 	int lvl, rv;
 
 	PMAP_LOCK_ASSERT(kernel_pmap, MA_OWNED);
+	va = (vm_offset_t)addr;
 	base = trunc_page(va);
 	offset = va & PAGE_MASK;
 	size = round_page(offset + size);
@@ -8508,7 +8506,7 @@ pmap_demote_l1(pmap_t pmap, pt_entry_t *l1, vm_offset_t va)
 	}
 
 	l2phys = VM_PAGE_TO_PHYS(ml2);
-	l2 = (pt_entry_t *)PHYS_TO_DMAP(l2phys);
+	l2 = PHYS_TO_DMAP(l2phys);
 
 	/* Address the range points at */
 	phys = PTE_TO_PHYS(oldl1);
@@ -8691,7 +8689,7 @@ pmap_demote_l2_locked(pmap_t pmap, pt_entry_t *l2, vm_offset_t va,
 		}
 	}
 	l3phys = VM_PAGE_TO_PHYS(ml3);
-	l3 = (pt_entry_t *)PHYS_TO_DMAP(l3phys);
+	l3 = PHYS_TO_DMAP(l3phys);
 	newl3 = ATTR_CONTIGUOUS | (oldl2 & ~ATTR_DESCR_MASK) | L3_PAGE;
 	KASSERT((oldl2 & (ATTR_S1_AP_RW_BIT | ATTR_SW_DBM)) !=
 	    (ATTR_S1_AP(ATTR_S1_AP_RO) | ATTR_SW_DBM),
@@ -9374,8 +9372,7 @@ pmap_sync_icache(pmap_t pmap, vm_offset_t va, vm_size_t sz)
 			/* Extract the physical address & find it in the DMAP */
 			pa = pmap_extract(pmap, va);
 			if (pa != 0)
-				cpu_icache_sync_range((void *)PHYS_TO_DMAP(pa),
-				    len);
+				cpu_icache_sync_range(PHYS_TO_DMAP(pa), len);
 
 			/* Move to the next page */
 			sz -= len;
@@ -9644,7 +9641,7 @@ pmap_map_io_transient(vm_page_t page[], void *vaddr[], int count,
 			vaddr[i] = (void *)addr;
 			needs_mapping = true;
 		} else {
-			vaddr[i] = (void *)PHYS_TO_DMAP(paddr);
+			vaddr[i] = PHYS_TO_DMAP(paddr);
 		}
 	}
 
@@ -10185,7 +10182,7 @@ sysctl_kmaps(SYSCTL_HANDLER_ARGS)
 			continue;
 		}
 		pa = PTE_TO_PHYS(l0e);
-		l1 = (pd_entry_t *)PHYS_TO_DMAP(pa);
+		l1 = PHYS_TO_DMAP(pa);
 
 		for (j = pmap_l1_index(sva); j < Ln_ENTRIES; j++) {
 			l1e = l1[j];
@@ -10203,7 +10200,7 @@ sysctl_kmaps(SYSCTL_HANDLER_ARGS)
 				continue;
 			}
 			pa = PTE_TO_PHYS(l1e);
-			l2 = (pd_entry_t *)PHYS_TO_DMAP(pa);
+			l2 = PHYS_TO_DMAP(pa);
 
 			for (k = pmap_l2_index(sva); k < Ln_ENTRIES; k++) {
 				l2e = l2[k];
@@ -10225,7 +10222,7 @@ sysctl_kmaps(SYSCTL_HANDLER_ARGS)
 					continue;
 				}
 				pa = PTE_TO_PHYS(l2e);
-				l3 = (pt_entry_t *)PHYS_TO_DMAP(pa);
+				l3 = PHYS_TO_DMAP(pa);
 
 				for (l = pmap_l3_index(sva); l < Ln_ENTRIES;
 				    l++, sva += L3_SIZE) {
diff --git a/sys/arm64/include/sf_buf.h b/sys/arm64/include/sf_buf.h
index c66095983bce..497789732c27 100644
--- a/sys/arm64/include/sf_buf.h
+++ b/sys/arm64/include/sf_buf.h
@@ -41,7 +41,7 @@ static inline void *
 sf_buf_kva(struct sf_buf *sf)
 {
 
-	return ((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS((vm_page_t)sf)));
+	return (PHYS_TO_DMAP(VM_PAGE_TO_PHYS((vm_page_t)sf)));
 }
 
 static inline vm_page_t
diff --git a/sys/arm64/include/vmparam.h b/sys/arm64/include/vmparam.h
index 650c6f5c9225..f33cde5894f3 100644
--- a/sys/arm64/include/vmparam.h
+++ b/sys/arm64/include/vmparam.h
@@ -254,7 +254,7 @@
 #define	PHYS_IN_DMAP_RANGE(pa)	((pa) >= DMAP_MIN_PHYSADDR && \
     (pa) < DMAP_MAX_PHYSADDR)
 #define	PHYS_IN_DMAP(pa)	(PHYS_IN_DMAP_RANGE(pa) && \
-    pmap_klookup(PHYS_TO_DMAP(pa), NULL))
+    pmap_klookup(PHYS_TO_DMAP_ADDR(pa), NULL))
 /* True if va is in the dmap range */
 #define	VIRT_IN_DMAP(va)						\
 ({									\
@@ -264,13 +264,14 @@
 })
 
 #define	PMAP_HAS_DMAP	1
-#define	PHYS_TO_DMAP(pa)						\
+#define	PHYS_TO_DMAP_ADDR(pa)						\
 ({									\
 	KASSERT(PHYS_IN_DMAP_RANGE(pa),					\
 	    ("%s: PA out of range, PA: 0x%lx", __func__,		\
 	    (vm_paddr_t)(pa)));						\
 	((pa) - dmap_phys_base) + DMAP_MIN_ADDRESS;			\
 })
+#define	PHYS_TO_DMAP(x)		((void *)PHYS_TO_DMAP_ADDR(x))
 
 #define	DMAP_TO_PHYS(va)						\
 ({									\
diff --git a/sys/arm64/iommu/iommu_pmap.c b/sys/arm64/iommu/iommu_pmap.c
index dc5c09239c04..e6183f7fde03 100644
--- a/sys/arm64/iommu/iommu_pmap.c
+++ b/sys/arm64/iommu/iommu_pmap.c
@@ -112,7 +112,7 @@ smmu_pmap_l0_to_l1(pd_entry_t *l0, vm_offset_t va)
 {
 	pd_entry_t *l1;
 
-	l1 = (pd_entry_t *)PHYS_TO_DMAP(smmu_pmap_load(l0) & ~ATTR_MASK);
+	l1 = PHYS_TO_DMAP(smmu_pmap_load(l0) & ~ATTR_MASK);
 	return (&l1[smmu_l1_index(va)]);
 }
 
@@ -143,7 +143,7 @@ smmu_pmap_l1_to_l2(pd_entry_t *l1p, vm_offset_t va)
 	    ("%s: L1 entry %#lx for %#lx is invalid", __func__, l1, va));
 	KASSERT((l1 & ATTR_DESCR_TYPE_MASK) == ATTR_DESCR_TYPE_TABLE,
 	    ("%s: L1 entry %#lx for %#lx is a leaf", __func__, l1, va));
-	l2p = (pd_entry_t *)PHYS_TO_DMAP(l1 & ~ATTR_MASK);
+	l2p = PHYS_TO_DMAP(l1 & ~ATTR_MASK);
 	return (&l2p[smmu_l2_index(va)]);
 }
 
@@ -175,7 +175,7 @@ smmu_pmap_l2_to_l3(pd_entry_t *l2p, vm_offset_t va)
 	    ("%s: L2 entry %#lx for %#lx is invalid", __func__, l2, va));
 	KASSERT((l2 & ATTR_DESCR_TYPE_MASK) == ATTR_DESCR_TYPE_TABLE,
 	    ("%s: L2 entry %#lx for %#lx is a leaf", __func__, l2, va));
-	l3p = (pt_entry_t *)PHYS_TO_DMAP(l2 & ~ATTR_MASK);
+	l3p = PHYS_TO_DMAP(l2 & ~ATTR_MASK);
 	return (&l3p[smmu_l3_index(va)]);
 }
 
@@ -410,7 +410,7 @@ smmu_pmap_pinit(struct smmu_pmap *pmap)
 	m = vm_page_alloc_noobj(VM_ALLOC_WAITOK | VM_ALLOC_WIRED |
 	    VM_ALLOC_ZERO);
 	pmap->sp_l0_paddr = VM_PAGE_TO_PHYS(m);
-	pmap->sp_l0 = (pd_entry_t *)PHYS_TO_DMAP(pmap->sp_l0_paddr);
+	pmap->sp_l0 = PHYS_TO_DMAP(pmap->sp_l0_paddr);
 
 #ifdef INVARIANTS
 	pmap->sp_resident_count = 0;
@@ -495,7 +495,7 @@ _pmap_alloc_l3(struct smmu_pmap *pmap, vm_pindex_t ptepindex)
 			l1pg->ref_count++;
 		}
 
-		l1 = (pd_entry_t *)PHYS_TO_DMAP(smmu_pmap_load(l0) &~ATTR_MASK);
+		l1 = PHYS_TO_DMAP(smmu_pmap_load(l0) &~ATTR_MASK);
 		l1 = &l1[ptepindex & Ln_ADDR_MASK];
 		smmu_pmap_store(l1, VM_PAGE_TO_PHYS(m) | IOMMU_L1_TABLE);
 	} else {
@@ -516,10 +516,10 @@ _pmap_alloc_l3(struct smmu_pmap *pmap, vm_pindex_t ptepindex)
 				return (NULL);
 			}
 			tl0 = smmu_pmap_load(l0);
-			l1 = (pd_entry_t *)PHYS_TO_DMAP(tl0 & ~ATTR_MASK);
+			l1 = PHYS_TO_DMAP(tl0 & ~ATTR_MASK);
 			l1 = &l1[l1index & Ln_ADDR_MASK];
 		} else {
-			l1 = (pd_entry_t *)PHYS_TO_DMAP(tl0 & ~ATTR_MASK);
+			l1 = PHYS_TO_DMAP(tl0 & ~ATTR_MASK);
 			l1 = &l1[l1index & Ln_ADDR_MASK];
 			tl1 = smmu_pmap_load(l1);
 			if (tl1 == 0) {
@@ -536,7 +536,7 @@ _pmap_alloc_l3(struct smmu_pmap *pmap, vm_pindex_t ptepindex)
 			}
 		}
 
-		l2 = (pd_entry_t *)PHYS_TO_DMAP(smmu_pmap_load(l1) &~ATTR_MASK);
+		l2 = PHYS_TO_DMAP(smmu_pmap_load(l1) &~ATTR_MASK);
 		l2 = &l2[ptepindex & Ln_ADDR_MASK];
 		smmu_pmap_store(l2, VM_PAGE_TO_PHYS(m) | IOMMU_L2_TABLE);
 	}
@@ -806,7 +806,7 @@ smmu_pmap_remove_pages(struct smmu_pmap *pmap)
 		}
 		pa0 = l0e & ~ATTR_MASK;
 		m0 = PHYS_TO_VM_PAGE(pa0);
-		l1 = (pd_entry_t *)PHYS_TO_DMAP(pa0);
+		l1 = PHYS_TO_DMAP(pa0);
 
 		for (j = 0; j < IOMMU_Ln_ENTRIES; j++) {
 			l1e = l1[j];
@@ -818,7 +818,7 @@ smmu_pmap_remove_pages(struct smmu_pmap *pmap)
 			}
 			pa1 = l1e & ~ATTR_MASK;
 			m1 = PHYS_TO_VM_PAGE(pa1);
-			l2 = (pd_entry_t *)PHYS_TO_DMAP(pa1);
+			l2 = PHYS_TO_DMAP(pa1);
 
 			for (k = 0; k < IOMMU_Ln_ENTRIES; k++) {
 				l2e = l2[k];
@@ -827,7 +827,7 @@ smmu_pmap_remove_pages(struct smmu_pmap *pmap)
 				}
 				pa = l2e & ~ATTR_MASK;
 				m = PHYS_TO_VM_PAGE(pa);
-				l3 = (pt_entry_t *)PHYS_TO_DMAP(pa);
+				l3 = PHYS_TO_DMAP(pa);
 
 				for (l = 0; l < IOMMU_Ln_ENTRIES; l++) {
 					l3e = l3[l];
diff --git a/sys/arm64/vmm/vmm_mmu.c b/sys/arm64/vmm/vmm_mmu.c
index ab876d4b47b6..b362af6421db 100644
--- a/sys/arm64/vmm/vmm_mmu.c
+++ b/sys/arm64/vmm/vmm_mmu.c
@@ -63,7 +63,7 @@ vmmpmap_init(void)
 		return (false);
 
 	l0_paddr = VM_PAGE_TO_PHYS(m);
-	l0 = (pd_entry_t *)PHYS_TO_DMAP(l0_paddr);
+	l0 = PHYS_TO_DMAP(l0_paddr);
 
 	mtx_init(&vmmpmap_mtx, "vmm pmap", NULL, MTX_DEF);
 
@@ -77,7 +77,7 @@ vmmpmap_release_l3(pd_entry_t l2e)
 	vm_page_t m;
 	int i;
 
-	l3 = (pd_entry_t *)PHYS_TO_DMAP(l2e & ~ATTR_MASK);
+	l3 = PHYS_TO_DMAP(l2e & ~ATTR_MASK);
 	for (i = 0; i < Ln_ENTRIES; i++) {
 		KASSERT(l3[i] == 0, ("%s: l3 still mapped: %p %lx", __func__,
 		    &l3[i], l3[i]));
@@ -95,7 +95,7 @@ vmmpmap_release_l2(pd_entry_t l1e)
 	vm_page_t m;
 	int i;
 
-	l2 = (pd_entry_t *)PHYS_TO_DMAP(l1e & ~ATTR_MASK);
+	l2 = PHYS_TO_DMAP(l1e & ~ATTR_MASK);
 	for (i = 0; i < Ln_ENTRIES; i++) {
 		if (l2[i] != 0) {
 			vmmpmap_release_l3(l2[i]);
@@ -114,7 +114,7 @@ vmmpmap_release_l1(pd_entry_t l0e)
 	vm_page_t m;
 	int i;
 
-	l1 = (pd_entry_t *)PHYS_TO_DMAP(l0e & ~ATTR_MASK);
+	l1 = PHYS_TO_DMAP(l0e & ~ATTR_MASK);
 	for (i = 0; i < Ln_ENTRIES; i++) {
 		if (l1[i] != 0) {
 			vmmpmap_release_l2(l1[i]);
@@ -189,7 +189,7 @@ again:
 		vm_page_free_zero(m);
 	}
 
-	l1 = (pd_entry_t *)PHYS_TO_DMAP(l0e & ~ATTR_MASK);
+	l1 = PHYS_TO_DMAP(l0e & ~ATTR_MASK);
 	return (l1);
 }
 
@@ -232,7 +232,7 @@ again:
 		vm_page_free_zero(m);
 	}
 
-	l2 = (pd_entry_t *)PHYS_TO_DMAP(l1e & ~ATTR_MASK);
+	l2 = PHYS_TO_DMAP(l1e & ~ATTR_MASK);
 	return (l2);
 }
 
@@ -275,7 +275,7 @@ again:
 		vm_page_free_zero(m);
 	}
 
-	l3 = (pt_entry_t *)PHYS_TO_DMAP(l2e & ~ATTR_MASK);
+	l3 = PHYS_TO_DMAP(l2e & ~ATTR_MASK);
 	return (l3);
 }
 
@@ -362,17 +362,17 @@ vmmpmap_remove(vm_offset_t va, vm_size_t size, bool invalidate)
 		MPASS(l0e != 0);
 		MPASS((l0e & ATTR_DESCR_MASK) == L0_TABLE);
 
-		l1 = (pd_entry_t *)PHYS_TO_DMAP(l0e & ~ATTR_MASK);
+		l1 = PHYS_TO_DMAP(l0e & ~ATTR_MASK);
 		l1e = atomic_load_64(&l1[pmap_l1_index(va)]);
 		MPASS(l1e != 0);
 		MPASS((l1e & ATTR_DESCR_MASK) == L1_TABLE);
 
-		l2 = (pd_entry_t *)PHYS_TO_DMAP(l1e & ~ATTR_MASK);
+		l2 = PHYS_TO_DMAP(l1e & ~ATTR_MASK);
 		l2e = atomic_load_64(&l2[pmap_l2_index(va)]);
 		MPASS(l2e != 0);
 		MPASS((l2e & ATTR_DESCR_MASK) == L2_TABLE);
 
-		l3 = (pd_entry_t *)PHYS_TO_DMAP(l2e & ~ATTR_MASK);
+		l3 = PHYS_TO_DMAP(l2e & ~ATTR_MASK);
 		if (invalidate) {
 			l3e = atomic_load_64(&l3[pmap_l3_index(va)]);
 			MPASS(l3e != 0);
diff --git a/sys/compat/linuxkpi/common/include/linux/highmem.h b/sys/compat/linuxkpi/common/include/linux/highmem.h
index 1374712735ac..b704e77b6c2f 100644
--- a/sys/compat/linuxkpi/common/include/linux/highmem.h
+++ b/sys/compat/linuxkpi/common/include/linux/highmem.h
@@ -62,7 +62,7 @@ kmap(struct page *page)
 	struct sf_buf *sf;
 
 	if (PMAP_HAS_DMAP) {
-		return ((void *)PHYS_TO_DMAP(page_to_phys(page)));
+		return (PHYS_TO_DMAP(page_to_phys(page)));
 	} else {
 		sched_pin();
 		sf = sf_buf_alloc(page, SFB_NOWAIT | SFB_CPUPRIVATE);
diff --git a/sys/compat/linuxkpi/common/include/linux/io.h b/sys/compat/linuxkpi/common/include/linux/io.h
index 01ea282aa914..f89c150e7a3b 100644
--- a/sys/compat/linuxkpi/common/include/linux/io.h
+++ b/sys/compat/linuxkpi/common/include/linux/io.h
@@ -542,10 +542,10 @@ static inline int
 arch_io_reserve_memtype_wc(resource_size_t start, resource_size_t size)
 {
 #if defined(__amd64__)
-	vm_offset_t va;
+	void *va;
 
 	va = PHYS_TO_DMAP(start);
-	return (-pmap_change_attr((void *)va, size, VM_MEMATTR_WRITE_COMBINING));
+	return (-pmap_change_attr(va, size, VM_MEMATTR_WRITE_COMBINING));
 #else
 	return (0);
 #endif
@@ -555,11 +555,11 @@ static inline void
 arch_io_free_memtype_wc(resource_size_t start, resource_size_t size)
 {
 #if defined(__amd64__)
-	vm_offset_t va;
+	void *va;
 
 	va = PHYS_TO_DMAP(start);
 
-	pmap_change_attr((void *)va, size, VM_MEMATTR_WRITE_BACK);
+	pmap_change_attr(va, size, VM_MEMATTR_WRITE_BACK);
 #endif
 }
 
diff --git a/sys/compat/linuxkpi/common/include/linux/scatterlist.h b/sys/compat/linuxkpi/common/include/linux/scatterlist.h
index 775ed499a7d0..c49c2179d359 100644
--- a/sys/compat/linuxkpi/common/include/linux/scatterlist.h
+++ b/sys/compat/linuxkpi/common/include/linux/scatterlist.h
@@ -656,7 +656,7 @@ sg_pcopy_to_buffer(struct scatterlist *sgl, unsigned int nents,
 				break;
 			vaddr = sf_buf_kva(sf);
 		} else
-			vaddr = (char *)PHYS_TO_DMAP(page_to_phys(page));
+			vaddr = PHYS_TO_DMAP(page_to_phys(page));
 		memcpy(buf, vaddr + sg->offset + offset, len);
 		if (!PMAP_HAS_DMAP)
 			sf_buf_free(sf);
diff --git a/sys/compat/linuxkpi/common/src/linux_page.c b/sys/compat/linuxkpi/common/src/linux_page.c
index 10ede3287bb4..39edb34545b7 100644
--- a/sys/compat/linuxkpi/common/src/linux_page.c
+++ b/sys/compat/linuxkpi/common/src/linux_page.c
@@ -87,8 +87,7 @@ linux_page_address(const struct page *page)
 {
 
 	if (page->object != kernel_object) {
-		return (PMAP_HAS_DMAP ?
-		    ((void *)(uintptr_t)PHYS_TO_DMAP(page_to_phys(page))) :
+		return (PMAP_HAS_DMAP ? PHYS_TO_DMAP(page_to_phys(page)) :
 		    NULL);
 	}
 	return ((void *)(uintptr_t)(VM_MIN_KERNEL_ADDRESS +
diff --git a/sys/contrib/ncsw/user/env/xx.c b/sys/contrib/ncsw/user/env/xx.c
index aaf795ffa57a..6c943f615a3f 100644
--- a/sys/contrib/ncsw/user/env/xx.c
+++ b/sys/contrib/ncsw/user/env/xx.c
@@ -718,7 +718,7 @@ XX_PhysToVirt(physAddress_t addr)
 		return ((void *)(pv->pv_va + ((vm_offset_t)addr & PAGE_MASK)));
 
 	if (PMAP_HAS_DMAP)
-		return ((void *)(uintptr_t)PHYS_TO_DMAP(addr));
+		return (PHYS_TO_DMAP(addr));
 
 	printf("NetCommSW: "
 	    "Unable to translate physical address 0x%09jx!\n", (uintmax_t)addr);
diff --git a/sys/crypto/ccp/ccp_hardware.c b/sys/crypto/ccp/ccp_hardware.c
index 497f80dbd676..9603539c7fb1 100644
--- a/sys/crypto/ccp/ccp_hardware.c
+++ b/sys/crypto/ccp/ccp_hardware.c
@@ -1601,7 +1601,7 @@ ccp_do_blkcipher(struct ccp_queue *qp, struct ccp_session *s,
 		return (error);
 
 	INSECURE_DEBUG(dev, "%s: Contents: %16D\n", __func__,
-	    (void *)PHYS_TO_DMAP(qp->cq_sg_ulptx->sg_segs[0].ss_paddr), " ");
+	    PHYS_TO_DMAP(qp->cq_sg_ulptx->sg_segs[0].ss_paddr), " ");
 
 	DPRINTF(dev, "%s: starting AES ops @ %u\n", __func__, qp->cq_tail);
 
diff --git a/sys/dev/efidev/efirt.c b/sys/dev/efidev/efirt.c
index b55c1c191077..c3ac120c6611 100644
--- a/sys/dev/efidev/efirt.c
+++ b/sys/dev/efidev/efirt.c
@@ -192,7 +192,7 @@ efi_init(void)
 		return (0);
 	}
 
-	efi_systbl = (struct efi_systbl *)efi_phys_to_kva(efi_systbl_phys);
+	efi_systbl = efi_phys_to_kva(efi_systbl_phys);
 	if (efi_systbl == NULL || efi_systbl->st_hdr.th_sig != EFI_SYSTBL_SIG) {
 		efi_systbl = NULL;
 		if (bootverbose)
@@ -243,7 +243,7 @@ efi_init(void)
 	 * with an old loader.efi, check if the RS->GetTime function is within
 	 * the EFI map, and fail to attach if not.
 	 */
-	rtdm = (struct efi_rt *)efi_phys_to_kva((uintptr_t)efi_runtime);
+	rtdm = efi_phys_to_kva((uintptr_t)efi_runtime);
 	if (rtdm == NULL || !efi_is_in_map(map, ndesc, efihdr->descriptor_size,
 	    (vm_offset_t)rtdm->rt_gettime)) {
 		if (bootverbose)
diff --git a/sys/dev/hwt/hwt_vm.c b/sys/dev/hwt/hwt_vm.c
index 18bbdbe37a99..0ea1fe44d4e3 100644
--- a/sys/dev/hwt/hwt_vm.c
+++ b/sys/dev/hwt/hwt_vm.c
@@ -110,7 +110,7 @@ hwt_vm_alloc_pages(struct hwt_vm *vm, int kva_req)
 	vm_paddr_t low, high, boundary;
 	vm_memattr_t memattr;
 #ifdef  __aarch64__
-	uintptr_t va;
+	void *va;
 #endif
 	int alignment;
 	vm_page_t m;
@@ -160,7 +160,7 @@ retry:
 
 #ifdef __aarch64__
 		va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
-		cpu_dcache_wb_range((void *)va, PAGE_SIZE);
+		cpu_dcache_wb_range(va, PAGE_SIZE);
 #endif
 
 		m->valid = VM_PAGE_BITS_ALL;
diff --git a/sys/dev/iscsi/icl_soft.c b/sys/dev/iscsi/icl_soft.c
index 8847680072d3..ea5b1e6c51c4 100644
--- a/sys/dev/iscsi/icl_soft.c
+++ b/sys/dev/iscsi/icl_soft.c
@@ -1112,7 +1112,7 @@ icl_soft_conn_pdu_append_bio(struct icl_conn *ic, struct icl_pdu *request,
 {
 	struct icl_soft_pdu *isp = (struct icl_soft_pdu *)request;
 	struct mbuf *m, *m_tail;
-	vm_offset_t vaddr;
+	char *vaddr;
 	size_t mtodo, page_offset, todo;
 	int i;
 
@@ -1200,8 +1200,8 @@ icl_soft_conn_pdu_append_bio(struct icl_conn *ic, struct icl_pdu *request,
 
 		do {
 			mtodo = min(todo, M_SIZE(m) - m->m_len);
-			memcpy(mtod(m, char *) + m->m_len, (char *)vaddr +
-			    page_offset, mtodo);
+			memcpy(mtod(m, char *) + m->m_len, vaddr + page_offset,
+			    mtodo);
 			m->m_len += mtodo;
 			if (m->m_len == M_SIZE(m))
 				m = m->m_next;
@@ -1269,7 +1269,7 @@ void
 icl_soft_conn_pdu_get_bio(struct icl_conn *ic, struct icl_pdu *ip,
     size_t pdu_off, struct bio *bp, size_t bio_off, size_t len)
 {
-	vm_offset_t vaddr;
+	char *vaddr;
 	size_t page_offset, todo;
 	int i __unused;
 
@@ -1288,7 +1288,7 @@ icl_soft_conn_pdu_get_bio(struct icl_conn *ic, struct icl_pdu *ip,
 		todo = MIN(len, PAGE_SIZE - page_offset);
 
 		vaddr = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(bp->bio_ma[i]));
-		m_copydata(ip->ip_data_mbuf, pdu_off, todo, (char *)vaddr +
+		m_copydata(ip->ip_data_mbuf, pdu_off, todo, vaddr +
 		    page_offset);
 
 		page_offset = 0;
diff --git a/sys/dev/vmm/vmm_mem.c b/sys/dev/vmm/vmm_mem.c
index 5a73cbf7fc5b..fc48756510ef 100644
--- a/sys/dev/vmm/vmm_mem.c
+++ b/sys/dev/vmm/vmm_mem.c
@@ -449,7 +449,7 @@ _vm_gpa_hold(struct vm *vm, vm_paddr_t gpa, size_t len, int reqprot,
 
 	if (count == 1) {
 		*cookie = m;
-		return ((void *)(PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)) + pageoff));
+		return ((char *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)) + pageoff);
 	} else {
 		*cookie = NULL;
 		return (NULL);
diff --git a/sys/dev/vnic/nicvf_queues.c b/sys/dev/vnic/nicvf_queues.c
index 45d6b54b18ed..95185d39a3a8 100644
--- a/sys/dev/vnic/nicvf_queues.c
+++ b/sys/dev/vnic/nicvf_queues.c
@@ -116,7 +116,8 @@ struct rbuf_info {
 	struct mbuf *	mbuf;
 };
 
-#define GET_RBUF_INFO(x) ((struct rbuf_info *)((x) - NICVF_RCV_BUF_ALIGN_BYTES))
+#define GET_RBUF_INFO(x)						\
+	((struct rbuf_info *)((char *)(x) - NICVF_RCV_BUF_ALIGN_BYTES))
 
 /* Poll a register for a specific value */
 static int nicvf_poll_reg(struct nicvf *nic, int qidx,
diff --git a/sys/fs/nfs/nfs_commonsubs.c b/sys/fs/nfs/nfs_commonsubs.c
index 39d7cb447d6a..3bff2737b687 100644
--- a/sys/fs/nfs/nfs_commonsubs.c
+++ b/sys/fs/nfs/nfs_commonsubs.c
@@ -913,8 +913,7 @@ nfsm_strtom(struct nfsrv_descript *nd, const char *cp, int siz)
 			if ((nd->nd_flag & ND_EXTPG) != 0) {
 				m2 = nfsm_add_ext_pgs(m2,
 				    nd->nd_maxextsiz, &nd->nd_bextpg);
-				cp2 = (char *)(void *)PHYS_TO_DMAP(
-				    m2->m_epg_pa[nd->nd_bextpg]);
+				cp2 = PHYS_TO_DMAP(m2->m_epg_pa[nd->nd_bextpg]);
 				nd->nd_bextpgsiz = left = PAGE_SIZE;
 			} else {
 				if (siz > ncl_mbuf_mlen)
@@ -5051,8 +5050,7 @@ nfsrvd_rephead(struct nfsrv_descript *nd)
 	if ((nd->nd_flag & ND_EXTPG) != 0) {
 		mreq = mb_alloc_ext_plus_pages(PAGE_SIZE, M_WAITOK);
 		nd->nd_mreq = nd->nd_mb = mreq;
-		nd->nd_bpos = (char *)(void *)
-		    PHYS_TO_DMAP(mreq->m_epg_pa[0]);
+		nd->nd_bpos = PHYS_TO_DMAP(mreq->m_epg_pa[0]);
 		nd->nd_bextpg = 0;
 		nd->nd_bextpgsiz = PAGE_SIZE;
 	} else {
@@ -5534,8 +5532,7 @@ nfsm_set(struct nfsrv_descript *nd, u_int offs)
 				break;
 			}
 		}
-		nd->nd_bpos = (char *)(void *)
-		    PHYS_TO_DMAP(m->m_epg_pa[nd->nd_bextpg]);
+		nd->nd_bpos = PHYS_TO_DMAP(m->m_epg_pa[nd->nd_bextpg]);
 		if (nd->nd_bextpg == 0)
 			nd->nd_bpos += m->m_epg_1st_off;
 		if (offs > 0) {
diff --git a/sys/fs/nfs/nfsm_subs.h b/sys/fs/nfs/nfsm_subs.h
index c15f3d1de848..a8b9fc4d2276 100644
--- a/sys/fs/nfs/nfsm_subs.h
+++ b/sys/fs/nfs/nfsm_subs.h
@@ -72,8 +72,7 @@ nfsm_build(struct nfsrv_descript *nd, int siz)
 	} else if ((nd->nd_flag & ND_EXTPG) != 0) {
 		if (siz > nd->nd_bextpgsiz) {
 			mb2 = mb_alloc_ext_plus_pages(PAGE_SIZE, M_WAITOK);
-			nd->nd_bpos = (char *)(void *)
-			    PHYS_TO_DMAP(mb2->m_epg_pa[0]);
+			nd->nd_bpos = PHYS_TO_DMAP(mb2->m_epg_pa[0]);
 			nd->nd_bextpg = 0;
 			nd->nd_bextpgsiz = PAGE_SIZE - siz;
 			nd->nd_mb->m_next = mb2;
diff --git a/sys/fs/nfsclient/nfs_clcomsubs.c b/sys/fs/nfsclient/nfs_clcomsubs.c
index 2b48e257381e..d76eecd2762f 100644
--- a/sys/fs/nfsclient/nfs_clcomsubs.c
+++ b/sys/fs/nfsclient/nfs_clcomsubs.c
@@ -86,8 +86,8 @@ nfsm_uiombuf(struct nfsrv_descript *nd, struct uio *uiop, int siz)
 				if ((nd->nd_flag & ND_EXTPG) != 0) {
 					mp = nfsm_add_ext_pgs(mp,
 					    nd->nd_maxextsiz, &nd->nd_bextpg);
-					mcp = (char *)(void *)PHYS_TO_DMAP(
-					  mp->m_epg_pa[nd->nd_bextpg]);
+					mcp = PHYS_TO_DMAP(
+					    mp->m_epg_pa[nd->nd_bextpg]);
 					nd->nd_bextpgsiz = mlen = PAGE_SIZE;
 				} else {
 					if (clflg)
@@ -137,8 +137,7 @@ nfsm_uiombuf(struct nfsrv_descript *nd, struct uio *uiop, int siz)
 		    nd->nd_bextpgsiz) {
 			mp = nfsm_add_ext_pgs(mp, nd->nd_maxextsiz,
 			    &nd->nd_bextpg);
-			mcp = (char *)(void *)
-			    PHYS_TO_DMAP(mp->m_epg_pa[nd->nd_bextpg]);
+			mcp = PHYS_TO_DMAP(mp->m_epg_pa[nd->nd_bextpg]);
 			nd->nd_bextpgsiz = PAGE_SIZE;
 		}
 		for (left = 0; left < rem; left++)
@@ -172,7 +171,7 @@ nfsm_uiombuflist(struct uio *uiop, int siz, u_int maxext)
 
 	if (maxext > 0) {
 		mp = mb_alloc_ext_plus_pages(PAGE_SIZE, M_WAITOK);
-		mcp = (char *)(void *)PHYS_TO_DMAP(mp->m_epg_pa[0]);
+		mcp = PHYS_TO_DMAP(mp->m_epg_pa[0]);
 		extpg = 0;
 		extpgsiz = PAGE_SIZE;
 	} else {
@@ -205,8 +204,7 @@ nfsm_uiombuflist(struct uio *uiop, int siz, u_int maxext)
 					mp = nfsm_add_ext_pgs(mp, maxext,
 					    &extpg);
 					mlen = extpgsiz = PAGE_SIZE;
-					mcp = (char *)(void *)PHYS_TO_DMAP(
-					    mp->m_epg_pa[extpg]);
+					mcp = PHYS_TO_DMAP(mp->m_epg_pa[extpg]);
 				} else {
 					if (clflg)
 						NFSMCLGET(mp, M_WAITOK);
diff --git a/sys/fs/nfsclient/nfs_clrpcops.c b/sys/fs/nfsclient/nfs_clrpcops.c
index 130cc4990152..7d7228a974f4 100644
--- a/sys/fs/nfsclient/nfs_clrpcops.c
+++ b/sys/fs/nfsclient/nfs_clrpcops.c
@@ -9834,11 +9834,11 @@ nfsm_split(struct mbuf *mp, uint64_t xfer)
 
 		/* Copy the data after left to the new page. */
 		trim = plen - left;
-		cp = (char *)(void *)PHYS_TO_DMAP(m->m_epg_pa[pgno]);
+		cp = PHYS_TO_DMAP(m->m_epg_pa[pgno]);
 		if (pgno == 0)
 			cp += m->m_epg_1st_off;
 		cp += left;
-		cp2 = (char *)(void *)PHYS_TO_DMAP(m2->m_epg_pa[0]);
+		cp2 = PHYS_TO_DMAP(m2->m_epg_pa[0]);
 		if (pgno == m->m_epg_npgs - 1)
 			m2->m_epg_last_len = trim;
 		else {
diff --git a/sys/fs/nfsserver/nfs_nfsdport.c b/sys/fs/nfsserver/nfs_nfsdport.c
index 350785487a2b..13133e6fd165 100644
--- a/sys/fs/nfsserver/nfs_nfsdport.c
+++ b/sys/fs/nfsserver/nfs_nfsdport.c
@@ -1012,7 +1012,7 @@ nfsrv_createiovec_extpgs(int len, int maxextsiz, struct mbuf **mpp,
 			panic("nfsvno_createiovec_extpgs iov");
 		siz = min(PAGE_SIZE, left);
 		if (siz > 0) {
-			iv->iov_base = (void *)PHYS_TO_DMAP(m->m_epg_pa[pgno]);
+			iv->iov_base = PHYS_TO_DMAP(m->m_epg_pa[pgno]);
 			iv->iov_len = siz;
 			m->m_len += siz;
 			if (pgno == m->m_epg_npgs - 1)
@@ -7358,7 +7358,7 @@ nfsm_trimtrailing(struct nfsrv_descript *nd, struct mbuf *mb, char *bpos,
 	if ((mb->m_flags & M_EXTPG) != 0) {
 		KASSERT(bextpg >= 0 && bextpg < mb->m_epg_npgs,
 		    ("nfsm_trimtrailing: bextpg out of range"));
-		KASSERT(bpos == (char *)(void *)
+		KASSERT(bpos == (char *)
 		    PHYS_TO_DMAP(mb->m_epg_pa[bextpg]) + PAGE_SIZE - bextpgsiz,
 		    ("nfsm_trimtrailing: bextpgsiz bad!"));
 
diff --git a/sys/fs/nfsserver/nfs_nfsdserv.c b/sys/fs/nfsserver/nfs_nfsdserv.c
index 601d536d2456..7f43654ae06d 100644
--- a/sys/fs/nfsserver/nfs_nfsdserv.c
+++ b/sys/fs/nfsserver/nfs_nfsdserv.c
@@ -862,7 +862,7 @@ nfsrvd_readlink(struct nfsrv_descript *nd, __unused int isdgram,
 		nd->nd_mb = mpend;
 		if ((mpend->m_flags & M_EXTPG) != 0) {
 			nd->nd_bextpg = mpend->m_epg_npgs - 1;
-			nd->nd_bpos = (char *)(void *)
+			nd->nd_bpos =
 			    PHYS_TO_DMAP(mpend->m_epg_pa[nd->nd_bextpg]);
 			off = (nd->nd_bextpg == 0) ? mpend->m_epg_1st_off : 0;
 			nd->nd_bpos += off + mpend->m_epg_last_len;
@@ -1068,8 +1068,7 @@ nfsrvd_read(struct nfsrv_descript *nd, __unused int isdgram,
 		if ((m2->m_flags & M_EXTPG) != 0) {
 			nd->nd_flag |= ND_EXTPG;
 			nd->nd_bextpg = m2->m_epg_npgs - 1;
-			nd->nd_bpos = (char *)(void *)
-			    PHYS_TO_DMAP(m2->m_epg_pa[nd->nd_bextpg]);
+			nd->nd_bpos = PHYS_TO_DMAP(m2->m_epg_pa[nd->nd_bextpg]);
 			poff = (nd->nd_bextpg == 0) ? m2->m_epg_1st_off : 0;
 			nd->nd_bpos += poff + m2->m_epg_last_len;
 			nd->nd_bextpgsiz = PAGE_SIZE - m2->m_epg_last_len -
@@ -6431,7 +6430,7 @@ nfsrvd_getxattr(struct nfsrv_descript *nd, __unused int isdgram,
 			if ((mpend->m_flags & M_EXTPG) != 0) {
 				nd->nd_flag |= ND_EXTPG;
 				nd->nd_bextpg = mpend->m_epg_npgs - 1;
-				nd->nd_bpos = (char *)(void *)
+				nd->nd_bpos =
 				   PHYS_TO_DMAP(mpend->m_epg_pa[nd->nd_bextpg]);
 				off = (nd->nd_bextpg == 0) ?
 				    mpend->m_epg_1st_off : 0;
diff --git a/sys/fs/nfsserver/nfs_nfsdsubs.c b/sys/fs/nfsserver/nfs_nfsdsubs.c
index fdedf959f0e5..f4a934edede3 100644
--- a/sys/fs/nfsserver/nfs_nfsdsubs.c
+++ b/sys/fs/nfsserver/nfs_nfsdsubs.c
@@ -1347,7 +1347,7 @@ nfsrv_adj(struct mbuf *mp, int len, int nul)
 			m->m_epg_last_len = plen;
 			m->m_len = lastlen;
 		}
-		cp = (char *)(void *)PHYS_TO_DMAP(m->m_epg_pa[pgno]);
+		cp = PHYS_TO_DMAP(m->m_epg_pa[pgno]);
 		cp += off + plen - nul;
 	} else {
 		m->m_len = lastlen;
diff --git a/sys/i386/include/vmparam.h b/sys/i386/include/vmparam.h
index 6f8885a539c3..5a7055661896 100644
--- a/sys/i386/include/vmparam.h
+++ b/sys/i386/include/vmparam.h
@@ -234,7 +234,8 @@
 #define	SFBUF_PROCESS_PAGE
 
 #define	PMAP_HAS_DMAP	0
-#define	PHYS_TO_DMAP(x)	({ panic("No direct map exists"); 0; })
+#define	PHYS_TO_DMAP_ADDR(x)	({ panic("No direct map exists"); 0; })
+#define	PHYS_TO_DMAP(x)		((void *)PHYS_TO_DMAP_ADDR(x))
 #define	DMAP_TO_PHYS(x)	({ panic("No direct map exists"); 0; })
 
 /*
diff --git a/sys/kern/kern_mbuf.c b/sys/kern/kern_mbuf.c
index 2741778414f4..9144366a9ff3 100644
--- a/sys/kern/kern_mbuf.c
+++ b/sys/kern/kern_mbuf.c
@@ -1767,7 +1767,7 @@ mb_mapped_to_unmapped(struct mbuf *mp, int len, int mlen, int how,
 	m = mout = mb_alloc_ext_plus_pages(mbufsiz, how);
 	if (m == NULL)
 		return (m);
-	pgpos = (char *)(void *)PHYS_TO_DMAP(m->m_epg_pa[0]);
+	pgpos = PHYS_TO_DMAP(m->m_epg_pa[0]);
 	pglen = PAGE_SIZE;
 	mblen = 0;
 	i = 0;
@@ -1785,7 +1785,7 @@ mb_mapped_to_unmapped(struct mbuf *mp, int len, int mlen, int how,
 				}
 				i = 0;
 			}
-			pgpos = (char *)(void *)PHYS_TO_DMAP(m->m_epg_pa[i]);
+			pgpos = PHYS_TO_DMAP(m->m_epg_pa[i]);
 			pglen = PAGE_SIZE;
 		}
 		while (mblen == 0) {
diff --git a/sys/kern/subr_memdesc.c b/sys/kern/subr_memdesc.c
index ff8aad7731cd..2b4de0a1ef1e 100644
--- a/sys/kern/subr_memdesc.c
+++ b/sys/kern/subr_memdesc.c
@@ -56,7 +56,7 @@ phys_copyback(vm_paddr_t pa, int off, int size, const void *src)
 	page_off = pa & PAGE_MASK;
 	while (size > 0) {
 		todo = min(PAGE_SIZE - page_off, size);
-		p = (void *)PHYS_TO_DMAP(pa);
+		p = PHYS_TO_DMAP(pa);
 		memcpy(p, cp, todo);
 		size -= todo;
 		cp += todo;
@@ -204,7 +204,7 @@ phys_copydata(vm_paddr_t pa, int off, int size, void *dst)
 	page_off = pa & PAGE_MASK;
 	while (size > 0) {
 		todo = min(PAGE_SIZE - page_off, size);
-		p = (const void *)PHYS_TO_DMAP(pa);
+		p = PHYS_TO_DMAP(pa);
 		memcpy(cp, p, todo);
 		size -= todo;
 		cp += todo;
diff --git a/sys/kern/uipc_ktls.c b/sys/kern/uipc_ktls.c
index 5f30f2046965..5e8bf3ba8a5d 100644
--- a/sys/kern/uipc_ktls.c
+++ b/sys/kern/uipc_ktls.c
@@ -449,7 +449,7 @@ ktls_buffer_import(void *arg, void **store, int count, int domain, int flags)
 		    VM_MEMATTR_DEFAULT);
 		if (m == NULL)
 			break;
-		store[i] = (void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
+		store[i] = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
 	}
 	return (i);
 }
@@ -473,7 +473,7 @@ static void
 ktls_free_mext_contig(struct mbuf *m)
 {
 	M_ASSERTEXTPG(m);
-	uma_zfree(ktls_buffer_zone, (void *)PHYS_TO_DMAP(m->m_epg_pa[0]));
+	uma_zfree(ktls_buffer_zone, PHYS_TO_DMAP(m->m_epg_pa[0]));
 }
 
 static int
diff --git a/sys/kern/uipc_mbuf.c b/sys/kern/uipc_mbuf.c
index 377a36287e3e..b3632c0bfff6 100644
--- a/sys/kern/uipc_mbuf.c
+++ b/sys/kern/uipc_mbuf.c
@@ -1394,7 +1394,7 @@ m_apply_extpg_one(struct mbuf *m, int off, int len,
 		pglen = m_epg_pagelen(m, i, pgoff);
 		if (off < pglen) {
 			count = min(pglen - off, len);
-			p = (void *)PHYS_TO_DMAP(m->m_epg_pa[i] + pgoff + off);
+			p = PHYS_TO_DMAP(m->m_epg_pa[i] + pgoff + off);
 			rval = f(arg, p, count);
 			if (rval)
 				return (rval);
diff --git a/sys/opencrypto/criov.c b/sys/opencrypto/criov.c
index 72143e6abca7..ffe13bcca5bb 100644
--- a/sys/opencrypto/criov.c
+++ b/sys/opencrypto/criov.c
@@ -162,7 +162,7 @@ cvm_page_apply(vm_page_t *pages, int off, int len,
 	processed = 0;
 	CVM_PAGE_SKIP();
 	while (len > 0) {
-		char *kaddr = (char *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(*pages));
+		char *kaddr = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(*pages));
 		count = min(PAGE_SIZE - off, len);
 		rval = (*f)(arg, kaddr + off, count);
 		if (rval)
@@ -272,7 +272,7 @@ m_epg_segment(struct mbuf *m, size_t offset, size_t *len)
 		pglen = m_epg_pagelen(m, i, pgoff);
 		if (offset < pglen) {
 			*len = m_epg_pages_extent(m, i, pglen) - offset;
-			return ((void *)PHYS_TO_DMAP(m->m_epg_pa[i] + pgoff +
+			return (PHYS_TO_DMAP(m->m_epg_pa[i] + pgoff +
 			    offset));
 		}
 		offset -= pglen;
diff --git a/sys/opencrypto/ktls_ocf.c b/sys/opencrypto/ktls_ocf.c
index ece509f5f969..ae2409d334e9 100644
--- a/sys/opencrypto/ktls_ocf.c
+++ b/sys/opencrypto/ktls_ocf.c
@@ -326,8 +326,7 @@ ktls_ocf_tls_cbc_encrypt(struct ktls_ocf_encrypt_state *state,
 	iov[0].iov_len = sizeof(*ad);
 	pgoff = m->m_epg_1st_off;
 	for (i = 0; i < m->m_epg_npgs; i++, pgoff = 0) {
-		iov[i + 1].iov_base = (void *)PHYS_TO_DMAP(m->m_epg_pa[i] +
-		    pgoff);
+		iov[i + 1].iov_base = PHYS_TO_DMAP(m->m_epg_pa[i] + pgoff);
 		iov[i + 1].iov_len = m_epg_pagelen(m, i, pgoff);
 	}
 	iov[m->m_epg_npgs + 1].iov_base = m->m_epg_trail;
diff --git a/sys/powerpc/aim/mmu_oea64.c b/sys/powerpc/aim/mmu_oea64.c
index ebc1f68bc063..93787d31256b 100644
--- a/sys/powerpc/aim/mmu_oea64.c
+++ b/sys/powerpc/aim/mmu_oea64.c
@@ -704,7 +704,7 @@ moea64_add_ofw_mappings(phandle_t mmu, size_t sz)
 		for (off = 0; off < translations[i].om_len; off += PAGE_SIZE) {
 			/* If this address is direct-mapped, skip remapping */
 			if (hw_direct_map &&
-			    translations[i].om_va == PHYS_TO_DMAP(pa_base) &&
+			    translations[i].om_va == PHYS_TO_DMAP_ADDR(pa_base) &&
 			    moea64_calc_wimg(pa_base + off, VM_MEMATTR_DEFAULT)
  			    == LPTE_M)
 				continue;
@@ -825,7 +825,7 @@ moea64_setup_direct_map(vm_offset_t kernelstart,
 			    pregions[i].mr_start + pregions[i].mr_size)
 				pte_lo |= LPTE_G;
 
-			moea64_kenter_large(PHYS_TO_DMAP(pa), pa, pte_lo, 1);
+			moea64_kenter_large(PHYS_TO_DMAP_ADDR(pa), pa, pte_lo, 1);
 		  }
 		}
 		PMAP_UNLOCK(kernel_pmap);
@@ -1061,7 +1061,7 @@ moea64_mid_bootstrap(vm_offset_t kernelstart, vm_offset_t kernelend)
 
 	/* Place at address usable through the direct map */
 	if (hw_direct_map)
-		moea64_bpvo_pool = (struct pvo_entry *)PHYS_TO_DMAP(pa);
+		moea64_bpvo_pool = PHYS_TO_DMAP(pa);
 	else
 		moea64_bpvo_pool = (struct pvo_entry *)pa;
 
@@ -1446,14 +1446,13 @@ moea64_copy_page(vm_page_t msrc, vm_page_t mdst)
 void
 moea64_copy_page_dmap(vm_page_t msrc, vm_page_t mdst)
 {
-	vm_offset_t	dst;
-	vm_offset_t	src;
+	vm_paddr_t dst;
+	vm_paddr_t src;
 
 	dst = VM_PAGE_TO_PHYS(mdst);
 	src = VM_PAGE_TO_PHYS(msrc);
 
-	bcopy((void *)PHYS_TO_DMAP(src), (void *)PHYS_TO_DMAP(dst),
-	    PAGE_SIZE);
+	bcopy(PHYS_TO_DMAP(src), PHYS_TO_DMAP(dst), PAGE_SIZE);
 }
 
 inline void
@@ -1467,12 +1466,12 @@ moea64_copy_pages_dmap(vm_page_t *ma, vm_offset_t a_offset,
 	while (xfersize > 0) {
 		a_pg_offset = a_offset & PAGE_MASK;
 		cnt = min(xfersize, PAGE_SIZE - a_pg_offset);
-		a_cp = (char *)(uintptr_t)PHYS_TO_DMAP(
+		a_cp = (char *)PHYS_TO_DMAP(
 		    VM_PAGE_TO_PHYS(ma[a_offset >> PAGE_SHIFT])) +
 		    a_pg_offset;
 		b_pg_offset = b_offset & PAGE_MASK;
 		cnt = min(cnt, PAGE_SIZE - b_pg_offset);
-		b_cp = (char *)(uintptr_t)PHYS_TO_DMAP(
+		b_cp = (char *)PHYS_TO_DMAP(
 		    VM_PAGE_TO_PHYS(mb[b_offset >> PAGE_SHIFT])) +
 		    b_pg_offset;
 		bcopy(a_cp, b_cp, cnt);
@@ -1519,7 +1518,7 @@ moea64_zero_page_area(vm_page_t m, int off, int size)
 		panic("moea64_zero_page: size + off > PAGE_SIZE");
 
 	if (hw_direct_map) {
-		bzero((caddr_t)(uintptr_t)PHYS_TO_DMAP(pa) + off, size);
+		bzero((caddr_t)PHYS_TO_DMAP(pa) + off, size);
 	} else {
 		mtx_lock(&moea64_scratchpage_mtx);
 		moea64_set_scratchpage_pa(0, pa);
@@ -1551,10 +1550,10 @@ void
 moea64_zero_page_dmap(vm_page_t m)
 {
 	vm_paddr_t pa = VM_PAGE_TO_PHYS(m);
-	vm_offset_t va;
+	void *va;
 
 	va = PHYS_TO_DMAP(pa);
-	bzero((void *)va, PAGE_SIZE);
+	bzero(va, PAGE_SIZE);
 }
 
 void *
@@ -1587,7 +1586,7 @@ void *
 moea64_quick_enter_page_dmap(vm_page_t m)
 {
 
-	return ((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)));
+	return (PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)));
 }
 
 void
@@ -1766,7 +1765,7 @@ moea64_syncicache(pmap_t pmap, vm_offset_t va, vm_paddr_t pa,
 	} else if (pmap == kernel_pmap) {
 		__syncicache((void *)va, sz);
 	} else if (hw_direct_map) {
-		__syncicache((void *)(uintptr_t)PHYS_TO_DMAP(pa), sz);
+		__syncicache(PHYS_TO_DMAP(pa), sz);
 	} else {
 		/* Use the scratch page to set up a temp mapping */
 
@@ -2334,7 +2333,7 @@ moea64_map(vm_offset_t *virt, vm_paddr_t pa_start,
 			if (moea64_calc_wimg(va, VM_MEMATTR_DEFAULT) != LPTE_M)
 				break;
 		if (va == pa_end)
-			return ((void *)PHYS_TO_DMAP(pa_start));
+			return (PHYS_TO_DMAP(pa_start));
 	}
 	sva = *virt;
 	va = sva;
diff --git a/sys/powerpc/aim/mmu_radix.c b/sys/powerpc/aim/mmu_radix.c
index cdfb979e2f87..63159107d856 100644
--- a/sys/powerpc/aim/mmu_radix.c
+++ b/sys/powerpc/aim/mmu_radix.c
@@ -331,7 +331,7 @@ pmap_l3e_to_pte(pt_entry_t *l3e, vm_offset_t va)
 	vm_paddr_t ptepa;
 
 	ptepa = (be64toh(*l3e) & NLB_MASK);
-	pte = (pt_entry_t *)PHYS_TO_DMAP(ptepa);
+	pte = PHYS_TO_DMAP(ptepa);
 	return (&pte[pmap_pte_index(va)]);
 }
 
@@ -343,7 +343,7 @@ pmap_l2e_to_l3e(pt_entry_t *l2e, vm_offset_t va)
 	vm_paddr_t l3pa;
 
 	l3pa = (be64toh(*l2e) & NLB_MASK);
-	l3e = (pml3_entry_t *)PHYS_TO_DMAP(l3pa);
+	l3e = PHYS_TO_DMAP(l3pa);
 	return (&l3e[pmap_pml3e_index(va)]);
 }
 
@@ -356,7 +356,7 @@ pmap_l1e_to_l2e(pt_entry_t *l1e, vm_offset_t va)
 
 	l2pa = (be64toh(*l1e) & NLB_MASK);
 
-	l2e = (pml2_entry_t *)PHYS_TO_DMAP(l2pa);
+	l2e = PHYS_TO_DMAP(l2pa);
 	return (&l2e[pmap_pml2e_index(va)]);
 }
 
@@ -883,11 +883,11 @@ pmap_resident_count_dec(pmap_t pmap, int count)
 }
 
 static void
-pagezero(vm_offset_t va)
+pagezero(void *va)
 {
 	va = trunc_page(va);
 
-	bzero((void *)va, PAGE_SIZE);
+	bzero(va, PAGE_SIZE);
 }
 
 static uint64_t
@@ -1224,7 +1224,7 @@ retry:
 		PV_STAT(atomic_add_int(&pc_chunk_count, 1));
 		PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
 		dump_add_page(m->phys_addr);
-		pc = (void *)PHYS_TO_DMAP(m->phys_addr);
+		pc = PHYS_TO_DMAP(m->phys_addr);
 		pc->pc_pmap = pmap;
 		pc->pc_map[0] = PC_FREE0;
 		pc->pc_map[1] = PC_FREE1;
@@ -1649,7 +1649,7 @@ retry:
 	PV_STAT(atomic_add_int(&pc_chunk_count, 1));
 	PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
 	dump_add_page(m->phys_addr);
-	pc = (void *)PHYS_TO_DMAP(m->phys_addr);
+	pc = PHYS_TO_DMAP(m->phys_addr);
 	pc->pc_pmap = pmap;
 	pc->pc_map[0] = PC_FREE0 & ~1ul;	/* preallocated bit 0 */
 	pc->pc_map[1] = PC_FREE1;
@@ -1787,12 +1787,12 @@ mmu_radix_dmap_range(vm_paddr_t start, vm_paddr_t end)
 		printf("%s %lx -> %lx\n", __func__, start, end);
 	while (start < end) {
 		pteval = start | DMAP_PAGE_BITS;
-		pte = pmap_pml1e(kernel_pmap, PHYS_TO_DMAP(start));
+		pte = pmap_pml1e(kernel_pmap, PHYS_TO_DMAP_ADDR(start));
 		if ((be64toh(*pte) & RPTE_VALID) == 0) {
 			page = alloc_pt_page();
 			pde_store(pte, page);
 		}
-		pte = pmap_l1e_to_l2e(pte, PHYS_TO_DMAP(start));
+		pte = pmap_l1e_to_l2e(pte, PHYS_TO_DMAP_ADDR(start));
 		if ((start & L2_PAGE_MASK) == 0 &&
 			end - start >= L2_PAGE_SIZE) {
 			start += L2_PAGE_SIZE;
@@ -1802,7 +1802,7 @@ mmu_radix_dmap_range(vm_paddr_t start, vm_paddr_t end)
 			pde_store(pte, page);
 		}
 
-		pte = pmap_l2e_to_l3e(pte, PHYS_TO_DMAP(start));
+		pte = pmap_l2e_to_l3e(pte, PHYS_TO_DMAP_ADDR(start));
 		if ((start & L3_PAGE_MASK) == 0 &&
 			end - start >= L3_PAGE_SIZE) {
 			start += L3_PAGE_SIZE;
@@ -1811,7 +1811,7 @@ mmu_radix_dmap_range(vm_paddr_t start, vm_paddr_t end)
 			page = alloc_pt_page();
 			pde_store(pte, page);
 		}
-		pte = pmap_l3e_to_pte(pte, PHYS_TO_DMAP(start));
+		pte = pmap_l3e_to_pte(pte, PHYS_TO_DMAP_ADDR(start));
 		start += PAGE_SIZE;
 	done:
 		pte_store(pte, pteval);
@@ -1853,7 +1853,7 @@ mmu_radix_setup_pagetables(vm_size_t hwphyssz)
 	MPASS((l1phys & (RADIX_PGD_SIZE-1)) == 0);
 	for (int i = 0; i < RADIX_PGD_SIZE/PAGE_SIZE; i++)
 		pagezero(PHYS_TO_DMAP(l1phys + i * PAGE_SIZE));
-	kernel_pmap->pm_pml1 = (pml1_entry_t *)PHYS_TO_DMAP(l1phys);
+	kernel_pmap->pm_pml1 = PHYS_TO_DMAP(l1phys);
 
 	mmu_radix_dmap_populate(hwphyssz);
 
@@ -2095,13 +2095,13 @@ mmu_radix_late_bootstrap(vm_offset_t start, vm_offset_t end)
 	 * Allocate virtual address space for the message buffer.
 	 */
 	pa = msgbuf_phys = allocpages((msgbufsize + PAGE_MASK)  >> PAGE_SHIFT);
-	msgbufp = (struct msgbuf *)PHYS_TO_DMAP(pa);
+	msgbufp = PHYS_TO_DMAP(pa);
 
 	/*
 	 * Allocate virtual address space for the dynamic percpu area.
 	 */
 	pa = allocpages(DPCPU_SIZE >> PAGE_SHIFT);
-	dpcpu = (void *)PHYS_TO_DMAP(pa);
+	dpcpu = PHYS_TO_DMAP(pa);
 	dpcpu_init(dpcpu, curcpu);
 
 	crashdumpmap = (caddr_t)virtual_avail;
@@ -2118,7 +2118,7 @@ mmu_parttab_init(void)
 {
 	uint64_t ptcr;
 
-	isa3_parttab = (struct pate *)PHYS_TO_DMAP(parttab_phys);
+	isa3_parttab = PHYS_TO_DMAP(parttab_phys);
 
 	if (bootverbose)
 		printf("%s parttab: %p\n", __func__, isa3_parttab);
@@ -2179,7 +2179,7 @@ mmu_radix_proctab_init(void)
 
 	isa3_base_pid = 1;
 
-	isa3_proctab = (void*)PHYS_TO_DMAP(proctab0pa);
+	isa3_proctab = PHYS_TO_DMAP(proctab0pa);
 	isa3_proctab->proctab0 =
 	    htobe64(RTS_SIZE | DMAP_TO_PHYS(kernel_pmap->pm_pml1) |
 		RADIX_PGD_INDEX_SHIFT);
@@ -2577,8 +2577,7 @@ mmu_radix_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr,
 			dst_pdpg = pmap_allocl3e(dst_pmap, addr, NULL);
 			if (dst_pdpg == NULL)
 				break;
-			l3e = (pml3_entry_t *)
-			    PHYS_TO_DMAP(VM_PAGE_TO_PHYS(dst_pdpg));
+			l3e = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(dst_pdpg));
 			l3e = &l3e[pmap_pml3e_index(addr)];
 			if (be64toh(*l3e) == 0 && ((srcptepaddr & PG_MANAGED) == 0 ||
 			    pmap_pv_insert_l3e(dst_pmap, addr, srcptepaddr,
@@ -2600,7 +2599,7 @@ mmu_radix_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr,
 		if (va_next > end_addr)
 			va_next = end_addr;
 
-		src_pte = (pt_entry_t *)PHYS_TO_DMAP(srcptepaddr);
+		src_pte = PHYS_TO_DMAP(srcptepaddr);
 		src_pte = &src_pte[pmap_pte_index(addr)];
 		dstmpte = NULL;
 		while (addr < va_next) {
@@ -2616,7 +2615,7 @@ mmu_radix_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr,
 				else if ((dstmpte = pmap_allocpte(dst_pmap,
 				    addr, NULL)) == NULL)
 					goto out;
-				dst_pte = (pt_entry_t *)
+				dst_pte =
 				    PHYS_TO_DMAP(VM_PAGE_TO_PHYS(dstmpte));
 				dst_pte = &dst_pte[pmap_pte_index(addr)];
 				if (be64toh(*dst_pte) == 0 &&
@@ -2671,14 +2670,14 @@ out:
 static void
 mmu_radix_copy_page(vm_page_t msrc, vm_page_t mdst)
 {
-	vm_offset_t src = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(msrc));
-	vm_offset_t dst = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mdst));
+	void *src = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(msrc));
+	void *dst = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mdst));
 
 	CTR3(KTR_PMAP, "%s(%p, %p)", __func__, src, dst);
 	/*
 	 * XXX slow
 	 */
-	bcopy((void *)src, (void *)dst, PAGE_SIZE);
+	bcopy(src, dst, PAGE_SIZE);
 }
 
 static void
@@ -2695,12 +2694,12 @@ mmu_radix_copy_pages(vm_page_t ma[], vm_offset_t a_offset, vm_page_t mb[],
         while (xfersize > 0) {
                 a_pg_offset = a_offset & PAGE_MASK;
                 cnt = min(xfersize, PAGE_SIZE - a_pg_offset);
-                a_cp = (char *)(uintptr_t)PHYS_TO_DMAP(
-                    VM_PAGE_TO_PHYS(ma[a_offset >> PAGE_SHIFT])) +
+                a_cp = (char *)PHYS_TO_DMAP(
+		    VM_PAGE_TO_PHYS(ma[a_offset >> PAGE_SHIFT])) +
                     a_pg_offset;
                 b_pg_offset = b_offset & PAGE_MASK;
                 cnt = min(cnt, PAGE_SIZE - b_pg_offset);
-                b_cp = (char *)(uintptr_t)PHYS_TO_DMAP(
+                b_cp = (char *)PHYS_TO_DMAP(
                     VM_PAGE_TO_PHYS(mb[b_offset >> PAGE_SHIFT])) +
                     b_pg_offset;
                 bcopy(a_cp, b_cp, cnt);
@@ -2733,7 +2732,7 @@ pmap_promote_l3e(pmap_t pmap, pml3_entry_t *pde, vm_offset_t va,
 	 * either invalid, unused, or does not map the first 4KB physical page
 	 * within a 2MB page.
 	 */
-	firstpte = (pt_entry_t *)PHYS_TO_DMAP(be64toh(*pde) & PG_FRAME);
+	firstpte = PHYS_TO_DMAP(be64toh(*pde) & PG_FRAME);
 setpde:
 	newpde = be64toh(*firstpte);
 	if ((newpde & ((PG_FRAME & L3_PAGE_MASK) | PG_A | PG_V)) != (PG_A | PG_V)) {
@@ -3217,7 +3216,7 @@ pmap_enter_l3e(pmap_t pmap, vm_offset_t va, pml3_entry_t newpde, u_int flags,
 		    " in pmap %p", va, pmap);
 		return (KERN_RESOURCE_SHORTAGE);
 	}
-	l3e = (pml3_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pdpg));
+	l3e = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pdpg));
 	l3e = &l3e[pmap_pml3e_index(va)];
 	oldl3e = be64toh(*l3e);
 	if ((oldl3e & PG_V) != 0) {
@@ -3280,8 +3279,7 @@ pmap_enter_l3e(pmap_t pmap, vm_offset_t va, pml3_entry_t newpde, u_int flags,
 		}
 		pmap_resident_count_inc(pmap, 1);
 		uwptpg->ref_count = NPTEPG;
-		pmap_fill_ptp((pt_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(uwptpg)),
-		    newpde);
+		pmap_fill_ptp(PHYS_TO_DMAP(VM_PAGE_TO_PHYS(uwptpg)), newpde);
 	}
 	if ((newpde & PG_MANAGED) != 0) {
 		/*
@@ -3424,7 +3422,7 @@ mmu_radix_enter_quick_locked(pmap_t pmap, vm_offset_t va, vm_page_t m,
 					return (mpte);
 			}
 		}
-		pte = (pt_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mpte));
+		pte = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mpte));
 		pte = &pte[pmap_pte_index(va)];
 	} else {
 		mpte = NULL;
@@ -3631,7 +3629,7 @@ radix_pgd_import(void *arg __unused, void **store, int count, int domain __unuse
 		    RADIX_PGD_SIZE / PAGE_SIZE,
 		    0, (vm_paddr_t)-1, RADIX_PGD_SIZE, L1_PAGE_SIZE,
 		    VM_MEMATTR_DEFAULT);
-		store[i] = (void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
+		store[i] = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
 	}
 	return (count);
 }
@@ -4037,7 +4035,7 @@ mmu_radix_map(vm_offset_t *virt __unused, vm_paddr_t start,
 
 	CTR5(KTR_PMAP, "%s(%p, %#x, %#x, %#x)", __func__, virt, start, end,
 		 prot);
-	return ((void *)PHYS_TO_DMAP(start));
+	return (PHYS_TO_DMAP(start));
 }
 
 void
@@ -4106,7 +4104,7 @@ mmu_radix_object_init_pt(pmap_t pmap, vm_offset_t addr,
 				addr += L3_PAGE_SIZE;
 				continue;
 			}
-			l3e = (pml3_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pdpg));
+			l3e = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pdpg));
 			l3e = &l3e[pmap_pml3e_index(addr)];
 			if ((be64toh(*l3e) & PG_V) == 0) {
 				pa |= PG_M | PG_A | PG_RW;
@@ -4256,7 +4254,7 @@ mmu_radix_pinit(pmap_t pmap)
 	pmap->pm_pml1 = uma_zalloc(zone_radix_pgd, M_WAITOK);
 
 	for (int j = 0; j <  RADIX_PGD_SIZE_SHIFT; j++)
-		pagezero((vm_offset_t)pmap->pm_pml1 + j * PAGE_SIZE);
+		pagezero((char *)pmap->pm_pml1 + j * PAGE_SIZE);
 	vm_radix_init(&pmap->pm_radix);
 	TAILQ_INIT(&pmap->pm_pvchunk);
 	bzero(&pmap->pm_stats, sizeof pmap->pm_stats);
@@ -4346,7 +4344,7 @@ _pmap_allocpte(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp)
 			pdppg = PHYS_TO_VM_PAGE(be64toh(*l1e) & PG_FRAME);
 			pdppg->ref_count++;
 		}
-		l2e = (pml2_entry_t *)PHYS_TO_DMAP(be64toh(*l1e) & PG_FRAME);
+		l2e = PHYS_TO_DMAP(be64toh(*l1e) & PG_FRAME);
 
 		/* Now find the pdp page */
 		l2e = &l2e[pdpindex & RPTE_MASK];
@@ -4374,10 +4372,10 @@ _pmap_allocpte(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp)
 				vm_page_free_zero(m);
 				return (NULL);
 			}
-			l2e = (pml2_entry_t *)PHYS_TO_DMAP(be64toh(*l1e) & PG_FRAME);
+			l2e = PHYS_TO_DMAP(be64toh(*l1e) & PG_FRAME);
 			l2e = &l2e[pdpindex & RPTE_MASK];
 		} else {
-			l2e = (pml2_entry_t *)PHYS_TO_DMAP(be64toh(*l1e) & PG_FRAME);
+			l2e = PHYS_TO_DMAP(be64toh(*l1e) & PG_FRAME);
 			l2e = &l2e[pdpindex & RPTE_MASK];
 			if ((be64toh(*l2e) & PG_V) == 0) {
 				/* Have to allocate a new pd, recurse */
@@ -4393,7 +4391,7 @@ _pmap_allocpte(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp)
 				pdpg->ref_count++;
 			}
 		}
-		l3e = (pml3_entry_t *)PHYS_TO_DMAP(be64toh(*l2e) & PG_FRAME);
+		l3e = PHYS_TO_DMAP(be64toh(*l2e) & PG_FRAME);
 
 		/* Now we know where the page directory page is */
 		l3e = &l3e[ptepindex & RPTE_MASK];
@@ -4977,7 +4975,7 @@ pmap_demote_l3e_locked(pmap_t pmap, pml3_entry_t *l3e, vm_offset_t va,
 			pmap_resident_count_inc(pmap, 1);
 	}
 	mptepa = VM_PAGE_TO_PHYS(mpte);
-	firstpte = (pt_entry_t *)PHYS_TO_DMAP(mptepa);
+	firstpte = PHYS_TO_DMAP(mptepa);
 	KASSERT((oldpde & PG_A) != 0,
 	    ("pmap_demote_l3e: oldpde is missing PG_A"));
 	KASSERT((oldpde & (PG_M | PG_RW)) != PG_RW,
@@ -5496,8 +5494,7 @@ mmu_radix_remove_pages(pmap_t pmap)
 				if ((tpte & (RPTE_LEAF | PG_V)) == PG_V) {
 					superpage = false;
 					ptel3e = tpte;
-					pte = (pt_entry_t *)PHYS_TO_DMAP(tpte &
-					    PG_FRAME);
+					pte = PHYS_TO_DMAP(tpte & PG_FRAME);
 					pte = &pte[pmap_pte_index(pv->pv_va)];
 					tpte = be64toh(*pte);
 				} else {
@@ -5783,7 +5780,7 @@ mmu_radix_unwire(pmap_t pmap, vm_offset_t sva, vm_offset_t eva)
 void
 mmu_radix_zero_page(vm_page_t m)
 {
-	vm_offset_t addr;
+	void *addr;
 
 	CTR2(KTR_PMAP, "%s(%p)", __func__, m);
 	addr = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
@@ -5797,7 +5794,7 @@ mmu_radix_zero_page_area(vm_page_t m, int off, int size)
 
 	CTR4(KTR_PMAP, "%s(%p, %d, %d)", __func__, m, off, size);
 	MPASS(off + size <= PAGE_SIZE);
-	addr = (caddr_t)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
+	addr = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
 	memset(addr + off, 0, size);
 }
 
@@ -5948,7 +5945,7 @@ mmu_radix_page_set_memattr(vm_page_t m, vm_memattr_t ma)
 	 * required for data coherence.
 	 */
 	if ((m->flags & PG_FICTITIOUS) == 0 &&
-	    mmu_radix_change_attr((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)),
+	    mmu_radix_change_attr(PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)),
 	    PAGE_SIZE, m->md.mdpg_cache_attrs))
 		panic("memory attribute change on the direct map failed");
 }
@@ -5990,7 +5987,7 @@ mmu_radix_sync_icache(pmap_t pm, vm_offset_t va, vm_size_t sz)
 		sync_sz = min(sync_sz, sz);
 		if (pa != 0) {
 			pa += (va & PAGE_MASK);
-			__syncicache((void *)PHYS_TO_DMAP(pa), sync_sz);
+			__syncicache(PHYS_TO_DMAP(pa), sync_sz);
 		}
 		va += sync_sz;
 		sz -= sync_sz;
@@ -6036,7 +6033,7 @@ pmap_demote_l2e(pmap_t pmap, pml2_entry_t *l2e, vm_offset_t va)
 	}
 	pdpg->pindex = va >> L2_PAGE_SIZE_SHIFT;
 	pdpgpa = VM_PAGE_TO_PHYS(pdpg);
-	firstpde = (pml3_entry_t *)PHYS_TO_DMAP(pdpgpa);
+	firstpde = PHYS_TO_DMAP(pdpgpa);
 	KASSERT((oldpdpe & PG_A) != 0,
 	    ("pmap_demote_pdpe: oldpdpe is missing PG_A"));
 	KASSERT((oldpdpe & (PG_M | PG_RW)) != PG_RW,
@@ -6185,7 +6182,7 @@ mmu_radix_quick_enter_page(vm_page_t m)
 
 	CTR2(KTR_PMAP, "%s(%p)", __func__, m);
 	paddr = VM_PAGE_TO_PHYS(m);
-	return ((void *)PHYS_TO_DMAP(paddr));
+	return (PHYS_TO_DMAP(paddr));
 }
 
 void
@@ -6332,7 +6329,7 @@ pmap_change_attr_locked(void *addr, vm_size_t size, int mode, bool flush)
 				else {
 					/* Run ended, update direct map. */
 					error = pmap_change_attr_locked(
-					    (void *)PHYS_TO_DMAP(pa_start),
+					    PHYS_TO_DMAP(pa_start),
 					    pa_end - pa_start, mode, flush);
 					if (error != 0)
 						break;
@@ -6362,7 +6359,7 @@ pmap_change_attr_locked(void *addr, vm_size_t size, int mode, bool flush)
 				else {
 					/* Run ended, update direct map. */
 					error = pmap_change_attr_locked(
-					    (void *)PHYS_TO_DMAP(pa_start),
+					    PHYS_TO_DMAP(pa_start),
 					    pa_end - pa_start, mode, flush);
 					if (error != 0)
 						break;
@@ -6390,7 +6387,7 @@ pmap_change_attr_locked(void *addr, vm_size_t size, int mode, bool flush)
 				else {
 					/* Run ended, update direct map. */
 					error = pmap_change_attr_locked(
-					    (void *)PHYS_TO_DMAP(pa_start),
+					    PHYS_TO_DMAP(pa_start),
 					    pa_end - pa_start, mode, flush);
 					if (error != 0)
 						break;
@@ -6405,7 +6402,7 @@ pmap_change_attr_locked(void *addr, vm_size_t size, int mode, bool flush)
 	if (error == 0 && pa_start != pa_end && pa_start < dmaplimit) {
 		pa_end1 = MIN(pa_end, dmaplimit);
 		if (pa_start != pa_end1)
-			error = pmap_change_attr_locked((void *)PHYS_TO_DMAP(pa_start),
+			error = pmap_change_attr_locked(PHYS_TO_DMAP(pa_start),
 			    pa_end1 - pa_start, mode, flush);
 	}
 
diff --git a/sys/powerpc/aim/moea64_native.c b/sys/powerpc/aim/moea64_native.c
index 169a4da7598b..351c93829635 100644
--- a/sys/powerpc/aim/moea64_native.c
+++ b/sys/powerpc/aim/moea64_native.c
@@ -610,14 +610,14 @@ moea64_bootstrap_native(vm_offset_t kernelstart, vm_offset_t kernelend)
 	 */
 	pa = moea64_bootstrap_alloc(size, MAX(256*1024, size));
 	if (hw_direct_map)
-		moea64_pteg_table = (struct lpte *)PHYS_TO_DMAP(pa);
+		moea64_pteg_table = PHYS_TO_DMAP(pa);
 	else
 		moea64_pteg_table = (struct lpte *)pa;
 
 	/* Allocate partition table (ISA 3.0). */
 	if (cpu_features2 & PPC_FEATURE2_ARCH_3_00) {
 		pa = moea64_bootstrap_alloc(PART_SIZE, PART_SIZE);
-		moea64_part_table = (struct pate *)PHYS_TO_DMAP(pa);
+		moea64_part_table = PHYS_TO_DMAP(pa);
 	}
 	DISABLE_TRANS(msr);
 	bzero(__DEVOLATILE(void *, moea64_pteg_table), moea64_pteg_count *
diff --git a/sys/powerpc/aim/slb.c b/sys/powerpc/aim/slb.c
index bd008234c40f..00e3577001cd 100644
--- a/sys/powerpc/aim/slb.c
+++ b/sys/powerpc/aim/slb.c
@@ -505,7 +505,7 @@ slb_uma_real_alloc(uma_zone_t zone, vm_size_t bytes, int domain,
 		return (NULL);
 
 	if (hw_direct_map)
-		va = (void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
+		va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
 	else {
 		va = (void *)(VM_PAGE_TO_PHYS(m) | DMAP_BASE_ADDRESS);
 		pmap_kenter((vm_offset_t)va, VM_PAGE_TO_PHYS(m));
diff --git a/sys/powerpc/booke/pmap.c b/sys/powerpc/booke/pmap.c
index 315e86aa64a9..625d57940c01 100644
--- a/sys/powerpc/booke/pmap.c
+++ b/sys/powerpc/booke/pmap.c
@@ -1580,7 +1580,7 @@ mmu_booke_map(vm_offset_t *virt, vm_paddr_t pa_start,
 #ifdef __powerpc64__
 	/* XXX: Handle memory not starting at 0x0. */
 	if (pa_end < ctob(Maxmem))
-		return ((void *)PHYS_TO_DMAP(pa_start));
+		return (PHYS_TO_DMAP(pa_start));
 #endif
 
 	while (pa_start < pa_end) {
diff --git a/sys/powerpc/booke/pmap_64.c b/sys/powerpc/booke/pmap_64.c
index a233248da4bd..6e08103f315c 100644
--- a/sys/powerpc/booke/pmap_64.c
+++ b/sys/powerpc/booke/pmap_64.c
@@ -148,7 +148,7 @@ static void kernel_pte_alloc(vm_offset_t, vm_offset_t);
 /**************************************************************************/
 
 /* Allocate a page, to be used in a page table. */
-static vm_offset_t
+static void *
 mmu_booke_alloc_page(pmap_t pmap, unsigned int idx, bool nosleep)
 {
 	vm_page_t	m;
@@ -254,19 +254,19 @@ unhold_free_page(pmap_t pmap, vm_page_t m)
 	return (false);
 }
 
-static vm_offset_t
-get_pgtbl_page(pmap_t pmap, vm_offset_t *ptr_tbl, uint32_t index,
+static void *
+get_pgtbl_page(pmap_t pmap, void **ptr_tbl, uint32_t index,
     bool nosleep, bool hold_parent, bool *isnew)
 {
-	vm_offset_t	page;
+	void		*page;
 	vm_page_t	m;
 
 	page = ptr_tbl[index];
 	KASSERT(page != 0 || pmap != kernel_pmap,
 	    ("NULL page table page found in kernel pmap!"));
-	if (page == 0) {
+	if (page == NULL) {
 		page = mmu_booke_alloc_page(pmap, index, nosleep);
-		if (ptr_tbl[index] == 0) {
+		if (ptr_tbl[index] == NULL) {
 			*isnew = true;
 			ptr_tbl[index] = page;
 			if (hold_parent) {
@@ -293,18 +293,18 @@ ptbl_alloc(pmap_t pmap, vm_offset_t va, bool nosleep, bool *is_new)
 	unsigned int	pg_root_idx = PG_ROOT_IDX(va);
 	unsigned int	pdir_l1_idx = PDIR_L1_IDX(va);
 	unsigned int	pdir_idx = PDIR_IDX(va);
-	vm_offset_t	pdir_l1, pdir, ptbl;
+	void		*pdir_l1, *pdir, *ptbl;
 
 	/* When holding a parent, no need to hold the root index pages. */
-	pdir_l1 = get_pgtbl_page(pmap, (vm_offset_t *)pmap->pm_root,
+	pdir_l1 = get_pgtbl_page(pmap, (void **)pmap->pm_root,
 	    pg_root_idx, nosleep, false, is_new);
-	if (pdir_l1 == 0)
+	if (pdir_l1 == NULL)
 		return (NULL);
-	pdir = get_pgtbl_page(pmap, (vm_offset_t *)pdir_l1, pdir_l1_idx,
+	pdir = get_pgtbl_page(pmap, pdir_l1, pdir_l1_idx,
 	    nosleep, !*is_new, is_new);
-	if (pdir == 0)
+	if (pdir == NULL)
 		return (NULL);
-	ptbl = get_pgtbl_page(pmap, (vm_offset_t *)pdir, pdir_idx,
+	ptbl = get_pgtbl_page(pmap, pdir, pdir_idx,
 	    nosleep, !*is_new, is_new);
 
 	return ((pte_t *)ptbl);
@@ -648,7 +648,7 @@ mmu_booke_sync_icache(pmap_t pm, vm_offset_t va, vm_size_t sz)
 		sync_sz = min(sync_sz, sz);
 		if (valid) {
 			pa += (va & PAGE_MASK);
-			__syncicache((void *)PHYS_TO_DMAP(pa), sync_sz);
+			__syncicache(PHYS_TO_DMAP(pa), sync_sz);
 		}
 		va += sync_sz;
 		sz -= sync_sz;
@@ -665,12 +665,12 @@ mmu_booke_sync_icache(pmap_t pm, vm_offset_t va, vm_size_t sz)
 static void
 mmu_booke_zero_page_area(vm_page_t m, int off, int size)
 {
-	vm_offset_t va;
+	char *va;
 
 	/* XXX KASSERT off and size are within a single page? */
 
 	va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
-	bzero((caddr_t)va + off, size);
+	bzero(va + off, size);
 }
 
 /*
@@ -679,11 +679,11 @@ mmu_booke_zero_page_area(vm_page_t m, int off, int size)
 static void
 mmu_booke_zero_page(vm_page_t m)
 {
-	vm_offset_t va;
+	void *va;
 
 	va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
 
-	bzero((void *)va, PAGE_SIZE);
+	bzero(va, PAGE_SIZE);
 }
 
 /*
@@ -694,11 +694,11 @@ mmu_booke_zero_page(vm_page_t m)
 static void
 mmu_booke_copy_page(vm_page_t sm, vm_page_t dm)
 {
-	vm_offset_t sva, dva;
+	void *sva, *dva;
 
 	sva = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(sm));
 	dva = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(dm));
-	memcpy((caddr_t)dva, (caddr_t)sva, PAGE_SIZE);
+	memcpy(dva, sva, PAGE_SIZE);
 }
 
 static inline void
@@ -718,10 +718,8 @@ mmu_booke_copy_pages(vm_page_t *ma, vm_offset_t a_offset,
 		pb = mb[b_offset >> PAGE_SHIFT];
 		cnt = min(xfersize, PAGE_SIZE - a_pg_offset);
 		cnt = min(cnt, PAGE_SIZE - b_pg_offset);
-		a_cp = (caddr_t)((uintptr_t)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pa)) +
-		    a_pg_offset);
-		b_cp = (caddr_t)((uintptr_t)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pb)) +
-		    b_pg_offset);
+		a_cp = (caddr_t)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pa)) + a_pg_offset;
+		b_cp = (caddr_t)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(pb)) + b_pg_offset;
 		bcopy(a_cp, b_cp, cnt);
 		a_offset += cnt;
 		b_offset += cnt;
@@ -732,7 +730,7 @@ mmu_booke_copy_pages(vm_page_t *ma, vm_offset_t a_offset,
 static void *
 mmu_booke_quick_enter_page(vm_page_t m)
 {
-	return ((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)));
+	return (PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)));
 }
 
 static void
diff --git a/sys/powerpc/include/vmparam.h b/sys/powerpc/include/vmparam.h
index 052fb2ab60af..3dbc79d41a69 100644
--- a/sys/powerpc/include/vmparam.h
+++ b/sys/powerpc/include/vmparam.h
@@ -312,9 +312,10 @@ extern	int vm_level_0_order;
 #endif
 
 #define	PMAP_HAS_DMAP	(hw_direct_map)
-#define PHYS_TO_DMAP(x) ({						\
+#define PHYS_TO_DMAP_ADDR(x) ({						\
 	KASSERT(hw_direct_map, ("Direct map not provided by PMAP"));	\
 	(x) | DMAP_BASE_ADDRESS; })
+#define	PHYS_TO_DMAP(x)	((void *)PHYS_TO_DMAP_ADDR(x))
 #define DMAP_TO_PHYS(x) ({						\
 	KASSERT(hw_direct_map, ("Direct map not provided by PMAP"));	\
 	(uintptr_t)(x) &~ DMAP_BASE_ADDRESS; })
diff --git a/sys/powerpc/ofw/ofw_initrd.c b/sys/powerpc/ofw/ofw_initrd.c
index f8d8a9551e0e..7828ee8d5054 100644
--- a/sys/powerpc/ofw/ofw_initrd.c
+++ b/sys/powerpc/ofw/ofw_initrd.c
@@ -92,7 +92,7 @@ ofw_initrd_probe_and_attach(void *junk)
 	}
 
 	if (end - start > 0) {
-		taste = (u_char*) PHYS_TO_DMAP(start);
+		taste = PHYS_TO_DMAP(start);
 		memcpy(&ehdr, taste, sizeof(ehdr));
 
 		if (IS_ELF(ehdr)) {
diff --git a/sys/powerpc/ofw/ofw_machdep.c b/sys/powerpc/ofw/ofw_machdep.c
index bffc04b15259..b1256c05b24d 100644
--- a/sys/powerpc/ofw/ofw_machdep.c
+++ b/sys/powerpc/ofw/ofw_machdep.c
@@ -94,7 +94,7 @@ ofw_save_trap_vec(char *save_trap_vec)
 	if (!ofw_real_mode || !hw_direct_map)
                 return;
 
-	bcopy((void *)PHYS_TO_DMAP(EXC_RST), save_trap_vec, EXC_LAST - EXC_RST);
+	bcopy(PHYS_TO_DMAP(EXC_RST), save_trap_vec, EXC_LAST - EXC_RST);
 }
 
 static __inline void
@@ -103,9 +103,8 @@ ofw_restore_trap_vec(char *restore_trap_vec)
 	if (!ofw_real_mode || !hw_direct_map)
                 return;
 
-	bcopy(restore_trap_vec, (void *)PHYS_TO_DMAP(EXC_RST),
-	    EXC_LAST - EXC_RST);
-	__syncicache((void *)PHYS_TO_DMAP(EXC_RSVD), EXC_LAST - EXC_RSVD);
+	bcopy(restore_trap_vec, PHYS_TO_DMAP(EXC_RST), EXC_LAST - EXC_RST);
+	__syncicache(PHYS_TO_DMAP(EXC_RSVD), EXC_LAST - EXC_RSVD);
 }
 
 #pragma clang diagnostic pop
diff --git a/sys/powerpc/powerpc/bus_machdep.c b/sys/powerpc/powerpc/bus_machdep.c
index e908750961d0..2c76f2758807 100644
--- a/sys/powerpc/powerpc/bus_machdep.c
+++ b/sys/powerpc/powerpc/bus_machdep.c
@@ -115,7 +115,7 @@ bs_remap_earlyboot(void)
 		spa = earlyboot_mappings[i].addr;
 
 		if (hw_direct_map &&
-		   PHYS_TO_DMAP(spa) == earlyboot_mappings[i].virt &&
+		   PHYS_TO_DMAP_ADDR(spa) == earlyboot_mappings[i].virt &&
 		   pmap_dev_direct_mapped(spa, earlyboot_mappings[i].size) == 0)
 			continue;
 
diff --git a/sys/powerpc/powerpc/machdep.c b/sys/powerpc/powerpc/machdep.c
index a98f095cadc0..a975bebebaad 100644
--- a/sys/powerpc/powerpc/machdep.c
+++ b/sys/powerpc/powerpc/machdep.c
@@ -562,7 +562,7 @@ load_external_symtab(void) {
 	if (!(end - start > 0))
 		return;
 
-	kernelimg_final = (u_char *) PHYS_TO_DMAP(start);
+	kernelimg_final = PHYS_TO_DMAP(start);
 #ifdef	AIM
 	kernelimg = kernelimg_final;
 #else	/* BOOKE */
diff --git a/sys/powerpc/powerpc/mem.c b/sys/powerpc/powerpc/mem.c
index 8ee562350dd6..51eb6ac3bec5 100644
--- a/sys/powerpc/powerpc/mem.c
+++ b/sys/powerpc/powerpc/mem.c
@@ -125,8 +125,7 @@ kmem_direct_mapped:	off = v & PAGE_MASK;
 			}
 
 			if (hw_direct_map && !pmap_dev_direct_mapped(v, cnt)) {
-				error = uiomove((void *)PHYS_TO_DMAP(v), cnt,
-				    uio);
+				error = uiomove(PHYS_TO_DMAP(v), cnt, uio);
 			} else {
 				m.phys_addr = trunc_page(v);
 				marr = &m;
diff --git a/sys/powerpc/powerpc/uma_machdep.c b/sys/powerpc/powerpc/uma_machdep.c
index 923a348d35a7..f5e3b8b3356d 100644
--- a/sys/powerpc/powerpc/uma_machdep.c
+++ b/sys/powerpc/powerpc/uma_machdep.c
@@ -67,7 +67,7 @@ uma_small_alloc(uma_zone_t zone, vm_size_t bytes, int domain, u_int8_t *flags,
 		pmap_kenter(pa, pa);
 		va = (void *)(vm_offset_t)pa;
 	} else {
-		va = (void *)(vm_offset_t)PHYS_TO_DMAP(pa);
+		va = PHYS_TO_DMAP(pa);
 	}
 	atomic_add_int(&hw_uma_mdpages, 1);
 
diff --git a/sys/powerpc/ps3/platform_ps3.c b/sys/powerpc/ps3/platform_ps3.c
index 556f723a0134..dff951305622 100644
--- a/sys/powerpc/ps3/platform_ps3.c
+++ b/sys/powerpc/ps3/platform_ps3.c
@@ -223,8 +223,7 @@ static int
 ps3_smp_start_cpu(platform_t plat, struct pcpu *pc)
 {
 	/* kernel is spinning on 0x40 == -1 right now */
-	volatile uint32_t *secondary_spin_sem =
-	    (uint32_t *)PHYS_TO_DMAP((uintptr_t)0x40);
+	volatile uint32_t *secondary_spin_sem = PHYS_TO_DMAP((uintptr_t)0x40);
 	int remote_pir = pc->pc_hwref;
 	int timeout;
 
diff --git a/sys/riscv/include/sf_buf.h b/sys/riscv/include/sf_buf.h
index 293b44726a7c..1ea67076e676 100644
--- a/sys/riscv/include/sf_buf.h
+++ b/sys/riscv/include/sf_buf.h
@@ -37,7 +37,7 @@ static inline void *
 sf_buf_kva(struct sf_buf *sf)
 {
 
-	return ((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS((vm_page_t)sf)));
+	return (PHYS_TO_DMAP(VM_PAGE_TO_PHYS((vm_page_t)sf)));
 }
 
 static inline vm_page_t
diff --git a/sys/riscv/include/vmparam.h b/sys/riscv/include/vmparam.h
index b9f4b9fc802f..50580face894 100644
--- a/sys/riscv/include/vmparam.h
+++ b/sys/riscv/include/vmparam.h
@@ -179,13 +179,14 @@
 })
 
 #define	PMAP_HAS_DMAP	1
-#define	PHYS_TO_DMAP(pa)						\
+#define	PHYS_TO_DMAP_ADDR(pa)						\
 ({									\
 	KASSERT(PHYS_IN_DMAP(pa),					\
 	    ("%s: PA out of range, PA: 0x%lx", __func__,		\
 	    (vm_paddr_t)(pa)));						\
 	((pa) - dmap_phys_base) + DMAP_MIN_ADDRESS;			\
 })
+#define	PHYS_TO_DMAP(x)		((void *)PHYS_TO_DMAP_ADDR(x))
 
 #define	DMAP_TO_PHYS(va)						\
 ({									\
diff --git a/sys/riscv/riscv/mem.c b/sys/riscv/riscv/mem.c
index 9792c01fa673..ce0848b0312f 100644
--- a/sys/riscv/riscv/mem.c
+++ b/sys/riscv/riscv/mem.c
@@ -105,8 +105,7 @@ memrw(struct cdev *dev, struct uio *uio, int flags)
 		case CDEV_MINOR_MEM:
 			/* If within the DMAP use this to copy from */
 			if (PHYS_IN_DMAP(v)) {
-				v = PHYS_TO_DMAP(v);
-				error = uiomove((void *)v, cnt, uio);
+				error = uiomove(PHYS_TO_DMAP(v), cnt, uio);
 				break;
 			}
 
diff --git a/sys/riscv/riscv/minidump_machdep.c b/sys/riscv/riscv/minidump_machdep.c
index 596be14015d9..3f8dc5ee439c 100644
--- a/sys/riscv/riscv/minidump_machdep.c
+++ b/sys/riscv/riscv/minidump_machdep.c
@@ -130,7 +130,7 @@ blk_write(struct dumperinfo *di, char *ptr, vm_paddr_t pa, size_t sz)
 			ptr += len;
 			sz -= len;
 		} else {
-			dump_va = (void *)PHYS_TO_DMAP(pa);
+			dump_va = PHYS_TO_DMAP(pa);
 			fragsz += len;
 			pa += len;
 			sz -= len;
diff --git a/sys/riscv/riscv/pmap.c b/sys/riscv/riscv/pmap.c
index bae106dcbfbc..a49265250850 100644
--- a/sys/riscv/riscv/pmap.c
+++ b/sys/riscv/riscv/pmap.c
@@ -419,7 +419,7 @@ pmap_l0_to_l1(pd_entry_t *l0, vm_offset_t va)
 
 	KASSERT(pmap_mode != PMAP_MODE_SV39, ("%s: in SV39 mode", __func__));
 	phys = PTE_TO_PHYS(pmap_load(l0));
-	l1 = (pd_entry_t *)PHYS_TO_DMAP(phys);
+	l1 = PHYS_TO_DMAP(phys);
 
 	return (&l1[pmap_l1_index(va)]);
 }
@@ -450,7 +450,7 @@ pmap_l1_to_l2(pd_entry_t *l1, vm_offset_t va)
 	pd_entry_t *l2;
 
 	phys = PTE_TO_PHYS(pmap_load(l1));
-	l2 = (pd_entry_t *)PHYS_TO_DMAP(phys);
+	l2 = PHYS_TO_DMAP(phys);
 
 	return (&l2[pmap_l2_index(va)]);
 }
@@ -478,7 +478,7 @@ pmap_l2_to_l3(pd_entry_t *l2, vm_offset_t va)
 	pt_entry_t *l3;
 
 	phys = PTE_TO_PHYS(pmap_load(l2));
-	l3 = (pd_entry_t *)PHYS_TO_DMAP(phys);
+	l3 = PHYS_TO_DMAP(phys);
 
 	return (&l3[pmap_l3_index(va)]);
 }
@@ -627,7 +627,7 @@ pmap_bootstrap_dmap(pd_entry_t *l1, vm_paddr_t freemempos)
 		endpa = physmap[idx + 1];
 
 		/* Virtual address for this range. */
-		va = PHYS_TO_DMAP(pa);
+		va = PHYS_TO_DMAP_ADDR(pa);
 
 		/* Any 2MB possible for this range? */
 		if (roundup(pa, L2_SIZE) + L2_SIZE > endpa)
@@ -954,7 +954,7 @@ pmap_bootstrap(vm_paddr_t kernstart, vm_size_t kernlen)
 
 	/* Switch to the newly created page tables. */
 	kernel_pmap->pm_stage = PM_STAGE1;
-	kernel_pmap->pm_top = (pd_entry_t *)PHYS_TO_DMAP(root_pt_phys);
+	kernel_pmap->pm_top = PHYS_TO_DMAP(root_pt_phys);
 	kernel_pmap->pm_satp = atop(root_pt_phys) | pmap_satp_mode();
 	csr_write(satp, kernel_pmap->pm_satp);
 	sfence_vma();
@@ -1372,7 +1372,7 @@ void *
 pmap_map(vm_offset_t *virt, vm_paddr_t start, vm_paddr_t end, int prot)
 {
 
-	return ((void *)PHYS_TO_DMAP(start));
+	return (PHYS_TO_DMAP(start));
 }
 
 /*
@@ -1627,7 +1627,7 @@ pmap_pinit_stage(pmap_t pmap, enum pmap_stage stage)
 		    4, 0, ~0ul, L2_SIZE, 0, VM_MEMATTR_DEFAULT);
 
 	topphys = VM_PAGE_TO_PHYS(m);
-	pmap->pm_top = (pd_entry_t *)PHYS_TO_DMAP(topphys);
+	pmap->pm_top = PHYS_TO_DMAP(topphys);
 	pmap->pm_satp = pmap_satp_mode() | (topphys >> PAGE_SHIFT);
 	pmap->pm_stage = stage;
 
@@ -1757,7 +1757,7 @@ _pmap_alloc_l3(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp)
 				pdpg = PHYS_TO_VM_PAGE(phys);
 				pdpg->ref_count++;
 			}
-			l1 = (pd_entry_t *)PHYS_TO_DMAP(phys);
+			l1 = PHYS_TO_DMAP(phys);
 			l1 = &l1[ptepindex & Ln_ADDR_MASK];
 		}
 		KASSERT((pmap_load(l1) & PTE_V) == 0,
@@ -1791,11 +1791,11 @@ _pmap_alloc_l3(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp)
 				    lockp) == NULL)
 					goto fail;
 				phys = PTE_TO_PHYS(pmap_load(l0));
-				l1 = (pd_entry_t *)PHYS_TO_DMAP(phys);
+				l1 = PHYS_TO_DMAP(phys);
 				l1 = &l1[l1index & Ln_ADDR_MASK];
 			} else {
 				phys = PTE_TO_PHYS(pmap_load(l0));
-				l1 = (pd_entry_t *)PHYS_TO_DMAP(phys);
+				l1 = PHYS_TO_DMAP(phys);
 				l1 = &l1[l1index & Ln_ADDR_MASK];
 				if (pmap_load(l1) == 0) {
 					/* Recurse to allocate the L2 page. */
@@ -1810,7 +1810,7 @@ _pmap_alloc_l3(pmap_t pmap, vm_pindex_t ptepindex, struct rwlock **lockp)
 		}
 
 		phys = PTE_TO_PHYS(pmap_load(l1));
-		l2 = (pd_entry_t *)PHYS_TO_DMAP(phys);
+		l2 = PHYS_TO_DMAP(phys);
 		l2 = &l2[ptepindex & Ln_ADDR_MASK];
 		KASSERT((pmap_load(l2) & PTE_V) == 0,
 		    ("%s: L2 entry %#lx is valid", __func__, pmap_load(l2)));
@@ -2194,7 +2194,7 @@ retry:
 	PV_STAT(atomic_add_int(&pc_chunk_count, 1));
 	PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
 	dump_add_page(m->phys_addr);
-	pc = (void *)PHYS_TO_DMAP(m->phys_addr);
+	pc = PHYS_TO_DMAP(m->phys_addr);
 	pc->pc_pmap = pmap;
 	pc->pc_map[0] = PC_FREEN & ~1ul;	/* preallocated bit 0 */
 	pc->pc_map[1] = PC_FREEN;
@@ -2257,7 +2257,7 @@ retry:
 		PV_STAT(atomic_add_int(&pc_chunk_count, 1));
 		PV_STAT(atomic_add_int(&pc_chunk_allocs, 1));
 		dump_add_page(m->phys_addr);
-		pc = (void *)PHYS_TO_DMAP(m->phys_addr);
+		pc = PHYS_TO_DMAP(m->phys_addr);
 		pc->pc_pmap = pmap;
 		pc->pc_map[0] = PC_FREEN;
 		pc->pc_map[1] = PC_FREEN;
@@ -2491,7 +2491,7 @@ pmap_remove_kernel_l2(pmap_t pmap, pt_entry_t *l2, vm_offset_t va)
 	 * contains valid mappings.  Zero it to invalidate those mappings.
 	 */
 	if (vm_page_any_valid(ml3))
-		pagezero((void *)PHYS_TO_DMAP(ml3pa));
+		pagezero(PHYS_TO_DMAP(ml3pa));
 
 	/*
 	 * Demote the mapping.
@@ -2988,7 +2988,7 @@ pmap_demote_l1(pmap_t pmap, pd_entry_t *l1, vm_offset_t va)
 	}
 
 	l2phys = VM_PAGE_TO_PHYS(m);
-	l2 = (pt_entry_t *)PHYS_TO_DMAP(l2phys);
+	l2 = PHYS_TO_DMAP(l2phys);
 
 	/*
 	 * Create new entries, relying on the fact that only the low bits
@@ -3069,7 +3069,7 @@ pmap_demote_l2_locked(pmap_t pmap, pd_entry_t *l2, vm_offset_t va,
 		}
 	}
 	mptepa = VM_PAGE_TO_PHYS(mpte);
-	firstl3 = (pt_entry_t *)PHYS_TO_DMAP(mptepa);
+	firstl3 = PHYS_TO_DMAP(mptepa);
 	newl2 = ((mptepa / PAGE_SIZE) << PTE_PPN0_S) | PTE_V;
 	KASSERT((oldl2 & PTE_A) != 0,
 	    ("pmap_demote_l2_locked: oldl2 is missing PTE_A"));
@@ -3144,7 +3144,7 @@ pmap_promote_l2(pmap_t pmap, pd_entry_t *l2, vm_offset_t va, vm_page_t ml3,
 	 * ineligible for promotion or does not map the first 4KB physical page
 	 * within a 2MB page.
 	 */
-	firstl3 = (pt_entry_t *)PHYS_TO_DMAP(PTE_TO_PHYS(pmap_load(l2)));
+	firstl3 = PHYS_TO_DMAP(PTE_TO_PHYS(pmap_load(l2)));
 	firstl3e = pmap_load(firstl3);
 	pa = PTE_TO_PHYS(firstl3e);
 	if ((pa & L2_OFFSET) != 0) {
@@ -3544,7 +3544,7 @@ pmap_every_pte_zero(vm_paddr_t pa)
 	pt_entry_t *pt_end, *pte;
 
 	KASSERT((pa & PAGE_MASK) == 0, ("pa is misaligned"));
-	pte = (pt_entry_t *)PHYS_TO_DMAP(pa);
+	pte = PHYS_TO_DMAP(pa);
 	for (pt_end = pte + Ln_ENTRIES; pte < pt_end; pte++) {
 		if (*pte != 0)
 			return (false);
@@ -3585,7 +3585,7 @@ pmap_enter_l2(pmap_t pmap, vm_offset_t va, pd_entry_t new_l2, u_int flags,
 		return (KERN_RESOURCE_SHORTAGE);
 	}
 
-	l2 = (pd_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(l2pg));
+	l2 = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(l2pg));
 	l2 = &l2[pmap_l2_index(va)];
 	if ((oldl2 = pmap_load(l2)) != 0) {
 		KASSERT(l2pg->ref_count > 1,
@@ -3827,7 +3827,7 @@ pmap_enter_quick_locked(pmap_t pmap, vm_offset_t va, vm_page_t m,
 					return (mpte);
 			}
 		}
-		l3 = (pt_entry_t *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mpte));
+		l3 = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mpte));
 		l3 = &l3[pmap_l3_index(va)];
 	} else {
 		mpte = NULL;
@@ -4032,9 +4032,9 @@ pmap_copy(pmap_t dst_pmap, pmap_t src_pmap, vm_offset_t dst_addr, vm_size_t len,
 void
 pmap_zero_page(vm_page_t m)
 {
-	vm_offset_t va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
+	void *va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
 
-	pagezero((void *)va);
+	pagezero(va);
 }
 
 /*
@@ -4046,10 +4046,10 @@ pmap_zero_page(vm_page_t m)
 void
 pmap_zero_page_area(vm_page_t m, int off, int size)
 {
-	vm_offset_t va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
+	void *va = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m));
 
 	if (off == 0 && size == PAGE_SIZE)
-		pagezero((void *)va);
+		pagezero(va);
 	else
 		bzero((char *)va + off, size);
 }
@@ -4063,10 +4063,10 @@ pmap_zero_page_area(vm_page_t m, int off, int size)
 void
 pmap_copy_page(vm_page_t msrc, vm_page_t mdst)
 {
-	vm_offset_t src = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(msrc));
-	vm_offset_t dst = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mdst));
+	void *src = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(msrc));
+	void *dst = PHYS_TO_DMAP(VM_PAGE_TO_PHYS(mdst));
 
-	pagecopy((void *)src, (void *)dst);
+	pagecopy(src, dst);
 }
 
 int unmapped_buf_allowed = 1;
@@ -4111,7 +4111,7 @@ void *
 pmap_quick_enter_page(vm_page_t m)
 {
 
-	return ((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)));
+	return (PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)));
 }
 
 void
@@ -4903,7 +4903,7 @@ void *
 pmap_mapbios(vm_paddr_t pa, vm_size_t size)
 {
 
-        return ((void *)PHYS_TO_DMAP(pa));
+        return (PHYS_TO_DMAP(pa));
 }
 
 void
@@ -4928,7 +4928,7 @@ pmap_page_set_memattr(vm_page_t m, vm_memattr_t ma)
 	 * required for data coherence.
 	 */
 	if ((m->flags & PG_FICTITIOUS) == 0 &&
-	    pmap_change_attr((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)), PAGE_SIZE,
+	    pmap_change_attr(PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)), PAGE_SIZE,
 	    m->md.pv_memattr) != 0)
 		panic("memory attribute change on the direct map failed");
 }
@@ -5062,7 +5062,7 @@ pmap_change_attr_locked(void *addr, vm_size_t size, int mode)
 			phys = L1PTE_TO_PHYS(l1e);
 			if (!VIRT_IN_DMAP(tmpva) && PHYS_IN_DMAP(phys)) {
 				error = pmap_change_attr_locked(
-				    (void *)PHYS_TO_DMAP(phys), L1_SIZE, mode);
+				    PHYS_TO_DMAP(phys), L1_SIZE, mode);
 				if (error != 0)
 					break;
 			}
@@ -5088,7 +5088,7 @@ pmap_change_attr_locked(void *addr, vm_size_t size, int mode)
 			phys = L2PTE_TO_PHYS(l2e);
 			if (!VIRT_IN_DMAP(tmpva) && PHYS_IN_DMAP(phys)) {
 				error = pmap_change_attr_locked(
-				    (void *)PHYS_TO_DMAP(phys), L2_SIZE, mode);
+				    PHYS_TO_DMAP(phys), L2_SIZE, mode);
 				if (error != 0)
 					break;
 			}
@@ -5112,7 +5112,7 @@ pmap_change_attr_locked(void *addr, vm_size_t size, int mode)
 
 		phys = PTE_TO_PHYS(l3e);
 		if (!VIRT_IN_DMAP(tmpva) && PHYS_IN_DMAP(phys)) {
-			error = pmap_change_attr_locked((void *)PHYS_TO_DMAP(phys),
+			error = pmap_change_attr_locked(PHYS_TO_DMAP(phys),
 			    L3_SIZE, mode);
 			if (error != 0)
 				break;
@@ -5323,7 +5323,7 @@ pmap_map_io_transient(vm_page_t page[], void *vaddr[], int count,
 			vaddr[i] = (void *)addr;
 			needs_mapping = true;
 		} else {
-			vaddr[i] = (void *)PHYS_TO_DMAP(paddr);
+			vaddr[i] = PHYS_TO_DMAP(paddr);
 		}
 	}
 
@@ -5558,7 +5558,7 @@ sysctl_kmaps(SYSCTL_HANDLER_ARGS)
 			continue;
 		}
 		pa = PTE_TO_PHYS(l1e);
-		l2 = (pd_entry_t *)PHYS_TO_DMAP(pa);
+		l2 = PHYS_TO_DMAP(pa);
 
 		for (j = pmap_l2_index(sva); j < Ln_ENTRIES; j++) {
 			l2e = l2[j];
@@ -5574,7 +5574,7 @@ sysctl_kmaps(SYSCTL_HANDLER_ARGS)
 				continue;
 			}
 			pa = PTE_TO_PHYS(l2e);
-			l3 = (pd_entry_t *)PHYS_TO_DMAP(pa);
+			l3 = PHYS_TO_DMAP(pa);
 
 			for (k = pmap_l3_index(sva); k < Ln_ENTRIES; k++,
 			    sva += L3_SIZE) {
diff --git a/sys/sys/efi.h b/sys/sys/efi.h
index b76ca4918f81..72c5bccd810b 100644
--- a/sys/sys/efi.h
+++ b/sys/sys/efi.h
@@ -265,7 +265,7 @@ struct efirt_callinfo;
 /* Internal MD EFI functions */
 int efi_arch_enter(void);
 void efi_arch_leave(void);
-vm_offset_t efi_phys_to_kva(vm_paddr_t);
+void *efi_phys_to_kva(vm_paddr_t);
 int efi_rt_arch_call(struct efirt_callinfo *);
 bool efi_create_1t1_map(struct efi_md *, int, int);
 void efi_destroy_1t1_map(void);
diff --git a/sys/sys/sf_buf.h b/sys/sys/sf_buf.h
index b11170d1fd5d..b03615237110 100644
--- a/sys/sys/sf_buf.h
+++ b/sys/sys/sf_buf.h
@@ -114,7 +114,7 @@ static inline void *
 sf_buf_kva(struct sf_buf *sf)
 {
 	if (PMAP_HAS_DMAP)
-		return ((void *)PHYS_TO_DMAP(VM_PAGE_TO_PHYS((vm_page_t)sf)));
+		return (PHYS_TO_DMAP(VM_PAGE_TO_PHYS((vm_page_t)sf)));
 
         return ((void *)sf->kva);
 }
diff --git a/sys/vm/uma_core.c b/sys/vm/uma_core.c
index 5342d8ccd217..8070db40c06d 100644
--- a/sys/vm/uma_core.c
+++ b/sys/vm/uma_core.c
@@ -2094,7 +2094,7 @@ uma_small_alloc(uma_zone_t zone, vm_size_t bytes, int domain, uint8_t *flags,
 	pa = m->phys_addr;
 	if ((wait & M_NODUMP) == 0)
 		dump_add_page(pa);
-	va = (void *)PHYS_TO_DMAP(pa);
+	va = PHYS_TO_DMAP(pa);
 	return (va);
 }
 #endif