diff --git a/drivers/include/drivers/CAN.h b/drivers/include/drivers/CAN.h
index be404f8..b1fa704 100644
--- a/drivers/include/drivers/CAN.h
+++ b/drivers/include/drivers/CAN.h
@@ -205,7 +205,7 @@
      */
     void attach(Callback<void()> func, IrqType type = IrqType::RxIrq);
 
-    static void _irq_handler(uint32_t id, CanIrqType type);
+    static void _irq_handler(uintptr_t context, CanIrqType type);
 
 #if !defined(DOXYGEN_ONLY)
 protected:
diff --git a/drivers/source/CAN.cpp b/drivers/source/CAN.cpp
index 2767c07..f8aa18e 100644
--- a/drivers/source/CAN.cpp
+++ b/drivers/source/CAN.cpp
@@ -26,28 +26,28 @@
 {
     // No lock needed in constructor
     can_init(&_can, rd, td);
-    can_irq_init(&_can, (&CAN::_irq_handler), (uint32_t)this);
+    can_irq_init(&_can, (&CAN::_irq_handler), reinterpret_cast<uintptr_t>(this));
 }
 
 CAN::CAN(PinName rd, PinName td, int hz) : _can(), _irq()
 {
     // No lock needed in constructor
     can_init_freq(&_can, rd, td, hz);
-    can_irq_init(&_can, (&CAN::_irq_handler), (uint32_t)this);
+    can_irq_init(&_can, (&CAN::_irq_handler), reinterpret_cast<uintptr_t>(this));
 }
 
 CAN::CAN(const can_pinmap_t &pinmap) : _can(), _irq()
 {
     // No lock needed in constructor
     can_init_direct(&_can, &pinmap);
-    can_irq_init(&_can, (&CAN::_irq_handler), (uint32_t)this);
+    can_irq_init(&_can, (&CAN::_irq_handler), reinterpret_cast<uintptr_t>(this));
 }
 
 CAN::CAN(const can_pinmap_t &pinmap, int hz) : _can(), _irq()
 {
     // No lock needed in constructor
     can_init_freq_direct(&_can, &pinmap, hz);
-    can_irq_init(&_can, (&CAN::_irq_handler), (uint32_t)this);
+    can_irq_init(&_can, (&CAN::_irq_handler), reinterpret_cast<uintptr_t>(this));
 }
 
 CAN::~CAN()
@@ -153,9 +153,9 @@
     unlock();
 }
 
-void CAN::_irq_handler(uint32_t id, CanIrqType type)
+void CAN::_irq_handler(uintptr_t context, CanIrqType type)
 {
-    CAN *handler = (CAN *)id;
+    CAN *handler = reinterpret_cast<CAN *>(context);
     if (handler->_irq[type]) {
         handler->_irq[type].call();
     }
diff --git a/hal/include/hal/can_api.h b/hal/include/hal/can_api.h
index 9774d12..61d9644 100644
--- a/hal/include/hal/can_api.h
+++ b/hal/include/hal/can_api.h
@@ -63,7 +63,7 @@
     int td_function;
 } can_pinmap_t;
 
-typedef void (*can_irq_handler)(uint32_t id, CanIrqType type);
+typedef void (*can_irq_handler)(uintptr_t context, CanIrqType type);
 
 typedef struct can_s can_t;
 
@@ -74,7 +74,7 @@
 void          can_free(can_t *obj);
 int           can_frequency(can_t *obj, int hz);
 
-void          can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id);
+void          can_irq_init(can_t *obj, can_irq_handler handler, uintptr_t context);
 void          can_irq_free(can_t *obj);
 void          can_irq_set(can_t *obj, CanIrqType irq, uint32_t enable);
 
diff --git a/targets/TARGET_GigaDevice/TARGET_GD32F30X/can_api.c b/targets/TARGET_GigaDevice/TARGET_GD32F30X/can_api.c
index db92b9d..afdc872 100644
--- a/targets/TARGET_GigaDevice/TARGET_GD32F30X/can_api.c
+++ b/targets/TARGET_GigaDevice/TARGET_GD32F30X/can_api.c
@@ -38,7 +38,7 @@
 /* CAN1 interrupt vector number */
 #define CAN1_IRQ_BASE_NUM             63
 
-static uint32_t can_irq_ids[2] = {0};
+static uintptr_t can_irq_contexts[2] = {0};
 static can_irq_handler irq_callback;
 
 /** CAN interrupt handle .
@@ -66,13 +66,13 @@
 
     /* CAN transmit complete interrupt handle */
     if (flag0 || flag1 || flag2) {
-        irq_callback(can_irq_ids[id], IRQ_TX);
+        irq_callback(can_irq_contexts[id], IRQ_TX);
     }
 
     /* CAN receive complete interrupt handle */
     if (CAN_INTEN_RFNEIE0 == (CAN_INTEN(periph) & CAN_INTEN_RFNEIE0)) {
         if (0 != can_receive_message_length_get(periph, CAN_FIFO0)) {
-            irq_callback(can_irq_ids[id], IRQ_RX);
+            irq_callback(can_irq_contexts[id], IRQ_RX);
         }
     }
 
