isr: Normalize usage of device instance through ISR

The goal of this patch is to replace the 'void *' parameter by 'struct
device *' if they use such variable or just 'const void *' on all
relevant ISRs

This will avoid not-so-nice const qualifier tweaks when device instances
will be constant.

Note that only the ISR passed to IRQ_CONNECT are of interest here.

In order to do so, the script fix_isr.py below is necessary:

from pathlib import Path
import subprocess
import pickle
import mmap
import sys
import re
import os

cocci_template = """
@r_fix_isr_0
@
type ret_type;
identifier P;
identifier D;
@@
-ret_type <!fn!>(void *P)
+ret_type <!fn!>(const struct device *P)
{
 ...
(
 const struct device *D = (const struct device *)P;
|
 const struct device *D = P;
)
 ...
}

@r_fix_isr_1
@
type ret_type;
identifier P;
identifier D;
@@
-ret_type <!fn!>(void *P)
+ret_type <!fn!>(const struct device *P)
{
 ...
 const struct device *D;
 ...
(
 D = (const struct device *)P;
|
 D = P;
)
 ...
}

@r_fix_isr_2
@
type ret_type;
identifier A;
@@
-ret_type <!fn!>(void *A)
+ret_type <!fn!>(const void *A)
{
 ...
}

@r_fix_isr_3
@
const struct device *D;
@@
-<!fn!>((void *)D);
+<!fn!>(D);

@r_fix_isr_4
@
type ret_type;
identifier D;
identifier P;
@@
-ret_type <!fn!>(const struct device *P)
+ret_type <!fn!>(const struct device *D)
{
 ...
(
-const struct device *D = (const struct device *)P;
|
-const struct device *D = P;
)
 ...
}

@r_fix_isr_5
@
type ret_type;
identifier D;
identifier P;
@@
-ret_type <!fn!>(const struct device *P)
+ret_type <!fn!>(const struct device *D)
{
 ...
-const struct device *D;
...
(
-D = (const struct device *)P;
|
-D = P;
)
 ...
}
"""

def find_isr(fn):
    db = []
    data = None
    start = 0

    try:
        with open(fn, 'r+') as f:
            data = str(mmap.mmap(f.fileno(), 0).read())
    except Exception as e:
        return db

    while True:
        isr = ""
        irq = data.find('IRQ_CONNECT', start)
        while irq > -1:
            p = 1
            arg = 1
            p_o = data.find('(', irq)
            if p_o < 0:
                irq = -1
                break;

            pos = p_o + 1

            while p > 0:
                if data[pos] == ')':
                    p -= 1
                elif data[pos] == '(':
                    p += 1
                elif data[pos] == ',' and p == 1:
                    arg += 1

                if arg == 3:
                    isr += data[pos]

                pos += 1

            isr = isr.strip(',\\n\\t ')
            if isr not in db and len(isr) > 0:
                db.append(isr)

            start = pos
            break

        if irq < 0:
            break

    return db

def patch_isr(fn, isr_list):
    if len(isr_list) <= 0:
        return

    for isr in isr_list:
        tmplt = cocci_template.replace('<!fn!>', isr)
        with open('/tmp/isr_fix.cocci', 'w') as f:
            f.write(tmplt)

        cmd = ['spatch', '--sp-file', '/tmp/isr_fix.cocci', '--in-place', fn]

        subprocess.run(cmd)

def process_files(path):
    if path.is_file() and path.suffix in ['.h', '.c']:
        p = str(path.parent) + '/' + path.name
        isr_list = find_isr(p)
        patch_isr(p, isr_list)
    elif path.is_dir():
        for p in path.iterdir():
            process_files(p)

if len(sys.argv) < 2:
    print("You need to provide a dir/file path")
    sys.exit(1)

process_files(Path(sys.argv[1]))

And is run: ./fix_isr.py <zephyr root directory>

Finally, some files needed manual fixes such.

Fixes #27399

Signed-off-by: Tomasz Bursztyka <tomasz.bursztyka@linux.intel.com>

arch/arc/core/arc_smp.c

@@ -87,7 +87,7 @@ void z_arc_slave_start(int cpu_num)
 
 #ifdef CONFIG_SMP
 
-static void sched_ipi_handler(void *unused)
+static void sched_ipi_handler(const void *unused)
 {
 	ARG_UNUSED(unused);
 

arch/xtensa/core/irq_offload.c

@@ -17,7 +17,7 @@ static irq_offload_routine_t offload_routine;
 static const void *offload_param;
 
 /* Called by ISR dispatcher */
-void z_irq_do_offload(void *unused)
+void z_irq_do_offload(const void *unused)
 {
 	ARG_UNUSED(unused);
 	offload_routine(offload_param);

boards/posix/nrf52_bsim/irq_handler.c

@@ -22,7 +22,7 @@
 
 static bool CPU_will_be_awaken_from_WFE;
 
-typedef void (*normal_irq_f_ptr)(void *);
+typedef void (*normal_irq_f_ptr)(const void *);
 typedef int (*direct_irq_f_ptr)(void);
 
 static struct _isr_list irq_vector_table[NRF_HW_NBR_IRQs];

drivers/adc/adc_mcux_adc12.c

@@ -188,9 +188,8 @@ static void adc_context_update_buffer_pointer(struct adc_context *ctx,
 	}
 }
 
-static void mcux_adc12_isr(void *arg)
+static void mcux_adc12_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct mcux_adc12_config *config = dev->config;
 	struct mcux_adc12_data *data = dev->data;
 	ADC_Type *base = config->base;

drivers/adc/adc_mcux_adc16.c

@@ -203,9 +203,8 @@ static void adc_context_update_buffer_pointer(struct adc_context *ctx,
 	}
 }
 
-static void mcux_adc16_isr(void *arg)
+static void mcux_adc16_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct mcux_adc16_config *config = dev->config;
 	struct mcux_adc16_data *data = dev->data;
 	ADC_Type *base = config->base;

drivers/adc/adc_nrfx_saadc.c

@@ -366,10 +366,8 @@ static int adc_nrfx_read_async(const struct device *dev,
 }
 #endif /* CONFIG_ADC_ASYNC */
 
-static void saadc_irq_handler(void *param)
+static void saadc_irq_handler(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)param;
-
 	if (nrf_saadc_event_check(NRF_SAADC, NRF_SAADC_EVENT_END)) {
 		nrf_saadc_event_clear(NRF_SAADC, NRF_SAADC_EVENT_END);
 

drivers/adc/adc_sam0.c

@@ -429,9 +429,8 @@ static int adc_sam0_read(const struct device *dev,
 	return error;
 }
 
-static void adc_sam0_isr(void *arg)
+static void adc_sam0_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct adc_sam0_data *data = DEV_DATA(dev);
 	const struct adc_sam0_cfg *const cfg = DEV_CFG(dev);
 	Adc *const adc = cfg->regs;

drivers/adc/adc_sam_afec.c

@@ -325,9 +325,8 @@ static const struct adc_driver_api adc_sam_api = {
 #endif
 };
 
-static void adc_sam_isr(void *arg)
+static void adc_sam_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct adc_sam_data *data = DEV_DATA(dev);
 	const struct adc_sam_cfg *const cfg = DEV_CFG(dev);
 	Afec *const afec = cfg->regs;

drivers/adc/adc_stm32.c

@@ -386,9 +386,8 @@ static void adc_context_update_buffer_pointer(struct adc_context *ctx,
 	}
 }
 
-static void adc_stm32_isr(void *arg)
+static void adc_stm32_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct adc_stm32_data *data = (struct adc_stm32_data *)dev->data;
 	const struct adc_stm32_cfg *config =
 		(const struct adc_stm32_cfg *)dev->config;

drivers/can/can_mcux_flexcan.c

@@ -611,9 +611,8 @@ static void mcux_flexcan_transfer_callback(CAN_Type *base,
 	}
 }
 
-static void mcux_flexcan_isr(void *arg)
+static void mcux_flexcan_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct mcux_flexcan_config *config = dev->config;
 	struct mcux_flexcan_data *data = dev->data;
 

drivers/can/can_stm32.c

