Index: uspace/drv/ohci/batch.c
===================================================================
--- uspace/drv/ohci/batch.c	(revision f13381bd14495597fae48bb54d6208b12ba4190d)
+++ uspace/drv/ohci/batch.c	(revision d017cea07b4e7cb0a582e6b399e54debc2523481)
@@ -73,9 +73,6 @@
 	CHECK_NULL_DISPOSE_RETURN(instance,
 	    "Failed to allocate batch instance.\n");
-	usb_target_t target =
-	    { .address = ep->address, .endpoint = ep->endpoint };
-	usb_transfer_batch_init(instance, target, ep->transfer_type, ep->speed,
-	    ep->max_packet_size, buffer, NULL, buffer_size, NULL, setup_size,
-	    func_in, func_out, arg, fun, ep, NULL);
+	usb_transfer_batch_init(instance, ep, buffer, NULL, buffer_size,
+	    NULL, setup_size, func_in, func_out, arg, fun, NULL);
 
 	ohci_batch_t *data = malloc(sizeof(ohci_batch_t));
@@ -101,6 +98,6 @@
 
         if (buffer_size > 0) {
-                instance->transport_buffer = malloc32(buffer_size);
-                CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
+                instance->data_buffer = malloc32(buffer_size);
+                CHECK_NULL_DISPOSE_RETURN(instance->data_buffer,
                     "Failed to allocate device accessible buffer.\n");
         }
@@ -124,5 +121,5 @@
 	free32(data->tds);
 	free32(instance->setup_buffer);
-	free32(instance->transport_buffer);
+	free32(instance->data_buffer);
 	free(data);
 	free(instance);
@@ -165,6 +162,5 @@
 	assert(instance);
 	/* We are data out, we are supposed to provide data */
-	memcpy(instance->transport_buffer, instance->buffer,
-	    instance->buffer_size);
+	memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
 	instance->next_step = batch_call_out_and_dispose;
 	batch_control(instance, USB_DIRECTION_OUT, USB_DIRECTION_IN);