@@ -81,18 +81,18 @@
         /* passive error interrupt handle */
         if (CAN_INTEN_PERRIE == (CAN_INTEN(periph) & CAN_INTEN_PERRIE)) {
             if (SET == can_flag_get(periph, CAN_FLAG_PERR)) {
-                irq_callback(can_irq_ids[id], IRQ_PASSIVE);
+                irq_callback(can_irq_contexts[id], IRQ_PASSIVE);
             }
         }
 
         /* bus-off interrupt handle */
         if (CAN_INTEN_BOIE == (CAN_INTEN(periph) & CAN_INTEN_BOIE)) {
             if (SET == can_flag_get(periph, CAN_FLAG_BOERR)) {
-                irq_callback(can_irq_ids[id], IRQ_BUS);
+                irq_callback(can_irq_contexts[id], IRQ_BUS);
             }
         }
 
-        irq_callback(can_irq_ids[id], IRQ_ERROR);
+        irq_callback(can_irq_contexts[id], IRQ_ERROR);
     }
 }
 
@@ -330,10 +330,10 @@
  *  @param handler the interrupt callback.
  *  @param id the CANx index.
  */
-void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id)
+void can_irq_init(can_t *obj, can_irq_handler handler, uintptr_t context)
 {
     irq_callback = handler;
-    can_irq_ids[obj->index] = id;
+    can_irq_contexts[obj->index] = context;
 }
 
 /** disable the interrupt.
@@ -351,7 +351,7 @@
                               CAN_INTEN_PERRIE | CAN_INTEN_BOIE | CAN_INTEN_ERRIE);
     }
 
-    can_irq_ids[obj->index] = 0;
+    can_irq_contexts[obj->index] = 0;
 }
 
 /** Set the interrupt handle.
diff --git a/targets/TARGET_GigaDevice/TARGET_GD32F4XX/can_api.c b/targets/TARGET_GigaDevice/TARGET_GD32F4XX/can_api.c
index 15c67b1..79614ff 100644
--- a/targets/TARGET_GigaDevice/TARGET_GD32F4XX/can_api.c
+++ b/targets/TARGET_GigaDevice/TARGET_GD32F4XX/can_api.c
@@ -38,7 +38,7 @@
 /* CAN1 interrupt vector number */
 #define CAN1_IRQ_BASE_NUM             63
 
-static uint32_t can_irq_ids[2] = {0};
+static uintptr_t can_irq_contexts[2] = {0};
 static can_irq_handler irq_callback;
 
 /** CAN interrupt handle .
@@ -66,13 +66,13 @@
 
     /* CAN transmit complete interrupt handle */
     if (flag0 || flag1 || flag2) {
-        irq_callback(can_irq_ids[id], IRQ_TX);
+        irq_callback(can_irq_contexts[id], IRQ_TX);
     }
 
     /* CAN receive complete interrupt handle */
     if (CAN_INTEN_RFNEIE0 == (CAN_INTEN(periph) & CAN_INTEN_RFNEIE0)) {
         if (0 != can_receive_message_length_get(periph, CAN_FIFO0)) {
-            irq_callback(can_irq_ids[id], IRQ_RX);
+            irq_callback(can_irq_contexts[id], IRQ_RX);
         }
     }
 
@@ -81,18 +81,18 @@
         /* passive error interrupt handle */
         if (CAN_INTEN_PERRIE == (CAN_INTEN(periph) & CAN_INTEN_PERRIE)) {
             if (SET == can_flag_get(periph, CAN_FLAG_PERR)) {
-                irq_callback(can_irq_ids[id], IRQ_PASSIVE);
+                irq_callback(can_irq_contexts[id], IRQ_PASSIVE);
             }
         }
 
         /* bus-off interrupt handle */
         if (CAN_INTEN_BOIE == (CAN_INTEN(periph) & CAN_INTEN_BOIE)) {
             if (SET == can_flag_get(periph, CAN_FLAG_BOERR)) {
-                irq_callback(can_irq_ids[id], IRQ_BUS);
+                irq_callback(can_irq_contexts[id], IRQ_BUS);
             }
         }
 
-        irq_callback(can_irq_ids[id], IRQ_ERROR);
+        irq_callback(can_irq_contexts[id], IRQ_ERROR);
     }
 }
 
@@ -331,10 +331,10 @@
  *  @param handler the interrupt callback.
  *  @param id the CANx index.
  */