@@ -173,14 +173,12 @@ void can_stm32_tx_isr_handler(CAN_TypeDef *can, struct can_stm32_data *data)
 
 #ifdef CONFIG_SOC_SERIES_STM32F0X
 
-static void can_stm32_isr(void *arg)
+static void can_stm32_isr(const struct device *dev)
 {
-	const struct device *dev;
 	struct can_stm32_data *data;
 	const struct can_stm32_config *cfg;
 	CAN_TypeDef *can;
 
-	dev = (const struct device *)arg;
 	data = DEV_DATA(dev);
 	cfg = DEV_CFG(dev);
 	can = cfg->can;
@@ -195,14 +193,12 @@ static void can_stm32_isr(void *arg)
 
 #else
 
-static void can_stm32_rx_isr(void *arg)
+static void can_stm32_rx_isr(const struct device *dev)
 {
-	const struct device *dev;
 	struct can_stm32_data *data;
 	const struct can_stm32_config *cfg;
 	CAN_TypeDef *can;
 
-	dev = (const struct device *)arg;
 	data = DEV_DATA(dev);
 	cfg = DEV_CFG(dev);
 	can = cfg->can;
@@ -210,14 +206,12 @@ static void can_stm32_rx_isr(void *arg)
 	can_stm32_rx_isr_handler(can, data);
 }
 
-static void can_stm32_tx_isr(void *arg)
+static void can_stm32_tx_isr(const struct device *dev)
 {
-	const struct device *dev;
 	struct can_stm32_data *data;
 	const struct can_stm32_config *cfg;
 	CAN_TypeDef *can;
 
-	dev = (const struct device *)arg;
 	data = DEV_DATA(dev);
 	cfg = DEV_CFG(dev);
 	can = cfg->can;
@@ -225,14 +219,12 @@ static void can_stm32_tx_isr(void *arg)
 	can_stm32_tx_isr_handler(can, data);
 }
 
-static void can_stm32_state_change_isr(void *arg)
+static void can_stm32_state_change_isr(const struct device *dev)
 {
-	const struct device *dev;
 	struct can_stm32_data *data;
 	const struct can_stm32_config *cfg;
 	CAN_TypeDef *can;
 
-	dev = (const struct device *)arg;
 	data = DEV_DATA(dev);
 	cfg = DEV_CFG(dev);
 	can = cfg->can;

drivers/counter/counter_imx_epit.c

@@ -29,9 +29,8 @@ static inline const struct imx_epit_config *get_epit_config(const struct device
 			    info);
 }
 
-static void imx_epit_isr(void *arg)
+static void imx_epit_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	EPIT_Type *base = get_epit_config(dev)->base;
 	struct imx_epit_data *driver_data = dev->data;
 

drivers/counter/counter_ll_stm32_rtc.c

@@ -245,9 +245,8 @@ static uint32_t rtc_stm32_get_max_relative_alarm(const struct device *dev)
 }
 
 
-void rtc_stm32_isr(void *arg)
+void rtc_stm32_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct rtc_stm32_data *data = DEV_DATA(dev);
 	counter_alarm_callback_t alarm_callback = data->callback;
 

drivers/counter/counter_mcux_gpt.c

@@ -100,9 +100,8 @@ static int mcux_gpt_cancel_alarm(const struct device *dev, uint8_t chan_id)
 	return 0;
 }
 
-void mcux_gpt_isr(void *p)
+void mcux_gpt_isr(const struct device *dev)
 {
-	const struct device *dev = p;
 	const struct mcux_gpt_config *config = dev->config;
 	struct mcux_gpt_data *data = dev->data;
 	uint32_t current = GPT_GetCurrentTimerCount(config->base);

drivers/counter/counter_mcux_lptmr.c

@@ -111,9 +111,8 @@ static uint32_t mcux_lptmr_get_max_relative_alarm(const struct device *dev)
 	return 0;
 }
 
-static void mcux_lptmr_isr(void *arg)
+static void mcux_lptmr_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	const struct mcux_lptmr_config *config = dev->config;
 	struct mcux_lptmr_data *data = dev->data;
 	uint32_t flags;

drivers/counter/counter_mcux_pit.c

@@ -114,9 +114,8 @@ static uint32_t mcux_pit_get_max_relative_alarm(const struct device *dev)
 	return config->info.max_top_value;
 }
 
-static void mcux_pit_isr(void *arg)
+static void mcux_pit_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	const struct mcux_pit_config *config = dev->config;
 	struct mcux_pit_data *data = dev->data;
 	uint32_t flags;

drivers/counter/counter_mcux_rtc.c

@@ -189,9 +189,8 @@ static uint32_t mcux_rtc_get_max_relative_alarm(const struct device *dev)
 	return info->max_top_value;
 }
 
-static void mcux_rtc_isr(void *arg)
+static void mcux_rtc_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	const struct counter_config_info *info = dev->config;
 	const struct mcux_rtc_config *config =
 		CONTAINER_OF(info, struct mcux_rtc_config, info);

drivers/counter/counter_native_posix.c

@@ -22,7 +22,7 @@ static struct counter_alarm_cfg pending_alarm;
 static bool is_alarm_pending;
 static const struct device *device;
 
-static void counter_isr(void *arg)
+static void counter_isr(const void *arg)
 {
 	ARG_UNUSED(arg);
 	uint32_t current_value = hw_counter_get_value();

drivers/counter/counter_sam0_tc32.c

@@ -310,9 +310,8 @@ static uint32_t counter_sam0_tc32_get_max_relative_alarm(const struct device *de
 	return counter_sam0_tc32_get_top_value(dev) - 1;
 }
 
-static void counter_sam0_tc32_isr(void *arg)
+static void counter_sam0_tc32_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct counter_sam0_tc32_data *data = DEV_DATA(dev);
 	const struct counter_sam0_tc32_config *const cfg = DEV_CFG(dev);
 	TcCount32 *tc = cfg->regs;

drivers/counter/timer_dtmr_cmsdk_apb.c

@@ -127,9 +127,8 @@ static const struct counter_driver_api dtmr_cmsdk_apb_api = {
 	.get_top_value = dtmr_cmsdk_apb_get_top_value,
 };
 
-static void dtmr_cmsdk_apb_isr(void *arg)
+static void dtmr_cmsdk_apb_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct dtmr_cmsdk_apb_dev_data *data = dev->data;
 	const struct dtmr_cmsdk_apb_cfg * const cfg = dev->config;
 

drivers/display/display_mcux_elcdif.c

@@ -164,9 +164,8 @@ static void mcux_elcdif_get_capabilities(const struct device *dev,
 	capabilities->current_orientation = DISPLAY_ORIENTATION_NORMAL;
 }
 
-static void mcux_elcdif_isr(void *arg)
+static void mcux_elcdif_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct mcux_elcdif_config *config = dev->config;
 	struct mcux_elcdif_data *data = dev->data;
 	uint32_t status;

drivers/dma/dma_dw.c

@@ -53,9 +53,8 @@ static ALWAYS_INLINE uint32_t dw_read(uint32_t dma_base, uint32_t reg)
 	return *((volatile uint32_t*)(dma_base + reg));
 }
 
-static void dw_dma_isr(void *arg)
+static void dw_dma_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct dw_dma_dev_cfg *const dev_cfg = DEV_CFG(dev);
 	struct dw_dma_dev_data *const dev_data = DEV_DATA(dev);
 	struct dma_chan_data *chan_data;

drivers/dma/dma_mcux_edma.c

@@ -135,9 +135,8 @@ static void channel_irq(edma_handle_t *handle)
 	}
 }
 
-static void dma_mcux_edma_irq_handler(void *arg)
+static void dma_mcux_edma_irq_handler(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	int i = 0;
 
 	LOG_DBG("IRQ CALLED");
@@ -165,11 +164,10 @@ static void dma_mcux_edma_irq_handler(void *arg)
 	}
 }
 
