diff --git a/sys/compat/linuxkpi/common/include/linux/seqlock.h b/sys/compat/linuxkpi/common/include/linux/seqlock.h
--- a/sys/compat/linuxkpi/common/include/linux/seqlock.h
+++ b/sys/compat/linuxkpi/common/include/linux/seqlock.h
@@ -99,7 +99,7 @@
 static inline seqc_t
 lkpi_seqprop_sequence(const seqc_t *seqcp)
 {
-	return (atomic_load_int(__DECONST(seqc_t *, seqcp)));
+	return (atomic_load_int(seqcp));
 }
 #define	seqprop_sequence(s)	lkpi_seqprop_sequence(&(s)->seqc)
 
diff --git a/sys/riscv/include/atomic.h b/sys/riscv/include/atomic.h
--- a/sys/riscv/include/atomic.h
+++ b/sys/riscv/include/atomic.h
@@ -569,7 +569,7 @@
 ATOMIC_FCMPSET_ACQ_REL(64);
 
 static __inline uint64_t
-atomic_load_acq_64(volatile uint64_t *p)
+atomic_load_acq_64(const volatile uint64_t *p)
 {
 	uint64_t ret;
 
diff --git a/sys/sys/atomic_common.h b/sys/sys/atomic_common.h
--- a/sys/sys/atomic_common.h
+++ b/sys/sys/atomic_common.h
@@ -133,7 +133,7 @@
  * openly resorting to the stronger acquire fence, to be sorted out.
  */
 #define	atomic_load_consume_ptr(p)	\
-    ((__typeof(*p)) atomic_load_acq_ptr((uintptr_t *)p))
+    ((__typeof(*p)) atomic_load_acq_ptr((const volatile uintptr_t *)p))
 
 #define	atomic_interrupt_fence()	__compiler_membar()
 
diff --git a/sys/sys/atomic_san.h b/sys/sys/atomic_san.h
--- a/sys/sys/atomic_san.h
+++ b/sys/sys/atomic_san.h
@@ -266,11 +266,10 @@
 #define	atomic_fcmpset_rel_ptr		ATOMIC_SAN(fcmpset_rel_ptr)
 #define	atomic_fetchadd_ptr		ATOMIC_SAN(fetchadd_ptr)
 #define	atomic_load_ptr(x)						\
-	((__typeof(*x))ATOMIC_SAN(load_ptr)(				\
-	    __DECONST(volatile uintptr_t *, (x))))
+	((__typeof(*x))ATOMIC_SAN(load_ptr)((const volatile uintptr_t *)(x)))
 #define	atomic_load_acq_ptr		ATOMIC_SAN(load_acq_ptr)
 #define	atomic_load_consume_ptr(x)					\
-	((__typeof(*x))atomic_load_acq_ptr((volatile uintptr_t *)(x)))
+	((__typeof(*x))atomic_load_acq_ptr((const volatile uintptr_t *)(x)))
 #define	atomic_readandclear_ptr		ATOMIC_SAN(readandclear_ptr)
 #define	atomic_set_ptr			ATOMIC_SAN(set_ptr)
 #define	atomic_set_acq_ptr		ATOMIC_SAN(set_acq_ptr)
diff --git a/sys/sys/seqc.h b/sys/sys/seqc.h
--- a/sys/sys/seqc.h
+++ b/sys/sys/seqc.h
@@ -78,14 +78,14 @@
 seqc_read_any(const seqc_t *seqcp)
 {
 
-	return (atomic_load_acq_int(__DECONST(seqc_t *, seqcp)));
+	return (atomic_load_acq_int(seqcp));
 }
 
 static __inline seqc_t
 seqc_read_notmodify(const seqc_t *seqcp)
 {
 
-	return (atomic_load_acq_int(__DECONST(seqc_t *, seqcp)) & ~SEQC_MOD);
+	return (atomic_load_acq_int(seqcp) & ~SEQC_MOD);
 }
 
 static __inline seqc_t
diff --git a/sys/sys/smr_types.h b/sys/sys/smr_types.h
--- a/sys/sys/smr_types.h
+++ b/sys/sys/smr_types.h
@@ -60,7 +60,8 @@
  */
 #define	smr_entered_load(p, smr) ({					\
 	SMR_ASSERT(SMR_ENTERED((smr)), "smr_entered_load");		\
-	(__typeof((p)->__ptr))atomic_load_acq_ptr((uintptr_t *)&(p)->__ptr); \
+	(__typeof((p)->__ptr))atomic_load_acq_ptr(			\
+	    (const uintptr_t *)&(p)->__ptr);				\
 })
 
 /*
@@ -70,7 +71,8 @@
  */
 #define	smr_serialized_load(p, ex) ({					\
 	SMR_ASSERT(ex, "smr_serialized_load");				\
-	(__typeof((p)->__ptr))atomic_load_ptr(&(p)->__ptr);		\
+	(__typeof((p)->__ptr))atomic_load_ptr(				\
+	    (const uintptr_t *)&(p)->__ptr);				\
 })
 
 /*