-void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id)
+void can_irq_init(can_t *obj, can_irq_handler handler, uintptr_t context)
 {
     irq_callback = handler;
-    can_irq_ids[obj->index] = id;
+    can_irq_contexts[obj->index] = context;
 }
 
 /** disable the interrupt.
@@ -352,7 +352,7 @@
                               CAN_INTEN_PERRIE | CAN_INTEN_BOIE | CAN_INTEN_ERRIE);
     }
 
-    can_irq_ids[obj->index] = 0;
+    can_irq_contexts[obj->index] = 0;
 }
 
 /** Set the interrupt handle.
diff --git a/targets/TARGET_NUVOTON/TARGET_M451/can_api.c b/targets/TARGET_NUVOTON/TARGET_M451/can_api.c
index 775f98f..fa2e7c2 100644
--- a/targets/TARGET_NUVOTON/TARGET_M451/can_api.c
+++ b/targets/TARGET_NUVOTON/TARGET_M451/can_api.c
@@ -31,7 +31,7 @@
  #define NU_CAN_DEBUG    0
  #define CAN_NUM         1
  
- static uint32_t can_irq_ids[CAN_NUM] = {0};
+ static uintptr_t can_irq_contexts[CAN_NUM] = {0};
  static can_irq_handler can0_irq_handler;
 
  
@@ -125,34 +125,34 @@
         /**************************/
         if(can->STATUS & CAN_STATUS_RXOK_Msk) {
             can->STATUS &= ~CAN_STATUS_RXOK_Msk;   /* Clear Rx Ok status*/
-            can0_irq_handler(can_irq_ids[id], IRQ_RX);
+            can0_irq_handler(can_irq_contexts[id], IRQ_RX);
         }
 
         if(can->STATUS & CAN_STATUS_TXOK_Msk) {
             can->STATUS &= ~CAN_STATUS_TXOK_Msk;    /* Clear Tx Ok status*/
-            can0_irq_handler(can_irq_ids[id], IRQ_TX);
+            can0_irq_handler(can_irq_contexts[id], IRQ_TX);
         }
 
         /**************************/
         /* Error Status interrupt */
         /**************************/
         if(can->STATUS & CAN_STATUS_EWARN_Msk) {
-            can0_irq_handler(can_irq_ids[id], IRQ_ERROR);
+            can0_irq_handler(can_irq_contexts[id], IRQ_ERROR);
         }
 
         if(can->STATUS & CAN_STATUS_BOFF_Msk) {
-            can0_irq_handler(can_irq_ids[id], IRQ_BUS);
+            can0_irq_handler(can_irq_contexts[id], IRQ_BUS);
         }
     } else if (u8IIDRstatus!=0) {
 
-        can0_irq_handler(can_irq_ids[id], IRQ_OVERRUN);
+        can0_irq_handler(can_irq_contexts[id], IRQ_OVERRUN);
         
         CAN_CLR_INT_PENDING_BIT(can, ((can->IIDR) -1));      /* Clear Interrupt Pending */
 
     } else if(can->WU_STATUS == 1) {
 
         can->WU_STATUS = 0;                       /* Write '0' to clear */
-        can0_irq_handler(can_irq_ids[id], IRQ_WAKEUP);
+        can0_irq_handler(can_irq_contexts[id], IRQ_WAKEUP);
     }
 }
 
@@ -161,17 +161,17 @@
     can_irq(CAN_0, 0);
 }
 
-void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id)
+void can_irq_init(can_t *obj, can_irq_handler handler, uintptr_t context)
 {
     can0_irq_handler = handler;
-    can_irq_ids[obj->index] = id; 
+    can_irq_contexts[obj->index] = context; 
 }
 
 void can_irq_free(can_t *obj)
 {
     CAN_DisableInt((CAN_T *)NU_MODBASE(obj->can), (CAN_CON_IE_Msk|CAN_CON_SIE_Msk|CAN_CON_EIE_Msk));
     
-    can_irq_ids[obj->index] = 0;
+    can_irq_contexts[obj->index] = 0;
     
     NVIC_DisableIRQ(CAN0_IRQn);    
 }
diff --git a/targets/TARGET_NUVOTON/TARGET_M480/can_api.c b/targets/TARGET_NUVOTON/TARGET_M480/can_api.c
index f532454..771cb6d 100644
--- a/targets/TARGET_NUVOTON/TARGET_M480/can_api.c
+++ b/targets/TARGET_NUVOTON/TARGET_M480/can_api.c
@@ -34,7 +34,7 @@
 #define NU_CAN_DEBUG    0
 #define CAN_NUM         2
 
-static uint32_t can_irq_ids[CAN_NUM] = {0};
+static uintptr_t can_irq_contexts[CAN_NUM] = {0};
 static can_irq_handler can0_irq_handler;
 static can_irq_handler can1_irq_handler;
 
@@ -140,17 +140,17 @@
         if(can->STATUS & CAN_STATUS_RXOK_Msk) {
             can->STATUS &= ~CAN_STATUS_RXOK_Msk;   /* Clear Rx Ok status*/
             if(id)
-                can1_irq_handler(can_irq_ids[id], IRQ_RX);
+                can1_irq_handler(can_irq_contexts[id], IRQ_RX);
             else
-                can0_irq_handler(can_irq_ids[id], IRQ_RX);
+                can0_irq_handler(can_irq_contexts[id], IRQ_RX);
         }
 
         if(can->STATUS & CAN_STATUS_TXOK_Msk) {
             can->STATUS &= ~CAN_STATUS_TXOK_Msk;    /* Clear Tx Ok status*/
             if(id)
-                can1_irq_handler(can_irq_ids[id], IRQ_TX);
+                can1_irq_handler(can_irq_contexts[id], IRQ_TX);
             else
-                can0_irq_handler(can_irq_ids[id], IRQ_TX);
+                can0_irq_handler(can_irq_contexts[id], IRQ_TX);
 
         }
 
