diff --git a/transport/include/hidl/LegacySupport.h b/transport/include/hidl/LegacySupport.h
index fdc5a48..7cb72a9 100644
--- a/transport/include/hidl/LegacySupport.h
+++ b/transport/include/hidl/LegacySupport.h
@@ -26,9 +26,12 @@
 namespace android {
 namespace hardware {
 namespace details {
-template <class Interface, typename Func>
+template <typename Interface>
+using RegisterServiceCb = std::function<status_t(const sp<Interface>&, const std::string&)>;
+
+template <class Interface, class ExpectInterface = Interface>
 __attribute__((warn_unused_result)) status_t registerPassthroughServiceImplementation(
-    Func registerServiceCb, const std::string& name = "default") {
+        RegisterServiceCb<Interface> registerServiceCb, const std::string& name = "default") {
     sp<Interface> service = Interface::getService(name, true /* getStub */);
 
     if (service == nullptr) {
@@ -40,6 +43,10 @@
     LOG_FATAL_IF(service->isRemote(), "Implementation of %s/%s is remote!",
             Interface::descriptor, name.c_str());
 
+    sp<ExpectInterface> expected = ExpectInterface::castFrom(service);
+    LOG_FATAL_IF(expected == nullptr, "Implementation of %s/%s is not a %s!", Interface::descriptor,
+                 name.c_str(), ExpectInterface::descriptor);
+
     status_t status = registerServiceCb(service, name);
 
     if (status == OK) {
@@ -57,14 +64,14 @@
 /**
  * Registers passthrough service implementation.
  */
-template <class Interface>
+template <class Interface, class ExpectInterface = Interface>
 __attribute__((warn_unused_result)) status_t registerPassthroughServiceImplementation(
-    const std::string& name = "default") {
-    return details::registerPassthroughServiceImplementation<Interface>(
-        [](const sp<Interface>& service, const std::string& name) {
-            return service->registerAsService(name);
-        },
-        name);
+        const std::string& name = "default") {
+    return details::registerPassthroughServiceImplementation<Interface, ExpectInterface>(
+            [](const sp<Interface>& service, const std::string& name) {
+                return service->registerAsService(name);
+            },
+            name);
 }
 
 /**
@@ -72,11 +79,11 @@
  *
  * Return value is exit status.
  */
-template <class Interface>
+template <class Interface, class ExpectInterface = Interface>
 __attribute__((warn_unused_result)) status_t defaultPassthroughServiceImplementation(
-    const std::string& name, size_t maxThreads = 1) {
+        const std::string& name, size_t maxThreads = 1) {
     configureRpcThreadpool(maxThreads, true);
-    status_t result = registerPassthroughServiceImplementation<Interface>(name);
+    status_t result = registerPassthroughServiceImplementation<Interface, ExpectInterface>(name);
 
     if (result != OK) {
         return result;
@@ -85,10 +92,11 @@
     joinRpcThreadpool();
     return UNKNOWN_ERROR;
 }
-template<class Interface>
-__attribute__((warn_unused_result))
-status_t defaultPassthroughServiceImplementation(size_t maxThreads = 1) {
-    return defaultPassthroughServiceImplementation<Interface>("default", maxThreads);
+template <class Interface, class ExpectInterface = Interface>
+__attribute__((warn_unused_result)) status_t defaultPassthroughServiceImplementation(
+        size_t maxThreads = 1) {
+    return defaultPassthroughServiceImplementation<Interface, ExpectInterface>("default",
+                                                                               maxThreads);
 }
 
 /**
@@ -99,10 +107,10 @@
  * through registerPassthroughServiceImplementation, so if that function is used in conjunction with
  * this one, the process may exit while a client is still using the HAL.
  */
-template <class Interface>
+template <class Interface, class ExpectInterface = Interface>
 __attribute__((warn_unused_result)) status_t registerLazyPassthroughServiceImplementation(
-    const std::string& name = "default") {
-    return details::registerPassthroughServiceImplementation<Interface>(
+        const std::string& name = "default") {
+    return details::registerPassthroughServiceImplementation<Interface, ExpectInterface>(
             [](const sp<Interface>& service, const std::string& name) {
                 using android::hardware::LazyServiceRegistrar;
                 return LazyServiceRegistrar::getInstance().registerService(service, name);
@@ -116,11 +124,12 @@
  *
  * Return value is exit status.
  */
-template <class Interface>
+template <class Interface, class ExpectInterface = Interface>
 __attribute__((warn_unused_result)) status_t defaultLazyPassthroughServiceImplementation(
-    const std::string& name, size_t maxThreads = 1) {
+        const std::string& name, size_t maxThreads = 1) {
     configureRpcThreadpool(maxThreads, true);
-    status_t result = registerLazyPassthroughServiceImplementation<Interface>(name);
+    status_t result =
+            registerLazyPassthroughServiceImplementation<Interface, ExpectInterface>(name);
 
     if (result != OK) {
         return result;
@@ -129,10 +138,11 @@
     joinRpcThreadpool();
     return UNKNOWN_ERROR;
 }
-template <class Interface>
+template <class Interface, class ExpectInterface = Interface>
 __attribute__((warn_unused_result)) status_t defaultLazyPassthroughServiceImplementation(
-    size_t maxThreads = 1) {
-    return defaultLazyPassthroughServiceImplementation<Interface>("default", maxThreads);
+        size_t maxThreads = 1) {
+    return defaultLazyPassthroughServiceImplementation<Interface, ExpectInterface>("default",
+                                                                                   maxThreads);
 }
 
 }  // namespace hardware