diff --git a/keystore/keystore.cpp b/keystore/keystore.cpp
index f00fa6f..194b87c 100644
--- a/keystore/keystore.cpp
+++ b/keystore/keystore.cpp
@@ -41,7 +41,7 @@
 #include <openssl/md5.h>
 #include <openssl/pem.h>
 
-#include <hardware/keymaster.h>
+#include <hardware/keymaster0.h>
 
 #include <keymaster/softkeymaster.h>
 
@@ -103,7 +103,7 @@
 typedef UniquePtr<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_Delete> Unique_PKCS8_PRIV_KEY_INFO;
 
 
-static int keymaster_device_initialize(keymaster_device_t** dev) {
+static int keymaster_device_initialize(keymaster0_device_t** dev) {
     int rc;
 
     const hw_module_t* mod;
@@ -113,7 +113,7 @@
         goto out;
     }
 
-    rc = keymaster_open(mod, dev);
+    rc = keymaster0_open(mod, dev);
     if (rc) {
         ALOGE("could not open keymaster device in %s (%s)",
             KEYSTORE_HARDWARE_MODULE_ID, strerror(-rc));
@@ -127,7 +127,7 @@
     return rc;
 }
 
-static int fallback_keymaster_device_initialize(keymaster_device_t** dev) {
+static int fallback_keymaster_device_initialize(keymaster0_device_t** dev) {
     int rc;
     rc = openssl_open(reinterpret_cast<hw_module_t*>(&softkeymaster_module),
                       KEYSTORE_KEYMASTER,
@@ -143,8 +143,8 @@
     return rc;
 }
 
-static void keymaster_device_release(keymaster_device_t* dev) {
-    keymaster_close(dev);
+static void keymaster_device_release(keymaster0_device_t* dev) {
+    keymaster0_close(dev);
 }
 
 /***************
@@ -961,7 +961,7 @@
 
 class KeyStore {
 public:
-    KeyStore(Entropy* entropy, keymaster_device_t* device, keymaster_device_t* fallback)
+    KeyStore(Entropy* entropy, keymaster0_device_t* device, keymaster0_device_t* fallback)
         : mEntropy(entropy)
         , mDevice(device)
         , mFallbackDevice(fallback)
@@ -983,15 +983,15 @@
         mMasterKeys.clear();
     }
 
-    keymaster_device_t *getDevice() const {
+    keymaster0_device_t *getDevice() const {
         return mDevice;
     }
 
-    keymaster_device_t *getFallbackDevice() const {
+    keymaster0_device_t *getFallbackDevice() const {
         return mFallbackDevice;
     }
 
-    keymaster_device_t *getDeviceForBlob(const Blob& blob) const {
+    keymaster0_device_t *getDeviceForBlob(const Blob& blob) const {
         return blob.isFallback() ? mFallbackDevice: mDevice;
     }
 
@@ -1389,8 +1389,8 @@
     static const android::String16 sRSAKeyType;
     Entropy* mEntropy;
 
-    keymaster_device_t* mDevice;
-    keymaster_device_t* mFallbackDevice;
+    keymaster0_device_t* mDevice;
+    keymaster0_device_t* mFallbackDevice;
 
     android::Vector<UserState*> mMasterKeys;
 
@@ -1869,8 +1869,8 @@
         int rc;
         bool isFallback = false;
 
-        const keymaster_device_t* device = mKeyStore->getDevice();
-        const keymaster_device_t* fallback = mKeyStore->getFallbackDevice();
+        const keymaster0_device_t* device = mKeyStore->getDevice();
+        const keymaster0_device_t* fallback = mKeyStore->getFallbackDevice();
         if (device == NULL) {
             return ::SYSTEM_ERROR;
         }
@@ -2045,7 +2045,7 @@
             return responseCode;
         }
 
-        const keymaster_device_t* device = mKeyStore->getDeviceForBlob(keyBlob);
+        const keymaster0_device_t* device = mKeyStore->getDeviceForBlob(keyBlob);
         if (device == NULL) {
             ALOGE("no keymaster device; cannot sign");
             return ::SYSTEM_ERROR;
@@ -2094,7 +2094,7 @@
             return responseCode;
         }
 
-        const keymaster_device_t* device = mKeyStore->getDeviceForBlob(keyBlob);
+        const keymaster0_device_t* device = mKeyStore->getDeviceForBlob(keyBlob);
         if (device == NULL) {
             return ::SYSTEM_ERROR;
         }
@@ -2146,7 +2146,7 @@
             return responseCode;
         }
 
-        const keymaster_device_t* device = mKeyStore->getDeviceForBlob(keyBlob);
+        const keymaster0_device_t* device = mKeyStore->getDeviceForBlob(keyBlob);
         if (device == NULL) {
             return ::SYSTEM_ERROR;
         }
@@ -2347,7 +2347,7 @@
             return ::PERMISSION_DENIED;
         }
 
-        const keymaster_device_t* device = mKeyStore->getDevice();
+        const keymaster0_device_t* device = mKeyStore->getDevice();
         if (device == NULL) {
             ALOGW("can't get keymaster device");
             return ::SYSTEM_ERROR;
@@ -2445,7 +2445,7 @@
         return false;
     }
 
-    bool isKeyTypeSupported(const keymaster_device_t* device, keymaster_keypair_t keyType) {
+    bool isKeyTypeSupported(const keymaster0_device_t* device, keymaster_keypair_t keyType) {
         const int32_t device_api = device->common.module->module_api_version;
         if (device_api == KEYMASTER_MODULE_API_VERSION_0_2) {
             switch (keyType) {
@@ -2492,13 +2492,13 @@
         return 1;
     }
 
-    keymaster_device_t* dev;
+    keymaster0_device_t* dev;
     if (keymaster_device_initialize(&dev)) {
         ALOGE("keystore keymaster could not be initialized; exiting");
         return 1;
     }
 
-    keymaster_device_t* fallback;
+    keymaster0_device_t* fallback;
     if (fallback_keymaster_device_initialize(&fallback)) {
         ALOGE("software keymaster could not be initialized; exiting");
         return 1;