@@ -159,23 +159,23 @@
         /**************************/
         if(can->STATUS & CAN_STATUS_EWARN_Msk) {
             if(id)
-                can1_irq_handler(can_irq_ids[id], IRQ_ERROR);
+                can1_irq_handler(can_irq_contexts[id], IRQ_ERROR);
             else
-                can0_irq_handler(can_irq_ids[id], IRQ_ERROR);
+                can0_irq_handler(can_irq_contexts[id], IRQ_ERROR);
         }
 
         if(can->STATUS & CAN_STATUS_BOFF_Msk) {
             if(id)
-                can1_irq_handler(can_irq_ids[id], IRQ_BUS);
+                can1_irq_handler(can_irq_contexts[id], IRQ_BUS);
             else
-                can0_irq_handler(can_irq_ids[id], IRQ_BUS);
+                can0_irq_handler(can_irq_contexts[id], IRQ_BUS);
         }
     } else if (u8IIDRstatus!=0) {
 
         if(id)
-            can1_irq_handler(can_irq_ids[id], IRQ_OVERRUN);
+            can1_irq_handler(can_irq_contexts[id], IRQ_OVERRUN);
         else
-            can0_irq_handler(can_irq_ids[id], IRQ_OVERRUN);
+            can0_irq_handler(can_irq_contexts[id], IRQ_OVERRUN);
 
         CAN_CLR_INT_PENDING_BIT(can, ((can->IIDR) -1));      /* Clear Interrupt Pending */
 
@@ -183,9 +183,9 @@
 
         can->WU_STATUS = 0;                       /* Write '0' to clear */
         if(id)
-            can1_irq_handler(can_irq_ids[id], IRQ_WAKEUP);
+            can1_irq_handler(can_irq_contexts[id], IRQ_WAKEUP);
         else
-            can0_irq_handler(can_irq_ids[id], IRQ_WAKEUP);
+            can0_irq_handler(can_irq_contexts[id], IRQ_WAKEUP);
     }
 }
 
@@ -199,13 +199,13 @@
     can_irq(CAN_1, 1);
 }
 
-void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id)
+void can_irq_init(can_t *obj, can_irq_handler handler, uintptr_t context)
 {
     if(obj->index)
         can1_irq_handler = handler;
     else
         can0_irq_handler = handler;
-    can_irq_ids[obj->index] = id;
+    can_irq_contexts[obj->index] = context;
 
 }
 
@@ -213,7 +213,7 @@
 {
     CAN_DisableInt((CAN_T *)NU_MODBASE(obj->can), (CAN_CON_IE_Msk|CAN_CON_SIE_Msk|CAN_CON_EIE_Msk));
 
-    can_irq_ids[obj->index] = 0;
+    can_irq_contexts[obj->index] = 0;
 
     if(!obj->index)
         NVIC_DisableIRQ(CAN0_IRQn);
diff --git a/targets/TARGET_NUVOTON/TARGET_NUC472/can_api.c b/targets/TARGET_NUVOTON/TARGET_NUC472/can_api.c
index f4d57e4..7ea08e7 100644
--- a/targets/TARGET_NUVOTON/TARGET_NUC472/can_api.c
+++ b/targets/TARGET_NUVOTON/TARGET_NUC472/can_api.c
@@ -31,7 +31,7 @@
  #define NU_CAN_DEBUG    0
  #define CAN_NUM         2
  
- static uint32_t can_irq_ids[CAN_NUM] = {0};
+ static uintptr_t can_irq_contexts[CAN_NUM] = {0};
  static can_irq_handler can0_irq_handler;
  static can_irq_handler can1_irq_handler;
 
@@ -134,17 +134,17 @@
         if(can->STATUS & CAN_STATUS_RXOK_Msk) {
             can->STATUS &= ~CAN_STATUS_RXOK_Msk;   /* Clear Rx Ok status*/
             if(id)
-                can1_irq_handler(can_irq_ids[id] , IRQ_RX);
+                can1_irq_handler(can_irq_contexts[id] , IRQ_RX);
             else
-                can0_irq_handler(can_irq_ids[id], IRQ_RX);
+                can0_irq_handler(can_irq_contexts[id], IRQ_RX);
         }
 
         if(can->STATUS & CAN_STATUS_TXOK_Msk) {
             can->STATUS &= ~CAN_STATUS_TXOK_Msk;    /* Clear Tx Ok status*/
             if(id)
-                can1_irq_handler(can_irq_ids[id] , IRQ_TX);
+                can1_irq_handler(can_irq_contexts[id] , IRQ_TX);
             else
-                can0_irq_handler(can_irq_ids[id], IRQ_TX);
+                can0_irq_handler(can_irq_contexts[id], IRQ_TX);
 
         }
 
@@ -153,23 +153,23 @@
         /**************************/
         if(can->STATUS & CAN_STATUS_EWARN_Msk) {
             if(id)
-                can1_irq_handler(can_irq_ids[id] , IRQ_ERROR);
+                can1_irq_handler(can_irq_contexts[id] , IRQ_ERROR);
             else
-                can0_irq_handler(can_irq_ids[id], IRQ_ERROR);
+                can0_irq_handler(can_irq_contexts[id], IRQ_ERROR);
         }
 
         if(can->STATUS & CAN_STATUS_BOFF_Msk) {
             if(id)
-                can1_irq_handler(can_irq_ids[id] , IRQ_BUS);
+                can1_irq_handler(can_irq_contexts[id] , IRQ_BUS);
             else
-                can0_irq_handler(can_irq_ids[id], IRQ_BUS);
+                can0_irq_handler(can_irq_contexts[id], IRQ_BUS);
         }
     } else if (u8IIDRstatus!=0) {
 
         if(id)
-            can1_irq_handler(can_irq_ids[id] , IRQ_OVERRUN);
+            can1_irq_handler(can_irq_contexts[id] , IRQ_OVERRUN);
         else
-            can0_irq_handler(can_irq_ids[id], IRQ_OVERRUN);
+            can0_irq_handler(can_irq_contexts[id], IRQ_OVERRUN);
         
         CAN_CLR_INT_PENDING_BIT(can, ((can->IIDR) -1));      /* Clear Interrupt Pending */
 
@@ -177,9 +177,9 @@
 
         can->WU_STATUS = 0;                       /* Write '0' to clear */
         if(id)
-            can1_irq_handler(can_irq_ids[id] , IRQ_WAKEUP);
+            can1_irq_handler(can_irq_contexts[id] , IRQ_WAKEUP);
         else
-            can0_irq_handler(can_irq_ids[id], IRQ_WAKEUP);
+            can0_irq_handler(can_irq_contexts[id], IRQ_WAKEUP);
     }
 }
 
