diff --git a/boards/arduino-duemilanove/Makefile.dep b/boards/arduino-duemilanove/Makefile.dep
index 580e800f2fcd..bf4b2e2e3668 100644
--- a/boards/arduino-duemilanove/Makefile.dep
+++ b/boards/arduino-duemilanove/Makefile.dep
@@ -1,3 +1,7 @@
 USEMODULE += boards_common_arduino-atmega
 
 include $(RIOTBOARD)/common/arduino-atmega/Makefile.dep
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/arduino-leonardo/Makefile.dep b/boards/arduino-leonardo/Makefile.dep
index 580e800f2fcd..d7f0ec5f89f1 100644
--- a/boards/arduino-leonardo/Makefile.dep
+++ b/boards/arduino-leonardo/Makefile.dep
@@ -1,3 +1,7 @@
 USEMODULE += boards_common_arduino-atmega
 
 include $(RIOTBOARD)/common/arduino-atmega/Makefile.dep
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE += mtd_eeprom
+endif
diff --git a/boards/arduino-nano/Makefile.dep b/boards/arduino-nano/Makefile.dep
index 580e800f2fcd..bf4b2e2e3668 100644
--- a/boards/arduino-nano/Makefile.dep
+++ b/boards/arduino-nano/Makefile.dep
@@ -1,3 +1,7 @@
 USEMODULE += boards_common_arduino-atmega
 
 include $(RIOTBOARD)/common/arduino-atmega/Makefile.dep
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/arduino-nano/include/board.h b/boards/arduino-nano/include/board.h
index 62a54ecf8461..2afc6c3a289e 100644
--- a/boards/arduino-nano/include/board.h
+++ b/boards/arduino-nano/include/board.h
@@ -10,7 +10,7 @@
  * @{
  *
  * @file
- * @brief       Board specific definitions for the Arduino Uno board
+ * @brief       Board specific definitions for the Arduino Nano board
  *
  * @author      Martine Lenders <m.lenders@fu-berlin.de>
  */
diff --git a/boards/arduino-uno/Makefile.dep b/boards/arduino-uno/Makefile.dep
index 580e800f2fcd..bf4b2e2e3668 100644
--- a/boards/arduino-uno/Makefile.dep
+++ b/boards/arduino-uno/Makefile.dep
@@ -1,3 +1,7 @@
 USEMODULE += boards_common_arduino-atmega
 
 include $(RIOTBOARD)/common/arduino-atmega/Makefile.dep
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/atmega256rfr2-xpro/Makefile.dep b/boards/atmega256rfr2-xpro/Makefile.dep
index 5fbb1fda53e0..ca096f6bca6d 100644
--- a/boards/atmega256rfr2-xpro/Makefile.dep
+++ b/boards/atmega256rfr2-xpro/Makefile.dep
@@ -5,3 +5,7 @@ ifneq (,$(filter saul_default,$(USEMODULE)))
   USEMODULE += at30tse75x
   USEMODULE += saul_gpio
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE += mtd_eeprom
+endif
diff --git a/boards/atmega328p-xplained-mini/Makefile.dep b/boards/atmega328p-xplained-mini/Makefile.dep
index a1b7040e408e..39680b634509 100644
--- a/boards/atmega328p-xplained-mini/Makefile.dep
+++ b/boards/atmega328p-xplained-mini/Makefile.dep
@@ -4,3 +4,7 @@ USEMODULE += atmega_pcint0
 ifneq (,$(filter saul_default,$(USEMODULE)))
   USEMODULE += saul_gpio
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/atmega8/Makefile.dep b/boards/atmega8/Makefile.dep
index 3d1c295b9b21..73ab1165da44 100644
--- a/boards/atmega8/Makefile.dep
+++ b/boards/atmega8/Makefile.dep
@@ -1 +1,5 @@
 USEMODULE += boards_common_atmega
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/avr-rss2/Makefile.dep b/boards/avr-rss2/Makefile.dep
index 0face22e340f..7027a20b7168 100644
--- a/boards/avr-rss2/Makefile.dep
+++ b/boards/avr-rss2/Makefile.dep
@@ -9,6 +9,7 @@ endif
 
 ifneq (,$(filter mtd,$(USEMODULE)))
   USEMODULE += mtd_at24cxxx at24mac
+  USEMODULE  += mtd_eeprom
 endif
 
 ifneq (,$(filter saul_default,$(USEMODULE)))
diff --git a/boards/b-l072z-lrwan1/Makefile.dep b/boards/b-l072z-lrwan1/Makefile.dep
index 6ed0cbb1b7fe..fc55709bd9b7 100644
--- a/boards/b-l072z-lrwan1/Makefile.dep
+++ b/boards/b-l072z-lrwan1/Makefile.dep
@@ -10,3 +10,7 @@ ifneq (,$(filter periph_spi,$(USEMODULE)))
   # The LED pin is also used for SPI
   DISABLE_MODULE += periph_init_led0
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/b-l072z-lrwan1/board.c b/boards/b-l072z-lrwan1/board.c
index 3612adb075e0..68656362bc6f 100644
--- a/boards/b-l072z-lrwan1/board.c
+++ b/boards/b-l072z-lrwan1/board.c
@@ -17,6 +17,12 @@
 
 #include "board.h"
 #include "periph/gpio.h"
+#include "mtd_eeprom.h"
+
+#if MODULE_MTD_EEPROM
+mtd_eeprom_t mtd_eeprom = MTD_EEPROM_INIT_VAL;
+MTD_XFA_ADD(mtd_eeprom, 0);
+#endif /* MODULE_MTD_EEPROM */
 
 void board_init(void)
 {
diff --git a/boards/common/atmega/board_common.c b/boards/common/atmega/board_common.c
new file mode 100644
index 000000000000..a37d7a366db6
--- /dev/null
+++ b/boards/common/atmega/board_common.c
@@ -0,0 +1,23 @@
+/*
+ * SPDX-FileCopyrightText: 2026 ML!PA Consulting GmbH
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+/**
+ * @ingroup     boards_common_atmega
+ * @{
+ *
+ * @file
+ * @brief       Definitions for all atmega boards.
+ *
+ * @author      Fabian Hüßler <fabian.huessler@ml-pa.com>
+ * @}
+ */
+
+#include "board.h"
+#include "mtd_eeprom.h"
+
+#if MODULE_MTD_EEPROM
+mtd_eeprom_t mtd_eeprom = MTD_EEPROM_INIT_VAL;
+MTD_XFA_ADD(mtd_eeprom, 0);
+#endif /* MODULE_MTD_EEPROM */
diff --git a/boards/common/native/board_init.c b/boards/common/native/board_init.c
index e4e236b3bc32..9b93df2fe8b4 100644
--- a/boards/common/native/board_init.c
+++ b/boards/common/native/board_init.c
@@ -20,6 +20,7 @@
 
 #ifdef MODULE_MTD
 #include "mtd_native.h"
+#include "mtd_eeprom.h"
 
 mtd_native_dev_t mtd0_dev = {
     .base = {
@@ -31,8 +32,10 @@ mtd_native_dev_t mtd0_dev = {
     },
     .fname = MTD_NATIVE_FILENAME,
 };
-
 MTD_XFA_ADD(mtd0_dev.base, 0);
+
+mtd_eeprom_t mtd_eeprom = MTD_EEPROM_INIT_VAL;
+MTD_XFA_ADD(mtd_eeprom, 1);
 #endif
 
 #ifdef MODULE_VFS_DEFAULT
diff --git a/boards/common/native/include/board.h b/boards/common/native/include/board.h
index ebc594b4267d..2c742eb8f7df 100644
--- a/boards/common/native/include/board.h
+++ b/boards/common/native/include/board.h
@@ -81,6 +81,7 @@ void _native_LED_RED_TOGGLE(void);
 
 /** Default MTD device (mtd flash emulation device) */
 #define MTD_0 mtd_dev_get(0)
+#define MTD_1 mtd_dev_get(1)
 #endif
 
 /**
@@ -131,8 +132,10 @@ void _native_LED_RED_TOGGLE(void);
 #endif
 
 #if SPIFFS_HAL_CALLBACK_EXTRA == 0
-/* Default MTD device if no callback parameter */
 #ifndef SPIFFS_MTD_DEV
+/**
+ * @brief   Default MTD device if no callback parameter is provided
+ */
 #define SPIFFS_MTD_DEV                      (MTD_0)
 #endif
 #endif
diff --git a/boards/common/nucleo/board_common.c b/boards/common/nucleo/board_common.c
new file mode 100644
index 000000000000..c1f42cb01814
--- /dev/null
+++ b/boards/common/nucleo/board_common.c
@@ -0,0 +1,23 @@
+/*
+ * SPDX-FileCopyrightText: 2026 ML!PA Consulting GmbH
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+/**
+ * @ingroup     boards_common_nucleo
+ * @{
+ *
+ * @file
+ * @brief       Definitions for all nucleo boards.
+ *
+ * @author      Fabian Hüßler <fabian.huessler@ml-pa.com>
+ * @}
+ */
+
+#include "board.h"
+#include "mtd_eeprom.h"
+
+#if MODULE_MTD_EEPROM
+mtd_eeprom_t mtd_eeprom = MTD_EEPROM_INIT_VAL;
+MTD_XFA_ADD(mtd_eeprom, 0);
+#endif /* MODULE_MTD_EEPROM */
diff --git a/boards/derfmega128/Makefile.dep b/boards/derfmega128/Makefile.dep
index 3d1c295b9b21..73ab1165da44 100644
--- a/boards/derfmega128/Makefile.dep
+++ b/boards/derfmega128/Makefile.dep
@@ -1 +1,5 @@
 USEMODULE += boards_common_atmega
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/derfmega256/Makefile.dep b/boards/derfmega256/Makefile.dep
index d3281ed0a6b7..74c63481169e 100644
--- a/boards/derfmega256/Makefile.dep
+++ b/boards/derfmega256/Makefile.dep
@@ -3,3 +3,7 @@ USEMODULE += boards_common_atmega
 ifneq (,$(filter eui_provider,$(USEMODULE)))
   FEATURES_REQUIRED += periph_eeprom
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/i-nucleo-lrwan1/Makefile.dep b/boards/i-nucleo-lrwan1/Makefile.dep
index 5d45d9f98101..eeaaecd7b690 100644
--- a/boards/i-nucleo-lrwan1/Makefile.dep
+++ b/boards/i-nucleo-lrwan1/Makefile.dep
@@ -4,3 +4,7 @@ endif
 ifneq (,$(filter netdev_default,$(USEMODULE)))
   USEMODULE += sx1272
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/i-nucleo-lrwan1/board.c b/boards/i-nucleo-lrwan1/board.c
new file mode 100644
index 000000000000..d6670a1b87d4
--- /dev/null
+++ b/boards/i-nucleo-lrwan1/board.c
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2026 ML!PA Consulting GmbH
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+/**
+ * @ingroup     boards_i-nucleo-lrwan1
+ * @{
+ *
+ * @file
+ * @brief       Board specific initialization for I-Nucleo-LRWAN1
+ *
+ * @author      Fabian Hüßler <fabian.huessler@ml-pa.com>
+ *
+ * @}
+ */
+
+#include "board.h"
+#include "mtd_eeprom.h"
+
+#if MODULE_MTD_EEPROM
+mtd_eeprom_t mtd_eeprom = MTD_EEPROM_INIT_VAL;
+MTD_XFA_ADD(mtd_eeprom, 0);
+#endif /* MODULE_MTD_EEPROM */
diff --git a/boards/im880b/Makefile.dep b/boards/im880b/Makefile.dep
index 127d32fd6f90..25ebaef65708 100644
--- a/boards/im880b/Makefile.dep
+++ b/boards/im880b/Makefile.dep
@@ -1,3 +1,7 @@
 ifneq (,$(filter netdev_default,$(USEMODULE)))
   USEMODULE += sx1272
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/im880b/board.c b/boards/im880b/board.c
new file mode 100644
index 000000000000..466f0dcaad20
--- /dev/null
+++ b/boards/im880b/board.c
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2026 ML!PA Consulting GmbH
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+/**
+ * @ingroup     boards_im880b
+ * @{
+ *
+ * @file
+ * @brief       Board specific initialization for IM880B
+ *
+ * @author      Fabian Hüßler <fabian.huessler@ml-pa.com>
+ *
+ * @}
+ */
+
+#include "board.h"
+#include "mtd_eeprom.h"
+
+#if MODULE_MTD_EEPROM
+mtd_eeprom_t mtd_eeprom = MTD_EEPROM_INIT_VAL;
+MTD_XFA_ADD(mtd_eeprom, 0);
+#endif /* MODULE_MTD_EEPROM */
diff --git a/boards/limifrog-v1/Makefile.dep b/boards/limifrog-v1/Makefile.dep
index 2c1c87fc0811..accd74a16f06 100644
--- a/boards/limifrog-v1/Makefile.dep
+++ b/boards/limifrog-v1/Makefile.dep
@@ -1,3 +1,7 @@
 ifneq (,$(filter saul_default,$(USEMODULE)))
   USEMODULE += lis3mdl
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/limifrog-v1/board.c b/boards/limifrog-v1/board.c
new file mode 100644
index 000000000000..ed6609aa5055
--- /dev/null
+++ b/boards/limifrog-v1/board.c
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2026 ML!PA Consulting GmbH
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+/**
+ * @ingroup     boards_limifrog-v1
+ * @{
+ *
+ * @file
+ * @brief       Board specific initialization for LIMIFROG-V1
+ *
+ * @author      Fabian Hüßler <fabian.huessler@ml-pa.com>
+ *
+ * @}
+ */
+
+#include "board.h"
+#include "mtd_eeprom.h"
+
+#if MODULE_MTD_EEPROM
+mtd_eeprom_t mtd_eeprom = MTD_EEPROM_INIT_VAL;
+MTD_XFA_ADD(mtd_eeprom, 0);
+#endif /* MODULE_MTD_EEPROM */
diff --git a/boards/lobaro-lorabox/Makefile.dep b/boards/lobaro-lorabox/Makefile.dep
index 2be2768b2be8..adeb378de7b8 100644
--- a/boards/lobaro-lorabox/Makefile.dep
+++ b/boards/lobaro-lorabox/Makefile.dep
@@ -5,3 +5,7 @@ endif
 ifneq (,$(filter netdev_default,$(USEMODULE)))
   USEMODULE += sx1272
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/lobaro-lorabox/board.c b/boards/lobaro-lorabox/board.c
index 83680c8d2e4e..6f6ce6eba801 100644
--- a/boards/lobaro-lorabox/board.c
+++ b/boards/lobaro-lorabox/board.c
@@ -16,6 +16,12 @@
 
 #include "board.h"
 #include "periph/gpio.h"
+#include "mtd_eeprom.h"
+
+#if MODULE_MTD_EEPROM
+mtd_eeprom_t mtd_eeprom = MTD_EEPROM_INIT_VAL;
+MTD_XFA_ADD(mtd_eeprom, 0);
+#endif /* MODULE_MTD_EEPROM */
 
 void board_init(void)
 {
diff --git a/boards/lsn50/Makefile.dep b/boards/lsn50/Makefile.dep
index 4ab749e2dd56..384c694457e2 100644
--- a/boards/lsn50/Makefile.dep
+++ b/boards/lsn50/Makefile.dep
@@ -1,3 +1,7 @@
 ifneq (,$(filter netdev_default,$(USEMODULE)))
   USEMODULE += sx1276
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/lsn50/board.c b/boards/lsn50/board.c
new file mode 100644
index 000000000000..265fe7d7c569
--- /dev/null
+++ b/boards/lsn50/board.c
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2026 ML!PA Consulting GmbH
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+/**
+ * @ingroup     boards_lsn50
+ * @{
+ *
+ * @file
+ * @brief       Board specific initialization for Dragino LSN50
+ *
+ * @author      Fabian Hüßler <fabian.huessler@ml-pa.com>
+ *
+ * @}
+ */
+
+#include "board.h"
+#include "mtd_eeprom.h"
+
+#if MODULE_MTD_EEPROM
+mtd_eeprom_t mtd_eeprom = MTD_EEPROM_INIT_VAL;
+MTD_XFA_ADD(mtd_eeprom, 0);
+#endif /* MODULE_MTD_EEPROM */
diff --git a/boards/mega-xplained/Makefile.dep b/boards/mega-xplained/Makefile.dep
index 81bcc4c14711..f7c61bcb6694 100644
--- a/boards/mega-xplained/Makefile.dep
+++ b/boards/mega-xplained/Makefile.dep
@@ -4,3 +4,7 @@ ifneq (,$(filter saul_default,$(USEMODULE)))
   USEMODULE += saul_adc
   USEMODULE += saul_gpio
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/microduino-corerf/Makefile.dep b/boards/microduino-corerf/Makefile.dep
index 3d1c295b9b21..73ab1165da44 100644
--- a/boards/microduino-corerf/Makefile.dep
+++ b/boards/microduino-corerf/Makefile.dep
@@ -1 +1,5 @@
 USEMODULE += boards_common_atmega
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/nucleo-l011k4/Makefile.dep b/boards/nucleo-l011k4/Makefile.dep
index d912f15ffc30..9564bc40f9fc 100644
--- a/boards/nucleo-l011k4/Makefile.dep
+++ b/boards/nucleo-l011k4/Makefile.dep
@@ -2,3 +2,7 @@
 FEATURES_REQUIRED += picolibc
 
 include $(RIOTBOARD)/common/nucleo32/Makefile.dep
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/nucleo-l031k6/Makefile.dep b/boards/nucleo-l031k6/Makefile.dep
index 8db84f184d45..af00f3387cf4 100644
--- a/boards/nucleo-l031k6/Makefile.dep
+++ b/boards/nucleo-l031k6/Makefile.dep
@@ -1 +1,5 @@
 include $(RIOTBOARD)/common/nucleo32/Makefile.dep
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/nucleo-l053r8/Makefile.dep b/boards/nucleo-l053r8/Makefile.dep
index dbfbd3bd2044..4bcf3bfe2bd5 100644
--- a/boards/nucleo-l053r8/Makefile.dep
+++ b/boards/nucleo-l053r8/Makefile.dep
@@ -1 +1,5 @@
 include $(RIOTBOARD)/common/nucleo64/Makefile.dep
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/nucleo-l073rz/Makefile.dep b/boards/nucleo-l073rz/Makefile.dep
index dbfbd3bd2044..4bcf3bfe2bd5 100644
--- a/boards/nucleo-l073rz/Makefile.dep
+++ b/boards/nucleo-l073rz/Makefile.dep
@@ -1 +1,5 @@
 include $(RIOTBOARD)/common/nucleo64/Makefile.dep
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/nucleo-l152re/Makefile.dep b/boards/nucleo-l152re/Makefile.dep
index dbfbd3bd2044..4bcf3bfe2bd5 100644
--- a/boards/nucleo-l152re/Makefile.dep
+++ b/boards/nucleo-l152re/Makefile.dep
@@ -1 +1,5 @@
 include $(RIOTBOARD)/common/nucleo64/Makefile.dep
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/nz32-sc151/Makefile.dep b/boards/nz32-sc151/Makefile.dep
index 5472bf8b8d8f..2353f53dc04e 100644
--- a/boards/nz32-sc151/Makefile.dep
+++ b/boards/nz32-sc151/Makefile.dep
@@ -1,3 +1,7 @@
 ifneq (,$(filter saul_default,$(USEMODULE)))
   USEMODULE += saul_gpio
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/nz32-sc151/board.c b/boards/nz32-sc151/board.c
new file mode 100644
index 000000000000..836ab68df44d
--- /dev/null
+++ b/boards/nz32-sc151/board.c
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2026 ML!PA Consulting GmbH
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+/**
+ * @ingroup     boards_nz32-sc151
+ * @{
+ *
+ * @file
+ * @brief       Board specific initialization for Modtronix nz32-sc151
+ *
+ * @author      Fabian Hüßler <fabian.huessler@ml-pa.com>
+ *
+ * @}
+ */
+
+#include "board.h"
+#include "mtd_eeprom.h"
+
+#if MODULE_MTD_EEPROM
+mtd_eeprom_t mtd_eeprom = MTD_EEPROM_INIT_VAL;
+MTD_XFA_ADD(mtd_eeprom, 0);
+#endif /* MODULE_MTD_EEPROM */
diff --git a/boards/stm32l0538-disco/Makefile.dep b/boards/stm32l0538-disco/Makefile.dep
index 5472bf8b8d8f..2353f53dc04e 100644
--- a/boards/stm32l0538-disco/Makefile.dep
+++ b/boards/stm32l0538-disco/Makefile.dep
@@ -1,3 +1,7 @@
 ifneq (,$(filter saul_default,$(USEMODULE)))
   USEMODULE += saul_gpio
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/boards/stm32l0538-disco/board.c b/boards/stm32l0538-disco/board.c
new file mode 100644
index 000000000000..f6067e2ef8cd
--- /dev/null
+++ b/boards/stm32l0538-disco/board.c
@@ -0,0 +1,24 @@
+/*
+ * SPDX-FileCopyrightText: 2026 ML!PA Consulting GmbH
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+/**
+ * @ingroup     boards_stm32l0538-disco
+ * @{
+ *
+ * @file
+ * @brief       Board specific initialization for STM32L0538-DISCO
+ *
+ * @author      Fabian Hüßler <fabian.huessler@ml-pa.com>
+ *
+ * @}
+ */
+
+#include "board.h"
+#include "mtd_eeprom.h"
+
+#if MODULE_MTD_EEPROM
+mtd_eeprom_t mtd_eeprom = MTD_EEPROM_INIT_VAL;
+MTD_XFA_ADD(mtd_eeprom, 0);
+#endif /* MODULE_MTD_EEPROM */
diff --git a/boards/zigduino/Makefile.dep b/boards/zigduino/Makefile.dep
index 81bcc4c14711..f7c61bcb6694 100644
--- a/boards/zigduino/Makefile.dep
+++ b/boards/zigduino/Makefile.dep
@@ -4,3 +4,7 @@ ifneq (,$(filter saul_default,$(USEMODULE)))
   USEMODULE += saul_adc
   USEMODULE += saul_gpio
 endif
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/cpu/atmega1284p/Makefile.dep b/cpu/atmega1284p/Makefile.dep
index 41c8200b0716..e2c2edf64426 100644
--- a/cpu/atmega1284p/Makefile.dep
+++ b/cpu/atmega1284p/Makefile.dep
@@ -4,3 +4,7 @@ ifneq (,$(filter atmega_pcint,$(USEMODULE)))
 endif
 
 include $(RIOTCPU)/atmega_common/Makefile.dep
+
+ifneq (,$(filter mtd,$(USEMODULE)))
+  USEMODULE  += mtd_eeprom
+endif
diff --git a/drivers/include/mtd_default.h b/drivers/include/mtd_default.h
index a0c85e3ce844..68b412db6d6d 100644
--- a/drivers/include/mtd_default.h
+++ b/drivers/include/mtd_default.h
@@ -27,11 +27,15 @@ extern "C" {
 #endif
 
 #if defined(MODULE_MTD_SDCARD_DEFAULT)
-#include "mtd_sdcard.h"
+#  include "mtd_sdcard.h"
 #endif
 
 #if defined(MODULE_MTD_EMULATED)
-#include "mtd_emulated.h"
+#  include "mtd_emulated.h"
+#endif
+
+#if defined(MODULE_MTD_EEPROM)
+#  include "mtd_eeprom.h"
 #endif
 
 #if defined(MODULE_MTD_SDCARD_DEFAULT)
@@ -42,6 +46,11 @@ extern mtd_sdcard_t mtd_sdcard_dev0;
 extern mtd_emulated_t mtd_emulated_dev0;
 #endif
 
+#if defined(MODULE_MTD_EEPROM)
+extern mtd_eeprom_t mtd_eeprom;
+#  define MTD_EEPROM (&mtd_eeprom.base)
+#endif
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/drivers/include/mtd_eeprom.h b/drivers/include/mtd_eeprom.h
new file mode 100644
index 000000000000..9a91936ae755
--- /dev/null
+++ b/drivers/include/mtd_eeprom.h
@@ -0,0 +1,88 @@
+/*
+ * SPDX-FileCopyrightText: ML!PA Consulting GmbH
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+#pragma once
+
+/**
+ * @defgroup    drivers_mtd_eeprom MTD wrapper for internal EEPROM devices
+ * @ingroup     drivers_mtd
+ * @brief       Driver for internal EEPROM devices implementing the MTD interface
+ *
+ * This header exposes the MTD implementation of RIOT for internal EEPROMs.
+ * Supported CPUs must provide the feature @c periph_eeprom and define the
+ * internal EEPROM size as @c EEPROM_SIZE.
+ * Supported boards must allocate the EEPROM MTD device by using the @ref MTD_EEPROM_INIT_VAL.
+ *
+ * Compared to external EEPROM like e.g. @ref drivers_mtd_at24cxxx, internal EEPROM is typically
+ * not organized in pages. Thus, the default MTD adaptation assumes 1 sector with 1 page having
+ * the size of the whole EEPROM. If a new CPU comes with EEPROM, which actually is divided in pages,
+ * the configurables @ref MTD_EEPROM_SECTORS_NUMOF, @ref MTD_EEPROM_PAGES_PER_SECTOR,
+ * and @ref MTD_EEPROM_PAGE_SIZE should be adjusted accordingly. If the layer above MTD
+ * e.g. filesystem requires multiple pages or a certain page size,
+ * then @ref MTD_EEPROM_PAGES_PER_SECTOR should be adjusted.
+ *
+ * @verbatim
+ * EEPROM_SIZE / <required page size or number of pages>
+ * @endverbatim
+ *
+ * @{
+ *
+ * @file
+ * @brief       MTD Driver for internal EEPROM
+ *
+ * @author      Fabian Hüßler <fabian.huessler@ml-pa.com>
+ */
+
+#include "mtd.h"
+#include "periph/eeprom.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Divide internal EEPROM in sectors if required */
+
+#if !defined(MTD_EEPROM_SECTORS_NUMOF) || defined(DOXYGEN)
+#  define MTD_EEPROM_SECTORS_NUMOF        (1U)  /**< number of sectors */
+#endif
+
+#if !defined(MTD_EEPROM_PAGES_PER_SECTOR) || defined(DOXYGEN)
+#  define MTD_EEPROM_PAGES_PER_SECTOR     (1U)  /**< number of pages per sector */
+#endif
+
+#if !defined(MTD_EEPROM_PAGE_SIZE) || defined(DOXYGEN)
+#  define MTD_EEPROM_PAGE_SIZE            ((EEPROM_SIZE / MTD_EEPROM_SECTORS_NUMOF) / \
+                                          MTD_EEPROM_PAGES_PER_SECTOR)  /**< page size in bytes */
+#endif
+
+/**
+ * @brief   Macro helper to initialize a mtd_t with EEPROM driver
+ */
+#define MTD_EEPROM_INIT_VAL {                                   \
+    .base = {                                                   \
+        .driver = &mtd_eeprom_driver,                           \
+        .sector_count = MTD_EEPROM_SECTORS_NUMOF,               \
+        .pages_per_sector = MTD_EEPROM_PAGES_PER_SECTOR,        \
+        .page_size = MTD_EEPROM_PAGE_SIZE,                      \
+        .write_size = 1                                         \
+    },                                                          \
+}
+
+/**
+ * @brief   EEPROM MTD device operations table
+ */
+extern const mtd_desc_t mtd_eeprom_driver;
+
+/**
+ * @brief    MTD EEPROM descriptor
+ */
+typedef struct {
+    mtd_dev_t base;     /**< MTD generic device */
+} mtd_eeprom_t;
+
+#ifdef __cplusplus
+}
+#endif
+/** @}  */
diff --git a/drivers/mtd_eeprom/Makefile b/drivers/mtd_eeprom/Makefile
new file mode 100644
index 000000000000..48422e909a47
--- /dev/null
+++ b/drivers/mtd_eeprom/Makefile
@@ -0,0 +1 @@
+include $(RIOTBASE)/Makefile.base
diff --git a/drivers/mtd_eeprom/Makefile.dep b/drivers/mtd_eeprom/Makefile.dep
new file mode 100644
index 000000000000..5dc182e0040c
--- /dev/null
+++ b/drivers/mtd_eeprom/Makefile.dep
@@ -0,0 +1 @@
+FEATURES_REQUIRED += periph_eeprom
diff --git a/drivers/mtd_eeprom/mtd_eeprom.c b/drivers/mtd_eeprom/mtd_eeprom.c
new file mode 100644
index 000000000000..363139f0e65d
--- /dev/null
+++ b/drivers/mtd_eeprom/mtd_eeprom.c
@@ -0,0 +1,73 @@
+/*
+ * SPDX-FileCopyrightText: 2026 ML!PA Consulting GmbH
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+/**
+ * @ingroup     drivers_mtd_eeprom
+ * @{
+ *
+ * @file
+ * @brief       MTD Driver for internal EEPROM
+ *
+ * @author      Fabian Hüßler <fabian.huessler@ml-pa.com>
+ *
+ * @}
+ */
+
+#include <assert.h>
+#include <errno.h>
+
+#include "board.h"
+#include "cpu.h"
+#include "cpu_conf.h"
+#include "mtd_eeprom.h"
+#include "periph/eeprom.h"
+#include "limits.h"
+
+#define ENABLE_DEBUG 0
+#include "debug.h"
+
+static int _init(mtd_dev_t *dev)
+{
+    assert(EEPROM_SIZE % dev->page_size == 0);
+    assert(EEPROM_SIZE / dev->sector_count == dev->pages_per_sector * dev->page_size);
+    return 0;
+}
+
+static int _read_page(mtd_dev_t *dev, void *buf, uint32_t page,
+                      uint32_t offset, uint32_t size)
+{
+    assert(size <= INT_MAX);
+    eeprom_read(dev->page_size * page + offset, buf, size);
+    return (int)size;
+}
+
+static int _write_page(mtd_dev_t *dev, const void *buf, uint32_t page, uint32_t offset,
+                       uint32_t size)
+{
+    assert(size <= INT_MAX);
+    eeprom_write(dev->page_size * page + offset, buf, size);
+    return (int)size;
+}
+
+static int _erase(mtd_dev_t *dev, uint32_t addr, uint32_t count)
+{
+    (void)dev;
+    if (count > UINT32_MAX - addr) {
+        return -EOVERFLOW;
+    }
+    if (addr + count > EEPROM_SIZE) {
+        return -EOVERFLOW;
+    }
+    eeprom_clear(addr, count);
+    return 0;
+}
+
+const mtd_desc_t mtd_eeprom_driver = {
+    .init = _init,
+    .read_page = _read_page,
+    .write_page = _write_page,
+    .erase = _erase,
+    .flags = MTD_DRIVER_FLAG_DIRECT_WRITE,
+};
diff --git a/sys/eepreg/Makefile.dep b/sys/eepreg/Makefile.dep
index 5dc182e0040c..0690d9f7a22c 100644
--- a/sys/eepreg/Makefile.dep
+++ b/sys/eepreg/Makefile.dep
@@ -1 +1,15 @@
-FEATURES_REQUIRED += periph_eeprom
+
+# eepreg works with other `mtd_%` subsystems than `mtd_eeprom` too as not all
+# microcontrollers have built-in EEPROMs. However at least one `mtd_%`
+# subsystem has to be configured, otherwise fall back to requiring the internal
+# EEPROM. This makes sure the automatic feature resolution of the CI only
+# tries to compile the test for boards that it would work on.
+# Checking the USEMODULE before adding to it makes sure we don't test in the
+# first round of dependency resolution to avoid false-negatives.
+ifneq (,$(filter mtd,$(USEMODULE)))
+  ifeq (,$(filter mtd_%,$(USEMODULE)))
+    USEMODULE += mtd_eeprom
+  endif
+endif
+
+USEMODULE += mtd
diff --git a/sys/eepreg/eepreg.c b/sys/eepreg/eepreg.c
index 43d63059164e..50b6b6b8c5b0 100644
--- a/sys/eepreg/eepreg.c
+++ b/sys/eepreg/eepreg.c
@@ -23,7 +23,7 @@
 #include <string.h>
 
 #include "eepreg.h"
-#include "periph/eeprom.h"
+#include "mtd.h"
 
 #define ENABLE_DEBUG 0
 #include "debug.h"
@@ -39,16 +39,16 @@ static const char eepreg_magic[] = "RIOTREG";
 #define REG_START          (EEPROM_RESERV_CPU_LOW + EEPROM_RESERV_BOARD_LOW)
 #define REG_MAGIC_LOC      (REG_START)
 #define REG_END_PTR_LOC    (REG_MAGIC_LOC + MAGIC_SIZE)
-#define REG_ENT1_LOC       (REG_END_PTR_LOC + EEPREG_PTR_LEN)
-#define DAT_START          (EEPROM_SIZE - EEPROM_RESERV_CPU_HI \
+#define REG_ENT1_LOC(mtd)  (REG_END_PTR_LOC + eepreg_ptr_len(mtd))
+#define DAT_START(mtd)     (eepreg_size(mtd) - EEPROM_RESERV_CPU_HI \
                             - EEPROM_RESERV_BOARD_HI - 1)
 
-static inline uint32_t _read_meta_uint(uint32_t loc)
+static inline uint32_t _read_meta_uint(mtd_dev_t *dev, uint32_t loc)
 {
     uint8_t data[4];
     uint32_t ret;
 
-    eeprom_read(loc, data, EEPREG_PTR_LEN);
+    mtd_read(dev, data, loc, eepreg_ptr_len(dev));
 
     /* unused array members will be discarded */
     ret = ((uint32_t)data[0] << 24)
@@ -57,43 +57,43 @@ static inline uint32_t _read_meta_uint(uint32_t loc)
           | ((uint32_t)data[3]);
 
     /* bit shift to discard unused array members */
-    ret >>= 8 * (4 - EEPREG_PTR_LEN);
+    ret >>= 8 * (4 - eepreg_ptr_len(dev));
 
     return ret;
 }
 
-static inline void _write_meta_uint(uint32_t loc, uint32_t val)
+static inline void _write_meta_uint(mtd_dev_t *dev, uint32_t loc, uint32_t val)
 {
     uint8_t data[4];
 
-    val <<= 8 * (4 - EEPREG_PTR_LEN);
+    val <<= 8 * (4 - eepreg_ptr_len(dev));
 
     data[0] = (uint8_t)(val >> 24);
     data[1] = (uint8_t)(val >> 16);
     data[2] = (uint8_t)(val >> 8);
     data[3] = (uint8_t)val;
 
-    eeprom_write(loc, data, EEPREG_PTR_LEN);
+    mtd_write(dev, data, loc, eepreg_ptr_len(dev));
 }
 
-static inline uint32_t _get_reg_end(void)
+static inline uint32_t _get_reg_end(mtd_dev_t *dev)
 {
-    return _read_meta_uint(REG_END_PTR_LOC);
+    return _read_meta_uint(dev, REG_END_PTR_LOC);
 }
 
-static inline void _set_reg_end(uint32_t loc)
+static inline void _set_reg_end(mtd_dev_t *dev, uint32_t loc)
 {
-    _write_meta_uint(REG_END_PTR_LOC, loc);
+    _write_meta_uint(dev, REG_END_PTR_LOC, loc);
 }
 
-static inline uint32_t _get_last_loc(uint32_t reg_end)
+static inline uint32_t _get_last_loc(mtd_dev_t *dev, uint32_t reg_end)
 {
-    if (reg_end == REG_ENT1_LOC) {
+    if (reg_end == REG_ENT1_LOC(dev)) {
         /* no entries yet */
-        return DAT_START;
+        return DAT_START(dev);
     }
 
-    return _read_meta_uint(reg_end - EEPREG_PTR_LEN);
+    return _read_meta_uint(dev, reg_end - eepreg_ptr_len(dev));
 }
 
 static inline uint32_t _calc_free_space(uint32_t reg_end, uint32_t last_loc)
@@ -101,49 +101,51 @@ static inline uint32_t _calc_free_space(uint32_t reg_end, uint32_t last_loc)
     return last_loc - reg_end;
 }
 
-static inline uint8_t _get_meta_len(uint32_t meta_loc)
+static inline uint8_t _get_meta_len(mtd_dev_t *dev, uint32_t meta_loc)
 {
-    return eeprom_read_byte(meta_loc);
+    uint8_t byte;
+    mtd_read(dev, &byte, meta_loc, 1);
+    return byte;
 }
 
-static inline void _set_meta_len(uint32_t meta_loc, uint8_t meta_len)
+static inline void _set_meta_len(mtd_dev_t *dev, uint32_t meta_loc, uint8_t meta_len)
 {
-    eeprom_write_byte(meta_loc, meta_len);
+    mtd_write(dev, &meta_len, meta_loc, 1);
 }
 
-static inline uint32_t _get_data_loc(uint32_t meta_loc, uint8_t meta_len)
+static inline uint32_t _get_data_loc(mtd_dev_t *dev, uint32_t meta_loc, uint8_t meta_len)
 {
     /* data location is at the end of meta-data */
-    return _read_meta_uint(meta_loc + meta_len - EEPREG_PTR_LEN);
+    return _read_meta_uint(dev, meta_loc + meta_len - eepreg_ptr_len(dev));
 }
 
-static inline void _set_data_loc(uint32_t meta_loc, uint8_t meta_len,
+static inline void _set_data_loc(mtd_dev_t *dev, uint32_t meta_loc, uint8_t meta_len,
                                  uint32_t data_loc)
 {
     /* data location is at the end of meta-data */
-    _write_meta_uint(meta_loc + meta_len - EEPREG_PTR_LEN, data_loc);
+    _write_meta_uint(dev, meta_loc + meta_len - eepreg_ptr_len(dev), data_loc);
 }
 
-static inline uint8_t _calc_name_len(uint8_t meta_len)
+static inline uint8_t _calc_name_len(mtd_dev_t *dev, uint8_t meta_len)
 {
     /* entry contents: meta-data length, name, data pointer */
-    return meta_len - ENT_LEN_SIZ - EEPREG_PTR_LEN;
+    return meta_len - ENT_LEN_SIZ - eepreg_ptr_len(dev);
 }
 
-static inline void _get_name(uint32_t meta_loc, char *name, uint8_t meta_len)
+static inline void _get_name(mtd_dev_t *dev, uint32_t meta_loc, char *name, uint8_t meta_len)
 {
     /* name is after entry length */
-    eeprom_read(meta_loc + ENT_LEN_SIZ, (uint8_t *)name,
-                _calc_name_len(meta_len));
+    mtd_read(dev, name, meta_loc + ENT_LEN_SIZ,
+             _calc_name_len(dev, meta_len));
 }
 
-static inline int _cmp_name(uint32_t meta_loc, const char *name,
+static inline int _cmp_name(mtd_dev_t *dev, uint32_t meta_loc, const char *name,
                             uint8_t meta_len)
 {
     /* name is after entry length */
     uint32_t loc = meta_loc + ENT_LEN_SIZ;
 
-    uint8_t len = _calc_name_len(meta_len);
+    uint8_t len = _calc_name_len(dev, meta_len);
 
     uint8_t offset;
     for (offset = 0; offset < len; offset++) {
@@ -152,7 +154,9 @@ static inline int _cmp_name(uint32_t meta_loc, const char *name,
             return 0;
         }
 
-        if (eeprom_read_byte(loc + offset) != (uint8_t)name[offset]) {
+        uint8_t byte;
+        mtd_read(dev, &byte, loc + offset, 1);
+        if (byte != (uint8_t)name[offset]) {
             /* non-matching character */
             return 0;
         }
@@ -167,15 +171,15 @@ static inline int _cmp_name(uint32_t meta_loc, const char *name,
     return 0;
 }
 
-static inline uint32_t _get_meta_loc(const char *name)
+static inline uint32_t _get_meta_loc(mtd_dev_t *dev, const char *name)
 {
-    uint32_t meta_loc = REG_ENT1_LOC;
-    uint32_t reg_end = _get_reg_end();
+    uint32_t meta_loc = REG_ENT1_LOC(dev);
+    uint32_t reg_end = _get_reg_end(dev);
 
     while (meta_loc < reg_end) {
-        uint8_t meta_len = _get_meta_len(meta_loc);
+        uint8_t meta_len = _get_meta_len(dev, meta_loc);
 
-        if (_cmp_name(meta_loc, name, meta_len)) {
+        if (_cmp_name(dev, meta_loc, name, meta_len)) {
             return meta_loc;
         }
 
@@ -186,28 +190,28 @@ static inline uint32_t _get_meta_loc(const char *name)
     return (uint32_t)UINT_MAX;
 }
 
-static inline uint32_t _get_data_len(uint32_t meta_loc, uint32_t data_loc)
+static inline uint32_t _get_data_len(mtd_dev_t *dev, uint32_t meta_loc, uint32_t data_loc)
 {
     uint32_t prev_loc;
-    if (meta_loc == REG_ENT1_LOC) {
-        prev_loc = DAT_START;
+    if (meta_loc == REG_ENT1_LOC(dev)) {
+        prev_loc = DAT_START(dev);
     }
     else {
         /* previous entry data pointer is just before this entry */
-        prev_loc = _read_meta_uint(meta_loc - EEPREG_PTR_LEN);
+        prev_loc = _read_meta_uint(dev, meta_loc - eepreg_ptr_len(dev));
     }
 
     return prev_loc - data_loc;
 }
 
-static inline int _new_entry(const char *name, uint32_t data_len)
+static inline int _new_entry(mtd_dev_t *dev, const char *name, uint32_t data_len)
 {
-    uint32_t reg_end = _get_reg_end();
-    uint32_t last_loc = _get_last_loc(reg_end);
+    uint32_t reg_end = _get_reg_end(dev);
+    uint32_t last_loc = _get_last_loc(dev, reg_end);
     uint32_t free_space = _calc_free_space(reg_end, last_loc);
 
     uint8_t name_len = (uint8_t)strlen(name);
-    uint8_t meta_len = ENT_LEN_SIZ + name_len + EEPREG_PTR_LEN;
+    uint8_t meta_len = ENT_LEN_SIZ + name_len + eepreg_ptr_len(dev);
 
     /* check to see if there is enough room */
     if (free_space < meta_len + data_len) {
@@ -215,21 +219,21 @@ static inline int _new_entry(const char *name, uint32_t data_len)
     }
 
     /* set the length of the meta-data */
-    _set_meta_len(reg_end, meta_len);
+    _set_meta_len(dev, reg_end, meta_len);
 
     /* write name of entry */
-    eeprom_write(reg_end + ENT_LEN_SIZ, (uint8_t *)name, name_len);
+    mtd_write(dev, name, reg_end + ENT_LEN_SIZ, name_len);
 
     /* set the location of the data */
-    _set_data_loc(reg_end, meta_len, last_loc - data_len);
+    _set_data_loc(dev, reg_end, meta_len, last_loc - data_len);
 
     /* update end of the registry */
-    _set_reg_end(reg_end + meta_len);
+    _set_reg_end(dev, reg_end + meta_len);
 
     return 0;
 }
 
-static inline void _move_data(uint32_t oldpos, uint32_t newpos, uint32_t len)
+static inline void _move_data(mtd_dev_t *dev, uint32_t oldpos, uint32_t newpos, uint32_t len)
 {
     for (uint32_t count = 0; count < len; count++) {
         uint32_t offset;
@@ -243,35 +247,35 @@ static inline void _move_data(uint32_t oldpos, uint32_t newpos, uint32_t len)
             offset = len - count;
         }
 
-        uint8_t byte = eeprom_read_byte(oldpos + offset);
-
-        eeprom_write_byte(newpos + offset, byte);
+        uint8_t byte;
+        mtd_read(dev, &byte, oldpos + offset, 1);
+        mtd_write(dev, &byte, newpos + offset, 1);
     }
 }
 
-int eepreg_add(uint32_t *pos, const char *name, uint32_t len)
+int eepreg_add(mtd_dev_t *dev, uint32_t *pos, const char *name, uint32_t len)
 {
-    int ret = eepreg_check();
+    int ret = eepreg_check(dev);
     if (ret == -ENOENT) {
         /* reg does not exist, so make a new one */
-        eepreg_reset();
+        eepreg_reset(dev);
     }
     else if (ret < 0) {
         DEBUG("[eepreg_add] eepreg_check failed\n");
         return ret;
     }
 
-    uint32_t reg_end = _get_reg_end();
+    uint32_t reg_end = _get_reg_end(dev);
 
-    uint32_t meta_loc = _get_meta_loc(name);
+    uint32_t meta_loc = _get_meta_loc(dev, name);
 
     if (meta_loc == (uint32_t)UINT_MAX) {
         /* entry does not exist, so make a new one */
 
         /* location of the new data */
-        *pos = _get_last_loc(reg_end) - len;
+        *pos = _get_last_loc(dev, reg_end) - len;
 
-        if (_new_entry(name, len) < 0) {
+        if (_new_entry(dev, name, len) < 0) {
             DEBUG("[eepreg_add] not enough space for %s\n", name);
             return -ENOSPC;
         }
@@ -279,9 +283,9 @@ int eepreg_add(uint32_t *pos, const char *name, uint32_t len)
         return 0;
     }
 
-    *pos = _get_data_loc(meta_loc, _get_meta_len(meta_loc));
+    *pos = _get_data_loc(dev, meta_loc, _get_meta_len(dev, meta_loc));
 
-    if (len != _get_data_len(meta_loc, *pos)) {
+    if (len != _get_data_len(dev, meta_loc, *pos)) {
         DEBUG("[eepreg_add] %s already exists with different length\n", name);
         return -EADDRINUSE;
     }
@@ -289,34 +293,34 @@ int eepreg_add(uint32_t *pos, const char *name, uint32_t len)
     return 0;
 }
 
-int eepreg_read(uint32_t *pos, const char *name)
+int eepreg_read(mtd_dev_t *dev, uint32_t *pos, const char *name)
 {
-    int ret = eepreg_check();
+    int ret = eepreg_check(dev);
     if (ret < 0) {
         DEBUG("[eepreg_read] eepreg_check failed\n");
         return ret;
     }
 
-    uint32_t meta_loc = _get_meta_loc(name);
+    uint32_t meta_loc = _get_meta_loc(dev, name);
 
     if (meta_loc == (uint32_t)UINT_MAX) {
         DEBUG("[eepreg_read] no entry for %s\n", name);
         return -ENOENT;
     }
 
-    *pos = _get_data_loc(meta_loc, _get_meta_len(meta_loc));
+    *pos = _get_data_loc(dev, meta_loc, _get_meta_len(dev, meta_loc));
 
     return 0;
 }
 
-int eepreg_write(uint32_t *pos, const char *name, uint32_t len)
+int eepreg_write(mtd_dev_t *dev, uint32_t *pos, const char *name, uint32_t len)
 {
-    uint32_t reg_end = _get_reg_end();
+    uint32_t reg_end = _get_reg_end(dev);
 
-    int ret = eepreg_check();
+    int ret = eepreg_check(dev);
     if (ret == -ENOENT) {
         /* reg does not exist, so make a new one */
-        eepreg_reset();
+        eepreg_reset(dev);
     }
     else if (ret < 0) {
         DEBUG("[eepreg_write] eepreg_check failed\n");
@@ -324,9 +328,9 @@ int eepreg_write(uint32_t *pos, const char *name, uint32_t len)
     }
 
     /* location of the new data */
-    *pos = _get_last_loc(reg_end) - len;
+    *pos = _get_last_loc(dev, reg_end) - len;
 
-    if (_new_entry(name, len) < 0) {
+    if (_new_entry(dev, name, len) < 0) {
         DEBUG("[eepreg_write] not enough space for %s\n", name);
         return -ENOSPC;
     }
@@ -334,47 +338,47 @@ int eepreg_write(uint32_t *pos, const char *name, uint32_t len)
     return 0;
 }
 
-int eepreg_rm(const char *name)
+int eepreg_rm(mtd_dev_t *dev, const char *name)
 {
-    int ret = eepreg_check();
+    int ret = eepreg_check(dev);
     if (ret < 0) {
         DEBUG("[eepreg_rm] eepreg_check failed\n");
         return ret;
     }
 
-    uint32_t meta_loc = _get_meta_loc(name);
+    uint32_t meta_loc = _get_meta_loc(dev, name);
 
     if (meta_loc == (uint32_t)UINT_MAX) {
         DEBUG("[eepreg_rm] no entry for %s\n", name);
         return -ENOENT;
     }
 
-    uint32_t reg_end = _get_reg_end();
-    uint32_t last_loc = _get_last_loc(reg_end);
+    uint32_t reg_end = _get_reg_end(dev);
+    uint32_t last_loc = _get_last_loc(dev, reg_end);
 
-    uint8_t meta_len = _get_meta_len(meta_loc);
+    uint8_t meta_len = _get_meta_len(dev, meta_loc);
     uint32_t tot_meta_len = reg_end - meta_loc;
 
-    uint32_t data_loc = _get_data_loc(meta_loc, meta_len);
-    uint32_t data_len = _get_data_len(meta_loc, data_loc);
+    uint32_t data_loc = _get_data_loc(dev, meta_loc, meta_len);
+    uint32_t data_len = _get_data_len(dev, meta_loc, data_loc);
 
     /* data_loc is above last_loc due to descending order */
     uint32_t tot_data_len = data_loc - last_loc;
 
-    _move_data(meta_loc + meta_len, meta_loc, tot_meta_len);
+    _move_data(dev, meta_loc + meta_len, meta_loc, tot_meta_len);
 
-    _move_data(last_loc, last_loc + data_len, tot_data_len);
+    _move_data(dev, last_loc, last_loc + data_len, tot_data_len);
 
     reg_end -= meta_len;
-    _set_reg_end(reg_end);
+    _set_reg_end(dev, reg_end);
 
     /* update data locations */
     while (meta_loc < reg_end) {
-        meta_len = _get_meta_len(meta_loc);
-        data_loc = _get_data_loc(meta_loc, meta_len);
+        meta_len = _get_meta_len(dev, meta_loc);
+        data_loc = _get_data_loc(dev, meta_loc, meta_len);
 
         /* addition due to descending order */
-        _set_data_loc(meta_loc, meta_len, data_loc + data_len);
+        _set_data_loc(dev, meta_loc, meta_len, data_loc + data_len);
 
         meta_loc += meta_len;
     }
@@ -382,32 +386,32 @@ int eepreg_rm(const char *name)
     return 0;
 }
 
-int eepreg_iter(eepreg_iter_cb_t cb, void *arg)
+int eepreg_iter(mtd_dev_t *dev, eepreg_iter_cb_t cb, void *arg)
 {
-    uint32_t reg_end = _get_reg_end();
+    uint32_t reg_end = _get_reg_end(dev);
 
-    int ret = eepreg_check();
+    int ret = eepreg_check(dev);
     if (ret < 0) {
         DEBUG("[eepreg_len] eepreg_check failed\n");
         return ret;
     }
 
-    uint32_t meta_loc = REG_ENT1_LOC;
+    uint32_t meta_loc = REG_ENT1_LOC(dev);
     while (meta_loc < reg_end) {
-        uint8_t meta_len = _get_meta_len(meta_loc);
+        uint8_t meta_len = _get_meta_len(dev, meta_loc);
 
         /* size of memory allocation */
-        uint8_t name_len = _calc_name_len(meta_len);
+        uint8_t name_len = _calc_name_len(dev, meta_len);
 
         char name[name_len + 1];
 
         /* terminate string */
         name[name_len] = '\0';
 
-        _get_name(meta_loc, name, meta_len);
+        _get_name(dev, meta_loc, name, meta_len);
 
         /* execute callback */
-        ret = cb(name, arg);
+        ret = cb(dev, name, arg);
 
         if (ret < 0) {
             DEBUG("[eepreg_iter] callback reports failure\n");
@@ -415,7 +419,7 @@ int eepreg_iter(eepreg_iter_cb_t cb, void *arg)
         }
 
         /* only advance if cb didn't delete entry */
-        if (_cmp_name(meta_loc, name, meta_len)) {
+        if (_cmp_name(dev, meta_loc, name, meta_len)) {
             meta_loc += meta_len;
         }
     }
@@ -423,13 +427,12 @@ int eepreg_iter(eepreg_iter_cb_t cb, void *arg)
     return 0;
 }
 
-int eepreg_check(void)
+int eepreg_check(mtd_dev_t *dev)
 {
     char magic[MAGIC_SIZE];
 
     /* get magic number from EEPROM */
-    if (eeprom_read(REG_MAGIC_LOC, (uint8_t *)magic, MAGIC_SIZE)
-        != MAGIC_SIZE) {
+    if (mtd_read(dev, magic, REG_MAGIC_LOC, MAGIC_SIZE)) {
 
         DEBUG("[eepreg_check] EEPROM read error\n");
         return -EIO;
@@ -444,54 +447,53 @@ int eepreg_check(void)
     return 0;
 }
 
-int eepreg_reset(void)
+int eepreg_reset(mtd_dev_t *dev)
 {
     /* write new registry magic number */
-    if (eeprom_write(REG_MAGIC_LOC, (uint8_t *)eepreg_magic, MAGIC_SIZE)
-        != MAGIC_SIZE) {
+    if (mtd_write(dev, eepreg_magic, REG_MAGIC_LOC, MAGIC_SIZE)) {
 
         DEBUG("[eepreg_reset] EEPROM write error\n");
         return -EIO;
     }
 
     /* new registry has no entries */
-    _set_reg_end(REG_ENT1_LOC);
+    _set_reg_end(dev, REG_ENT1_LOC(dev));
 
     return 0;
 }
 
-int eepreg_len(uint32_t *len, const char *name)
+int eepreg_len(mtd_dev_t *dev, uint32_t *len, const char *name)
 {
-    int ret = eepreg_check();
+    int ret = eepreg_check(dev);
     if (ret < 0) {
         DEBUG("[eepreg_len] eepreg_check failed\n");
         return ret;
     }
 
-    uint32_t meta_loc = _get_meta_loc(name);
+    uint32_t meta_loc = _get_meta_loc(dev, name);
 
     if (meta_loc == (uint32_t)UINT_MAX) {
         DEBUG("[eepreg_len] no entry for %s\n", name);
         return -ENOENT;
     }
 
-    uint32_t data_loc = _get_data_loc(meta_loc, _get_meta_len(meta_loc));
+    uint32_t data_loc = _get_data_loc(dev, meta_loc, _get_meta_len(dev, meta_loc));
 
-    *len = _get_data_len(meta_loc, data_loc);
+    *len = _get_data_len(dev, meta_loc, data_loc);
 
     return 0;
 }
 
-int eepreg_free(uint32_t *len)
+int eepreg_free(mtd_dev_t *dev, uint32_t *len)
 {
-    int ret = eepreg_check();
+    int ret = eepreg_check(dev);
     if (ret < 0) {
         DEBUG("[eepreg_free] eepreg_check failed\n");
         return ret;
     }
 
-    uint32_t reg_end = _get_reg_end();
-    uint32_t last_loc = _get_last_loc(reg_end);
+    uint32_t reg_end = _get_reg_end(dev);
+    uint32_t last_loc = _get_last_loc(dev, reg_end);
     *len = _calc_free_space(reg_end, last_loc);
 
     return 0;
diff --git a/sys/include/eepreg.h b/sys/include/eepreg.h
index e898afa585ba..777b52a44c23 100644
--- a/sys/include/eepreg.h
+++ b/sys/include/eepreg.h
@@ -58,6 +58,7 @@
 
 #include <stdint.h>
 
+#include "mtd.h"
 #include "periph_cpu.h"
 #include "periph_conf.h"
 
@@ -102,17 +103,39 @@ extern "C" {
 #endif
 
 /**
- * @brief   Size in bytes of pointer meta-data in EEPROM
+ * @brief   EEPROM registry size
+ *
+ * @param[in]       dev     the EEPROM MTD to access
+ *
+ * @return  the size of the EEPROM registry
  */
-#if (EEPROM_SIZE > 0x1000000)
-#define EEPREG_PTR_LEN    (4U)
-#elif (EEPROM_SIZE > 0x10000)
-#define EEPREG_PTR_LEN    (3U)
-#elif (EEPROM_SIZE > 0x100)
-#define EEPREG_PTR_LEN    (2U)
-#else
-#define EEPREG_PTR_LEN    (1U)
-#endif
+static inline uint32_t eepreg_size(mtd_dev_t *dev)
+{
+    /* works anyway only up to 4GiB because of 32bit position in API */
+    return dev->sector_count * dev->pages_per_sector * dev->page_size;
+}
+
+/**
+ * @brief   EEPROM registry pointer length
+ *
+ * @param[in]       dev     the EEPROM MTD to access
+ *
+ * @return  the length of an EEPROM registry address
+ */
+static inline uint8_t eepreg_ptr_len(mtd_dev_t *dev)
+{
+    uint32_t size = eepreg_size(dev);
+    if (size > 0x1000000) {
+        return 4U;
+    }
+    if (size > 0x10000) {
+        return 3U;
+    }
+    if (size > 0x100) {
+        return 2U;
+    }
+    return 1U;
+}
 
 /**
  * @brief   Signature of callback for iterating over entries in EEPROM registry
@@ -123,7 +146,7 @@ extern "C" {
  * @return    0 on success
  * @return    < 0 on failure
  */
-typedef int (*eepreg_iter_cb_t)(char *name, void *arg);
+typedef int (*eepreg_iter_cb_t)(mtd_dev_t *dev, char *name, void *arg);
 
 /**
  * @brief   Load or write meta-data in EEPROM registry
@@ -134,6 +157,7 @@ typedef int (*eepreg_iter_cb_t)(char *name, void *arg);
  * remaining. Requesting a different length for an existent entry returns an
  * error.
  *
+ * @param[in] dev     the EEPROM MTD to access
  * @param[out] pos    pointer to position variable
  * @param[in] name    name of entry to load or write
  * @param[in] len     requested amount of data storage
@@ -143,13 +167,14 @@ typedef int (*eepreg_iter_cb_t)(char *name, void *arg);
  * @return    -ENOSPC on insufficient EEPROM for entry
  * @return    -EADDRINUSE on existing entry with different length
  */
-int eepreg_add(uint32_t *pos, const char *name, uint32_t len);
+int eepreg_add(mtd_dev_t *dev, uint32_t *pos, const char *name, uint32_t len);
 
 /**
  * @brief   Read position meta-data from EEPROM registry
  *
  * This is similar to eepreg_add, except it never writes meta-data.
  *
+ * @param[in] dev     the EEPROM MTD to access
  * @param[out] pos    pointer to position variable
  * @param[in] name    name of entry to load
  *
@@ -157,7 +182,7 @@ int eepreg_add(uint32_t *pos, const char *name, uint32_t len);
  * @return    -EIO on EEPROM I/O error
  * @return    -ENOENT on non-existent registry or entry
  */
-int eepreg_read(uint32_t *pos, const char *name);
+int eepreg_read(mtd_dev_t *dev, uint32_t *pos, const char *name);
 
 /**
  * @brief   Write meta-data to EEPROM registry
@@ -167,6 +192,7 @@ int eepreg_read(uint32_t *pos, const char *name);
  * If multiple entries with the same name exist, eepreg functions will find
  * the oldest. Mainly intended for use by migration utilities.
  *
+ * @param[in] dev     the EEPROM MTD to access
  * @param[out] pos    pointer to position variable
  * @param[in] name    name of entry to write
  * @param[in] len     requested amount of data storage
@@ -175,7 +201,7 @@ int eepreg_read(uint32_t *pos, const char *name);
  * @return    -EIO on EEPROM I/O error
  * @return    -ENOSPC on insufficient EEPROM for entry
  */
-int eepreg_write(uint32_t *pos, const char *name, uint32_t len);
+int eepreg_write(mtd_dev_t *dev, uint32_t *pos, const char *name, uint32_t len);
 
 /**
  * @brief   Remove entry from EEPROM registry and free space
@@ -186,13 +212,14 @@ int eepreg_write(uint32_t *pos, const char *name, uint32_t len);
  * Warning: this is a read/write intensive operation! Mainly intended for use
  * by migration utilities.
  *
+ * @param[in] dev     the EEPROM MTD to access
  * @param[in] name    name of entry to remove
  *
  * @return    0 on success
  * @return    -EIO on EEPROM I/O error
  * @return    -ENOENT on non-existent registry or entry
  */
-int eepreg_rm(const char *name);
+int eepreg_rm(mtd_dev_t *dev, const char *name);
 
 /**
  * @brief   Iterate over meta-data entries in EEPROM registry
@@ -205,6 +232,7 @@ int eepreg_rm(const char *name);
  * @note   It is safe for the callback to remove the entry it is called with,
  * or to add new entries.
  *
+ * @param[in] dev    the EEPROM MTD to access
  * @param[in] cb     callback to iterate over entries
  * @param[in] arg    argument for cb
  *
@@ -213,16 +241,18 @@ int eepreg_rm(const char *name);
  * @return    -ENOENT on non-existent registry
  * @return    return value of cb when cb returns < 0
  */
-int eepreg_iter(eepreg_iter_cb_t cb, void *arg);
+int eepreg_iter(mtd_dev_t *dev, eepreg_iter_cb_t cb, void *arg);
 
 /**
  * @brief   Check for the presence of meta-data registry
  *
+ * @param[in] dev    the EEPROM MTD to access
+ *
  * @return    0 on success
  * @return    -EIO on EEPROM I/O error
  * @return    -ENOENT on non-existent registry
  */
-int eepreg_check(void);
+int eepreg_check(mtd_dev_t *dev);
 
 /**
  * @brief   Clear existing meta-data registry
@@ -230,10 +260,12 @@ int eepreg_check(void);
  * This removes any existing meta-data registry by writing a new registry with
  * no entries.
  *
+ * @param[in] dev    the EEPROM MTD to access
+ *
  * @return    0 on success
  * @return    -EIO on EEPROM I/O error
  */
-int eepreg_reset(void);
+int eepreg_reset(mtd_dev_t *dev);
 
 /**
  * @brief   Calculate data length from meta-data in EEPROM registry
@@ -241,6 +273,7 @@ int eepreg_reset(void);
  * @note   This information is typically already available to code that has
  * called eepreg_add.
  *
+ * @param[in] dev    the EEPROM MTD to access
  * @param[out] len    pointer to length variable
  * @param[in] name    name of entry to load or write
  *
@@ -248,18 +281,19 @@ int eepreg_reset(void);
  * @return    -EIO on EEPROM I/O error
  * @return    -ENOENT on non-existent registry or entry
  */
-int eepreg_len(uint32_t *len, const char *name);
+int eepreg_len(mtd_dev_t *dev, uint32_t *len, const char *name);
 
 /**
  * @brief   Calculate length of remaining EEPROM free space
  *
+ * @param[in] dev    the EEPROM MTD to access
  * @param[out] len    pointer to length variable
  *
  * @return    0 on success
  * @return    -EIO on EEPROM I/O error
  * @return    -ENOENT on non-existent registry
  */
-int eepreg_free(uint32_t *len);
+int eepreg_free(mtd_dev_t *dev, uint32_t *len);
 
 #ifdef __cplusplus
 }
diff --git a/tests/drivers/mtd_eeprom/Makefile b/tests/drivers/mtd_eeprom/Makefile
new file mode 100644
index 000000000000..d7405e292df4
--- /dev/null
+++ b/tests/drivers/mtd_eeprom/Makefile
@@ -0,0 +1,6 @@
+include ../Makefile.drivers_common
+
+USEMODULE += mtd_eeprom
+USEMODULE += embunit
+
+include $(RIOTBASE)/Makefile.include
diff --git a/tests/drivers/mtd_eeprom/Makefile.ci b/tests/drivers/mtd_eeprom/Makefile.ci
new file mode 100644
index 000000000000..72db76ccb5cc
--- /dev/null
+++ b/tests/drivers/mtd_eeprom/Makefile.ci
@@ -0,0 +1,3 @@
+BOARD_INSUFFICIENT_MEMORY := \
+    atmega8 \
+    #
diff --git a/tests/drivers/mtd_eeprom/main.c b/tests/drivers/mtd_eeprom/main.c
new file mode 100644
index 000000000000..54df91dbd446
--- /dev/null
+++ b/tests/drivers/mtd_eeprom/main.c
@@ -0,0 +1,140 @@
+/*
+ * SPDX-FileCopyrightText: 2026 ML!PA Consulting GmbH
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+/**
+ * @ingroup     tests
+ * @{
+ *
+ * @file
+ * @brief       Application for testing MTD EEPROM implementations
+ *
+ * @author      Fabian Hüßler <fabian.huessler@ml-pa.com>
+ *
+ * @}
+ */
+
+#include <string.h>
+#include <errno.h>
+
+#include "embUnit.h"
+
+#include "mtd.h"
+#include "mtd_eeprom.h"
+
+#define TEST_ADDRESS 22
+
+static mtd_eeprom_t _dev = MTD_EEPROM_INIT_VAL;
+static mtd_dev_t *dev = &_dev.base;
+
+static void setup(void)
+{
+    int ret = mtd_init(dev);
+    TEST_ASSERT_EQUAL_INT(0, ret);
+    mtd_erase(dev, TEST_ADDRESS, dev->pages_per_sector * dev->page_size);
+}
+
+static void teardown(void)
+{
+    /* Erase whole EEPROM */
+    mtd_erase(dev, 0, EEPROM_SIZE);
+}
+
+static void test_mtd_init(void)
+{
+    int ret = mtd_init(dev);
+    TEST_ASSERT_EQUAL_INT(0, ret);
+}
+
+static void test_mtd_erase(void)
+{
+    int ret;
+
+    /* Unaligned erase */
+    ret = mtd_erase(dev, 1, EEPROM_SIZE -1);
+    TEST_ASSERT_EQUAL_INT(0, ret);
+
+    /* Erase out of memory area */
+    ret = mtd_erase(dev, 1, EEPROM_SIZE);
+    TEST_ASSERT_EQUAL_INT(-EOVERFLOW, ret);
+}
+
+static void test_mtd_write_erase(void)
+{
+    const char buf[] = "ABCDEFGHIJKLMNO";
+
+    uint8_t buf_empty[sizeof(buf)];
+    memset(buf_empty, EEPROM_CLEAR_BYTE, sizeof(buf_empty));
+
+    uint8_t buf_read[sizeof(buf)];
+    memset(buf_read, 0, sizeof(buf_read));
+
+    /* write */
+    int ret = mtd_write(dev, buf, TEST_ADDRESS, sizeof(buf));
+    TEST_ASSERT_EQUAL_INT(0, ret);
+
+    /* erase */
+    ret = mtd_erase(dev, TEST_ADDRESS, sizeof(buf));
+    TEST_ASSERT_EQUAL_INT(0, ret);
+
+    /* read */
+    ret = mtd_read(dev, buf_read, TEST_ADDRESS, sizeof(buf_read));
+    TEST_ASSERT_EQUAL_INT(0, ret);
+    TEST_ASSERT_EQUAL_INT(0, memcmp(buf_empty, buf_read, sizeof(buf_empty)));
+}
+
+static void test_mtd_write_read(void)
+{
+    const char buf[] = "ABCDEFGHIJKLMNO";
+
+    uint8_t buf_read[sizeof(buf)];
+    memset(buf_read, 0, sizeof(buf_read));
+
+    /* Basic write / read */
+    int ret = mtd_write(dev, buf, TEST_ADDRESS, sizeof(buf));
+    TEST_ASSERT_EQUAL_INT(0, ret);
+
+    /* read */
+    ret = mtd_read(dev, buf_read, TEST_ADDRESS, sizeof(buf_read));
+    TEST_ASSERT_EQUAL_INT(0, ret);
+    TEST_ASSERT_EQUAL_INT(0, memcmp(buf, buf_read, sizeof(buf)));
+
+    /* Out of bounds read */
+    ret = mtd_read(dev, buf_read, TEST_ADDRESS + EEPROM_SIZE, sizeof(buf_read));
+    TEST_ASSERT_EQUAL_INT(-EOVERFLOW, ret);
+
+    /* Out of bounds write */
+    ret = mtd_write(dev, buf, TEST_ADDRESS + EEPROM_SIZE, sizeof(buf));
+    TEST_ASSERT_EQUAL_INT(-EOVERFLOW, ret);
+
+    /* Unaligned write / read */
+    ret = mtd_write(dev, &buf[1],
+                    TEST_ADDRESS + !(TEST_ADDRESS % dev->page_size), sizeof(buf) - 1);
+    TEST_ASSERT_EQUAL_INT(0, ret);
+    ret = mtd_read(dev, &buf_read[1],
+                   TEST_ADDRESS + !(TEST_ADDRESS % dev->page_size), sizeof(buf_read) - 1);
+    TEST_ASSERT_EQUAL_INT(0, ret);
+}
+
+Test *tests_mtd_eeprom_tests(void)
+{
+    EMB_UNIT_TESTFIXTURES(fixtures) {
+        new_TestFixture(test_mtd_init),
+        new_TestFixture(test_mtd_erase),
+        new_TestFixture(test_mtd_write_erase),
+        new_TestFixture(test_mtd_write_read),
+    };
+
+    EMB_UNIT_TESTCALLER(mtd_eeprom_tests, setup, teardown, fixtures);
+
+    return (Test *)&mtd_eeprom_tests;
+}
+
+int main(void)
+{
+    TESTS_START();
+    TESTS_RUN(tests_mtd_eeprom_tests());
+    TESTS_END();
+    return 0;
+}
diff --git a/tests/drivers/mtd_eeprom/tests/01-run.py b/tests/drivers/mtd_eeprom/tests/01-run.py
new file mode 100755
index 000000000000..173ed4dcee20
--- /dev/null
+++ b/tests/drivers/mtd_eeprom/tests/01-run.py
@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+
+# SPDX-FileCopyrightText: 2026 ML!PA Consulting GmbH
+# SPDX-License-Identifier: LGPL-2.1-only
+
+import sys
+from testrunner import run_check_unittests
+
+if __name__ == "__main__":
+    sys.exit(run_check_unittests())
diff --git a/tests/sys/eepreg/Makefile b/tests/sys/eepreg/Makefile
index 619f0dae106b..2ac236e190c0 100644
--- a/tests/sys/eepreg/Makefile
+++ b/tests/sys/eepreg/Makefile
@@ -1,5 +1,9 @@
 include ../Makefile.sys_common
 
 USEMODULE += eepreg
+# EEPREG could be run on other MTD than EEPROM but not all are guaranteed to work.
+# Alternatives are mtd_at24cxxx and mtd_at25cxxx, but the test is only run for
+# boards with internal EEPROM.
+USEMODULE += mtd_eeprom
 
 include $(RIOTBASE)/Makefile.include
diff --git a/tests/sys/eepreg/README.md b/tests/sys/eepreg/README.md
index e53b28f005c4..d68b5a4e2e16 100644
--- a/tests/sys/eepreg/README.md
+++ b/tests/sys/eepreg/README.md
@@ -4,3 +4,5 @@ This test will verify the functionality of the eepreg module.
 
 WARNING: This will write to your EEPROM and probably corrupt any data that is
 there!
+
+Add `CFLAGS += -DTEST_EEPREG_MTD=<MTD>` if a different MTD should be used than MTD_EEPROM.
diff --git a/tests/sys/eepreg/main.c b/tests/sys/eepreg/main.c
index 30c1444e5640..d3a084e5dc2d 100644
--- a/tests/sys/eepreg/main.c
+++ b/tests/sys/eepreg/main.c
@@ -19,10 +19,20 @@
 #include <stdio.h>
 #include <string.h>
 
+#include "board.h"
 #include "eepreg.h"
-#include "periph/eeprom.h"
+#include "mtd_default.h"
 
-#define DAT_START    (EEPROM_SIZE - EEPROM_RESERV_CPU_HI \
+#ifndef TEST_EEPREG_MTD
+#  define TEST_EEPREG_MTD       MTD_EEPROM
+#endif
+
+/* works anyway only up to 4GiB because of 32bit position in API */
+#define TEST_EEPROM_SIZE      ((TEST_EEPREG_MTD)->sector_count * \
+                               (TEST_EEPREG_MTD)->pages_per_sector * \
+                               (TEST_EEPREG_MTD)->page_size)
+
+#define DAT_START    (TEST_EEPROM_SIZE - EEPROM_RESERV_CPU_HI \
                       - EEPROM_RESERV_BOARD_HI - 1)
 
 #define ENT1_NAME    "foo"
@@ -31,8 +41,9 @@
 #define ENT2_SIZE    (34U)
 #define DATA         "spam and eggs"
 
-int eepreg_iter_cb(char *name, void *arg)
+int eepreg_iter_cb(mtd_dev_t *dev, char *name, void *arg)
 {
+    (void)dev;
     (void)arg;
 
     printf("%s ", name);
@@ -45,20 +56,23 @@ int main(void)
     int ret;
     uint32_t tmp1, tmp2, tmp3;
     char data[sizeof(DATA)];
+    mtd_dev_t *dev = TEST_EEPREG_MTD;
+    assert(dev);
+    mtd_init(dev);
 
     puts("EEPROM registry (eepreg) test routine");
 
     printf("Testing new registry creation: ");
 
     printf("reset ");
-    ret = eepreg_reset();
+    ret = eepreg_reset(dev);
     if (ret < 0) {
         puts("[FAILED]");
         return 1;
     }
 
     printf("check ");
-    ret = eepreg_check();
+    ret = eepreg_check(dev);
     if (ret < 0) {
         puts("[FAILED]");
         return 1;
@@ -69,14 +83,14 @@ int main(void)
     printf("Testing writing and reading entries: ");
 
     printf("add ");
-    ret = eepreg_add(&tmp1, ENT1_NAME, ENT1_SIZE);
+    ret = eepreg_add(dev, &tmp1, ENT1_NAME, ENT1_SIZE);
     if (ret < 0 || tmp1 != DAT_START - ENT1_SIZE) {
         puts("[FAILED]");
         return 1;
     }
 
     printf("write ");
-    ret = eepreg_write(&tmp2, ENT2_NAME, ENT2_SIZE);
+    ret = eepreg_write(dev, &tmp2, ENT2_NAME, ENT2_SIZE);
     if (ret < 0 || tmp2 != DAT_START - ENT1_SIZE - ENT2_SIZE) {
         puts("[FAILED]");
         return 1;
@@ -84,14 +98,14 @@ int main(void)
 
     /* read via add */
     printf("add ");
-    ret = eepreg_add(&tmp3, ENT1_NAME, ENT1_SIZE);
+    ret = eepreg_add(dev, &tmp3, ENT1_NAME, ENT1_SIZE);
     if (ret < 0 || tmp1 != tmp3) {
         puts("[FAILED]");
         return 1;
     }
 
     printf("read ");
-    ret = eepreg_read(&tmp1, ENT2_NAME);
+    ret = eepreg_read(dev, &tmp1, ENT2_NAME);
     if (ret < 0 || tmp1 != tmp2) {
         puts("[FAILED]");
         return 1;
@@ -102,7 +116,7 @@ int main(void)
     printf("Testing detection of conflicting size: ");
 
     printf("add ");
-    ret = eepreg_add(&tmp1, ENT1_NAME, ENT1_SIZE + 1);
+    ret = eepreg_add(dev, &tmp1, ENT1_NAME, ENT1_SIZE + 1);
     if (ret != -EADDRINUSE) {
         puts("[FAILED]");
         return 1;
@@ -113,14 +127,14 @@ int main(void)
     printf("Testing calculation of lengths: ");
 
     printf("len ");
-    ret = eepreg_len(&tmp1, ENT1_NAME);
+    ret = eepreg_len(dev, &tmp1, ENT1_NAME);
     if (ret < 0 || tmp1 != ENT1_SIZE) {
         puts("[FAILED]");
         return 1;
     }
 
     printf("len ");
-    ret = eepreg_len(&tmp2, ENT2_NAME);
+    ret = eepreg_len(dev, &tmp2, ENT2_NAME);
     if (ret < 0 || tmp2 != ENT2_SIZE) {
         puts("[FAILED]");
         return 1;
@@ -131,24 +145,24 @@ int main(void)
     printf("Testing of successful data move after rm: ");
 
     printf("rm ");
-    eepreg_read(&tmp1, ENT1_NAME);
-    eepreg_read(&tmp2, ENT2_NAME);
-    eeprom_write(tmp2, (uint8_t *)DATA, sizeof(DATA));
-    ret = eepreg_rm(ENT1_NAME);
+    eepreg_read(dev, &tmp1, ENT1_NAME);
+    eepreg_read(dev, &tmp2, ENT2_NAME);
+    mtd_write(dev, (uint8_t *)DATA, tmp2, sizeof(DATA));
+    ret = eepreg_rm(dev, ENT1_NAME);
     if (ret < 0) {
         puts("[FAILED]");
         return 1;
     }
 
     printf("read ");
-    ret = eepreg_read(&tmp3, ENT2_NAME);
+    ret = eepreg_read(dev, &tmp3, ENT2_NAME);
     if (ret < 0 || tmp3 != (DAT_START - ENT2_SIZE)) {
         puts("[FAILED]");
         return 1;
     }
 
     printf("data ");
-    eeprom_read(tmp3, (uint8_t *)data, sizeof(DATA));
+    mtd_read(dev, data, tmp3, sizeof(DATA));
     if (strcmp(data, DATA) != 0) {
         puts("[FAILED]");
         return 1;
@@ -159,23 +173,23 @@ int main(void)
     printf("Testing of free space change after write: ");
 
     printf("free ");
-    ret = eepreg_free(&tmp1);
+    ret = eepreg_free(dev, &tmp1);
     if (ret < 0) {
         puts("[FAILED]");
         return 1;
     }
 
     printf("add ");
-    ret = eepreg_add(&tmp3, ENT1_NAME, ENT1_SIZE);
+    ret = eepreg_add(dev, &tmp3, ENT1_NAME, ENT1_SIZE);
     if (ret < 0) {
         puts("[FAILED]");
         return 1;
     }
 
     printf("free ");
-    ret = eepreg_free(&tmp2);
+    ret = eepreg_free(dev, &tmp2);
     if (ret < 0
-        || tmp1 != (tmp2 + ENT1_SIZE + sizeof(ENT1_NAME) + EEPREG_PTR_LEN)) {
+        || tmp1 != (tmp2 + ENT1_SIZE + sizeof(ENT1_NAME) + eepreg_ptr_len(dev))) {
 
         puts("[FAILED]");
         return 1;
@@ -186,7 +200,7 @@ int main(void)
     printf("Testing of iteration over registry: ");
 
     printf("iter ");
-    ret = eepreg_iter(eepreg_iter_cb, NULL);
+    ret = eepreg_iter(dev, eepreg_iter_cb, NULL);
     if (ret < 0) {
         puts("[FAILED]");
         return 1;