diff --git a/hal/api/Callback.h b/hal/api/Callback.h
index 8ffd70164c4..3e5fc3f1423 100644
--- a/hal/api/Callback.h
+++ b/hal/api/Callback.h
@@ -31,13 +31,13 @@ class Callback;
 
 /** Templated function class
  */
-template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
-class Callback<R(A0, A1, A2, A3, A4)> {
+template <typename R>
+class Callback<R()> {
 public:
     /** Create a Callback with a static function
      *  @param func Static function to attach
      */
-    Callback(R (*func)(A0, A1, A2, A3, A4) = 0) {
+    Callback(R (*func)() = 0) {
         attach(func);
     }
 
@@ -46,7 +46,7 @@ class Callback<R(A0, A1, A2, A3, A4)> {
      *  @param func Static function to attach
      */
     template<typename T>
-    Callback(T *obj, R (*func)(T*, A0, A1, A2, A3, A4)) {
+    Callback(T *obj, R (*func)(T*)) {
         attach(obj, func);
     }
 
@@ -55,21 +55,21 @@ class Callback<R(A0, A1, A2, A3, A4)> {
      *  @param func Member function to attach
      */
     template<typename T>
-    Callback(T *obj, R (T::*func)(A0, A1, A2, A3, A4)) {
+    Callback(T *obj, R (T::*func)()) {
         attach(obj, func);
     }
 
     /** Create a Callback with another Callback
      *  @param func Callback to attach
      */
-    Callback(const Callback<R(A0, A1, A2, A3, A4)> &func) {
+    Callback(const Callback<R()> &func) {
         attach(func);
     }
 
     /** Attach a static function
      *  @param func Static function to attach
      */
-    void attach(R (*func)(A0, A1, A2, A3, A4)) {
+    void attach(R (*func)()) {
         memcpy(&_func, &func, sizeof func);
         _thunk = func ? &Callback::_staticthunk : 0;
     }
@@ -79,7 +79,7 @@ class Callback<R(A0, A1, A2, A3, A4)> {
      *  @param func Static function to attach
      */
     template <typename T>
-    void attach(T *obj, R (*func)(T*, A0, A1, A2, A3, A4)) {
+    void attach(T *obj, R (*func)(T*)) {
         _obj = (void*)obj;
         memcpy(&_func, &func, sizeof func);
         _thunk = &Callback::_boundthunk<T>;
@@ -90,7 +90,7 @@ class Callback<R(A0, A1, A2, A3, A4)> {
      *  @param func Member function to attach
      */
     template<typename T>
-    void attach(T *obj, R (T::*func)(A0, A1, A2, A3, A4)) {
+    void attach(T *obj, R (T::*func)()) {
         _obj = static_cast<void*>(obj);
         memcpy(&_func, &func, sizeof func);
         _thunk = &Callback::_methodthunk<T>;
@@ -99,7 +99,7 @@ class Callback<R(A0, A1, A2, A3, A4)> {
     /** Attach a Callback
      *  @param func The Callback to attach
      */
-    void attach(const Callback<R(A0, A1, A2, A3, A4)> &func) {
+    void attach(const Callback<R()> &func) {
         _obj = func._obj;
         memcpy(&_func, &func._func, sizeof _func);
         _thunk = func._thunk;
@@ -107,17 +107,17 @@ class Callback<R(A0, A1, A2, A3, A4)> {
 
     /** Call the attached function
      */
-    R call(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
+    R call() {
         if (!_thunk) {
             return (R)0;
         }
-        return _thunk(_obj, &_func, a0, a1, a2, a3, a4);
+        return _thunk(_obj, &_func);
     }
 
     /** Call the attached function
      */
-    R operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
-        return call(a0, a1, a2, a3, a4);
+    R operator()() {
+        return call();
     }
 
     /** Test if function has been attached
@@ -129,29 +129,29 @@ class Callback<R(A0, A1, A2, A3, A4)> {
     /** Static thunk for passing as C-style function
      *  @param func Callback to call passed as void pointer
      */
-    static R thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
-        return static_cast<Callback<R(A0, A1, A2, A3, A4)>*>(func)
-                ->call(a0, a1, a2, a3, a4);
+    static R thunk(void *func) {
+        return static_cast<Callback<R()>*>(func)
+                ->call();
     }
 
 private:
     // Internal thunks for various function types
-    static R _staticthunk(void*, void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
-        return (*reinterpret_cast<R (**)(A0, A1, A2, A3, A4)>(func))
-                (a0, a1, a2, a3, a4);
+    static R _staticthunk(void*, void *func) {
+        return (*reinterpret_cast<R (**)()>(func))
+                ();
     }
 
     template<typename T>
-    static R _boundthunk(void *obj, void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
-        return (*reinterpret_cast<R (**)(T*, A0, A1, A2, A3, A4)>(func))
-                (static_cast<T*>(obj), a0, a1, a2, a3, a4);
+    static R _boundthunk(void *obj, void *func) {
+        return (*reinterpret_cast<R (**)(T*)>(func))
+                (static_cast<T*>(obj));
     }
 
     template<typename T>
-    static R _methodthunk(void *obj, void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
+    static R _methodthunk(void *obj, void *func) {
         return (static_cast<T*>(obj)->*
-                (*reinterpret_cast<R (T::**)(A0, A1, A2, A3, A4)>(func)))
-                (a0, a1, a2, a3, a4);
+                (*reinterpret_cast<R (T::**)()>(func)))
+                ();
     }
 
     // Stored as pointer to function and pointer to optional object
@@ -167,18 +167,18 @@ class Callback<R(A0, A1, A2, A3, A4)> {
     void *_obj;
 
     // Thunk registered on attach to dispatch calls
-    R (*_thunk)(void*, void*, A0, A1, A2, A3, A4); 
+    R (*_thunk)(void*, void*);
 };
 
 /** Templated function class
  */
-template <typename R, typename A0, typename A1, typename A2, typename A3>
-class Callback<R(A0, A1, A2, A3)> {
+template <typename R, typename A0>
+class Callback<R(A0)> {
 public:
     /** Create a Callback with a static function
      *  @param func Static function to attach
      */
-    Callback(R (*func)(A0, A1, A2, A3) = 0) {
+    Callback(R (*func)(A0) = 0) {
         attach(func);
     }
 
@@ -187,7 +187,7 @@ class Callback<R(A0, A1, A2, A3)> {
      *  @param func Static function to attach
      */
     template<typename T>
-    Callback(T *obj, R (*func)(T*, A0, A1, A2, A3)) {
+    Callback(T *obj, R (*func)(T*, A0)) {
         attach(obj, func);
     }
 
@@ -196,21 +196,21 @@ class Callback<R(A0, A1, A2, A3)> {
      *  @param func Member function to attach
      */
     template<typename T>
-    Callback(T *obj, R (T::*func)(A0, A1, A2, A3)) {
+    Callback(T *obj, R (T::*func)(A0)) {
         attach(obj, func);
     }
 
     /** Create a Callback with another Callback
      *  @param func Callback to attach
      */
-    Callback(const Callback<R(A0, A1, A2, A3)> &func) {
+    Callback(const Callback<R(A0)> &func) {
         attach(func);
     }
 
     /** Attach a static function
      *  @param func Static function to attach
      */
-    void attach(R (*func)(A0, A1, A2, A3)) {
+    void attach(R (*func)(A0)) {
         memcpy(&_func, &func, sizeof func);
         _thunk = func ? &Callback::_staticthunk : 0;
     }
@@ -220,7 +220,7 @@ class Callback<R(A0, A1, A2, A3)> {
      *  @param func Static function to attach
      */
     template <typename T>
-    void attach(T *obj, R (*func)(T*, A0, A1, A2, A3)) {
+    void attach(T *obj, R (*func)(T*, A0)) {
         _obj = (void*)obj;
         memcpy(&_func, &func, sizeof func);
         _thunk = &Callback::_boundthunk<T>;
@@ -231,7 +231,7 @@ class Callback<R(A0, A1, A2, A3)> {
      *  @param func Member function to attach
      */
     template<typename T>
-    void attach(T *obj, R (T::*func)(A0, A1, A2, A3)) {
+    void attach(T *obj, R (T::*func)(A0)) {
         _obj = static_cast<void*>(obj);
         memcpy(&_func, &func, sizeof func);
         _thunk = &Callback::_methodthunk<T>;
@@ -240,7 +240,7 @@ class Callback<R(A0, A1, A2, A3)> {
     /** Attach a Callback
      *  @param func The Callback to attach
      */
-    void attach(const Callback<R(A0, A1, A2, A3)> &func) {
+    void attach(const Callback<R(A0)> &func) {
         _obj = func._obj;
         memcpy(&_func, &func._func, sizeof _func);
         _thunk = func._thunk;
@@ -248,17 +248,17 @@ class Callback<R(A0, A1, A2, A3)> {
 
     /** Call the attached function
      */
-    R call(A0 a0, A1 a1, A2 a2, A3 a3) {
+    R call(A0 a0) {
         if (!_thunk) {
             return (R)0;
         }
-        return _thunk(_obj, &_func, a0, a1, a2, a3);
+        return _thunk(_obj, &_func, a0);
     }
 
     /** Call the attached function
      */
-    R operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
-        return call(a0, a1, a2, a3);
+    R operator()(A0 a0) {
+        return call(a0);
     }
 
     /** Test if function has been attached
@@ -270,29 +270,29 @@ class Callback<R(A0, A1, A2, A3)> {
     /** Static thunk for passing as C-style function
      *  @param func Callback to call passed as void pointer
      */
-    static R thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3) {
-        return static_cast<Callback<R(A0, A1, A2, A3)>*>(func)
-                ->call(a0, a1, a2, a3);
+    static R thunk(void *func, A0 a0) {
+        return static_cast<Callback<R(A0)>*>(func)
+                ->call(a0);
     }
 
 private:
     // Internal thunks for various function types
-    static R _staticthunk(void*, void *func, A0 a0, A1 a1, A2 a2, A3 a3) {
-        return (*reinterpret_cast<R (**)(A0, A1, A2, A3)>(func))
-                (a0, a1, a2, a3);
+    static R _staticthunk(void*, void *func, A0 a0) {
+        return (*reinterpret_cast<R (**)(A0)>(func))
+                (a0);
     }
 
     template<typename T>
-    static R _boundthunk(void *obj, void *func, A0 a0, A1 a1, A2 a2, A3 a3) {
-        return (*reinterpret_cast<R (**)(T*, A0, A1, A2, A3)>(func))
-                (static_cast<T*>(obj), a0, a1, a2, a3);
+    static R _boundthunk(void *obj, void *func, A0 a0) {
+        return (*reinterpret_cast<R (**)(T*, A0)>(func))
+                (static_cast<T*>(obj), a0);
     }
 
     template<typename T>
-    static R _methodthunk(void *obj, void *func, A0 a0, A1 a1, A2 a2, A3 a3) {
+    static R _methodthunk(void *obj, void *func, A0 a0) {
         return (static_cast<T*>(obj)->*
-                (*reinterpret_cast<R (T::**)(A0, A1, A2, A3)>(func)))
-                (a0, a1, a2, a3);
+                (*reinterpret_cast<R (T::**)(A0)>(func)))
+                (a0);
     }
 
     // Stored as pointer to function and pointer to optional object
@@ -308,18 +308,18 @@ class Callback<R(A0, A1, A2, A3)> {
     void *_obj;
 
     // Thunk registered on attach to dispatch calls
-    R (*_thunk)(void*, void*, A0, A1, A2, A3); 
+    R (*_thunk)(void*, void*, A0);
 };
 
 /** Templated function class
  */
-template <typename R, typename A0, typename A1, typename A2>
-class Callback<R(A0, A1, A2)> {
+template <typename R, typename A0, typename A1>
+class Callback<R(A0, A1)> {
 public:
     /** Create a Callback with a static function
      *  @param func Static function to attach
      */
-    Callback(R (*func)(A0, A1, A2) = 0) {
+    Callback(R (*func)(A0, A1) = 0) {
         attach(func);
     }
 
@@ -328,7 +328,7 @@ class Callback<R(A0, A1, A2)> {
      *  @param func Static function to attach
      */
     template<typename T>
-    Callback(T *obj, R (*func)(T*, A0, A1, A2)) {
+    Callback(T *obj, R (*func)(T*, A0, A1)) {
         attach(obj, func);
     }
 
@@ -337,21 +337,21 @@ class Callback<R(A0, A1, A2)> {
      *  @param func Member function to attach
      */
     template<typename T>
-    Callback(T *obj, R (T::*func)(A0, A1, A2)) {
+    Callback(T *obj, R (T::*func)(A0, A1)) {
         attach(obj, func);
     }
 
     /** Create a Callback with another Callback
      *  @param func Callback to attach
      */
-    Callback(const Callback<R(A0, A1, A2)> &func) {
+    Callback(const Callback<R(A0, A1)> &func) {
         attach(func);
     }
 
     /** Attach a static function
      *  @param func Static function to attach
      */
-    void attach(R (*func)(A0, A1, A2)) {
+    void attach(R (*func)(A0, A1)) {
         memcpy(&_func, &func, sizeof func);
         _thunk = func ? &Callback::_staticthunk : 0;
     }
@@ -361,7 +361,7 @@ class Callback<R(A0, A1, A2)> {
      *  @param func Static function to attach
      */
     template <typename T>
-    void attach(T *obj, R (*func)(T*, A0, A1, A2)) {
+    void attach(T *obj, R (*func)(T*, A0, A1)) {
         _obj = (void*)obj;
         memcpy(&_func, &func, sizeof func);
         _thunk = &Callback::_boundthunk<T>;
@@ -372,7 +372,7 @@ class Callback<R(A0, A1, A2)> {
      *  @param func Member function to attach
      */
     template<typename T>
-    void attach(T *obj, R (T::*func)(A0, A1, A2)) {
+    void attach(T *obj, R (T::*func)(A0, A1)) {
         _obj = static_cast<void*>(obj);
         memcpy(&_func, &func, sizeof func);
         _thunk = &Callback::_methodthunk<T>;
@@ -381,7 +381,7 @@ class Callback<R(A0, A1, A2)> {
     /** Attach a Callback
      *  @param func The Callback to attach
      */
-    void attach(const Callback<R(A0, A1, A2)> &func) {
+    void attach(const Callback<R(A0, A1)> &func) {
         _obj = func._obj;
         memcpy(&_func, &func._func, sizeof _func);
         _thunk = func._thunk;
@@ -389,17 +389,17 @@ class Callback<R(A0, A1, A2)> {
 
     /** Call the attached function
      */
-    R call(A0 a0, A1 a1, A2 a2) {
+    R call(A0 a0, A1 a1) {
         if (!_thunk) {
             return (R)0;
         }
-        return _thunk(_obj, &_func, a0, a1, a2);
+        return _thunk(_obj, &_func, a0, a1);
     }
 
     /** Call the attached function
      */
-    R operator()(A0 a0, A1 a1, A2 a2) {
-        return call(a0, a1, a2);
+    R operator()(A0 a0, A1 a1) {
+        return call(a0, a1);
     }
 
     /** Test if function has been attached
@@ -411,29 +411,29 @@ class Callback<R(A0, A1, A2)> {
     /** Static thunk for passing as C-style function
      *  @param func Callback to call passed as void pointer
      */
-    static R thunk(void *func, A0 a0, A1 a1, A2 a2) {
-        return static_cast<Callback<R(A0, A1, A2)>*>(func)
-                ->call(a0, a1, a2);
+    static R thunk(void *func, A0 a0, A1 a1) {
+        return static_cast<Callback<R(A0, A1)>*>(func)
+                ->call(a0, a1);
     }
 
 private:
     // Internal thunks for various function types
-    static R _staticthunk(void*, void *func, A0 a0, A1 a1, A2 a2) {
-        return (*reinterpret_cast<R (**)(A0, A1, A2)>(func))
-                (a0, a1, a2);
+    static R _staticthunk(void*, void *func, A0 a0, A1 a1) {
+        return (*reinterpret_cast<R (**)(A0, A1)>(func))
+                (a0, a1);
     }
 
     template<typename T>
-    static R _boundthunk(void *obj, void *func, A0 a0, A1 a1, A2 a2) {
-        return (*reinterpret_cast<R (**)(T*, A0, A1, A2)>(func))
-                (static_cast<T*>(obj), a0, a1, a2);
+    static R _boundthunk(void *obj, void *func, A0 a0, A1 a1) {
+        return (*reinterpret_cast<R (**)(T*, A0, A1)>(func))
+                (static_cast<T*>(obj), a0, a1);
     }
 
     template<typename T>
-    static R _methodthunk(void *obj, void *func, A0 a0, A1 a1, A2 a2) {
+    static R _methodthunk(void *obj, void *func, A0 a0, A1 a1) {
         return (static_cast<T*>(obj)->*
-                (*reinterpret_cast<R (T::**)(A0, A1, A2)>(func)))
-                (a0, a1, a2);
+                (*reinterpret_cast<R (T::**)(A0, A1)>(func)))
+                (a0, a1);
     }
 
     // Stored as pointer to function and pointer to optional object
@@ -449,18 +449,18 @@ class Callback<R(A0, A1, A2)> {
     void *_obj;
 
     // Thunk registered on attach to dispatch calls
-    R (*_thunk)(void*, void*, A0, A1, A2);
+    R (*_thunk)(void*, void*, A0, A1);
 };
 
 /** Templated function class
  */
-template <typename R, typename A0, typename A1>
-class Callback<R(A0, A1)> {
+template <typename R, typename A0, typename A1, typename A2>
+class Callback<R(A0, A1, A2)> {
 public:
     /** Create a Callback with a static function
      *  @param func Static function to attach
      */
-    Callback(R (*func)(A0, A1) = 0) {
+    Callback(R (*func)(A0, A1, A2) = 0) {
         attach(func);
     }
 
@@ -469,7 +469,7 @@ class Callback<R(A0, A1)> {
      *  @param func Static function to attach
      */
     template<typename T>
-    Callback(T *obj, R (*func)(T*, A0, A1)) {
+    Callback(T *obj, R (*func)(T*, A0, A1, A2)) {
         attach(obj, func);
     }
 
@@ -478,21 +478,21 @@ class Callback<R(A0, A1)> {
      *  @param func Member function to attach
      */
     template<typename T>
-    Callback(T *obj, R (T::*func)(A0, A1)) {
+    Callback(T *obj, R (T::*func)(A0, A1, A2)) {
         attach(obj, func);
     }
 
     /** Create a Callback with another Callback
      *  @param func Callback to attach
      */
-    Callback(const Callback<R(A0, A1)> &func) {
+    Callback(const Callback<R(A0, A1, A2)> &func) {
         attach(func);
     }
 
     /** Attach a static function
      *  @param func Static function to attach
      */
-    void attach(R (*func)(A0, A1)) {
+    void attach(R (*func)(A0, A1, A2)) {
         memcpy(&_func, &func, sizeof func);
         _thunk = func ? &Callback::_staticthunk : 0;
     }
@@ -502,7 +502,7 @@ class Callback<R(A0, A1)> {
      *  @param func Static function to attach
      */
     template <typename T>
-    void attach(T *obj, R (*func)(T*, A0, A1)) {
+    void attach(T *obj, R (*func)(T*, A0, A1, A2)) {
         _obj = (void*)obj;
         memcpy(&_func, &func, sizeof func);
         _thunk = &Callback::_boundthunk<T>;
@@ -513,7 +513,7 @@ class Callback<R(A0, A1)> {
      *  @param func Member function to attach
      */
     template<typename T>
-    void attach(T *obj, R (T::*func)(A0, A1)) {
+    void attach(T *obj, R (T::*func)(A0, A1, A2)) {
         _obj = static_cast<void*>(obj);
         memcpy(&_func, &func, sizeof func);
         _thunk = &Callback::_methodthunk<T>;
@@ -522,7 +522,7 @@ class Callback<R(A0, A1)> {
     /** Attach a Callback
      *  @param func The Callback to attach
      */
-    void attach(const Callback<R(A0, A1)> &func) {
+    void attach(const Callback<R(A0, A1, A2)> &func) {
         _obj = func._obj;
         memcpy(&_func, &func._func, sizeof _func);
         _thunk = func._thunk;
@@ -530,17 +530,17 @@ class Callback<R(A0, A1)> {
 
     /** Call the attached function
      */
-    R call(A0 a0, A1 a1) {
+    R call(A0 a0, A1 a1, A2 a2) {
         if (!_thunk) {
             return (R)0;
         }
-        return _thunk(_obj, &_func, a0, a1);
+        return _thunk(_obj, &_func, a0, a1, a2);
     }
 
     /** Call the attached function
      */
-    R operator()(A0 a0, A1 a1) {
-        return call(a0, a1);
+    R operator()(A0 a0, A1 a1, A2 a2) {
+        return call(a0, a1, a2);
     }
 
     /** Test if function has been attached
@@ -552,29 +552,29 @@ class Callback<R(A0, A1)> {
     /** Static thunk for passing as C-style function
      *  @param func Callback to call passed as void pointer
      */
-    static R thunk(void *func, A0 a0, A1 a1) {
-        return static_cast<Callback<R(A0, A1)>*>(func)
-                ->call(a0, a1);
+    static R thunk(void *func, A0 a0, A1 a1, A2 a2) {
+        return static_cast<Callback<R(A0, A1, A2)>*>(func)
+                ->call(a0, a1, a2);
     }
 
 private:
     // Internal thunks for various function types
-    static R _staticthunk(void*, void *func, A0 a0, A1 a1) {
-        return (*reinterpret_cast<R (**)(A0, A1)>(func))
-                (a0, a1);
+    static R _staticthunk(void*, void *func, A0 a0, A1 a1, A2 a2) {
+        return (*reinterpret_cast<R (**)(A0, A1, A2)>(func))
+                (a0, a1, a2);
     }
 
     template<typename T>
-    static R _boundthunk(void *obj, void *func, A0 a0, A1 a1) {
-        return (*reinterpret_cast<R (**)(T*, A0, A1)>(func))
-                (static_cast<T*>(obj), a0, a1);
+    static R _boundthunk(void *obj, void *func, A0 a0, A1 a1, A2 a2) {
+        return (*reinterpret_cast<R (**)(T*, A0, A1, A2)>(func))
+                (static_cast<T*>(obj), a0, a1, a2);
     }
 
     template<typename T>
-    static R _methodthunk(void *obj, void *func, A0 a0, A1 a1) {
+    static R _methodthunk(void *obj, void *func, A0 a0, A1 a1, A2 a2) {
         return (static_cast<T*>(obj)->*
-                (*reinterpret_cast<R (T::**)(A0, A1)>(func)))
-                (a0, a1);
+                (*reinterpret_cast<R (T::**)(A0, A1, A2)>(func)))
+                (a0, a1, a2);
     }
 
     // Stored as pointer to function and pointer to optional object
@@ -590,18 +590,18 @@ class Callback<R(A0, A1)> {
     void *_obj;
 
     // Thunk registered on attach to dispatch calls
-    R (*_thunk)(void*, void*, A0, A1); 
+    R (*_thunk)(void*, void*, A0, A1, A2);
 };
 
 /** Templated function class
  */
-template <typename R, typename A0>
-class Callback<R(A0)> {
+template <typename R, typename A0, typename A1, typename A2, typename A3>
+class Callback<R(A0, A1, A2, A3)> {
 public:
     /** Create a Callback with a static function
      *  @param func Static function to attach
      */
-    Callback(R (*func)(A0) = 0) {
+    Callback(R (*func)(A0, A1, A2, A3) = 0) {
         attach(func);
     }
 
@@ -610,7 +610,7 @@ class Callback<R(A0)> {
      *  @param func Static function to attach
      */
     template<typename T>
-    Callback(T *obj, R (*func)(T*, A0)) {
+    Callback(T *obj, R (*func)(T*, A0, A1, A2, A3)) {
         attach(obj, func);
     }
 
@@ -619,21 +619,21 @@ class Callback<R(A0)> {
      *  @param func Member function to attach
      */
     template<typename T>
-    Callback(T *obj, R (T::*func)(A0)) {
+    Callback(T *obj, R (T::*func)(A0, A1, A2, A3)) {
         attach(obj, func);
     }
 
     /** Create a Callback with another Callback
      *  @param func Callback to attach
      */
-    Callback(const Callback<R(A0)> &func) {
+    Callback(const Callback<R(A0, A1, A2, A3)> &func) {
         attach(func);
     }
 
     /** Attach a static function
      *  @param func Static function to attach
      */
-    void attach(R (*func)(A0)) {
+    void attach(R (*func)(A0, A1, A2, A3)) {
         memcpy(&_func, &func, sizeof func);
         _thunk = func ? &Callback::_staticthunk : 0;
     }
@@ -643,7 +643,7 @@ class Callback<R(A0)> {
      *  @param func Static function to attach
      */
     template <typename T>
-    void attach(T *obj, R (*func)(T*, A0)) {
+    void attach(T *obj, R (*func)(T*, A0, A1, A2, A3)) {
         _obj = (void*)obj;
         memcpy(&_func, &func, sizeof func);
         _thunk = &Callback::_boundthunk<T>;
@@ -654,7 +654,7 @@ class Callback<R(A0)> {
      *  @param func Member function to attach
      */
     template<typename T>
-    void attach(T *obj, R (T::*func)(A0)) {
+    void attach(T *obj, R (T::*func)(A0, A1, A2, A3)) {
         _obj = static_cast<void*>(obj);
         memcpy(&_func, &func, sizeof func);
         _thunk = &Callback::_methodthunk<T>;
@@ -663,7 +663,7 @@ class Callback<R(A0)> {
     /** Attach a Callback
      *  @param func The Callback to attach
      */
-    void attach(const Callback<R(A0)> &func) {
+    void attach(const Callback<R(A0, A1, A2, A3)> &func) {
         _obj = func._obj;
         memcpy(&_func, &func._func, sizeof _func);
         _thunk = func._thunk;
@@ -671,17 +671,17 @@ class Callback<R(A0)> {
 
     /** Call the attached function
      */
-    R call(A0 a0) {
+    R call(A0 a0, A1 a1, A2 a2, A3 a3) {
         if (!_thunk) {
             return (R)0;
         }
-        return _thunk(_obj, &_func, a0);
+        return _thunk(_obj, &_func, a0, a1, a2, a3);
     }
 
     /** Call the attached function
      */
-    R operator()(A0 a0) {
-        return call(a0);
+    R operator()(A0 a0, A1 a1, A2 a2, A3 a3) {
+        return call(a0, a1, a2, a3);
     }
 
     /** Test if function has been attached
@@ -693,29 +693,29 @@ class Callback<R(A0)> {
     /** Static thunk for passing as C-style function
      *  @param func Callback to call passed as void pointer
      */
-    static R thunk(void *func, A0 a0) {
-        return static_cast<Callback<R(A0)>*>(func)
-                ->call(a0);
+    static R thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3) {
+        return static_cast<Callback<R(A0, A1, A2, A3)>*>(func)
+                ->call(a0, a1, a2, a3);
     }
 
 private:
     // Internal thunks for various function types
-    static R _staticthunk(void*, void *func, A0 a0) {
-        return (*reinterpret_cast<R (**)(A0)>(func))
-                (a0);
+    static R _staticthunk(void*, void *func, A0 a0, A1 a1, A2 a2, A3 a3) {
+        return (*reinterpret_cast<R (**)(A0, A1, A2, A3)>(func))
+                (a0, a1, a2, a3);
     }
 
     template<typename T>
-    static R _boundthunk(void *obj, void *func, A0 a0) {
-        return (*reinterpret_cast<R (**)(T*, A0)>(func))
-                (static_cast<T*>(obj), a0);
+    static R _boundthunk(void *obj, void *func, A0 a0, A1 a1, A2 a2, A3 a3) {
+        return (*reinterpret_cast<R (**)(T*, A0, A1, A2, A3)>(func))
+                (static_cast<T*>(obj), a0, a1, a2, a3);
     }
 
     template<typename T>
-    static R _methodthunk(void *obj, void *func, A0 a0) {
+    static R _methodthunk(void *obj, void *func, A0 a0, A1 a1, A2 a2, A3 a3) {
         return (static_cast<T*>(obj)->*
-                (*reinterpret_cast<R (T::**)(A0)>(func)))
-                (a0);
+                (*reinterpret_cast<R (T::**)(A0, A1, A2, A3)>(func)))
+                (a0, a1, a2, a3);
     }
 
     // Stored as pointer to function and pointer to optional object
@@ -731,18 +731,18 @@ class Callback<R(A0)> {
     void *_obj;
 
     // Thunk registered on attach to dispatch calls
-    R (*_thunk)(void*, void*, A0); 
+    R (*_thunk)(void*, void*, A0, A1, A2, A3);
 };
 
 /** Templated function class
  */
-template <typename R>
-class Callback<R()> {
+template <typename R, typename A0, typename A1, typename A2, typename A3, typename A4>
+class Callback<R(A0, A1, A2, A3, A4)> {
 public:
     /** Create a Callback with a static function
      *  @param func Static function to attach
      */
-    Callback(R (*func)() = 0) {
+    Callback(R (*func)(A0, A1, A2, A3, A4) = 0) {
         attach(func);
     }
 
@@ -751,7 +751,7 @@ class Callback<R()> {
      *  @param func Static function to attach
      */
     template<typename T>
-    Callback(T *obj, R (*func)(T*)) {
+    Callback(T *obj, R (*func)(T*, A0, A1, A2, A3, A4)) {
         attach(obj, func);
     }
 
@@ -760,21 +760,21 @@ class Callback<R()> {
      *  @param func Member function to attach
      */
     template<typename T>
-    Callback(T *obj, R (T::*func)()) {
+    Callback(T *obj, R (T::*func)(A0, A1, A2, A3, A4)) {
         attach(obj, func);
     }
 
     /** Create a Callback with another Callback
      *  @param func Callback to attach
      */
-    Callback(const Callback<R()> &func) {
+    Callback(const Callback<R(A0, A1, A2, A3, A4)> &func) {
         attach(func);
     }
 
     /** Attach a static function
      *  @param func Static function to attach
      */
-    void attach(R (*func)()) {
+    void attach(R (*func)(A0, A1, A2, A3, A4)) {
         memcpy(&_func, &func, sizeof func);
         _thunk = func ? &Callback::_staticthunk : 0;
     }
@@ -784,7 +784,7 @@ class Callback<R()> {
      *  @param func Static function to attach
      */
     template <typename T>
-    void attach(T *obj, R (*func)(T*)) {
+    void attach(T *obj, R (*func)(T*, A0, A1, A2, A3, A4)) {
         _obj = (void*)obj;
         memcpy(&_func, &func, sizeof func);
         _thunk = &Callback::_boundthunk<T>;
@@ -795,7 +795,7 @@ class Callback<R()> {
      *  @param func Member function to attach
      */
     template<typename T>
-    void attach(T *obj, R (T::*func)()) {
+    void attach(T *obj, R (T::*func)(A0, A1, A2, A3, A4)) {
         _obj = static_cast<void*>(obj);
         memcpy(&_func, &func, sizeof func);
         _thunk = &Callback::_methodthunk<T>;
@@ -804,7 +804,7 @@ class Callback<R()> {
     /** Attach a Callback
      *  @param func The Callback to attach
      */
-    void attach(const Callback<R()> &func) {
+    void attach(const Callback<R(A0, A1, A2, A3, A4)> &func) {
         _obj = func._obj;
         memcpy(&_func, &func._func, sizeof _func);
         _thunk = func._thunk;
@@ -812,17 +812,17 @@ class Callback<R()> {
 
     /** Call the attached function
      */
-    R call() {
+    R call(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
         if (!_thunk) {
             return (R)0;
         }
-        return _thunk(_obj, &_func);
+        return _thunk(_obj, &_func, a0, a1, a2, a3, a4);
     }
 
     /** Call the attached function
      */
-    R operator()() {
-        return call();
+    R operator()(A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
+        return call(a0, a1, a2, a3, a4);
     }
 
     /** Test if function has been attached
@@ -834,29 +834,29 @@ class Callback<R()> {
     /** Static thunk for passing as C-style function
      *  @param func Callback to call passed as void pointer
      */
-    static R thunk(void *func) {
-        return static_cast<Callback<R()>*>(func)
-                ->call();
+    static R thunk(void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
+        return static_cast<Callback<R(A0, A1, A2, A3, A4)>*>(func)
+                ->call(a0, a1, a2, a3, a4);
     }
 
 private:
     // Internal thunks for various function types
-    static R _staticthunk(void*, void *func) {
-        return (*reinterpret_cast<R (**)()>(func))
-                ();
+    static R _staticthunk(void*, void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
+        return (*reinterpret_cast<R (**)(A0, A1, A2, A3, A4)>(func))
+                (a0, a1, a2, a3, a4);
     }
 
     template<typename T>
-    static R _boundthunk(void *obj, void *func) {
-        return (*reinterpret_cast<R (**)(T*)>(func))
-                (static_cast<T*>(obj));
+    static R _boundthunk(void *obj, void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
+        return (*reinterpret_cast<R (**)(T*, A0, A1, A2, A3, A4)>(func))
+                (static_cast<T*>(obj), a0, a1, a2, a3, a4);
     }
 
     template<typename T>
-    static R _methodthunk(void *obj, void *func) {
+    static R _methodthunk(void *obj, void *func, A0 a0, A1 a1, A2 a2, A3 a3, A4 a4) {
         return (static_cast<T*>(obj)->*
-                (*reinterpret_cast<R (T::**)()>(func)))
-                ();
+                (*reinterpret_cast<R (T::**)(A0, A1, A2, A3, A4)>(func)))
+                (a0, a1, a2, a3, a4);
     }
 
     // Stored as pointer to function and pointer to optional object
@@ -872,12 +872,12 @@ class Callback<R()> {
     void *_obj;
 
     // Thunk registered on attach to dispatch calls
-    R (*_thunk)(void*, void*); 
+    R (*_thunk)(void*, void*, A0, A1, A2, A3, A4);
 };
 
- typedef Callback<void(int)> event_callback_t;
+typedef Callback<void(int)> event_callback_t;
 
 
 } // namespace mbed
 
-#endif
+#endif
\ No newline at end of file
diff --git a/hal/api/Callback.j2 b/hal/api/Callback.j2
new file mode 100644
index 00000000000..0d1291c27b6
--- /dev/null
+++ b/hal/api/Callback.j2
@@ -0,0 +1,195 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2006-2015 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef MBED_CALLBACK_H
+#define MBED_CALLBACK_H
+
+#include <string.h>
+#include <stdint.h>
+
+namespace mbed {
+
+{%- set MBED_MAX_ARGS = 5 -%}
+
+{%- macro comma(n) -%}
+  {%- if n > 0 %}, {% endif -%}
+{%- endmacro -%}
+
+{%- macro va(format, n) -%}
+  {%- for i in range(n) -%}
+    {{ format.format(i) }}
+    {%- if not loop.last %}, {% endif -%}
+  {%- endfor -%}
+{%- endmacro %}
+
+
+/** Callback class based on template specialization
+ *
+ * @Note Synchronization level: Not protected
+ */
+template <typename F>
+class Callback;
+
+{% for n in range(MBED_MAX_ARGS+1) -%}
+
+/** Templated function class
+ */
+template <typename R{{comma(n) ~ va("typename A{0}", n)}}>
+class Callback<R({{va("A{0}", n)}})> {
+public:
+    /** Create a Callback with a static function
+     *  @param func Static function to attach
+     */
+    Callback(R (*func)({{va("A{0}", n)}}) = 0) {
+        attach(func);
+    }
+
+    /** Create a Callback with a static function and bound pointer
+     *  @param obj  Pointer to object to bind to function
+     *  @param func Static function to attach
+     */
+    template<typename T>
+    Callback(T *obj, R (*func)(T*{{comma(n) ~ va("A{0}", n)}})) {
+        attach(obj, func);
+    }
+
+    /** Create a Callback with a member function
+     *  @param obj  Pointer to object to invoke member function on
+     *  @param func Member function to attach
+     */
+    template<typename T>
+    Callback(T *obj, R (T::*func)({{va("A{0}", n)}})) {
+        attach(obj, func);
+    }
+
+    /** Create a Callback with another Callback
+     *  @param func Callback to attach
+     */
+    Callback(const Callback<R({{va("A{0}", n)}})> &func) {
+        attach(func);
+    }
+
+    /** Attach a static function
+     *  @param func Static function to attach
+     */
+    void attach(R (*func)({{va("A{0}", n)}})) {
+        memcpy(&_func, &func, sizeof func);
+        _thunk = func ? &Callback::_staticthunk : 0;
+    }
+
+    /** Attach a static function with a bound pointer
+     *  @param obj  Pointer to object to bind to function
+     *  @param func Static function to attach
+     */
+    template <typename T>
+    void attach(T *obj, R (*func)(T*{{comma(n) ~ va("A{0}", n)}})) {
+        _obj = (void*)obj;
+        memcpy(&_func, &func, sizeof func);
+        _thunk = &Callback::_boundthunk<T>;
+    }
+
+    /** Attach a member function
+     *  @param obj  Pointer to object to invoke member function on
+     *  @param func Member function to attach
+     */
+    template<typename T>
+    void attach(T *obj, R (T::*func)({{va("A{0}", n)}})) {
+        _obj = static_cast<void*>(obj);
+        memcpy(&_func, &func, sizeof func);
+        _thunk = &Callback::_methodthunk<T>;
+    }
+
+    /** Attach a Callback
+     *  @param func The Callback to attach
+     */
+    void attach(const Callback<R({{va("A{0}", n)}})> &func) {
+        _obj = func._obj;
+        memcpy(&_func, &func._func, sizeof _func);
+        _thunk = func._thunk;
+    }
+
+    /** Call the attached function
+     */
+    R call({{va("A{0} a{0}", n)}}) {
+        if (!_thunk) {
+            return (R)0;
+        }
+        return _thunk(_obj, &_func{{comma(n) ~ va("a{0}", n)}});
+    }
+
+    /** Call the attached function
+     */
+    R operator()({{va("A{0} a{0}", n)}}) {
+        return call({{va("a{0}", n)}});
+    }
+
+    /** Test if function has been attached
+     */
+    operator bool() const {
+        return _thunk;
+    }
+
+    /** Static thunk for passing as C-style function
+     *  @param func Callback to call passed as void pointer
+     */
+    static R thunk(void *func{{comma(n) ~ va("A{0} a{0}", n)}}) {
+        return static_cast<Callback<R({{va("A{0}", n)}})>*>(func)
+                ->call({{va("a{0}", n)}});
+    }
+
+private:
+    // Internal thunks for various function types
+    static R _staticthunk(void*, void *func{{comma(n) ~ va("A{0} a{0}", n)}}) {
+        return (*reinterpret_cast<R (**)({{va("A{0}", n)}})>(func))
+                ({{va("a{0}", n)}});
+    }
+
+    template<typename T>
+    static R _boundthunk(void *obj, void *func{{comma(n) ~ va("A{0} a{0}", n)}}) {
+        return (*reinterpret_cast<R (**)(T*{{comma(n) ~ va("A{0}", n)}})>(func))
+                (static_cast<T*>(obj){{comma(n) ~ va("a{0}", n)}});
+    }
+
+    template<typename T>
+    static R _methodthunk(void *obj, void *func{{comma(n) ~ va("A{0} a{0}", n)}}) {
+        return (static_cast<T*>(obj)->*
+                (*reinterpret_cast<R (T::**)({{va("A{0}", n)}})>(func)))
+                ({{va("a{0}", n)}});
+    }
+
+    // Stored as pointer to function and pointer to optional object
+    // Function pointer is stored as union of possible function types
+    // to garuntee proper size and alignment
+    struct _class;
+    union {
+        void (*_staticfunc)();
+        void (*_boundfunc)(_class *);
+        void (_class::*_methodfunc)();
+    } _func;
+
+    void *_obj;
+
+    // Thunk registered on attach to dispatch calls
+    R (*_thunk)(void*, void*{{comma(n) ~ va("A{0}", n)}});
+};
+
+{% endfor -%}
+
+typedef Callback<void(int)> event_callback_t;
+
+
+} // namespace mbed
+
+#endif