@@ -193,13 +193,13 @@
     can_irq(CAN_1, 1);
 }
 
-void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id)
+void can_irq_init(can_t *obj, can_irq_handler handler, uintptr_t context)
 {
     if(obj->index)
         can1_irq_handler = handler;
     else
         can0_irq_handler = handler;
-    can_irq_ids[obj->index] = id; 
+    can_irq_contexts[obj->index] = context; 
 
 }
 
@@ -207,7 +207,7 @@
 {
     CAN_DisableInt((CAN_T *)NU_MODBASE(obj->can), (CAN_CON_IE_Msk|CAN_CON_SIE_Msk|CAN_CON_EIE_Msk));
     
-    can_irq_ids[obj->index] = 0;
+    can_irq_contexts[obj->index] = 0;
     
     if(!obj->index)
         NVIC_DisableIRQ(CAN0_IRQn);
diff --git a/targets/TARGET_NXP/TARGET_LPC176X/can_api.c b/targets/TARGET_NXP/TARGET_LPC176X/can_api.c
index 07a7aa0..dde466a 100644
--- a/targets/TARGET_NXP/TARGET_LPC176X/can_api.c
+++ b/targets/TARGET_NXP/TARGET_LPC176X/can_api.c
@@ -64,7 +64,7 @@
 };
 typedef struct CANMsg CANMsg;
 
-static uint32_t can_irq_ids[CAN_NUM] = {0};
+static uintptr_t can_irq_contexts[CAN_NUM] = {0};
 static can_irq_handler irq_handler;
 
 static uint32_t can_disable(can_t *obj) {
@@ -130,18 +130,18 @@
     
     for(i = 0; i < 8; i++)
     {
-        if((can_irq_ids[index] != 0) && (icr & (1 << i)))
+        if((can_irq_contexts[index] != 0) && (icr & (1 << i)))
         {
             switch (i) {
-                case 0: irq_handler(can_irq_ids[index], IRQ_RX);      break;
-                case 1: irq_handler(can_irq_ids[index], IRQ_TX);      break;
-                case 2: irq_handler(can_irq_ids[index], IRQ_ERROR);   break;
-                case 3: irq_handler(can_irq_ids[index], IRQ_OVERRUN); break;
-                case 4: irq_handler(can_irq_ids[index], IRQ_WAKEUP);  break;
-                case 5: irq_handler(can_irq_ids[index], IRQ_PASSIVE); break;
-                case 6: irq_handler(can_irq_ids[index], IRQ_ARB);     break;
-                case 7: irq_handler(can_irq_ids[index], IRQ_BUS);     break;
-                case 8: irq_handler(can_irq_ids[index], IRQ_READY);   break;
+                case 0: irq_handler(can_irq_contexts[index], IRQ_RX);      break;
+                case 1: irq_handler(can_irq_contexts[index], IRQ_TX);      break;
+                case 2: irq_handler(can_irq_contexts[index], IRQ_ERROR);   break;
+                case 3: irq_handler(can_irq_contexts[index], IRQ_OVERRUN); break;
+                case 4: irq_handler(can_irq_contexts[index], IRQ_WAKEUP);  break;
+                case 5: irq_handler(can_irq_contexts[index], IRQ_PASSIVE); break;
+                case 6: irq_handler(can_irq_contexts[index], IRQ_ARB);     break;
+                case 7: irq_handler(can_irq_contexts[index], IRQ_BUS);     break;
+                case 8: irq_handler(can_irq_contexts[index], IRQ_READY);   break;
             }
         }
     }
@@ -164,17 +164,17 @@
 }
 
 // Register CAN object's irq handler