@@ -183,5 +179,4 @@
 {
 	assert(instance);
-	assert(instance->direction == USB_DIRECTION_IN);
 	instance->next_step = batch_call_in_and_dispose;
 	batch_data(instance);
@@ -192,8 +187,6 @@
 {
 	assert(instance);
-	assert(instance->direction == USB_DIRECTION_OUT);
 	/* We are data out, we are supposed to provide data */
-	memcpy(instance->transport_buffer, instance->buffer,
-	    instance->buffer_size);
+	memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
 	instance->next_step = batch_call_out_and_dispose;
 	batch_data(instance);
@@ -204,5 +197,4 @@
 {
 	assert(instance);
-	instance->direction = USB_DIRECTION_IN;
 	instance->next_step = batch_call_in_and_dispose;
 	batch_data(instance);
@@ -213,5 +205,4 @@
 {
 	assert(instance);
-	instance->direction = USB_DIRECTION_IN;
 	instance->next_step = batch_call_in_and_dispose;
 	batch_data(instance);
@@ -249,5 +240,5 @@
 	size_t td_current = 1;
 	size_t remain_size = instance->buffer_size;
-	char *transfer_buffer = instance->transport_buffer;
+	char *buffer = instance->data_buffer;
 	while (remain_size > 0) {
 		size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
@@ -255,5 +246,5 @@
 		toggle = 1 - toggle;
 
-		td_init(&data->tds[td_current], data_dir, transfer_buffer,
+		td_init(&data->tds[td_current], data_dir, buffer,
 		    transfer_size, toggle);
 		td_set_next(&data->tds[td_current], &data->tds[td_current + 1]);
@@ -262,5 +253,5 @@
 		    data->tds[td_current].next, data->tds[td_current].be);
 
-		transfer_buffer += transfer_size;
+		buffer += transfer_size;
 		remain_size -= transfer_size;
 		assert(td_current < data->td_count - 2);
@@ -290,5 +281,5 @@
 	size_t td_current = 0;
 	size_t remain_size = instance->buffer_size;
-	char *transfer_buffer = instance->transport_buffer;
+	char *buffer = instance->data_buffer;
 	while (remain_size > 0) {
 		size_t transfer_size = remain_size > OHCI_TD_MAX_TRANSFER ?
@@ -296,5 +287,5 @@
 
 		td_init(&data->tds[td_current], instance->ep->direction,
-		    transfer_buffer, transfer_size, -1);
+		    buffer, transfer_size, -1);
 		td_set_next(&data->tds[td_current], &data->tds[td_current + 1]);
 		usb_log_debug("Created DATA TD: %x:%x:%x:%x.\n",
@@ -302,5 +293,5 @@
 		    data->tds[td_current].next, data->tds[td_current].be);
 
-		transfer_buffer += transfer_size;
+		buffer += transfer_size;
 		remain_size -= transfer_size;
 		assert(td_current < data->td_count);
Index: uspace/drv/ohci/hc.c
===================================================================
--- uspace/drv/ohci/hc.c	(revision f13381bd14495597fae48bb54d6208b12ba4190d)
+++ uspace/drv/ohci/hc.c	(revision d017cea07b4e7cb0a582e6b399e54debc2523481)
@@ -130,16 +130,17 @@
 	assert(instance);
 	assert(batch);
+	assert(batch->ep);
 
 	/* check for root hub communication */
-	if (batch->target.address == instance->rh.address) {
+	if (batch->ep->address == instance->rh.address) {
 		return rh_request(&instance->rh, batch);
 	}
 
 	fibril_mutex_lock(&instance->guard);
-	switch (batch->transfer_type) {
+	switch (batch->ep->transfer_type) {
 	case USB_TRANSFER_CONTROL:
 		instance->registers->control &= ~C_CLE;
 		transfer_list_add_batch(
-		    instance->transfers[batch->transfer_type], batch);
+		    instance->transfers[batch->ep->transfer_type], batch);
 		instance->registers->command_status |= CS_CLF;
 		usb_log_debug2("Set CS control transfer filled: %x.\n",
@@ -151,5 +152,5 @@
 		instance->registers->control &= ~C_BLE;
 		transfer_list_add_batch(
-		    instance->transfers[batch->transfer_type], batch);
+		    instance->transfers[batch->ep->transfer_type], batch);
 		instance->registers->command_status |= CS_BLF;
 		usb_log_debug2("Set bulk transfer filled: %x.\n",
@@ -161,5 +162,5 @@
 		instance->registers->control &= (~C_PLE & ~C_IE);
 		transfer_list_add_batch(
-		    instance->transfers[batch->transfer_type], batch);
+		    instance->transfers[batch->ep->transfer_type], batch);
 		instance->registers->control |= C_PLE | C_IE;
 		usb_log_debug2("Added periodic transfer: %x.\n",
Index: uspace/drv/ohci/root_hub.c
===================================================================
--- uspace/drv/ohci/root_hub.c	(revision f13381bd14495597fae48bb54d6208b12ba4190d)
+++ uspace/drv/ohci/root_hub.c	(revision d017cea07b4e7cb0a582e6b399e54debc2523481)
@@ -237,13 +237,13 @@
 	assert(request);
 	int opResult;
-	if (request->transfer_type == USB_TRANSFER_CONTROL) {
+	if (request->ep->transfer_type == USB_TRANSFER_CONTROL) {
 		usb_log_info("Root hub got CONTROL packet\n");
 		opResult = process_ctrl_request(instance, request);
-	} else if (request->transfer_type == USB_TRANSFER_INTERRUPT) {
+	} else if (request->ep->transfer_type == USB_TRANSFER_INTERRUPT) {
 		usb_log_info("Root hub got INTERRUPT packet\n");
 		void * buffer;
 		create_interrupt_mask(instance, &buffer,
 			&(request->transfered_size));
-		memcpy(request->transport_buffer, buffer,
+		memcpy(request->data_buffer, buffer,
 			request->transfered_size);
 		opResult = EOK;
@@ -374,5 +374,5 @@
 	if (port < 1 || port > instance->port_count)
 		return EINVAL;
-	uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
+	uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
 	request->transfered_size = 4;
 	uint32_buffer[0] = instance->registers->rh_port_status[port - 1];
@@ -400,5 +400,5 @@
 static int process_get_hub_status_request(rh_t *instance,
 	usb_transfer_batch_t * request) {
-	uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
+	uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
 	request->transfered_size = 4;
 	//bits, 0,1,16,17
@@ -550,5 +550,5 @@
 	}
 	request->transfered_size = size;
-	memcpy(request->transport_buffer, result_descriptor, size);
+	memcpy(request->data_buffer, result_descriptor, size);
 	if (del)
 		free(result_descriptor);
@@ -571,5 +571,5 @@
 	if (request->buffer_size != 1)
 		return EINVAL;
-	request->transport_buffer[0] = 1;
+	request->data_buffer[0] = 1;
 	request->transfered_size = 1;
 	return EOK;
Index: uspace/drv/uhci-hcd/batch.c
===================================================================
--- uspace/drv/uhci-hcd/batch.c	(revision f13381bd14495597fae48bb54d6208b12ba4190d)
+++ uspace/drv/uhci-hcd/batch.c	(revision d017cea07b4e7cb0a582e6b399e54debc2523481)
@@ -103,7 +103,7 @@
 	usb_target_t target =
 	    { .address = ep->address, .endpoint = ep->endpoint };
-	usb_transfer_batch_init(instance, target, ep->transfer_type, ep->speed,
-	    ep->max_packet_size, buffer, NULL, buffer_size, NULL, setup_size,
-	    func_in, func_out, arg, fun, ep, NULL);
+	usb_transfer_batch_init(instance, ep,
+	    buffer, NULL, buffer_size, NULL, setup_size,
+	    func_in, func_out, arg, fun, NULL);
 
 
@@ -131,6 +131,6 @@
 
 	if (buffer_size > 0) {
-		instance->transport_buffer = malloc32(buffer_size);
-		CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
+		instance->data_buffer = malloc32(buffer_size);
+		CHECK_NULL_DISPOSE_RETURN(instance->data_buffer,
 		    "Failed to allocate device accessible buffer.\n");
 	}
@@ -205,6 +205,5 @@
 	assert(instance);
 	/* We are data out, we are supposed to provide data */
-	memcpy(instance->transport_buffer, instance->buffer,
-	    instance->buffer_size);
+	memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
 	batch_control(instance, USB_PID_OUT, USB_PID_IN);
 	instance->next_step = batch_call_out_and_dispose;
@@ -235,5 +234,5 @@
 {
 	assert(instance);
-	instance->direction = USB_DIRECTION_IN;
+//	instance->direction = USB_DIRECTION_IN;
 	batch_data(instance, USB_PID_IN);
 	instance->next_step = batch_call_in_and_dispose;
@@ -250,8 +249,6 @@
 {
 	assert(instance);
-	instance->direction = USB_DIRECTION_OUT;
 	/* We are data out, we are supposed to provide data */
-	memcpy(instance->transport_buffer, instance->buffer,
-	    instance->buffer_size);
+	memcpy(instance->data_buffer, instance->buffer, instance->buffer_size);
 	batch_data(instance, USB_PID_OUT);
 	instance->next_step = batch_call_out_and_dispose;
@@ -269,5 +266,4 @@
 	assert(instance);
 	batch_data(instance, USB_PID_IN);
-	instance->direction = USB_DIRECTION_IN;
 	instance->next_step = batch_call_in_and_dispose;
 	usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
@@ -283,7 +279,6 @@
 {
 	assert(instance);
-	instance->direction = USB_DIRECTION_OUT;
 	/* We are data out, we are supposed to provide data */
-	memcpy(instance->transport_buffer, instance->buffer,
+	memcpy(instance->data_buffer, instance->buffer,
 	    instance->buffer_size);
 	batch_data(instance, USB_PID_OUT);
@@ -306,5 +301,5 @@
 	assert(data);
 
-	const bool low_speed = instance->speed == USB_SPEED_LOW;
+	const bool low_speed = instance->ep->speed == USB_SPEED_LOW;
 	int toggle = endpoint_toggle_get(instance->ep);
 	assert(toggle == 0 || toggle == 1);
@@ -314,10 +309,10 @@
 	while (remain_size > 0) {
 		char *trans_data =
-		    instance->transport_buffer + instance->buffer_size
+		    instance->data_buffer + instance->buffer_size
 		    - remain_size;
 
 		const size_t packet_size =
-		    (instance->max_packet_size > remain_size) ?
-		    remain_size : instance->max_packet_size;
+		    (instance->ep->max_packet_size > remain_size) ?
+		    remain_size : instance->ep->max_packet_size;
 
 		td_t *next_transfer = (transfer + 1 < data->transfers)
@@ -326,8 +321,10 @@
 		assert(transfer < data->transfers);
 		assert(packet_size <= remain_size);
+		usb_target_t target =
+		    { instance->ep->address, instance->ep->endpoint };
 
 		td_init(
 		    &data->tds[transfer], DEFAULT_ERROR_COUNT, packet_size,
-		    toggle, false, low_speed, instance->target, pid, trans_data,
+		    toggle, false, low_speed, target, pid, trans_data,
 		    next_transfer);
 
@@ -360,10 +357,13 @@
 	assert(data->transfers >= 2);
 
-	const bool low_speed = instance->speed == USB_SPEED_LOW;
+	const bool low_speed = instance->ep->speed == USB_SPEED_LOW;
 	int toggle = 0;
+	const usb_target_t target =
+	    { instance->ep->address, instance->ep->endpoint };
+
 	/* setup stage */
 	td_init(
 	    data->tds, DEFAULT_ERROR_COUNT, instance->setup_size, toggle, false,
-	    low_speed, instance->target, USB_PID_SETUP, instance->setup_buffer,
+	    low_speed, target, USB_PID_SETUP, instance->setup_buffer,
 	    &data->tds[1]);
 
@@ -373,5 +373,5 @@
 	while (remain_size > 0) {
 		char *control_data =
-		    instance->transport_buffer + instance->buffer_size
+		    instance->data_buffer + instance->buffer_size
 		    - remain_size;
 
@@ -379,10 +379,10 @@
 
 		const size_t packet_size =
-		    (instance->max_packet_size > remain_size) ?
-		    remain_size : instance->max_packet_size;
+		    (instance->ep->max_packet_size > remain_size) ?
+		    remain_size : instance->ep->max_packet_size;
 
 		td_init(
 		    &data->tds[transfer], DEFAULT_ERROR_COUNT, packet_size,
-		    toggle, false, low_speed, instance->target, data_stage,
+		    toggle, false, low_speed, target, data_stage,
 		    control_data, &data->tds[transfer + 1]);
 
@@ -398,5 +398,5 @@
 	td_init(
 	    &data->tds[transfer], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
-	    instance->target, status_stage, NULL, NULL);
+	    target, status_stage, NULL, NULL);
 	td_set_ioc(&data->tds[transfer]);
 
@@ -449,5 +449,5 @@
 	free32(data->qh);
 	free32(instance->setup_buffer);
-	free32(instance->transport_buffer);
+	free32(instance->data_buffer);
 	free(data);
 	free(instance);
Index: uspace/drv/uhci-hcd/hc.c
===================================================================
--- uspace/drv/uhci-hcd/hc.c	(revision f13381bd14495597fae48bb54d6208b12ba4190d)
+++ uspace/drv/uhci-hcd/hc.c	(revision d017cea07b4e7cb0a582e6b399e54debc2523481)
@@ -329,5 +329,5 @@
 
 	transfer_list_t *list =
-	    instance->transfers[batch->speed][batch->transfer_type];
+	    instance->transfers[batch->ep->speed][batch->ep->transfer_type];
 	assert(list);
 	transfer_list_add_batch(list, batch);