diff --git a/drivers/can/can_esp32_twai.c b/drivers/can/can_esp32_twai.c
index ee6a85de6bb..fb4400641da 100644
--- a/drivers/can/can_esp32_twai.c
+++ b/drivers/can/can_esp32_twai.c
@@ -203,11 +203,15 @@ static int can_esp32_twai_init(const struct device *dev)
 	can_esp32_twai_write_reg32(dev, TWAI_CLOCK_DIVIDER_REG, twai_config->cdr32);
 #endif /* !CONFIG_SOC_SERIES_ESP32 */
 
-	esp_intr_alloc(twai_config->irq_source,
+	err = esp_intr_alloc(twai_config->irq_source,
 			ESP_PRIO_TO_FLAGS(twai_config->irq_priority) | ESP_INTR_FLAG_IRAM,
 			can_esp32_twai_isr, (void *)dev, NULL);
 
-	return 0;
+	if (err != 0) {
+		LOG_ERR("could not allocate interrupt (err %d)", err);
+	}
+
+	return err;
 }
 
 const struct can_driver_api can_esp32_twai_driver_api = {
diff --git a/drivers/counter/counter_esp32_rtc.c b/drivers/counter/counter_esp32_rtc.c
index 4382a8b541f..4de0086dba0 100644
--- a/drivers/counter/counter_esp32_rtc.c
+++ b/drivers/counter/counter_esp32_rtc.c
@@ -63,13 +63,17 @@ static int counter_esp32_init(const struct device *dev)
 			       (clock_control_subsys_t)ESP32_CLOCK_CONTROL_SUBSYS_RTC_SLOW,
 			       &data->clk_src_freq);
 
-	esp_intr_alloc(cfg->irq_source,
-			ESP_PRIO_TO_FLAGS(cfg->irq_priority),
-			(ESP32_COUNTER_RTC_ISR_HANDLER)counter_esp32_isr,
-			(void *)dev,
-			NULL);
+	int ret = esp_intr_alloc(cfg->irq_source,
+				ESP_PRIO_TO_FLAGS(cfg->irq_priority),
+				(ESP32_COUNTER_RTC_ISR_HANDLER)counter_esp32_isr,
+				(void *)dev,
+				NULL);
 
-	return 0;
+	if (ret != 0) {
+		LOG_ERR("could not allocate interrupt (err %d)", ret);
+	}
+
+	return ret;
 }
 
 static int counter_esp32_start(const struct device *dev)
diff --git a/drivers/counter/counter_esp32_tmr.c b/drivers/counter/counter_esp32_tmr.c
index 0dfd3fd1d27..06e8c8a2e18 100644
--- a/drivers/counter/counter_esp32_tmr.c
+++ b/drivers/counter/counter_esp32_tmr.c
@@ -96,13 +96,17 @@ static int counter_esp32_init(const struct device *dev)
 	timer_ll_set_reload_value(data->hal_ctx.dev, data->hal_ctx.timer_id, 0);
 	timer_ll_enable_counter(data->hal_ctx.dev, data->hal_ctx.timer_id, cfg->config.counter_en);
 
-	esp_intr_alloc(cfg->irq_source,
-			ESP_PRIO_TO_FLAGS(cfg->irq_priority),
-			(ISR_HANDLER)counter_esp32_isr, (void *)dev, NULL);
-
 	k_spin_unlock(&lock, key);
 
-	return 0;
+	int ret = esp_intr_alloc(cfg->irq_source,
+				ESP_PRIO_TO_FLAGS(cfg->irq_priority),
+				(ISR_HANDLER)counter_esp32_isr, (void *)dev, NULL);
+
+	if (ret != 0) {
+		LOG_ERR("could not allocate interrupt (err %d)", ret);
+	}
+
+	return ret;
 }
 
 static int counter_esp32_start(const struct device *dev)