-void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id) {
+void can_irq_init(can_t *obj, can_irq_handler handler, uintptr_t context) {
     irq_handler = handler;
-    can_irq_ids[obj->index] = id;
+    can_irq_contexts[obj->index] = context;
 }
 
 // Unregister CAN object's irq handler
 void can_irq_free(can_t *obj) {
     obj->dev->IER &= ~(1);
-    can_irq_ids[obj->index] = 0;
+    can_irq_contexts[obj->index] = 0;
 
-    if ((can_irq_ids[0] == 0) && (can_irq_ids[1] == 0)) {
+    if ((can_irq_contexts[0] == 0) && (can_irq_contexts[1] == 0)) {
         NVIC_DisableIRQ(CAN_IRQn);
     }
 }
diff --git a/targets/TARGET_RENESAS/TARGET_RZ_A1XX/can_api.c b/targets/TARGET_RENESAS/TARGET_RZ_A1XX/can_api.c
index 6015146..8909c5a 100644
--- a/targets/TARGET_RENESAS/TARGET_RZ_A1XX/can_api.c
+++ b/targets/TARGET_RENESAS/TARGET_RZ_A1XX/can_api.c
@@ -104,7 +104,7 @@
 } can_info_int_t;
 
 static can_irq_handler irq_handler;
-static uint32_t can_irq_id[CAN_NUM];
+static uintptr_t can_irq_contexts[CAN_NUM];
 static int can_initialized[CAN_NUM] = {0};
 
 
@@ -310,13 +310,13 @@
 static __IO uint32_t *dmy_gaflp0 = &RSCAN0GAFLP00;
 static __IO uint32_t *dmy_gaflp1 = &RSCAN0GAFLP10;
 
-void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id) {
+void can_irq_init(can_t *obj, can_irq_handler handler, uintptr_t context) {
     irq_handler = handler;
-    can_irq_id[obj->ch] = id;
+    can_irq_contexts[obj->ch] = context;
 }
 
 void can_irq_free(can_t *obj) {
-    can_irq_id[obj->ch] = 0;
+    can_irq_contexts[obj->ch] = 0;
 }
 
 void can_irq_set(can_t *obj, CanIrqType type, uint32_t enable) {
@@ -358,7 +358,7 @@
     dmy_cfsts = CFSTS_TBL[ch][CAN_RECV];
     *dmy_cfsts &= 0xFFFFFFF7;           // Clear CFRXIF
 
-    irq_handler(can_irq_id[ch], IRQ_RX);
+    irq_handler(can_irq_contexts[ch], IRQ_RX);
 }
 
 static void can_trx_irq(uint32_t ch) {
@@ -367,7 +367,7 @@
     dmy_cfsts = CFSTS_TBL[ch][CAN_SEND];
     *dmy_cfsts &= 0xFFFFFFEF;           // Clear CFTXIF
 
-    irq_handler(can_irq_id[ch], IRQ_TX);
+    irq_handler(can_irq_contexts[ch], IRQ_TX);
 }
 
 static void can_err_irq(uint32_t ch, CanIrqType type) {
@@ -400,7 +400,7 @@
             break;
     }
     if (val == 1) {
-        irq_handler(can_irq_id[ch], type);
+        irq_handler(can_irq_contexts[ch], type);
     }
 }
 
diff --git a/targets/TARGET_RENESAS/TARGET_RZ_A2XX/can_api.c b/targets/TARGET_RENESAS/TARGET_RZ_A2XX/can_api.c
index 74c70e2..5dc7333 100644
--- a/targets/TARGET_RENESAS/TARGET_RZ_A2XX/can_api.c
+++ b/targets/TARGET_RENESAS/TARGET_RZ_A2XX/can_api.c
@@ -382,17 +382,17 @@
 volatile int g_data_bitrate[CHANNEL_MAX] = {D_CH0_BITRATE, D_CH1_BITRATE};
 uint32_t rx_buf[RX_BUFFER_MAX];
 static can_irq_handler irq_handler[CHANNEL_MAX] = {NULL};
-static uint32_t can_irq_id[CHANNEL_MAX] = {0};
+static uintptr_t can_irq_contexts[CHANNEL_MAX] = {0};
 
-void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id)
+void can_irq_init(can_t *obj, can_irq_handler handler, uintptr_t context)
 {
     irq_handler[obj->ch] = handler;
-    can_irq_id[obj->ch] = id;
+    can_irq_contexts[obj->ch] = context;
 }
 
 void can_irq_free(can_t *obj)
 {
-    can_irq_id[obj->ch] = 0;
+    can_irq_contexts[obj->ch] = 0;
     *g_regtbl_cfcc[obj->ch][CAN_RX] &= ~CFCC_CFRXIE;
     *g_regtbl_cfcc[obj->ch][CAN_TX] &= ~CFCC_CFTXIE;
     *g_regtbl_ctr[obj->ch] &= ~(CTR_EWIE | CTR_OLIE | CTR_EPIE | CTR_ALIE | CTR_BEIE);
@@ -454,13 +454,13 @@
 static void can_rec_irq(uint32_t ch)
 {
     *g_regtbl_cfsts[ch][CAN_RX] &= ~CFSTS_CFRXIF;
-    irq_handler[ch](can_irq_id[ch], IRQ_RX);
+    irq_handler[ch](can_irq_contexts[ch], IRQ_RX);
 }
 
 static void can_trx_irq(uint32_t ch)
 {
     *g_regtbl_cfsts[ch][CAN_TX] &= ~CFSTS_CFTXIF;
-    irq_handler[ch](can_irq_id[ch], IRQ_TX);
+    irq_handler[ch](can_irq_contexts[ch], IRQ_TX);
 }
 
 static void can_err_irq(uint32_t ch)
@@ -468,32 +468,32 @@
     /* error warning */
     if (*g_regtbl_erfl[ch] & ERFL_EWF) {
         *g_regtbl_erfl[ch] &= ~ERFL_EWF;
-        irq_handler[ch](can_irq_id[ch], IRQ_ERROR);
+        irq_handler[ch](can_irq_contexts[ch], IRQ_ERROR);
     }
 
     /* over load */
     if (*g_regtbl_erfl[ch] & ERFL_OVLF) {
         *g_regtbl_erfl[ch] &= ~ERFL_OVLF;
-        irq_handler[ch](can_irq_id[ch], IRQ_OVERRUN);
+        irq_handler[ch](can_irq_contexts[ch], IRQ_OVERRUN);
     }
 
     /* error passive */
     if (*g_regtbl_erfl[ch] & ERFL_EPF) {
         *g_regtbl_erfl[ch] &= ~ERFL_EPF;
-        irq_handler[ch](can_irq_id[ch], IRQ_PASSIVE);
+        irq_handler[ch](can_irq_contexts[ch], IRQ_PASSIVE);
     }
 
     /* arbitration lost */
     if (*g_regtbl_erfl[ch] & ERFL_ALF) {
         *g_regtbl_erfl[ch] &= ~ERFL_ALF;
-        irq_handler[ch](can_irq_id[ch], IRQ_ARB);
+        irq_handler[ch](can_irq_contexts[ch], IRQ_ARB);
     }
 
     /* bus error */
     if (*g_regtbl_erfl[ch] & ERFL_ALLERR) {
         *g_regtbl_erfl[ch] &= ~ERFL_ALLERR;
         *g_regtbl_erfl[ch] &= ~ERFL_BEF;
-        irq_handler[ch](can_irq_id[ch], IRQ_BUS);
+        irq_handler[ch](can_irq_contexts[ch], IRQ_BUS);
     }
 }
 
