diff --git a/driver/linux b/driver/linux
index b722f95..bb7ae41 160000
--- a/driver/linux
+++ b/driver/linux
@@ -1 +1 @@
-Subproject commit b722f95ee1dfd26dc4d54628aa343170a7d3b2de
+Subproject commit bb7ae41a9456dc4e051468e61320cac0d5248f87
diff --git a/inc/hf/api.h b/inc/hf/api.h
index 42c371b..a936558 100644
--- a/inc/hf/api.h
+++ b/inc/hf/api.h
@@ -3,15 +3,15 @@
 #include "hf/cpu.h"
 #include "hf/vm.h"
 
-int32_t api_vm_get_count(void);
-int32_t api_vcpu_get_count(uint32_t vm_id);
-int32_t api_vcpu_run(uint32_t vm_id, uint32_t vcpu_idx, struct vcpu **next);
-int32_t api_vm_configure(ipaddr_t send, ipaddr_t recv);
+int64_t api_vm_get_count(void);
+int64_t api_vcpu_get_count(uint32_t vm_id);
+int64_t api_vcpu_run(uint32_t vm_id, uint32_t vcpu_idx, struct vcpu **next);
+int64_t api_vm_configure(ipaddr_t send, ipaddr_t recv);
 
-int32_t api_rpc_request(uint32_t vm_id, size_t size);
-int32_t api_rpc_read_request(bool block, struct vcpu **next);
-int32_t api_rpc_reply(size_t size, bool ack, struct vcpu **next);
-int32_t api_rpc_ack(void);
+int64_t api_rpc_request(uint32_t vm_id, size_t size);
+int64_t api_rpc_read_request(bool block, struct vcpu **next);
+int64_t api_rpc_reply(size_t size, bool ack, struct vcpu **next);
+int64_t api_rpc_ack(void);
 
 struct vcpu *api_wait_for_interrupt(void);
 struct vcpu *api_yield(void);
diff --git a/inc/vmapi/hf/call.h b/inc/vmapi/hf/call.h
index 418f0c0..0650868 100644
--- a/inc/vmapi/hf/call.h
+++ b/inc/vmapi/hf/call.h
@@ -51,12 +51,12 @@
  * This function must be implemented to trigger the architecture specific
  * mechanism to call to the hypervisor.
  */
-size_t hf_call(size_t arg0, size_t arg1, size_t arg2, size_t arg3);
+int64_t hf_call(size_t arg0, size_t arg1, size_t arg2, size_t arg3);
 
 /**
  * Runs the given vcpu of the given vm.
  */
-static inline int32_t hf_vcpu_run(uint32_t vm_id, uint32_t vcpu_idx)
+static inline int64_t hf_vcpu_run(uint32_t vm_id, uint32_t vcpu_idx)
 {
 	return hf_call(HF_VCPU_RUN, vm_id, vcpu_idx, 0);
 }
@@ -64,7 +64,7 @@
 /**
  * Returns the number of secondary VMs.
  */
-static inline int32_t hf_vm_get_count(void)
+static inline int64_t hf_vm_get_count(void)
 {
 	return hf_call(HF_VM_GET_COUNT, 0, 0, 0);
 }
@@ -72,7 +72,7 @@
 /**
  * Returns the number of VCPUs configured in the given secondary VM.
  */
-static inline int32_t hf_vcpu_get_count(uint32_t vm_id)
+static inline int64_t hf_vcpu_get_count(uint32_t vm_id)
 {
 	return hf_call(HF_VCPU_GET_COUNT, vm_id, 0, 0);
 }
@@ -81,7 +81,7 @@
  * Configures the pages to send/receive data through. The pages must not be
  * shared.
  */
-static inline int32_t hf_vm_configure(hf_ipaddr_t send, hf_ipaddr_t recv)
+static inline int64_t hf_vm_configure(hf_ipaddr_t send, hf_ipaddr_t recv)
 {
 	return hf_call(HF_VM_CONFIGURE, send, recv, 0);
 }
@@ -90,7 +90,7 @@
  * Called by the primary VM to send an RPC request to a secondary VM. Data is
  * copied from the caller's send buffer to the destination's receive buffer.
  */
-static inline int32_t hf_rpc_request(uint32_t vm_id, size_t size)
+static inline int64_t hf_rpc_request(uint32_t vm_id, size_t size)
 {
 	return hf_call(HF_RPC_REQUEST, vm_id, size, 0);
 }
@@ -104,7 +104,7 @@
  * either calling api_rpc_reply or api_rpc_ack. No new requests can be accepted
  * until the current one is acknowledged.
  */
-static inline int32_t hf_rpc_read_request(bool block)
+static inline int64_t hf_rpc_read_request(bool block)
 {
 	return hf_call(HF_RPC_READ_REQUEST, block, 0, 0);
 }
@@ -114,7 +114,7 @@
  * After this call completes, the caller will be able to receive additional
  * requests or replies.
  */
-static inline int32_t hf_rpc_ack(void)
+static inline int64_t hf_rpc_ack(void)
 {
 	return hf_call(HF_RPC_ACK, 0, 0, 0);
 }
@@ -125,7 +125,7 @@
  *
  * It can optionally acknowledge the pending request.
  */
-static inline int32_t hf_rpc_reply(size_t size, bool ack)
+static inline int64_t hf_rpc_reply(size_t size, bool ack)
 {
 	return hf_call(HF_RPC_REPLY, size, ack, 0);
 }
diff --git a/src/api.c b/src/api.c
index 6b9e37c..11a2632 100644
--- a/src/api.c
+++ b/src/api.c
@@ -41,7 +41,7 @@
 /**
  * Returns the number of VMs configured to run.
  */