diff --git a/drivers/gpio/gpio_esp32.c b/drivers/gpio/gpio_esp32.c
index 1cec57b3b76..a63a0e31595 100644
--- a/drivers/gpio/gpio_esp32.c
+++ b/drivers/gpio/gpio_esp32.c
@@ -478,12 +478,17 @@ static int gpio_esp32_init(const struct device *dev)
 	static bool isr_connected;
 
 	if (!isr_connected) {
-		esp_intr_alloc(DT_IRQ_BY_IDX(DT_NODELABEL(gpio0), 0, irq),
+		int ret = esp_intr_alloc(DT_IRQ_BY_IDX(DT_NODELABEL(gpio0), 0, irq),
 			ESP_PRIO_TO_FLAGS(DT_IRQ_BY_IDX(DT_NODELABEL(gpio0), 0, priority)),
 			(ISR_HANDLER)gpio_esp32_isr,
 			(void *)dev,
 			NULL);
 
+		if (ret != 0) {
+			LOG_ERR("could not allocate interrupt (err %d)", ret);
+			return ret;
+		}
+
 		isr_connected = true;
 	}
 
diff --git a/drivers/i2c/i2c_esp32.c b/drivers/i2c/i2c_esp32.c
index 7f14772b96f..7f74250d74f 100644
--- a/drivers/i2c/i2c_esp32.c
+++ b/drivers/i2c/i2c_esp32.c
@@ -762,12 +762,17 @@ static int IRAM_ATTR i2c_esp32_init(const struct device *dev)
 
 	clock_control_on(config->clock_dev, config->clock_subsys);
 
-	esp_intr_alloc(config->irq_source,
+	ret = esp_intr_alloc(config->irq_source,
 			ESP_PRIO_TO_FLAGS(config->irq_priority) | ESP_INTR_FLAG_IRAM,
 			i2c_esp32_isr,
 			(void *)dev,
 			NULL);
 
+	if (ret != 0) {
+		LOG_ERR("could not allocate interrupt (err %d)", ret);
+		return ret;
+	}
+
 	i2c_hal_master_init(&data->hal);
 
 	i2c_esp32_configure_data_mode(dev);
diff --git a/drivers/ipm/ipm_esp32.c b/drivers/ipm/ipm_esp32.c
index faf23c8fd1b..1cfe21de007 100644
--- a/drivers/ipm/ipm_esp32.c
+++ b/drivers/ipm/ipm_esp32.c
@@ -208,6 +208,7 @@ static int esp32_ipm_init(const struct device *dev)
 {
 	struct esp32_ipm_data *data = (struct esp32_ipm_data *)dev->data;
 	struct esp32_ipm_config *cfg = (struct esp32_ipm_config *)dev->config;
+	int ret;
 
 	data->this_core_id = esp_core_id();
 	data->other_core_id = (data->this_core_id  == 0) ? 1 : 0;
@@ -219,22 +220,34 @@ static int esp32_ipm_init(const struct device *dev)
 
 	/* pro_cpu is responsible to initialize the lock of shared memory */
 	if (data->this_core_id == 0) {
-		esp_intr_alloc(cfg->irq_source_pro_cpu,
-			ESP_PRIO_TO_FLAGS(cfg->irq_priority_pro_cpu) | ESP_INTR_FLAG_IRAM,
-			(intr_handler_t)esp32_ipm_isr,
-			(void *)dev,
-			NULL);
+		ret = esp_intr_alloc(cfg->irq_source_pro_cpu,
+				ESP_PRIO_TO_FLAGS(cfg->irq_priority_pro_cpu) |
+					ESP_INTR_FLAG_IRAM,
+				(intr_handler_t)esp32_ipm_isr,
+				(void *)dev,
+				NULL);
+
+		if (ret != 0) {
+			LOG_ERR("could not allocate interrupt (err %d)", ret);
+			return ret;
+		}
 
 		atomic_set(&data->control->lock, ESP32_IPM_LOCK_FREE_VAL);
 	} else {
 		/* app_cpu wait for initialization from pro_cpu, then takes it,
 		 * after that releases
 		 */
-		esp_intr_alloc(cfg->irq_source_app_cpu,
-			ESP_PRIO_TO_FLAGS(cfg->irq_priority_app_cpu) | ESP_INTR_FLAG_IRAM,
-			(intr_handler_t)esp32_ipm_isr,
-			(void *)dev,
-			NULL);
+		ret = esp_intr_alloc(cfg->irq_source_app_cpu,
+				ESP_PRIO_TO_FLAGS(cfg->irq_priority_app_cpu) |
+					ESP_INTR_FLAG_IRAM,
+				(intr_handler_t)esp32_ipm_isr,
+				(void *)dev,
+				NULL);
+
+		if (ret != 0) {
+			LOG_ERR("could not allocate interrupt (err %d)", ret);
+			return ret;
+		}
 
 		LOG_DBG("Waiting CPU0 to sync");
 		while (!atomic_cas(&data->control->lock,
diff --git a/drivers/pwm/pwm_mc_esp32.c b/drivers/pwm/pwm_mc_esp32.c
index 0b6bbcf0bc8..2f8db7da433 100644
--- a/drivers/pwm/pwm_mc_esp32.c
+++ b/drivers/pwm/pwm_mc_esp32.c
@@ -87,7 +87,7 @@ struct mcpwm_esp32_config {
 	uint8_t prescale_timer2;
 	struct mcpwm_esp32_channel_config channel_config[MCPWM_CHANNEL_NUM];
 #ifdef CONFIG_PWM_CAPTURE
-	void (*irq_config_func)(const struct device *dev);
+	int (*irq_config_func)(const struct device *dev);
 #endif /* CONFIG_PWM_CAPTURE */
 };
 
@@ -435,9 +435,13 @@ int mcpwm_esp32_init(const struct device *dev)
 	mcpwm_ll_group_flush_shadow(data->hal.dev);
 
 #ifdef CONFIG_PWM_CAPTURE
-	config->irq_config_func(dev);
+	ret = config->irq_config_func(dev);
+
+	if (ret != 0) {
+		LOG_ERR("could not allocate interrupt (err %d)", ret);
+	}
 #endif /* CONFIG_PWM_CAPTURE */
-	return 0;
+	return ret;
 }
 
 #ifdef CONFIG_PWM_CAPTURE
@@ -531,12 +535,14 @@ static const struct pwm_driver_api mcpwm_esp32_api = {
 
 #ifdef CONFIG_PWM_CAPTURE
 #define IRQ_CONFIG_FUNC(idx)                                                                       \
-	static void mcpwm_esp32_irq_config_func_##idx(const struct device *dev)                    \
+	static int mcpwm_esp32_irq_config_func_##idx(const struct device *dev)                    \
 	{                                                                                          \
-		esp_intr_alloc(DT_INST_IRQ_BY_IDX(idx, 0, irq),                            \
+		int ret;                                                                   \
+		ret = esp_intr_alloc(DT_INST_IRQ_BY_IDX(idx, 0, irq),                      \
 				ESP_PRIO_TO_FLAGS(DT_INST_IRQ_BY_IDX(idx, 0, priority)) |          \
 					ESP_INTR_FLAG_IRAM,                                            \
 				(intr_handler_t)mcpwm_esp32_isr, (void *)dev, NULL);               \
+		return ret;                                                                \
 	}
 #define CAPTURE_INIT(idx) .irq_config_func = mcpwm_esp32_irq_config_func_##idx
 #else
diff --git a/drivers/serial/serial_esp32_usb.c b/drivers/serial/serial_esp32_usb.c
index 31f1b364405..2c730cdd5b8 100644
--- a/drivers/serial/serial_esp32_usb.c
+++ b/drivers/serial/serial_esp32_usb.c
@@ -107,8 +107,12 @@ static int serial_esp32_usb_init(const struct device *dev)
 
 	int ret = clock_control_on(config->clock_dev, config->clock_subsys);
 
+	if (ret != 0) {
+		return ret;
+	}
+
 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
-	esp_intr_alloc(config->irq_source,
+	ret = esp_intr_alloc(config->irq_source,
 			ESP_PRIO_TO_FLAGS(config->irq_priority),
 			(ISR_HANDLER)serial_esp32_usb_isr,
 			(void *)dev, NULL);
diff --git a/drivers/spi/spi_esp32_spim.c b/drivers/spi/spi_esp32_spim.c
index 7efa047d8e4..25ba6308f45 100644
--- a/drivers/spi/spi_esp32_spim.c
+++ b/drivers/spi/spi_esp32_spim.c
@@ -244,11 +244,16 @@ static int spi_esp32_init(const struct device *dev)
 	spi_ll_disable_int(cfg->spi);
 	spi_ll_clear_int_stat(cfg->spi);
 
-	esp_intr_alloc(cfg->irq_source,
+	err = esp_intr_alloc(cfg->irq_source,
 			ESP_PRIO_TO_FLAGS(cfg->irq_priority) | ESP_INTR_FLAG_IRAM,
 			(ISR_HANDLER)spi_esp32_isr,
 			(void *)dev,
 			NULL);
+
+	if (err != 0) {
+		LOG_ERR("could not allocate interrupt (err %d)", err);
+		return err;
+	}
 #endif
 
 	err = spi_context_cs_configure_all(&data->ctx);
diff --git a/drivers/timer/esp32_sys_timer.c b/drivers/timer/esp32_sys_timer.c
index d657cc09f2f..f745ff7b9d5 100644
--- a/drivers/timer/esp32_sys_timer.c
+++ b/drivers/timer/esp32_sys_timer.c
@@ -143,12 +143,18 @@ void sys_clock_disable(void)
 
 static int sys_clock_driver_init(void)
 {
-	esp_intr_alloc(DT_IRQ_BY_IDX(DT_NODELABEL(systimer0), 0, irq),
+	int ret;
+
+	ret = esp_intr_alloc(DT_IRQ_BY_IDX(DT_NODELABEL(systimer0), 0, irq),
 		ESP_PRIO_TO_FLAGS(DT_IRQ_BY_IDX(DT_NODELABEL(systimer0), 0, priority)),
 		sys_timer_isr,
 		NULL,
 		NULL);
 
+	if (ret != 0) {
+		return ret;
+	}
+
 	systimer_hal_init(&systimer_hal);
 	systimer_hal_connect_alarm_counter(&systimer_hal,
 		SYSTIMER_ALARM_OS_TICK_CORE0, SYSTIMER_COUNTER_OS_TICK);
diff --git a/drivers/watchdog/wdt_esp32.c b/drivers/watchdog/wdt_esp32.c
index 62119e7c5a3..20ae12c9d02 100644
--- a/drivers/watchdog/wdt_esp32.c
+++ b/drivers/watchdog/wdt_esp32.c
@@ -167,11 +167,16 @@ static int wdt_esp32_init(const struct device *dev)
 
 	wdt_hal_init(&data->hal, config->wdt_inst, MWDT_TICK_PRESCALER, true);
 
-	esp_intr_alloc(config->irq_source,
-		ESP_PRIO_TO_FLAGS(cfg->irq_priority),
-		(ISR_HANDLER)wdt_esp32_isr,
-		(void *)dev,
-		NULL);
+	int ret = esp_intr_alloc(config->irq_source,
+				ESP_PRIO_TO_FLAGS(config->irq_priority),
+				(ISR_HANDLER)wdt_esp32_isr,
+				(void *)dev,
+				NULL);
+
+	if (ret != 0) {
+		LOG_ERR("could not allocate interrupt (err %d)", ret);
+		return ret;
+	}
 
 #ifndef CONFIG_WDT_DISABLE_AT_BOOT
 	wdt_esp32_enable(dev);