diff --git a/targets/TARGET_STM/can_api.c b/targets/TARGET_STM/can_api.c
index e1468ab..eed3a1f 100644
--- a/targets/TARGET_STM/can_api.c
+++ b/targets/TARGET_STM/can_api.c
@@ -24,7 +24,7 @@
 #include "PeripheralPins.h"
 #include "mbed_error.h"
 
-static uint32_t can_irq_ids[2] = {0};
+static uintptr_t can_irq_contexts[2] = {0};
 static can_irq_handler irq_handler;
 
 /** Call all the init functions
@@ -222,10 +222,10 @@
     can_init_freq(obj, rd, td, 100000);
 }
 
-void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id)
+void can_irq_init(can_t *obj, can_irq_handler handler, uintptr_t context)
 {
     irq_handler = handler;
-    can_irq_ids[obj->index] = id;
+    can_irq_contexts[obj->index] = context;
 }
 
 void can_irq_free(can_t *obj)
@@ -253,7 +253,7 @@
 #ifndef TARGET_STM32G4
     HAL_NVIC_DisableIRQ(FDCAN_CAL_IRQn);
 #endif
-    can_irq_ids[obj->index] = 0;
+    can_irq_contexts[obj->index] = 0;
 }
 
 void can_free(can_t *obj)
@@ -517,42 +517,42 @@
     if (__HAL_FDCAN_GET_IT_SOURCE(&CanHandle, FDCAN_IT_TX_COMPLETE)) {
         if (__HAL_FDCAN_GET_FLAG(&CanHandle, FDCAN_FLAG_TX_COMPLETE)) {
             __HAL_FDCAN_CLEAR_FLAG(&CanHandle, FDCAN_FLAG_TX_COMPLETE);
-            irq_handler(can_irq_ids[id], IRQ_TX);
+            irq_handler(can_irq_contexts[id], IRQ_TX);
         }
     }
 #ifndef TARGET_STM32G4
     if (__HAL_FDCAN_GET_IT_SOURCE(&CanHandle, FDCAN_IT_RX_BUFFER_NEW_MESSAGE)) {
         if (__HAL_FDCAN_GET_FLAG(&CanHandle, FDCAN_IT_RX_BUFFER_NEW_MESSAGE)) {
             __HAL_FDCAN_CLEAR_FLAG(&CanHandle, FDCAN_IT_RX_BUFFER_NEW_MESSAGE);
-            irq_handler(can_irq_ids[id], IRQ_RX);
+            irq_handler(can_irq_contexts[id], IRQ_RX);
         }
     }
 #else
     if (__HAL_FDCAN_GET_IT_SOURCE(&CanHandle, FDCAN_IT_RX_FIFO0_NEW_MESSAGE)) {
         if (__HAL_FDCAN_GET_FLAG(&CanHandle, FDCAN_IT_RX_FIFO0_NEW_MESSAGE)) {
             __HAL_FDCAN_CLEAR_FLAG(&CanHandle, FDCAN_IT_RX_FIFO0_NEW_MESSAGE);
-            irq_handler(can_irq_ids[id], IRQ_RX);
+            irq_handler(can_irq_contexts[id], IRQ_RX);
         }
     }
 #endif
     if (__HAL_FDCAN_GET_IT_SOURCE(&CanHandle, FDCAN_IT_ERROR_WARNING)) {
         if (__HAL_FDCAN_GET_FLAG(&CanHandle, FDCAN_FLAG_ERROR_WARNING)) {
             __HAL_FDCAN_CLEAR_FLAG(&CanHandle, FDCAN_FLAG_ERROR_WARNING);
-            irq_handler(can_irq_ids[id], IRQ_ERROR);
+            irq_handler(can_irq_contexts[id], IRQ_ERROR);
         }
     }
 
     if (__HAL_FDCAN_GET_IT_SOURCE(&CanHandle, FDCAN_IT_ERROR_PASSIVE)) {
         if (__HAL_FDCAN_GET_FLAG(&CanHandle, FDCAN_FLAG_ERROR_PASSIVE)) {
             __HAL_FDCAN_CLEAR_FLAG(&CanHandle, FDCAN_FLAG_ERROR_PASSIVE);
-            irq_handler(can_irq_ids[id], IRQ_PASSIVE);
+            irq_handler(can_irq_contexts[id], IRQ_PASSIVE);
         }
     }
 
     if (__HAL_FDCAN_GET_IT_SOURCE(&CanHandle, FDCAN_IT_BUS_OFF)) {
         if (__HAL_FDCAN_GET_FLAG(&CanHandle, FDCAN_FLAG_BUS_OFF)) {
             __HAL_FDCAN_CLEAR_FLAG(&CanHandle, FDCAN_FLAG_BUS_OFF);
-            irq_handler(can_irq_ids[id], IRQ_BUS);
+            irq_handler(can_irq_contexts[id], IRQ_BUS);
         }
     }
 }
@@ -666,7 +666,7 @@
 
 #define DEFAULT_RXFIFO    0 // default rx fifo for can by hardware is FIFO0
 
-static uint32_t can_irq_ids[CAN_NUM] = {0};
+static uint32_t can_irq_contexts[CAN_NUM] = {0};
 static can_irq_handler irq_handler;
 
 static void can_registers_init(can_t *obj)
@@ -774,10 +774,10 @@
     can_init_freq(obj, rd, td, 100000);
 }
 
-void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id)
+void can_irq_init(can_t *obj, can_irq_handler handler, uintptr_t context)
 {
     irq_handler = handler;
-    can_irq_ids[obj->index] = id;
+    can_irq_contexts[obj->index] = context;
     obj->rxIrqEnabled = false;
 }
 
@@ -787,7 +787,7 @@
 
     can->IER &= ~(CAN_IT_FMP0 | CAN_IT_FMP1 | CAN_IT_TME | \
                   CAN_IT_ERR | CAN_IT_EPV | CAN_IT_BOF);
-    can_irq_ids[obj->index] = 0;
+    can_irq_contexts[obj->index] = 0;
     obj->rxIrqEnabled = false;
 }
 
@@ -1177,7 +1177,7 @@
             __HAL_CAN_CLEAR_FLAG(&CanHandle, CAN_FLAG_RQCP2);
         }
         if (tmp1 || tmp2 || tmp3) {
-            irq_handler(can_irq_ids[id], IRQ_TX);
+            irq_handler(can_irq_contexts[id], IRQ_TX);
         }
     }
 
@@ -1191,7 +1191,7 @@
     __HAL_CAN_DISABLE_IT(&CanHandle, CAN_IT_FMP0);
 
     if ((tmp1 != 0) && tmp2) {
-        irq_handler(can_irq_ids[id], IRQ_RX);
+        irq_handler(can_irq_contexts[id], IRQ_RX);
     }
 
     tmp1 = __HAL_CAN_GET_FLAG(&CanHandle, CAN_FLAG_EPV);
@@ -1199,19 +1199,19 @@
     tmp3 = __HAL_CAN_GET_IT_SOURCE(&CanHandle, CAN_IT_ERR);
 
     if (tmp1 && tmp2 && tmp3) {
-        irq_handler(can_irq_ids[id], IRQ_PASSIVE);
+        irq_handler(can_irq_contexts[id], IRQ_PASSIVE);
     }
 
     tmp1 = __HAL_CAN_GET_FLAG(&CanHandle, CAN_FLAG_BOF);
     tmp2 = __HAL_CAN_GET_IT_SOURCE(&CanHandle, CAN_IT_BOF);
     tmp3 = __HAL_CAN_GET_IT_SOURCE(&CanHandle, CAN_IT_ERR);
     if (tmp1 && tmp2 && tmp3) {
-        irq_handler(can_irq_ids[id], IRQ_BUS);
+        irq_handler(can_irq_contexts[id], IRQ_BUS);
     }
 
     tmp3 = __HAL_CAN_GET_IT_SOURCE(&CanHandle, CAN_IT_ERR);
     if (tmp1 && tmp2 && tmp3) {
-        irq_handler(can_irq_ids[id], IRQ_ERROR);
+        irq_handler(can_irq_contexts[id], IRQ_ERROR);
     }
 }
 
diff --git a/targets/TARGET_Silicon_Labs/TARGET_EFM32/can_api.c b/targets/TARGET_Silicon_Labs/TARGET_EFM32/can_api.c
index 0e84740..412e9a0 100644
--- a/targets/TARGET_Silicon_Labs/TARGET_EFM32/can_api.c
+++ b/targets/TARGET_Silicon_Labs/TARGET_EFM32/can_api.c
@@ -27,7 +27,7 @@
 #include "em_cmu.h"
 #include "em_can.h"
 
-static uint32_t can_irq_ids[CAN_COUNT] = {0};
+static uintptr_t can_irq_contexts[CAN_COUNT] = {0};
 static can_irq_handler irq_handler;
 
 // CAN bus interfaces
@@ -104,7 +104,7 @@
 	CAN_SetIdAndFilter(obj->instance, CAN_RX_IF, true, &receiver, true);
 }
 
-void can_irq_init(can_t *obj, can_irq_handler handler, uint32_t id)
+void can_irq_init(can_t *obj, can_irq_handler handler, uintptr_t context)
 {
 	int index = 0;
 
@@ -122,7 +122,7 @@
     }
 
 	irq_handler = handler;
-    can_irq_ids[index] = id;
+    can_irq_contexts[index] = context;
 }
 
 void can_irq_free(can_t *obj)
@@ -294,12 +294,12 @@
 	can = (CAN_TypeDef *)name;
 
 	if (can->STATUS & CAN_STATUS_RXOK) {
-		irq_handler(can_irq_ids[id], IRQ_RX);
+		irq_handler(can_irq_contexts[id], IRQ_RX);
 	    CAN_MessageIntClear(can, 0xFFFFFFFF);
 	}
 
 	if (can->STATUS & CAN_STATUS_TXOK) {
-		irq_handler(can_irq_ids[id], IRQ_TX);
+		irq_handler(can_irq_contexts[id], IRQ_TX);
 	    CAN_MessageIntClear(can, 0xFFFFFFFF);
 	}
 }