Remove SubscribableCallback

src/callback.rs

diff --git a/src/callback.rs b/src/callback.rs
index 0d0d6fc..95d4e04 100644
--- a/src/callback.rs
+++ b/src/callback.rs
@@ -38,10 +38,6 @@
     }
 }
 
-pub(crate) trait SubscribableCallback {
-    fn call_rust(&mut self, arg1: usize, arg2: usize, arg3: usize);
-}
-
 #[must_use = "Subscriptions risk being dropped too early. Drop them manually."]
 pub struct CallbackSubscription<'a> {
     driver_number: usize,

src/simple_ble.rs

diff --git a/src/simple_ble.rs b/src/simple_ble.rs
index 8298cce..2876bce 100644
--- a/src/simple_ble.rs
+++ b/src/simple_ble.rs
@@ -1,6 +1,6 @@
 use crate::ble_composer::BlePayload;
 use crate::callback::CallbackSubscription;
-use crate::callback::SubscribableCallback;
+use crate::callback::Consumer;
 use crate::result::TockResult;
 use crate::shared_memory::SharedMemory;
 use crate::syscalls;
@@ -79,9 +79,9 @@
     }
 }
 
-impl<CB: FnMut(usize, usize)> SubscribableCallback for BleCallback<CB> {
-    fn call_rust(&mut self, arg1: usize, arg2: usize, _: usize) {
-        (self.callback)(arg1, arg2);
+impl<CB: FnMut(usize, usize)> Consumer<BleCallback<CB>> for BleCallback<CB> {
+    fn consume(data: &mut BleCallback<CB>, arg1: usize, arg2: usize, _: usize) {
+        (data.callback)(arg1, arg2);
     }
 }
 
@@ -104,8 +104,11 @@
         &'a mut self,
         callback: &'a mut BleCallback<CB>,
     ) -> TockResult<CallbackSubscription> {
-        let subscription =
-            syscalls::subscribe_cb(DRIVER_NUMBER, subscribe_nr::BLE_PASSIVE_SCAN_SUB, callback)?;
+        let subscription = syscalls::subscribe::<BleCallback<CB>, _>(
+            DRIVER_NUMBER,
+            subscribe_nr::BLE_PASSIVE_SCAN_SUB,
+            callback,
+        )?;
         syscalls::command(DRIVER_NUMBER, command_nr::PASSIVE_SCAN, 1, 0)?;
         Ok(subscription)
     }

src/syscalls/mod.rs

diff --git a/src/syscalls/mod.rs b/src/syscalls/mod.rs
index 2aafe6e..c0289e5 100644
--- a/src/syscalls/mod.rs
+++ b/src/syscalls/mod.rs
@@ -8,7 +8,6 @@
 
 use crate::callback::CallbackSubscription;
 use crate::callback::Consumer;
-use crate::callback::SubscribableCallback;
 use crate::result::AllowError;
 use crate::result::CommandError;
 use crate::result::SubscribeError;
@@ -34,22 +33,6 @@
     }
 }
 
-pub(crate) fn subscribe_cb<CB: SubscribableCallback>(
-    driver_number: usize,
-    subscribe_number: usize,
-    callback: &mut CB,
-) -> Result<CallbackSubscription, SubscribeError> {
-    subscribe::<SubscribableCallbackConsumer, _>(driver_number, subscribe_number, callback)
-}
-
-struct SubscribableCallbackConsumer;
-
-impl<CB: SubscribableCallback> Consumer<CB> for SubscribableCallbackConsumer {
-    fn consume(data: &mut CB, arg1: usize, arg2: usize, arg3: usize) {
-        data.call_rust(arg1, arg2, arg3);
-    }
-}
-
 pub fn subscribe<C: Consumer<T>, T>(
     driver_number: usize,
     subscribe_number: usize,

src/timer.rs

diff --git a/src/timer.rs b/src/timer.rs
index 7319109..946c6e5 100644
--- a/src/timer.rs
+++ b/src/timer.rs
@@ -1,7 +1,7 @@
 //! Async timer driver. Can be used for (non-busy)  sleeping.
 
 use crate::callback::CallbackSubscription;
-use crate::callback::SubscribableCallback;
+use crate::callback::Consumer;
 use crate::futures;
 use crate::result::OtherError;
 use crate::result::TockError;
@@ -33,12 +33,14 @@
     phantom: PhantomData<&'a mut ()>,
 }
 
-impl<CB: FnMut(ClockValue, Alarm)> SubscribableCallback for WithCallback<'_, CB> {
-    fn call_rust(&mut self, clock_value: usize, alarm_id: usize, _: usize) {
-        (self.callback)(
+struct TimerEventConsumer;
+
+impl<CB: FnMut(ClockValue, Alarm)> Consumer<WithCallback<'_, CB>> for TimerEventConsumer {
+    fn consume(data: &mut WithCallback<CB>, clock_value: usize, alarm_id: usize, _: usize) {
+        (data.callback)(
             ClockValue {
                 num_ticks: clock_value as isize,
-                clock_frequency: self.clock_frequency,
+                clock_frequency: data.clock_frequency,
             },
             Alarm { alarm_id },
         );
@@ -61,8 +63,11 @@
             hz: clock_frequency,
         };
 
-        let subscription =
-            syscalls::subscribe_cb(DRIVER_NUMBER, subscribe_nr::SUBSCRIBE_CALLBACK, self)?;
+        let subscription = syscalls::subscribe::<TimerEventConsumer, _>(
+            DRIVER_NUMBER,
+            subscribe_nr::SUBSCRIBE_CALLBACK,
+            self,
+        )?;
 
         Ok(Timer {
             num_notifications,
@@ -331,8 +336,10 @@
 
 struct Callback;
 
-impl SubscribableCallback for Callback {
-    fn call_rust(&mut self, _: usize, _: usize, _: usize) {}
+struct ParallelTimerConsumer;
+
+impl<'a> Consumer<Callback> for ParallelTimerConsumer {
+    fn consume(_: &mut Callback, _: usize, _: usize, _: usize) {}
 }
 
 /// Activated time driver. Updates current time in the context and manages
@@ -358,7 +365,7 @@
     /// Activate the timer driver, will return a ParallelSleepDriver which
     /// can used to sleep.
     pub fn activate(&'a mut self) -> TockResult<ParallelSleepDriver<'a>> {
-        let subscription = syscalls::subscribe_cb(
+        let subscription = syscalls::subscribe::<ParallelTimerConsumer, _>(
             DRIVER_NUMBER,
             subscribe_nr::SUBSCRIBE_CALLBACK,
             &mut self.callback,