-static void dma_mcux_edma_error_irq_handler(void *arg)
+static void dma_mcux_edma_error_irq_handler(const struct device *dev)
 {
 	int i = 0;
 	uint32_t flag = 0;
-	const struct device *dev = (const struct device *)arg;
 
 	for (i = 0; i < DT_INST_PROP(0, dma_channels); i++) {
 		if (DEV_CHANNEL_DATA(dev, i)->busy) {

drivers/dma/dma_mcux_lpc.c

@@ -73,10 +73,8 @@ static void nxp_lpc_dma_callback(dma_handle_t *handle, void *param,
 }
 
 /* Handles DMA interrupts and dispatches to the individual channel */
-static void dma_mcux_lpc_irq_handler(void *arg)
+static void dma_mcux_lpc_irq_handler(const struct device *dev)
 {
-	const struct device *dev = arg;
-
 	DMA_IRQHandle(DEV_BASE(dev));
 /*
  * Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store

drivers/dma/dma_sam0.c

@@ -31,9 +31,8 @@ struct dma_sam0_data {
 
 
 /* Handles DMA interrupts and dispatches to the individual channel */
-static void dma_sam0_isr(void *arg)
+static void dma_sam0_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct dma_sam0_data *data = DEV_DATA(dev);
 	struct dma_sam0_channel *chdata;
 	uint16_t pend = DMA_REGS->INTPEND.reg;

drivers/dma/dma_sam_xdmac.c

@@ -51,9 +51,8 @@ struct sam_xdmac_dev_data {
 #define DEV_DATA(dev) \
 	((struct sam_xdmac_dev_data *const)(dev)->data)
 
-static void sam_xdmac_isr(void *arg)
+static void sam_xdmac_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct sam_xdmac_dev_cfg *const dev_cfg = DEV_CFG(dev);
 	struct sam_xdmac_dev_data *const dev_data = DEV_DATA(dev);
 	Xdmac *const xdmac = dev_cfg->regs;

drivers/entropy/entropy_cc13xx_cc26xx.c

@@ -136,7 +136,7 @@ static int entropy_cc13xx_cc26xx_get_entropy(const struct device *dev,
 	return 0;
 }
 
-static void entropy_cc13xx_cc26xx_isr(void *arg)
+static void entropy_cc13xx_cc26xx_isr(const void *arg)
 {
 	struct entropy_cc13xx_cc26xx_data *data = get_dev_data(arg);
 	uint32_t src = 0;

drivers/entropy/entropy_nrf5.c

@@ -204,7 +204,7 @@ static void rng_pool_init(struct rng_pool *rngp, uint16_t size, uint8_t threshol
 	rngp->threshold	  = threshold;
 }
 
-static void isr(void *arg)
+static void isr(const void *arg)
 {
 	int byte, ret;
 

drivers/entropy/entropy_stm32.c

@@ -216,7 +216,7 @@ static void rng_pool_init(struct rng_pool *rngp, uint16_t size,
 	rngp->threshold	  = threshold;
 }
 
-static void stm32_rng_isr(void *arg)
+static void stm32_rng_isr(const void *arg)
 {
 	int byte, ret;
 

drivers/espi/espi_mchp_xec.c

@@ -1204,9 +1204,8 @@ static uint8_t m2s_vwires_isr_cnt =
 	sizeof(m2s_vwires_isr) / sizeof(struct espi_isr);
 static uint8_t periph_isr_cnt = sizeof(peripherals_isr) / sizeof(struct espi_isr);
 
-static void espi_xec_bus_isr(void *arg)
+static void espi_xec_bus_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct espi_xec_config *config = dev->config;
 	uint32_t girq_result;
 
@@ -1225,9 +1224,8 @@ static void espi_xec_bus_isr(void *arg)
 	REG32(MCHP_GIRQ_SRC_ADDR(config->bus_girq_id)) = girq_result;
 }
 
-static void espi_xec_vw_isr(void *arg)
+static void espi_xec_vw_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct espi_xec_config *config = dev->config;
 	uint32_t girq_result;
 
@@ -1246,9 +1244,8 @@ static void espi_xec_vw_isr(void *arg)
 	REG32(MCHP_GIRQ_SRC_ADDR(config->vw_girq_id)) = girq_result;
 }
 
-static void espi_xec_periph_isr(void *arg)
+static void espi_xec_periph_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct espi_xec_config *config = dev->config;
 	uint32_t girq_result;
 

drivers/ethernet/eth_gecko.c

@@ -367,9 +367,8 @@ static void rx_thread(void *arg1, void *unused1, void *unused2)
 	}
 }
 
-static void eth_isr(void *arg)
+static void eth_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct eth_gecko_dev_data *const dev_data = DEV_DATA(dev);
 	const struct eth_gecko_dev_cfg *const cfg = DEV_CFG(dev);
 	ETH_TypeDef *eth = cfg->regs;
@@ -381,7 +380,6 @@ static void eth_isr(void *arg)
 				ETH_IENS_AMBAERR);
 	uint32_t rx_irq_mask = (ETH_IENS_RXCMPLT | ETH_IENS_RXUSEDBITREAD);
 
-	__ASSERT_NO_MSG(arg != NULL);
 	__ASSERT_NO_MSG(dev_data != NULL);
 	__ASSERT_NO_MSG(cfg != NULL);
 

drivers/ethernet/eth_mcux.c

@@ -1214,9 +1214,8 @@ static const struct ethernet_api api_funcs = {
 };
 
 #if defined(CONFIG_PTP_CLOCK_MCUX)
-static void eth_mcux_ptp_isr(void *p)
+static void eth_mcux_ptp_isr(const struct device *dev)
 {
-	const struct device *dev = p;
 	struct eth_context *context = dev->data;
 
 	ENET_Ptp1588TimerIRQHandler(context->base, &context->enet_handle);
@@ -1224,9 +1223,8 @@ static void eth_mcux_ptp_isr(void *p)
 #endif
 
 #if DT_INST_IRQ_HAS_NAME(0, common)
-static void eth_mcux_dispacher_isr(void *p)
+static void eth_mcux_dispacher_isr(const struct device *dev)
 {
-	const struct device *dev = p;
 	struct eth_context *context = dev->data;
 	uint32_t EIR = ENET_GetInterruptStatus(context->base);
 	int irq_lock_key = irq_lock();
@@ -1247,9 +1245,8 @@ static void eth_mcux_dispacher_isr(void *p)
 #endif
 
 #if DT_INST_IRQ_HAS_NAME(0, rx)
-static void eth_mcux_rx_isr(void *p)
+static void eth_mcux_rx_isr(const struct device *dev)
 {
-	const struct device *dev = p;
 	struct eth_context *context = dev->data;
 
 	ENET_ReceiveIRQHandler(context->base, &context->enet_handle);
@@ -1257,9 +1254,8 @@ static void eth_mcux_rx_isr(void *p)
 #endif
 
 #if DT_INST_IRQ_HAS_NAME(0, tx)
-static void eth_mcux_tx_isr(void *p)
+static void eth_mcux_tx_isr(const struct device *dev)
 {
-	const struct device *dev = p;
 	struct eth_context *context = dev->data;
 
 	ENET_TransmitIRQHandler(context->base, &context->enet_handle);
@@ -1267,9 +1263,8 @@ static void eth_mcux_tx_isr(void *p)
 #endif
 
 #if DT_INST_IRQ_HAS_NAME(0, err_misc)
-static void eth_mcux_error_isr(void *p)
+static void eth_mcux_error_isr(const struct device *dev)
 {
-	const struct device *dev = p;
 	struct eth_context *context = dev->data;
 	uint32_t pending = ENET_GetInterruptStatus(context->base);
 

drivers/ethernet/eth_sam_gmac.c

@@ -1624,9 +1624,8 @@ static int eth_tx(const struct device *dev, struct net_pkt *pkt)
 	return 0;
 }
 
-static void queue0_isr(void *arg)
+static void queue0_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct eth_sam_dev_cfg *const cfg = DEV_CFG(dev);
 	struct eth_sam_dev_data *const dev_data = DEV_DATA(dev);
 	Gmac *gmac = cfg->regs;
@@ -1726,35 +1725,35 @@ static inline void priority_queue_isr(void *arg, unsigned int queue_idx)
 #endif
 
 #if GMAC_ACTIVE_PRIORITY_QUEUE_NUM >= 1
-static void queue1_isr(void *arg)
+static void queue1_isr(const void *arg)
 {
 	priority_queue_isr(arg, 1);
 }
 #endif
 
 #if GMAC_ACTIVE_PRIORITY_QUEUE_NUM >= 2
-static void queue2_isr(void *arg)
+static void queue2_isr(const void *arg)
 {
 	priority_queue_isr(arg, 2);
 }
 #endif
 
 #if GMAC_ACTIVE_PRIORITY_QUEUE_NUM >= 3
-static void queue3_isr(void *arg)
+static void queue3_isr(const void *arg)
 {
 	priority_queue_isr(arg, 3);
 }
 #endif
 
 #if GMAC_ACTIVE_PRIORITY_QUEUE_NUM >= 4
-static void queue4_isr(void *arg)
+static void queue4_isr(const void *arg)
 {
 	priority_queue_isr(arg, 4);
 }
 #endif
 
 #if GMAC_ACTIVE_PRIORITY_QUEUE_NUM >= 5
-static void queue5_isr(void *arg)
+static void queue5_isr(const void *arg)
 {
 	priority_queue_isr(arg, 5);
 }

drivers/ethernet/eth_stellaris.c

@@ -227,10 +227,8 @@ err_mem:
 	eth_stellaris_rx_error(iface);
 }
 
-static void eth_stellaris_isr(void *arg)
+static void eth_stellaris_isr(const struct device *dev)
 {
-	/* Read the interrupt status */
-	const struct device *dev = (const struct device *)arg;
 	struct eth_stellaris_runtime *dev_data = DEV_DATA(dev);
 	int isr_val = sys_read32(REG_MACRIS);
 	uint32_t lock;

drivers/ethernet/eth_stm32_hal.c

@@ -465,15 +465,13 @@ static void rx_thread(void *arg1, void *unused1, void *unused2)
 	}
 }
 
-static void eth_isr(void *arg)
+static void eth_isr(const struct device *dev)
 {
-	const struct device *dev;
 	struct eth_stm32_hal_dev_data *dev_data;
 	ETH_HandleTypeDef *heth;
 
-	__ASSERT_NO_MSG(arg != NULL);
+	__ASSERT_NO_MSG(dev != NULL);
 
-	dev = (const struct device *)arg;
 	dev_data = DEV_DATA(dev);
 
 	__ASSERT_NO_MSG(dev_data != NULL);

drivers/gpio/gpio_cc13xx_cc26xx.c

@@ -198,9 +198,8 @@ static uint32_t gpio_cc13xx_cc26xx_get_pending_int(const struct device *dev)
 
 DEVICE_DECLARE(gpio_cc13xx_cc26xx);
 
-static void gpio_cc13xx_cc26xx_isr(void *arg)
+static void gpio_cc13xx_cc26xx_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct gpio_cc13xx_cc26xx_data *data = dev->data;
 
 	uint32_t status = GPIO_getEventMultiDio(GPIO_DIO_ALL_MASK);

drivers/gpio/gpio_cc32xx.c

@@ -217,9 +217,8 @@ static int gpio_cc32xx_manage_callback(const struct device *dev,
 	return gpio_manage_callback(&data->callbacks, callback, set);
 }
 
-static void gpio_cc32xx_port_isr(void *arg)
+static void gpio_cc32xx_port_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	const struct gpio_cc32xx_config *config = DEV_CFG(dev);
 	struct gpio_cc32xx_data *data = DEV_DATA(dev);
 	uint32_t int_status;

drivers/gpio/gpio_cmsdk_ahb.c

@@ -191,9 +191,8 @@ static int gpio_cmsdk_ahb_pin_interrupt_configure(const struct device *dev,
 	return 0;
 }
 
-static void gpio_cmsdk_ahb_isr(void *arg)
+static void gpio_cmsdk_ahb_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct gpio_cmsdk_ahb_cfg * const cfg = dev->config;
 	struct gpio_cmsdk_ahb_dev_data *data = dev->data;
 	uint32_t int_stat;

drivers/gpio/gpio_dw.c

@@ -487,9 +487,8 @@ static int gpio_dw_device_ctrl(const struct device *port,
 
 #define gpio_dw_unmask_int(...)
 
-static void gpio_dw_isr(void *arg)
+static void gpio_dw_isr(const struct device *port)
 {
-	const struct device *port = (const struct device *)arg;
 	struct gpio_dw_runtime *context = port->data;
 	uint32_t base_addr = dw_base_to_block_base(context->base_addr);
 	uint32_t int_status;

drivers/gpio/gpio_esp32.c

@@ -263,7 +263,7 @@ static void gpio_esp32_fire_callbacks(const struct device *device)
 	gpio_fire_callbacks(&data->cb, device, irq_status);
 }
 
-static void gpio_esp32_isr(void *param);
+static void gpio_esp32_isr(const void *param);
 
 static int gpio_esp32_init(const struct device *device)
 {
@@ -355,7 +355,7 @@ GPIO_DEVICE_INIT(0);
 GPIO_DEVICE_INIT(1);
 #endif
 
-static void gpio_esp32_isr(void *param)
+static void gpio_esp32_isr(const void *param)
 {
 
 #if defined(CONFIG_GPIO_ESP32_0)

drivers/gpio/gpio_gecko.c

@@ -234,9 +234,8 @@ static int gpio_gecko_manage_callback(const struct device *dev,
 /**
  * Handler for both odd and even pin interrupts
  */
-static void gpio_gecko_common_isr(void *arg)
+static void gpio_gecko_common_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct gpio_gecko_common_data *data = dev->data;
 	uint32_t enabled_int, int_status;
 	const struct device *port_dev;

drivers/gpio/gpio_imx.c

@@ -183,9 +183,8 @@ static int imx_gpio_manage_callback(const struct device *port,
 	return gpio_manage_callback(&data->callbacks, cb, set);
 }
 
-static void imx_gpio_port_isr(void *arg)
+static void imx_gpio_port_isr(const struct device *port)
 {
-	const struct device *port = (const struct device *)arg;
 	const struct imx_gpio_config *config = port->config;
 	struct imx_gpio_data *data = port->data;
 	uint32_t int_status;

drivers/gpio/gpio_intel_apl.c

@@ -184,9 +184,8 @@ static int nr_isr_devs;
 
 static const struct device *isr_devs[GPIO_INTEL_APL_NR_SUBDEVS];
 
-static void gpio_intel_apl_isr(void *arg)
+static void gpio_intel_apl_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct gpio_intel_apl_config *cfg;
 	struct gpio_intel_apl_data *data;
 	struct gpio_callback *cb, *tmp;

drivers/gpio/gpio_lpc11u6x.c

@@ -428,9 +428,10 @@ DEVICE_DECLARE(gpio_lpc11u6x_1);
 DEVICE_DECLARE(gpio_lpc11u6x_2);
 #endif
 
-static void gpio_lpc11u6x_isr(void *arg)
+static void gpio_lpc11u6x_isr(const void *arg)
 {
-	struct gpio_lpc11u6x_shared *shared = arg;
+	struct gpio_lpc11u6x_shared *shared =
+		(struct gpio_lpc11u6x_shared *)arg;
 	struct lpc11u6x_pint_regs *pint_regs = (struct lpc11u6x_pint_regs *)
 		(shared->gpio_base + LPC11U6X_PINT_REGS);
 	uint32_t *pintsel_reg =

drivers/gpio/gpio_mchp_xec.c

@@ -277,9 +277,8 @@ static int gpio_xec_manage_callback(const struct device *dev,
 	return 0;
 }
 
-static void gpio_gpio_xec_port_isr(void *arg)
+static void gpio_gpio_xec_port_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct gpio_xec_config *config = dev->config;
 	struct gpio_xec_data *data = dev->data;
 	uint32_t girq_result;

drivers/gpio/gpio_mcux.c

@@ -226,9 +226,8 @@ static int gpio_mcux_manage_callback(const struct device *dev,
 	return gpio_manage_callback(&data->callbacks, callback, set);
 }
 
-static void gpio_mcux_port_isr(void *arg)
+static void gpio_mcux_port_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct gpio_mcux_config *config = dev->config;
 	struct gpio_mcux_data *data = dev->data;
 	uint32_t int_status;

drivers/gpio/gpio_mcux_igpio.c

@@ -177,9 +177,8 @@ static int mcux_igpio_manage_callback(const struct device *dev,
 	return gpio_manage_callback(&data->callbacks, callback, set);
 }
 
-static void mcux_igpio_port_isr(void *arg)
+static void mcux_igpio_port_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct mcux_igpio_config *config = dev->config;
 	struct mcux_igpio_data *data = dev->data;
 	GPIO_Type *base = config->base;

drivers/gpio/gpio_mcux_lpc.c

@@ -183,9 +183,8 @@ static int gpio_mcux_lpc_port_toggle_bits(const struct device *dev,
 	return 0;
 }
 
-static void gpio_mcux_lpc_port_isr(void *arg)
+static void gpio_mcux_lpc_port_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct gpio_mcux_lpc_config *config = dev->config;
 	struct gpio_mcux_lpc_data *data = dev->data;
 	uint32_t enabled_int;
@@ -251,7 +250,7 @@ static uint32_t attach_pin_to_isr(uint32_t port, uint32_t pin, uint32_t isr_no)
 	return pint_idx;
 }
 
-static void gpio_mcux_lpc_port_isr(void *arg);
+static void gpio_mcux_lpc_port_isr(const struct device *dev);
 
 
 static int gpio_mcux_lpc_pin_interrupt_configure(const struct device *dev,

drivers/gpio/gpio_rv32m1.c

@@ -246,9 +246,8 @@ static int gpio_rv32m1_manage_callback(const struct device *dev,
 	return 0;
 }
 
-static void gpio_rv32m1_port_isr(void *arg)
+static void gpio_rv32m1_port_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct gpio_rv32m1_config *config = dev->config;
 	struct gpio_rv32m1_data *data = dev->data;
 	uint32_t int_status;

drivers/gpio/gpio_sam.c

@@ -264,9 +264,8 @@ static int gpio_sam_pin_interrupt_configure(const struct device *dev,
 	return gpio_sam_port_interrupt_configure(dev, BIT(pin), mode, trig);
 }
 
-static void gpio_sam_isr(void *arg)
+static void gpio_sam_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct gpio_sam_config * const cfg = DEV_CFG(dev);
 	Pio * const pio = cfg->regs;
 	struct gpio_sam_runtime *context = dev->data;

drivers/gpio/gpio_sifive.c

@@ -112,9 +112,8 @@ static inline int gpio_sifive_plic_to_pin(unsigned int base_irq, int plic_irq)
 	return (plic_irq - base_irq);
 }
 
-static void gpio_sifive_irq_handler(void *arg)
+static void gpio_sifive_irq_handler(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct gpio_sifive_data *data = DEV_GPIO_DATA(dev);
 	volatile struct gpio_sifive_t *gpio = DEV_GPIO(dev);
 	const struct gpio_sifive_config *cfg = DEV_GPIO_CFG(dev);

drivers/gpio/gpio_stellaris.c

@@ -57,9 +57,8 @@ enum gpio_regs {
 	GPIO_ICR_OFFSET = 0x41C,
 };
 
-static void gpio_stellaris_isr(void *arg)
+static void gpio_stellaris_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct gpio_stellaris_config * const cfg = DEV_CFG(dev);
 	struct gpio_stellaris_runtime *context = DEV_DATA(dev);
 	uint32_t base = cfg->base;

drivers/i2c/i2c_cc13xx_cc26xx.c

@@ -284,7 +284,7 @@ static int i2c_cc13xx_cc26xx_configure(const struct device *dev,
 	return 0;
 }
 
-static void i2c_cc13xx_cc26xx_isr(void *arg)
+static void i2c_cc13xx_cc26xx_isr(const void *arg)
 {
 	const uint32_t base = get_dev_config(arg)->base;
 	struct i2c_cc13xx_cc26xx_data *data = get_dev_data(arg);

drivers/i2c/i2c_cc32xx.c

@@ -261,9 +261,8 @@ static void i2c_cc32xx_isr_handle_read(uint32_t base,
 	}
 }
 
-static void i2c_cc32xx_isr(void *arg)
+static void i2c_cc32xx_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	uint32_t base = DEV_BASE(dev);
 	struct i2c_cc32xx_data *data = DEV_DATA(dev);
 	uint32_t err_status;

drivers/i2c/i2c_esp32.c

@@ -549,13 +549,12 @@ static int i2c_esp32_transfer(const struct device *dev, struct i2c_msg *msgs,
 	return ret;
 }
 
-static void i2c_esp32_isr(void *arg)
+static void i2c_esp32_isr(const struct device *device)
 {
 	const int fifo_give_mask = I2C_ACK_ERR_INT_ST |
 				   I2C_TIME_OUT_INT_ST |
 				   I2C_TRANS_COMPLETE_INT_ST |
 				   I2C_ARBITRATION_LOST_INT_ST;
-	const struct device *device = arg;
 	const struct i2c_esp32_config *config = device->config;
 
 	if (sys_read32(I2C_INT_STATUS_REG(config->index)) & fifo_give_mask) {

drivers/i2c/i2c_imx.c

@@ -269,9 +269,8 @@ finish:
 }
 
 
-static void i2c_imx_isr(void *arg)
+static void i2c_imx_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	I2C_Type *base = DEV_BASE(dev);
 	struct i2c_imx_data *data = DEV_DATA(dev);
 	struct i2c_master_transfer *transfer = &data->transfer;

drivers/i2c/i2c_lpc11u6x.c

@@ -192,7 +192,7 @@ static int lpc11u6x_i2c_slave_unregister(const struct device *dev,
 	return 0;
 }
 
-static void lpc11u6x_i2c_isr(void *arg)
+static void lpc11u6x_i2c_isr(const void *arg)
 {
 	struct lpc11u6x_i2c_data *data = DEV_DATA((const struct device *)arg);
 	struct lpc11u6x_i2c_regs *i2c = DEV_BASE((const struct device *) arg);

drivers/i2c/i2c_mcux.c

@@ -163,9 +163,8 @@ static int i2c_mcux_transfer(const struct device *dev, struct i2c_msg *msgs,
 	return 0;
 }
 
-static void i2c_mcux_isr(void *arg)
+static void i2c_mcux_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	I2C_Type *base = DEV_BASE(dev);
 	struct i2c_mcux_data *data = DEV_DATA(dev);
 

drivers/i2c/i2c_mcux_flexcomm.c

@@ -159,9 +159,8 @@ static int mcux_flexcomm_transfer(const struct device *dev,
 	return 0;
 }
 
-static void mcux_flexcomm_isr(void *arg)
+static void mcux_flexcomm_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct mcux_flexcomm_config *config = dev->config;
 	struct mcux_flexcomm_data *data = dev->data;
 	I2C_Type *base = config->base;

drivers/i2c/i2c_mcux_lpi2c.c

@@ -169,9 +169,8 @@ static int mcux_lpi2c_transfer(const struct device *dev, struct i2c_msg *msgs,
 	return 0;
 }
 
-static void mcux_lpi2c_isr(void *arg)
+static void mcux_lpi2c_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct mcux_lpi2c_config *config = dev->config;
 	struct mcux_lpi2c_data *data = dev->data;
 	LPI2C_Type *base = config->base;

drivers/i2c/i2c_nios2.c

@@ -141,9 +141,8 @@ i2c_transfer_err:
 	return rc;
 }
 
-static void i2c_nios2_isr(void *arg)
+static void i2c_nios2_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct i2c_nios2_config *config = DEV_CFG(dev);
 
 	/* Call Altera HAL driver ISR */

drivers/i2c/i2c_rv32m1_lpi2c.c

@@ -200,9 +200,8 @@ out:
 	return ret;
 }
 
-static void rv32m1_lpi2c_isr(void *arg)
+static void rv32m1_lpi2c_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct rv32m1_lpi2c_config *config = dev->config;
 	struct rv32m1_lpi2c_data *data = dev->data;
 

drivers/i2c/i2c_sam0.c

@@ -126,9 +126,8 @@ static bool i2c_sam0_terminate_on_error(const struct device *dev)
 	return true;
 }
 
-static void i2c_sam0_isr(void *arg)
+static void i2c_sam0_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct i2c_sam0_dev_data *data = DEV_DATA(dev);
 	const struct i2c_sam0_dev_config *const cfg = DEV_CFG(dev);
 	SercomI2cm *i2c = cfg->regs;

drivers/i2c/i2c_sam_twi.c

@@ -235,9 +235,8 @@ static int i2c_sam_twi_transfer(const struct device *dev,
 	return 0;
 }
 
-static void i2c_sam_twi_isr(void *arg)
+static void i2c_sam_twi_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct i2c_sam_twi_dev_cfg *const dev_cfg = DEV_CFG(dev);
 	struct i2c_sam_twi_dev_data *const dev_data = DEV_DATA(dev);
 	Twi *const twi = dev_cfg->regs;

drivers/i2c/i2c_sam_twihs.c

@@ -222,9 +222,8 @@ static int i2c_sam_twihs_transfer(const struct device *dev,
 	return 0;
 }
 
-static void i2c_sam_twihs_isr(void *arg)
+static void i2c_sam_twihs_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct i2c_sam_twihs_dev_cfg *const dev_cfg = DEV_CFG(dev);
 	struct i2c_sam_twihs_dev_data *const dev_data = DEV_DATA(dev);
 	Twihs *const twihs = dev_cfg->regs;

drivers/i2s/i2s_cavs.c

@@ -819,9 +819,8 @@ static int i2s_cavs_write(const struct device *dev, void *mem_block,
 }
 
 /* clear IRQ sources atm */
-static void i2s_cavs_isr(void *arg)
+static void i2s_cavs_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct i2s_cavs_config *const dev_cfg = DEV_CFG(dev);
 	volatile struct i2s_cavs_ssp *const ssp = dev_cfg->regs;
 	struct i2s_cavs_dev_data *const dev_data = DEV_DATA(dev);

drivers/i2s/i2s_ll_stm32.c

@@ -631,9 +631,8 @@ tx_disable:
 static uint32_t i2s_stm32_irq_count;
 static uint32_t i2s_stm32_irq_ovr_count;
 
-static void i2s_stm32_isr(void *arg)
+static void i2s_stm32_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *) arg;
 	const struct i2s_stm32_cfg *cfg = DEV_CFG(dev);
 	struct i2s_stm32_data *const dev_data = DEV_DATA(dev);
 	struct stream *stream = &dev_data->rx;

drivers/i2s/i2s_sam_ssc.c

@@ -889,9 +889,8 @@ static int i2s_sam_write(const struct device *dev, void *mem_block,
 	return 0;
 }
 
-static void i2s_sam_isr(void *arg)
+static void i2s_sam_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct i2s_sam_dev_cfg *const dev_cfg = DEV_CFG(dev);
 	struct i2s_sam_dev_data *const dev_data = DEV_DATA(dev);
 	Ssc *const ssc = dev_cfg->regs;

drivers/ieee802154/ieee802154_cc13xx_cc26xx.c

@@ -381,7 +381,7 @@ static void ieee802154_cc13xx_cc26xx_cpe0_isr(void *arg)
 	}
 }
 
-static void ieee802154_cc13xx_cc26xx_cpe1_isr(void *arg)
+static void ieee802154_cc13xx_cc26xx_cpe1_isr(const void *arg)
 {
 	uint32_t flags;
 

drivers/interrupt_controller/intc_cavs.c

@@ -48,9 +48,8 @@ static ALWAYS_INLINE void cavs_ictl_dispatch_child_isrs(uint32_t intr_status,
 	}
 }
 
-static void cavs_ictl_isr(void *arg)
+static void cavs_ictl_isr(const struct device *port)
 {
-	const struct device *port = (const struct device *)arg;
 	struct cavs_ictl_runtime *context = port->data;
 
 	const struct cavs_ictl_config *config = port->config;

drivers/interrupt_controller/intc_dw.c

@@ -46,9 +46,8 @@ static int dw_ictl_initialize(const struct device *dev)
 	return 0;
 }
 
-static void dw_ictl_isr(void *arg)
+static void dw_ictl_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct dw_ictl_config *config = dev->config;
 	volatile struct dw_ictl_registers * const regs =
 			(struct dw_ictl_registers *)config->base_addr;

drivers/interrupt_controller/intc_exti_stm32.c

@@ -248,111 +248,111 @@ static void __stm32_exti_isr(int min, int max, void *arg)
 #if defined(CONFIG_SOC_SERIES_STM32F0X) || \
 	defined(CONFIG_SOC_SERIES_STM32L0X) || \
 	defined(CONFIG_SOC_SERIES_STM32G0X)
-static inline void __stm32_exti_isr_0_1(void *arg)
+static inline void __stm32_exti_isr_0_1(const void *arg)
 {
 	__stm32_exti_isr(0, 2, arg);
 }
 
-static inline void __stm32_exti_isr_2_3(void *arg)
+static inline void __stm32_exti_isr_2_3(const void *arg)
 {
 	__stm32_exti_isr(2, 4, arg);
 }
 
-static inline void __stm32_exti_isr_4_15(void *arg)
+static inline void __stm32_exti_isr_4_15(const void *arg)
 {
 	__stm32_exti_isr(4, 16, arg);
 }
 
 #else
-static inline void __stm32_exti_isr_0(void *arg)
+static inline void __stm32_exti_isr_0(const void *arg)
 {
 	__stm32_exti_isr(0, 1, arg);
 }
 
-static inline void __stm32_exti_isr_1(void *arg)
+static inline void __stm32_exti_isr_1(const void *arg)
 {
 	__stm32_exti_isr(1, 2, arg);
 }
 
-static inline void __stm32_exti_isr_2(void *arg)
+static inline void __stm32_exti_isr_2(const void *arg)
 {
 	__stm32_exti_isr(2, 3, arg);
 }
 
-static inline void __stm32_exti_isr_3(void *arg)
+static inline void __stm32_exti_isr_3(const void *arg)
 {
 	__stm32_exti_isr(3, 4, arg);
 }
 
-static inline void __stm32_exti_isr_4(void *arg)
+static inline void __stm32_exti_isr_4(const void *arg)
 {
 	__stm32_exti_isr(4, 5, arg);
 }
 
 #if defined(CONFIG_SOC_SERIES_STM32MP1X) || \
 	defined(CONFIG_SOC_SERIES_STM32L5X)
-static inline void __stm32_exti_isr_5(void *arg)
+static inline void __stm32_exti_isr_5(const void *arg)
 {
 	__stm32_exti_isr(5, 6, arg);
 }
 
-static inline void __stm32_exti_isr_6(void *arg)
+static inline void __stm32_exti_isr_6(const void *arg)
 {
 	__stm32_exti_isr(6, 7, arg);
 }
 
-static inline void __stm32_exti_isr_7(void *arg)
+static inline void __stm32_exti_isr_7(const void *arg)
 {
 	__stm32_exti_isr(7, 8, arg);
 }
 
-static inline void __stm32_exti_isr_8(void *arg)
+static inline void __stm32_exti_isr_8(const void *arg)
 {
 	__stm32_exti_isr(8, 9, arg);
 }
 
-static inline void __stm32_exti_isr_9(void *arg)
+static inline void __stm32_exti_isr_9(const void *arg)
 {
 	__stm32_exti_isr(9, 10, arg);
 }
 
-static inline void __stm32_exti_isr_10(void *arg)
+static inline void __stm32_exti_isr_10(const void *arg)
 {
 	__stm32_exti_isr(10, 11, arg);
 }
 
-static inline void __stm32_exti_isr_11(void *arg)
+static inline void __stm32_exti_isr_11(const void *arg)
 {
 	__stm32_exti_isr(11, 12, arg);
 }
 
-static inline void __stm32_exti_isr_12(void *arg)
+static inline void __stm32_exti_isr_12(const void *arg)
 {
 	__stm32_exti_isr(12, 13, arg);
 }
 
-static inline void __stm32_exti_isr_13(void *arg)
+static inline void __stm32_exti_isr_13(const void *arg)
 {
 	__stm32_exti_isr(13, 14, arg);
 }
 
-static inline void __stm32_exti_isr_14(void *arg)
+static inline void __stm32_exti_isr_14(const void *arg)
 {
 	__stm32_exti_isr(14, 15, arg);
 }
 
-static inline void __stm32_exti_isr_15(void *arg)
+static inline void __stm32_exti_isr_15(const void *arg)
 {
 	__stm32_exti_isr(15, 16, arg);
 }
 #endif
 
-static inline void __stm32_exti_isr_9_5(void *arg)
+static inline void __stm32_exti_isr_9_5(const void *arg)
 {
 	__stm32_exti_isr(5, 10, arg);
 }
 
-static inline void __stm32_exti_isr_15_10(void *arg)
+static inline void __stm32_exti_isr_15_10(const void *arg)
 {
 	__stm32_exti_isr(10, 16, arg);
 }
@@ -361,29 +361,29 @@ static inline void __stm32_exti_isr_15_10(void *arg)
 	defined(CONFIG_SOC_SERIES_STM32F7X) || \
 	defined(CONFIG_SOC_SERIES_STM32F2X) || \
 	defined(CONFIG_SOC_SERIES_STM32MP1X)
-static inline void __stm32_exti_isr_16(void *arg)
+static inline void __stm32_exti_isr_16(const void *arg)
 {
 	__stm32_exti_isr(16, 17, arg);
 }
 
-static inline void __stm32_exti_isr_18(void *arg)
+static inline void __stm32_exti_isr_18(const void *arg)
 {
 	__stm32_exti_isr(18, 19, arg);
 }
 
-static inline void __stm32_exti_isr_21(void *arg)
+static inline void __stm32_exti_isr_21(const void *arg)
 {
 	__stm32_exti_isr(21, 22, arg);
 }
 
-static inline void __stm32_exti_isr_22(void *arg)
+static inline void __stm32_exti_isr_22(const void *arg)
 {
 	__stm32_exti_isr(22, 23, arg);
 }
 #endif
 #if defined(CONFIG_SOC_SERIES_STM32F7X) || \
 	defined(CONFIG_SOC_SERIES_STM32MP1X)
-static inline void __stm32_exti_isr_23(void *arg)
+static inline void __stm32_exti_isr_23(const void *arg)
 {
 	__stm32_exti_isr(23, 24, arg);
 }

drivers/interrupt_controller/intc_plic.c

@@ -134,7 +134,7 @@ int riscv_plic_get_irq(void)
 	return save_irq;
 }
 
-static void plic_irq_handler(void *arg)
+static void plic_irq_handler(const void *arg)
 {
 	volatile struct plic_regs_t *regs =
 	    (volatile struct plic_regs_t *) PLIC_REG;

drivers/interrupt_controller/intc_rv32m1_intmux.c

@@ -109,7 +109,7 @@ static int rv32m1_intmux_get_line_state(const struct device *dev,
 #define ISR_ENTRY(channel, line) \
 	((channel) * CONFIG_MAX_IRQ_PER_AGGREGATOR + line)
 
-static void rv32m1_intmux_isr(void *arg)
+static void rv32m1_intmux_isr(const void *arg)
 {
 	const struct device *dev = DEVICE_GET(intmux);
 	INTMUX_Type *regs = DEV_REGS(dev);

drivers/interrupt_controller/intc_sam0_eic.c

@@ -53,9 +53,8 @@ static inline void set_eic_enable(bool on)
 #endif
 }
 
-static void sam0_eic_isr(void *arg)
+static void sam0_eic_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct sam0_eic_data *const dev_data = DEV_DATA(dev);
 	uint16_t bits = EIC->INTFLAG.reg;
 	uint32_t line_index;

drivers/interrupt_controller/intc_swerv_pic.c

@@ -114,7 +114,7 @@ int swerv_pic_get_irq(void)
 	return save_irq;
 }
 
-static void swerv_pic_irq_handler(void *arg)
+static void swerv_pic_irq_handler(const void *arg)
 {
 	uint32_t tmp;
 	uint32_t irq;

drivers/interrupt_controller/intc_vexriscv_litex.c

@@ -56,7 +56,7 @@ static inline void vexriscv_litex_irq_setie(uint32_t ie)
 	}
 }
 
-static void vexriscv_litex_irq_handler(void *device)
+static void vexriscv_litex_irq_handler(const void *device)
 {
 	struct _isr_table_entry *ite;
 	uint32_t pending, mask, irqs;

drivers/ipm/ipm_imx.c

@@ -31,9 +31,8 @@ struct imx_mu_data {
 	void *user_data;
 };
 
-static void imx_mu_isr(void *arg)
+static void imx_mu_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct imx_mu_config *config = dev->config;
 	MU_Type *base = MU(config);
 	struct imx_mu_data *data = dev->data;

drivers/ipm/ipm_intel_adsp.c

@@ -45,9 +45,8 @@ struct ipm_adsp_data {
 	void *user_data;
 };
 
-static void ipm_adsp_isr(void *arg)
+static void ipm_adsp_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct ipm_adsp_data *data = dev->data;
 	uint32_t dipcctl, dipcie, dipct;
 

drivers/ipm/ipm_mcux.c

@@ -34,9 +34,8 @@ struct mcux_mailbox_data {
 	void *callback_ctx;
 };
 
-static void mcux_mailbox_isr(void *arg)
+static void mcux_mailbox_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct mcux_mailbox_data *data = dev->data;
 	const struct mcux_mailbox_config *config = dev->config;
 	mailbox_cpu_id_t cpu_id;

drivers/ipm/ipm_mhu.c

@@ -124,9 +124,8 @@ static int ipm_mhu_init(const struct device *d)
 	return 0;
 }
 
-static void ipm_mhu_isr(void *arg)
+static void ipm_mhu_isr(const struct device *d)
 {
-	const struct device *d = arg;
 	struct ipm_mhu_data *driver_data = DEV_DATA(d);
 	enum ipm_mhu_cpu_id_t cpu_id;
 	uint32_t ipm_mhu_status;

drivers/ipm/ipm_stm32_ipcc.c

@@ -101,9 +101,8 @@ struct stm32_ipcc_mbx_data {
 
 static struct stm32_ipcc_mbx_data stm32_IPCC_data;
 
-static void stm32_ipcc_mailbox_rx_isr(void *arg)
+static void stm32_ipcc_mailbox_rx_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct stm32_ipcc_mbx_data *data = DEV_DATA(dev);
 	const struct stm32_ipcc_mailbox_config *cfg = DEV_CFG(dev);
 	unsigned int value = 0;
@@ -130,9 +129,8 @@ static void stm32_ipcc_mailbox_rx_isr(void *arg)
 	}
 }
 
-static void stm32_ipcc_mailbox_tx_isr(void *arg)
+static void stm32_ipcc_mailbox_tx_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct stm32_ipcc_mbx_data *data = DEV_DATA(dev);
 	const struct stm32_ipcc_mailbox_config *cfg = DEV_CFG(dev);
 	uint32_t mask, i;

drivers/kscan/kscan_mchp_xec.c

@@ -145,7 +145,7 @@ static bool read_keyboard_matrix(uint8_t *new_state)
 	return key_event != 0U ? true : false;
 }
 
-static void scan_matrix_xec_isr(void *arg)
+static void scan_matrix_xec_isr(const void *arg)
 {
 	ARG_UNUSED(arg);
 

drivers/pcie/endpoint/pcie_ep_bcm_iproc.c

@@ -304,9 +304,8 @@ static void iproc_pcie_hot_reset(void *arg)
 #endif
 
 #if DT_INST_IRQ_HAS_NAME(0, flr)
-static void iproc_pcie_flr(void *arg)
+static void iproc_pcie_flr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	const struct iproc_pcie_ep_config *cfg = dev->config;
 	struct iproc_pcie_ep_ctx *ctx = dev->data;
 	void *reset_data;

drivers/peci/peci_mchp_xec.c

@@ -293,7 +293,7 @@ static int peci_xec_transfer(const struct device *dev, struct peci_msg *msg)
 }
 
 #ifdef CONFIG_PECI_INTERRUPT_DRIVEN
-static void peci_xec_isr(void *arg)
+static void peci_xec_isr(const void *arg)
 {
 	ARG_UNUSED(arg);
 	PECI_Type *base = peci_xec_config.base;

drivers/ps2/ps2_mchp_xec.c

@@ -149,9 +149,8 @@ static int ps2_xec_enable_interface(const struct device *dev)
 
 	return 0;
 }
-static void ps2_xec_isr(void *arg)
+static void ps2_xec_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	const struct ps2_xec_config *config = dev->config;
 	struct ps2_xec_data *data = dev->data;
 	PS2_Type *base = config->base;

drivers/serial/leuart_gecko.c

@@ -232,9 +232,8 @@ static void leuart_gecko_irq_callback_set(const struct device *dev,
 	data->cb_data = cb_data;
 }
 
-static void leuart_gecko_isr(void *arg)
+static void leuart_gecko_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct leuart_gecko_data *data = dev->data;
 
 	if (data->callback) {

drivers/serial/uart_cc13xx_cc26xx.c

@@ -348,9 +348,8 @@ static void uart_cc13xx_cc26xx_irq_callback_set(const struct device *dev,
 	data->user_data = user_data;
 }
 
-static void uart_cc13xx_cc26xx_isr(void *arg)
+static void uart_cc13xx_cc26xx_isr(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct uart_cc13xx_cc26xx_data *data = get_dev_data(dev);
 
 	if (data->callback) {

drivers/serial/uart_cc32xx.c

@@ -35,7 +35,7 @@ struct uart_cc32xx_dev_data_t {
 DEVICE_DECLARE(uart_cc32xx_0);
 
 #ifdef CONFIG_UART_INTERRUPT_DRIVEN
-static void uart_cc32xx_isr(void *arg);
+static void uart_cc32xx_isr(const struct device *dev);
 #endif
 
 static const struct uart_device_config uart_cc32xx_dev_cfg_0 = {
@@ -273,9 +273,8 @@ static void uart_cc32xx_irq_callback_set(const struct device *dev,
  *
  * @return N/A
  */
-static void uart_cc32xx_isr(void *arg)
+static void uart_cc32xx_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	const struct uart_device_config *config = DEV_CFG(dev);
 	struct uart_cc32xx_dev_data_t * const dev_data = DEV_DATA(dev);
 

drivers/serial/uart_cmsdk_apb.c

@@ -84,7 +84,7 @@ struct uart_cmsdk_apb_dev_data {
 	((volatile struct uart_cmsdk_apb *)(DEV_CFG(dev))->base)
 
 static const struct uart_driver_api uart_cmsdk_apb_driver_api;
-static void uart_cmsdk_apb_isr(void *arg);
+static void uart_cmsdk_apb_isr(const struct device *dev);
 
 /**
  * @brief Set the baud rate
@@ -419,9 +419,8 @@ static void uart_cmsdk_apb_irq_callback_set(const struct device *dev,
  *
  * @return N/A
  */
-void uart_cmsdk_apb_isr(void *arg)
+void uart_cmsdk_apb_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	volatile struct uart_cmsdk_apb *uart = UART_STRUCT(dev);
 	struct uart_cmsdk_apb_dev_data *data = DEV_DATA(dev);
 

drivers/serial/uart_esp32.c

@@ -431,9 +431,8 @@ static void uart_esp32_irq_callback_set(const struct device *dev,
 	DEV_DATA(dev)->irq_cb_data = cb_data;
 }
 
-void uart_esp32_isr(void *arg)
+void uart_esp32_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct uart_esp32_data *data = DEV_DATA(dev);
 
 	/* Verify if the callback has been registered */

drivers/serial/uart_gecko.c

@@ -275,9 +275,8 @@ static void uart_gecko_irq_callback_set(struct device *dev,
 	data->cb_data = cb_data;
 }
 
-static void uart_gecko_isr(void *arg)
+static void uart_gecko_isr(const struct device *dev)
 {
-	struct device *dev = arg;
 	struct uart_gecko_data *data = dev->data;
 
 	if (data->callback) {

drivers/serial/uart_imx.c

@@ -250,9 +250,8 @@ static void uart_imx_irq_callback_set(const struct device *dev,
  *
  * @return N/A
  */
-void uart_imx_isr(void *arg)
+void uart_imx_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct imx_uart_data *data = dev->data;
 
 	if (data->callback) {

drivers/serial/uart_liteuart.c

@@ -272,9 +272,8 @@ static void uart_liteuart_irq_callback_set(const struct device *dev,
 	data->cb_data = cb_data;
 }
 
-static void liteuart_uart_irq_handler(void *arg)
+static void liteuart_uart_irq_handler(const struct device *dev)
 {
-	const struct device *dev = (const struct device *)arg;
 	struct uart_liteuart_data *data = DEV_DATA(dev);
 	int key = irq_lock();
 

drivers/serial/uart_lpc11u6x.c

@@ -332,9 +332,8 @@ static void lpc11u6x_uart0_irq_callback_set(const struct device *dev,
 	data->cb_data = user_data;
 }
 
-static void lpc11u6x_uart0_isr(void *arg)
+static void lpc11u6x_uart0_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct lpc11u6x_uart0_data *data = DEV_DATA(dev);
 
 	if (data->cb) {
@@ -770,9 +769,10 @@ static void lpc11u6x_uartx_isr(const struct device *dev)
 	}
 }
 
-static void lpc11u6x_uartx_shared_isr(void *arg)
+static void lpc11u6x_uartx_shared_isr(const void *arg)
 {
-	struct lpc11u6x_uartx_shared_irq *shared_irq = arg;
+	struct lpc11u6x_uartx_shared_irq *shared_irq =
+		(struct lpc11u6x_uartx_shared_irq *)arg;
 	int i;
 
 	for (i = 0; i < ARRAY_SIZE(shared_irq->devices); i++) {

drivers/serial/uart_mcux.c

@@ -306,9 +306,8 @@ static void uart_mcux_irq_callback_set(const struct device *dev,
 	data->cb_data = cb_data;
 }
 
-static void uart_mcux_isr(void *arg)
+static void uart_mcux_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct uart_mcux_data *data = dev->data;
 
 	if (data->callback) {

drivers/serial/uart_mcux_flexcomm.c

@@ -231,9 +231,8 @@ static void mcux_flexcomm_irq_callback_set(const struct device *dev,
 	data->cb_data = cb_data;
 }
 
-static void mcux_flexcomm_isr(void *arg)
+static void mcux_flexcomm_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct mcux_flexcomm_data *data = dev->data;
 
 	if (data->callback) {

drivers/serial/uart_mcux_iuart.c

@@ -211,9 +211,8 @@ static void mcux_iuart_irq_callback_set(const struct device *dev,
 	data->cb_data = cb_data;
 }
 
-static void mcux_iuart_isr(void *arg)
+static void mcux_iuart_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct mcux_iuart_data *data = dev->data;
 
 	if (data->callback) {

drivers/serial/uart_mcux_lpsci.c

@@ -222,9 +222,8 @@ static void mcux_lpsci_irq_callback_set(const struct device *dev,
 	data->cb_data = cb_data;
 }
 
-static void mcux_lpsci_isr(void *arg)
+static void mcux_lpsci_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct mcux_lpsci_data *data = dev->data;
 
 	if (data->callback) {

drivers/serial/uart_mcux_lpuart.c

@@ -222,9 +222,8 @@ static void mcux_lpuart_irq_callback_set(const struct device *dev,
 	data->cb_data = cb_data;
 }
 
-static void mcux_lpuart_isr(void *arg)
+static void mcux_lpuart_isr(const struct device *dev)
 {
-	const struct device *dev = arg;
 	struct mcux_lpuart_data *data = dev->data;
 
 	if (data->callback) {