-int32_t api_vm_get_count(void)
+int64_t api_vm_get_count(void)
 {
 	return vm_get_count();
 }
@@ -49,7 +49,7 @@
 /**
  * Returns the number of vcpus configured in the given VM.
  */
-int32_t api_vcpu_get_count(uint32_t vm_id)
+int64_t api_vcpu_get_count(uint32_t vm_id)
 {
 	struct vm *vm;
 
@@ -69,11 +69,11 @@
 /**
  * Runs the given vcpu of the given vm.
  */
-int32_t api_vcpu_run(uint32_t vm_id, uint32_t vcpu_idx, struct vcpu **next)
+int64_t api_vcpu_run(uint32_t vm_id, uint32_t vcpu_idx, struct vcpu **next)
 {
 	struct vm *vm;
 	struct vcpu *vcpu;
-	int32_t ret;
+	int64_t ret;
 
 	/* Only the primary VM can switch vcpus. */
 	if (cpu()->current->vm->id != HF_PRIMARY_VM_ID) {
@@ -119,14 +119,14 @@
  * Configures the VM to send/receive data through the specified pages. The pages
  * must not be shared.
  */
-int32_t api_vm_configure(ipaddr_t send, ipaddr_t recv)
+int64_t api_vm_configure(ipaddr_t send, ipaddr_t recv)
 {
 	struct vm *vm = cpu()->current->vm;
 	paddr_t pa_send_begin;
 	paddr_t pa_send_end;
 	paddr_t pa_recv_begin;
 	paddr_t pa_recv_end;
-	int32_t ret;
+	int64_t ret;
 
 	/* Fail if addresses are not page-aligned. */
 	if ((ipa_addr(send) & (PAGE_SIZE - 1)) ||
@@ -199,12 +199,12 @@
  * Sends an RPC request from the primary VM to a secondary VM. Data is copied
  * from the caller's send buffer to the destination's receive buffer.
  */
-int32_t api_rpc_request(uint32_t vm_id, size_t size)
+int64_t api_rpc_request(uint32_t vm_id, size_t size)
 {
 	struct vm *from = cpu()->current->vm;
 	struct vm *to;
 	const void *from_buf;
-	int32_t ret;
+	int64_t ret;
 
 	/* Basic argument validation. */
 	if (size > HF_RPC_REQUEST_MAX_SIZE) {
@@ -285,12 +285,12 @@
  * either calling api_rpc_reply or api_rpc_ack. No new requests can be accepted
  * until the current one is acknowledged.
  */
-int32_t api_rpc_read_request(bool block, struct vcpu **next)
+int64_t api_rpc_read_request(bool block, struct vcpu **next)
 {
 	struct vcpu *vcpu = cpu()->current;
 	struct vm *vm = vcpu->vm;
 	struct vm *primary = vm_get(HF_PRIMARY_VM_ID);
-	int32_t ret;
+	int64_t ret;
 
 	/* Only the secondary VMs can receive calls. */
 	if (vm->id == HF_PRIMARY_VM_ID) {
@@ -337,7 +337,7 @@
  *
  * It can optionally acknowledge the pending request.
  */
-int32_t api_rpc_reply(size_t size, bool ack, struct vcpu **next)
+int64_t api_rpc_reply(size_t size, bool ack, struct vcpu **next)
 {
 	struct vm *from = cpu()->current->vm;
 	struct vm *to;
@@ -404,10 +404,10 @@
  * After this call completes, the caller will be able to receive additional
  * requests or replies.
  */
-int32_t api_rpc_ack(void)
+int64_t api_rpc_ack(void)
 {
 	struct vm *vm = cpu()->current->vm;
-	int32_t ret;
+	int64_t ret;
 
 	sl_lock(&vm->lock);
 	if (vm->rpc.state != rpc_state_inflight) {
diff --git a/src/arch/aarch64/handler.c b/src/arch/aarch64/handler.c
index 88aaf38..b982bf9 100644
--- a/src/arch/aarch64/handler.c
+++ b/src/arch/aarch64/handler.c
@@ -9,7 +9,7 @@
 #include "psci.h"
 
 struct hvc_handler_return {
-	long user_ret;
+	uint64_t user_ret;
 	struct vcpu *new;
 };
 
@@ -62,7 +62,7 @@
  * Returns true if the request was a PSCI one, false otherwise.
  */
 static bool psci_handler(uint32_t func, size_t arg0, size_t arg1, size_t arg2,
-			 long *ret)
+			 int32_t *ret)
 {
 	struct cpu *c;
 	int32_t sret;
@@ -164,9 +164,12 @@
 
 	ret.new = NULL;
 
-	if (cpu()->current->vm->id == HF_PRIMARY_VM_ID &&
-	    psci_handler(arg0, arg1, arg2, arg3, &ret.user_ret)) {
-		return ret;
+	if (cpu()->current->vm->id == HF_PRIMARY_VM_ID) {
+		int32_t psci_ret;
+		if (psci_handler(arg0, arg1, arg2, arg3, &psci_ret)) {
+			ret.user_ret = psci_ret;
+			return ret;
+		}
 	}
 
 	switch ((uint32_t)arg0 & ~PSCI_CONVENTION_MASK) {
@@ -221,7 +224,7 @@
 {
 	struct cpu *c = cpu();
 	struct vcpu *vcpu = c->current;
-	long ret;
+	int32_t ret;
 
 	switch (esr >> 26) {
 	case 0x01: /* EC = 000001, WFI or WFE. */