Index: uspace/lib/drv/generic/remote_usbhc.c
===================================================================
--- uspace/lib/drv/generic/remote_usbhc.c	(revision 3be9d10120f7923a0b3d52282b8de0b670566c71)
+++ uspace/lib/drv/generic/remote_usbhc.c	(revision a46e56be16ae82f0d007dd26c68b250f3f725ae0)
@@ -232,5 +232,5 @@
 static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
 static void remote_usbhc_unregister_endpoint(ddf_fun_t *, void *, cap_call_handle_t, ipc_call_t *);
-static void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call);
+static void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call);
 
 /** Remote USB interface operations. */
@@ -257,10 +257,10 @@
 
 void remote_usbhc_default_address_reservation(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
 
 	if (usbhc_iface->default_address_reservation == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -268,15 +268,15 @@
 	const bool reserve = IPC_GET_ARG2(*call);
 	const errno_t ret = usbhc_iface->default_address_reservation(fun, reserve);
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 
 static void remote_usbhc_device_enumerate(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
 
 	if (usbhc_iface->device_enumerate == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -285,14 +285,14 @@
 	usb_speed_t speed = DEV_IPC_GET_ARG2(*call);
 	const errno_t ret = usbhc_iface->device_enumerate(fun, port, speed);
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 static void remote_usbhc_device_remove(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	const usbhc_iface_t *usbhc_iface = (usbhc_iface_t *) iface;
 
 	if (usbhc_iface->device_remove == NULL) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
@@ -300,9 +300,9 @@
 	const unsigned port = DEV_IPC_GET_ARG1(*call);
 	const errno_t ret = usbhc_iface->device_remove(fun, port);
-	async_answer_0(callid, ret);
+	async_answer_0(chandle, ret);
 }
 
 static void remote_usbhc_register_endpoint(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(fun);
@@ -313,33 +313,33 @@
 
 	if (!usbhc_iface->register_endpoint) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	usb_endpoint_descriptors_t ep_desc;
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 	size_t len;
 
-	if (!async_data_write_receive(&data_callid, &len)
+	if (!async_data_write_receive(&data_chandle, &len)
 	    || len != sizeof(ep_desc)) {
-		async_answer_0(callid, EINVAL);
-		return;
-	}
-	async_data_write_finalize(data_callid, &ep_desc, sizeof(ep_desc));
+		async_answer_0(chandle, EINVAL);
+		return;
+	}
+	async_data_write_finalize(data_chandle, &ep_desc, sizeof(ep_desc));
 
 	usb_pipe_desc_t pipe_desc;
 
 	const errno_t rc = usbhc_iface->register_endpoint(fun, &pipe_desc, &ep_desc);
-	async_answer_0(callid, rc);
-
-	if (!async_data_read_receive(&data_callid, &len)
+	async_answer_0(chandle, rc);
+
+	if (!async_data_read_receive(&data_chandle, &len)
 	    || len != sizeof(pipe_desc)) {
 		return;
 	}
-	async_data_read_finalize(data_callid, &pipe_desc, sizeof(pipe_desc));
+	async_data_read_finalize(data_chandle, &pipe_desc, sizeof(pipe_desc));
 }
 
 static void remote_usbhc_unregister_endpoint(ddf_fun_t *fun, void *iface,
-    cap_call_handle_t callid, ipc_call_t *call)
+    cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(fun);
@@ -350,21 +350,21 @@
 
 	if (!usbhc_iface->unregister_endpoint) {
-		async_answer_0(callid, ENOTSUP);
+		async_answer_0(chandle, ENOTSUP);
 		return;
 	}
 
 	usb_pipe_desc_t pipe_desc;
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 	size_t len;
 
-	if (!async_data_write_receive(&data_callid, &len)
+	if (!async_data_write_receive(&data_chandle, &len)
 	    || len != sizeof(pipe_desc)) {
-		async_answer_0(callid, EINVAL);
-		return;
-	}
-	async_data_write_finalize(data_callid, &pipe_desc, sizeof(pipe_desc));
+		async_answer_0(chandle, EINVAL);
+		return;
+	}
+	async_data_write_finalize(data_chandle, &pipe_desc, sizeof(pipe_desc));
 
 	const errno_t rc = usbhc_iface->unregister_endpoint(fun, &pipe_desc);
-	async_answer_0(callid, rc);
+	async_answer_0(chandle, rc);
 }
 
@@ -410,17 +410,17 @@
 
 	errno_t err;
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 	size_t size;
 	unsigned flags;
 
-	if (!async_share_out_receive(&data_callid, &size, &flags))
+	if (!async_share_out_receive(&data_chandle, &size, &flags))
 		return EPARTY;
 
 	if (size < required_size || (flags & required_flags) != required_flags) {
-		async_answer_0(data_callid, EINVAL);
+		async_answer_0(data_chandle, EINVAL);
 		return EINVAL;
 	}
 
-	if ((err = async_share_out_finalize(data_callid, &trans->request.buffer.virt)))
+	if ((err = async_share_out_finalize(data_chandle, &trans->request.buffer.virt)))
 		return err;
 
@@ -445,5 +445,5 @@
 }
 
-void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t callid, ipc_call_t *call)
+void remote_usbhc_transfer(ddf_fun_t *fun, void *iface, cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(fun);
@@ -454,11 +454,11 @@
 
 	if (!usbhc_iface->transfer) {
-		async_answer_0(callid, ENOTSUP);
-		return;
-	}
-
-	async_transaction_t *trans = async_transaction_create(callid);
+		async_answer_0(chandle, ENOTSUP);
+		return;
+	}
+
+	async_transaction_t *trans = async_transaction_create(chandle);
 	if (trans == NULL) {
-		async_answer_0(callid, ENOMEM);
+		async_answer_0(chandle, ENOMEM);
 		return;
 	}
@@ -466,13 +466,13 @@
 	errno_t err = EPARTY;
 
-	cap_call_handle_t data_callid;
+	cap_call_handle_t data_chandle;
 	size_t len;
-	if (!async_data_write_receive(&data_callid, &len)
+	if (!async_data_write_receive(&data_chandle, &len)
 	    || len != sizeof(trans->request)) {
-		async_answer_0(data_callid, EINVAL);
+		async_answer_0(data_chandle, EINVAL);
 		goto err;
 	}
 
-	if ((err = async_data_write_finalize(data_callid,
+	if ((err = async_data_write_finalize(data_chandle,
 			    &trans->request, sizeof(trans->request))))
 		goto err;
@@ -494,5 +494,5 @@
 
 err:
-	async_answer_0(callid, err);
+	async_answer_0(chandle, err);
 	async_transaction_destroy(trans);
 }
