USB: Use generic_io_vec in Transfer.

Prepares the way for actual physical-address request support,
which is not yet wired up.

Change-Id: I1b2d04a31e334a79b8361280fa0f3a5fbdb43d2b
Reviewed-on: https://review.haiku-os.org/c/haiku/+/6478
Reviewed-by: waddlesplash <[email protected]>

src/add-ons/kernel/bus_managers/usb/Pipe.cpp

@@ -235,8 +235,9 @@ BulkPipe::QueueBulkV(iovec *vector, size_t vectorCount,
 	Transfer *transfer = new(std::nothrow) Transfer(this);
 	if (!transfer)
 		return B_NO_MEMORY;
+	if (physical)
+		return B_NOT_SUPPORTED;
 
-	transfer->SetPhysical(physical);
 	transfer->SetVector(vector, vectorCount);
 	transfer->SetCallback(callback, callbackCookie);
 

src/add-ons/kernel/bus_managers/usb/Transfer.cpp

@@ -63,9 +63,10 @@ Transfer::SetIsochronousData(usb_isochronous_data *data)
 void
 Transfer::SetData(uint8 *data, size_t dataLength)
 {
+	fPhysical = false;
 	fBaseAddress = data;
-	fData.iov_base = data;
-	fData.iov_len = dataLength;
+	fData.base = (generic_addr_t)data;
+	fData.length = dataLength;
 
 	if (data && dataLength > 0)
 		fVectorCount = 1;
@@ -80,24 +81,21 @@ Transfer::SetData(uint8 *data, size_t dataLength)
 }
 
 
-void
-Transfer::SetPhysical(bool physical)
-{
-	fPhysical = physical;
-}
-
-
 void
 Transfer::SetVector(iovec *vector, size_t vectorCount)
 {
-	fVector = new(std::nothrow) iovec[vectorCount];
-	memcpy(fVector, vector, vectorCount * sizeof(iovec));
+	fPhysical = false;
+	fVector = new(std::nothrow) generic_io_vec[vectorCount];
+	for (size_t i = 0; i < vectorCount; i++) {
+		fVector[i].base = (generic_addr_t)vector[i].iov_base;
+		fVector[i].length = vector[i].iov_len;
+	}
 	fVectorCount = vectorCount;
-	fBaseAddress = fVector[0].iov_base;
+	fBaseAddress = vector[0].iov_base;
 
 	size_t length = 0;
 	for (size_t i = 0; i < fVectorCount && length <= USB_MAX_FRAGMENT_SIZE; i++)
-		length += fVector[i].iov_len;
+		length += fVector[i].length;
 
 	fFragmented = length > USB_MAX_FRAGMENT_SIZE;
 }
@@ -108,7 +106,7 @@ Transfer::FragmentLength() const
 {
 	size_t length = 0;
 	for (size_t i = 0; i < fVectorCount; i++)
-		length += fVector[i].iov_len;
+		length += fVector[i].length;
 
 	if (length > USB_MAX_FRAGMENT_SIZE)
 		length = USB_MAX_FRAGMENT_SIZE;
@@ -122,14 +120,14 @@ Transfer::AdvanceByFragment(size_t actualLength)
 {
 	size_t length = USB_MAX_FRAGMENT_SIZE;
 	for (size_t i = 0; i < fVectorCount; i++) {
-		if (fVector[i].iov_len <= length) {
-			length -= fVector[i].iov_len;
-			fVector[i].iov_len = 0;
+		if (fVector[i].length <= length) {
+			length -= fVector[i].length;
+			fVector[i].length = 0;
 			continue;
 		}
 
-		fVector[i].iov_base = (uint8 *)fVector[i].iov_base + length;
-		fVector[i].iov_len -= length;
+		fVector[i].base = fVector[i].base + length;
+		fVector[i].length -= length;
 		break;
 	}
 
@@ -148,10 +146,10 @@ Transfer::InitKernelAccess()
 	// be possible in the kernel space finisher thread unless we
 	// get the proper area id for the space we need and then clone it
 	// before reading from or writing to it.
-	iovec *vector = fVector;
+	generic_io_vec *vector = fVector;
 	for (size_t i = 0; i < fVectorCount; i++) {
-		if (IS_USER_ADDRESS(vector[i].iov_base)) {
-			fUserArea = area_for(vector[i].iov_base);
+		if (IS_USER_ADDRESS(vector[i].base)) {
+			fUserArea = area_for((void*)vector[i].base);
 			if (fUserArea < B_OK) {
 				TRACE_ERROR("failed to find area for user space buffer!\n");
 				return B_BAD_ADDRESS;
@@ -171,10 +169,10 @@ Transfer::InitKernelAccess()
 	}
 
 	for (size_t i = 0; i < fVectorCount; i++) {
-		vector[i].iov_base = (uint8 *)vector[i].iov_base - (addr_t)areaInfo.address;
+		vector[i].base = vector[i].base - (addr_t)areaInfo.address;
 
-		if ((size_t)vector[i].iov_base > areaInfo.size
-			|| (size_t)vector[i].iov_base + vector[i].iov_len > areaInfo.size) {
+		if (vector[i].base > areaInfo.size
+				|| (vector[i].base + vector[i].length) > areaInfo.size) {
 			TRACE_ERROR("data buffer spans across multiple areas!\n");
 			return B_BAD_ADDRESS;
 		}
@@ -200,7 +198,7 @@ Transfer::PrepareKernelAccess()
 		return fClonedArea;
 
 	for (size_t i = 0; i < fVectorCount; i++)
-		fVector[i].iov_base = (uint8 *)fVector[i].iov_base + (addr_t)clonedMemory;
+		fVector[i].base = fVector[i].base + (addr_t)clonedMemory;
 	return B_OK;
 }
 
@@ -244,11 +242,11 @@ Transfer::_CalculateBandwidth()
 			// Direction doesn't matter for highspeed
 			if (type & USB_OBJECT_ISO_PIPE)
 				bandwidthNS = (uint16)((38 * 8 * 2.083)
-					+ (2.083 * ((uint32)(3.167 * (1.1667 * 8 * fData.iov_len))))
+					+ (2.083 * ((uint32)(3.167 * (1.1667 * 8 * fData.length))))
 					+ USB_BW_HOST_DELAY);
 			else
 				bandwidthNS = (uint16)((55 * 8 * 2.083)
-					+ (2.083 * ((uint32)(3.167 * (1.1667 * 8 * fData.iov_len))))
+					+ (2.083 * ((uint32)(3.167 * (1.1667 * 8 * fData.length))))
 					+ USB_BW_HOST_DELAY);
 			break;
 		}
@@ -258,11 +256,11 @@ Transfer::_CalculateBandwidth()
 			if (type & USB_OBJECT_ISO_PIPE)
 				bandwidthNS = (uint16)
 					(((fPipe->Direction() == Pipe::In) ? 7268 : 6265)
-					+ (83.54 * ((uint32)(3.167 + (1.1667 * 8 * fData.iov_len))))
+					+ (83.54 * ((uint32)(3.167 + (1.1667 * 8 * fData.length))))
 					+ USB_BW_HOST_DELAY);
 			else
 				bandwidthNS = (uint16)(9107
-					+ (83.54 * ((uint32)(3.167 + (1.1667 * 8 * fData.iov_len))))
+					+ (83.54 * ((uint32)(3.167 + (1.1667 * 8 * fData.length))))
 					+ USB_BW_HOST_DELAY);
 			break;
 		}
@@ -270,11 +268,11 @@ Transfer::_CalculateBandwidth()
 		{
 			if (fPipe->Direction() == Pipe::In)
 				bandwidthNS = (uint16) (64060 + (2 * USB_BW_SETUP_LOW_SPEED_PORT_DELAY)
-					+ (676.67 * ((uint32)(3.167 + (1.1667 * 8 * fData.iov_len))))
+					+ (676.67 * ((uint32)(3.167 + (1.1667 * 8 * fData.length))))
 					+ USB_BW_HOST_DELAY);
 			else
 				bandwidthNS = (uint16)(64107 + (2 * USB_BW_SETUP_LOW_SPEED_PORT_DELAY)
-					+ (667.0 * ((uint32)(3.167 + (1.1667 * 8 * fData.iov_len))))
+					+ (667.0 * ((uint32)(3.167 + (1.1667 * 8 * fData.length))))
 					+ USB_BW_HOST_DELAY);
 			break;
 		}

src/add-ons/kernel/bus_managers/usb/usb_private.h

@@ -16,6 +16,7 @@
 #include "usbspec_private.h"
 #include <lock.h>
 #include <util/Vector.h>
+#include <util/iovec_support.h>
 
 
 #define TRACE_OUTPUT(x, y, z...) \
@@ -714,15 +715,13 @@ public:
 
 		void						SetData(uint8 *buffer, size_t length);
 		uint8 *						Data() const
-										{ return (uint8 *)fData.iov_base; }
-		size_t						DataLength() const { return fData.iov_len; }
+										{ return fPhysical ? NULL : (uint8 *)fData.base; }
+		size_t						DataLength() const { return fData.length; }
 
-		void						SetPhysical(bool physical);
 		bool						IsPhysical() const { return fPhysical; }
 
-		void						SetVector(iovec *vector,
-										size_t vectorCount);
-		iovec *						Vector() { return fVector; }
+		void						SetVector(iovec *vector, size_t vectorCount);
+		generic_io_vec *			Vector() { return fVector; }
 		size_t						VectorCount() const { return fVectorCount; }
 
 		uint16						Bandwidth() const { return fBandwidth; }
@@ -752,8 +751,8 @@ private:
 
 		// Data that is related to the transfer
 		Pipe *						fPipe;
-		iovec						fData;
-		iovec *						fVector;
+		generic_io_vec				fData;
+		generic_io_vec *			fVector;
 		size_t						fVectorCount;
 		void *						fBaseAddress;
 		bool						fPhysical;

src/add-ons/kernel/busses/usb/ehci.cpp

@@ -1019,7 +1019,7 @@ EHCI::CheckDebugTransfer(Transfer *transfer)
 		bool nextDataToggle = false;
 		if (transferData->data_descriptor != NULL && transferData->incoming) {
 			// data to read out
-			iovec *vector = transfer->Vector();
+			generic_io_vec *vector = transfer->Vector();
 			size_t vectorCount = transfer->VectorCount();
 
 			ReadDescriptorChain(transferData->data_descriptor,
@@ -2004,7 +2004,7 @@ EHCI::FinishTransfers()
 					bool nextDataToggle = false;
 					if (transfer->data_descriptor && transfer->incoming) {
 						// data to read out
-						iovec *vector = transfer->transfer->Vector();
+						generic_io_vec *vector = transfer->transfer->Vector();
 						size_t vectorCount = transfer->transfer->VectorCount();
 						callbackStatus = transfer->transfer->PrepareKernelAccess();
 						if (callbackStatus == B_OK) {
@@ -2445,9 +2445,9 @@ EHCI::FillQueueWithRequest(Transfer *transfer, ehci_qh *queueHead,
 		return B_NO_MEMORY;
 	}
 
-	iovec vector;
-	vector.iov_base = requestData;
-	vector.iov_len = sizeof(usb_request_data);
+	generic_io_vec vector;
+	vector.base = (generic_addr_t)requestData;
+	vector.length = sizeof(usb_request_data);
 	WriteDescriptorChain(setupDescriptor, &vector, 1);
 
 	ehci_qtd *strayDescriptor = queueHead->stray_log;
@@ -2784,7 +2784,7 @@ EHCI::UnlinkSITDescriptors(ehci_sitd *sitd, ehci_sitd **last)
 
 
 size_t
-EHCI::WriteDescriptorChain(ehci_qtd *topDescriptor, iovec *vector,
+EHCI::WriteDescriptorChain(ehci_qtd *topDescriptor, generic_io_vec *vector,
 	size_t vectorCount)
 {
 	ehci_qtd *current = topDescriptor;
@@ -2799,16 +2799,16 @@ EHCI::WriteDescriptorChain(ehci_qtd *topDescriptor, iovec *vector,
 
 		while (true) {
 			size_t length = min_c(current->buffer_size - bufferOffset,
-				vector[vectorIndex].iov_len - vectorOffset);
+				vector[vectorIndex].length - vectorOffset);
 
 			memcpy((uint8 *)current->buffer_log + bufferOffset,
-				(uint8 *)vector[vectorIndex].iov_base + vectorOffset, length);
+				(uint8 *)vector[vectorIndex].base + vectorOffset, length);
 
 			actualLength += length;
 			vectorOffset += length;
 			bufferOffset += length;
 
-			if (vectorOffset >= vector[vectorIndex].iov_len) {
+			if (vectorOffset >= vector[vectorIndex].length) {
 				if (++vectorIndex >= vectorCount) {
 					TRACE("wrote descriptor chain (%ld bytes, no more vectors)"
 						"\n", actualLength);
@@ -2836,7 +2836,7 @@ EHCI::WriteDescriptorChain(ehci_qtd *topDescriptor, iovec *vector,
 
 
 size_t
-EHCI::ReadDescriptorChain(ehci_qtd *topDescriptor, iovec *vector,
+EHCI::ReadDescriptorChain(ehci_qtd *topDescriptor, generic_io_vec *vector,
 	size_t vectorCount, bool *nextDataToggle)
 {
 	uint32 dataToggle = 0;
@@ -2857,16 +2857,16 @@ EHCI::ReadDescriptorChain(ehci_qtd *topDescriptor, iovec *vector,
 
 		while (true) {
 			size_t length = min_c(bufferSize - bufferOffset,
-				vector[vectorIndex].iov_len - vectorOffset);
+				vector[vectorIndex].length - vectorOffset);
 
-			memcpy((uint8 *)vector[vectorIndex].iov_base + vectorOffset,
+			memcpy((uint8 *)vector[vectorIndex].base + vectorOffset,
 				(uint8 *)current->buffer_log + bufferOffset, length);
 
 			actualLength += length;
 			vectorOffset += length;
 			bufferOffset += length;
 
-			if (vectorOffset >= vector[vectorIndex].iov_len) {
+			if (vectorOffset >= vector[vectorIndex].length) {
 				if (++vectorIndex >= vectorCount) {
 					TRACE("read descriptor chain (%ld bytes, no more vectors)"
 						"\n", actualLength);
@@ -2923,7 +2923,7 @@ EHCI::ReadActualLength(ehci_qtd *topDescriptor, bool *nextDataToggle)
 
 size_t
 EHCI::WriteIsochronousDescriptorChain(isochronous_transfer_data *transfer,
-	uint32 packetCount,	iovec *vector)
+	uint32 packetCount,	generic_io_vec *vector)
 {
 	// TODO implement
 	return 0;
@@ -2933,7 +2933,7 @@ EHCI::WriteIsochronousDescriptorChain(isochronous_transfer_data *transfer,
 size_t
 EHCI::ReadIsochronousDescriptorChain(isochronous_transfer_data *transfer)
 {
-	iovec *vector = transfer->transfer->Vector();
+	generic_io_vec *vector = transfer->transfer->Vector();
 	size_t vectorCount = transfer->transfer->VectorCount();
 	size_t vectorOffset = 0;
 	size_t vectorIndex = 0;
@@ -2971,14 +2971,14 @@ EHCI::ReadIsochronousDescriptorChain(isochronous_transfer_data *transfer)
 			size_t skipSize = packetSize - bufferSize;
 			while (bufferSize > 0) {
 				size_t length = min_c(bufferSize,
-					vector[vectorIndex].iov_len - vectorOffset);
-				memcpy((uint8 *)vector[vectorIndex].iov_base + vectorOffset,
+					vector[vectorIndex].length - vectorOffset);
+				memcpy((uint8 *)vector[vectorIndex].base + vectorOffset,
 					(uint8 *)transfer->buffer_log + bufferOffset, length);
 				offset += length;
 				vectorOffset += length;
 				bufferSize -= length;
 
-				if (vectorOffset >= vector[vectorIndex].iov_len) {
+				if (vectorOffset >= vector[vectorIndex].length) {
 					if (++vectorIndex >= vectorCount) {
 						TRACE("read isodescriptor chain (%ld bytes, no more "
 							"vectors)\n", totalLength);
@@ -2992,10 +2992,10 @@ EHCI::ReadIsochronousDescriptorChain(isochronous_transfer_data *transfer)
 			// skip to next packet offset
 			while (skipSize > 0) {
 				size_t length = min_c(skipSize,
-					vector[vectorIndex].iov_len - vectorOffset);
+					vector[vectorIndex].length - vectorOffset);
 				vectorOffset += length;
 				skipSize -= length;
-				if (vectorOffset >= vector[vectorIndex].iov_len) {
+				if (vectorOffset >= vector[vectorIndex].length) {
 					if (++vectorIndex >= vectorCount) {
 						TRACE("read isodescriptor chain (%ld bytes, no more "
 							"vectors)\n", totalLength);

src/add-ons/kernel/busses/usb/ehci.h

@@ -178,16 +178,16 @@ static int32						FinishIsochronousThread(void *data);
 
 		size_t						WriteDescriptorChain(
 										ehci_qtd *topDescriptor,
-										iovec *vector, size_t vectorCount);
+										generic_io_vec *vector, size_t vectorCount);
 		size_t						ReadDescriptorChain(ehci_qtd *topDescriptor,
-										iovec *vector, size_t vectorCount,
+										generic_io_vec *vector, size_t vectorCount,
 										bool *nextDataToggle);
 		size_t						ReadActualLength(ehci_qtd *topDescriptor,
 										bool *nextDataToggle);
 		size_t						WriteIsochronousDescriptorChain(
 										isochronous_transfer_data *transfer,
 										uint32 packetCount,
-										iovec *vector);
+										generic_io_vec *vector);
 		size_t						ReadIsochronousDescriptorChain(
 										isochronous_transfer_data *transfer);
 

src/add-ons/kernel/busses/usb/ohci.cpp

@@ -1261,7 +1261,7 @@ OHCI::_FinishTransfers()
 				if (callbackStatus == B_OK) {
 					if (transfer->data_descriptor && transfer->incoming) {
 						// data to read out
-						iovec *vector = transfer->transfer->Vector();
+						generic_io_vec *vector = transfer->transfer->Vector();
 						size_t vectorCount = transfer->transfer->VectorCount();
 
 						transfer->transfer->PrepareKernelAccess();
@@ -1430,7 +1430,7 @@ OHCI::_FinishIsochronousTransfer(transfer_data *transfer,
 		if (callbackStatus == B_OK && actualLength > 0) {
 			if (transfer->data_descriptor && transfer->incoming) {
 				// data to read out
-				iovec *vector = transfer->transfer->Vector();
+				generic_io_vec *vector = transfer->transfer->Vector();
 				size_t vectorCount = transfer->transfer->VectorCount();
 
 				transfer->transfer->PrepareKernelAccess();
@@ -1482,9 +1482,9 @@ OHCI::_SubmitRequest(Transfer *transfer)
 		| OHCI_TD_TOGGLE_1
 		| OHCI_TD_SET_DELAY_INTERRUPT(OHCI_TD_INTERRUPT_IMMEDIATE);
 
-	iovec vector;
-	vector.iov_base = requestData;
-	vector.iov_len = sizeof(usb_request_data);
+	generic_io_vec vector;
+	vector.base = (generic_addr_t)requestData;
+	vector.length = sizeof(usb_request_data);
 	_WriteDescriptorChain(setupDescriptor, &vector, 1);
 
 	status_t result;
@@ -2278,7 +2278,7 @@ OHCI::_FreeIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor)
 
 
 size_t
-OHCI::_WriteDescriptorChain(ohci_general_td *topDescriptor, iovec *vector,
+OHCI::_WriteDescriptorChain(ohci_general_td *topDescriptor, generic_io_vec *vector,
 	size_t vectorCount)
 {
 	ohci_general_td *current = topDescriptor;
@@ -2293,19 +2293,19 @@ OHCI::_WriteDescriptorChain(ohci_general_td *topDescriptor, iovec *vector,
 
 		while (true) {
 			size_t length = min_c(current->buffer_size - bufferOffset,
-				vector[vectorIndex].iov_len - vectorOffset);
+				vector[vectorIndex].length - vectorOffset);
 
 			TRACE("copying %ld bytes to bufferOffset %ld from"
 				" vectorOffset %ld at index %ld of %ld\n", length, bufferOffset,
 				vectorOffset, vectorIndex, vectorCount);
 			memcpy((uint8 *)current->buffer_logical + bufferOffset,
-				(uint8 *)vector[vectorIndex].iov_base + vectorOffset, length);
+				(uint8 *)vector[vectorIndex].base + vectorOffset, length);
 
 			actualLength += length;
 			vectorOffset += length;
 			bufferOffset += length;
 
-			if (vectorOffset >= vector[vectorIndex].iov_len) {
+			if (vectorOffset >= vector[vectorIndex].length) {
 				if (++vectorIndex >= vectorCount) {
 					TRACE("wrote descriptor chain (%ld bytes, no"
 						" more vectors)\n", actualLength);
@@ -2334,7 +2334,7 @@ OHCI::_WriteDescriptorChain(ohci_general_td *topDescriptor, iovec *vector,
 
 size_t
 OHCI::_WriteIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor,
-	iovec *vector, size_t vectorCount)
+	generic_io_vec *vector, size_t vectorCount)
 {
 	ohci_isochronous_td *current = topDescriptor;
 	size_t actualLength = 0;
@@ -2348,19 +2348,19 @@ OHCI::_WriteIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor,
 
 		while (true) {
 			size_t length = min_c(current->buffer_size - bufferOffset,
-				vector[vectorIndex].iov_len - vectorOffset);
+				vector[vectorIndex].length - vectorOffset);
 
 			TRACE("copying %ld bytes to bufferOffset %ld from"
 				" vectorOffset %ld at index %ld of %ld\n", length, bufferOffset,
 				vectorOffset, vectorIndex, vectorCount);
 			memcpy((uint8 *)current->buffer_logical + bufferOffset,
-				(uint8 *)vector[vectorIndex].iov_base + vectorOffset, length);
+				(uint8 *)vector[vectorIndex].base + vectorOffset, length);
 
 			actualLength += length;
 			vectorOffset += length;
 			bufferOffset += length;
 
-			if (vectorOffset >= vector[vectorIndex].iov_len) {
+			if (vectorOffset >= vector[vectorIndex].length) {
 				if (++vectorIndex >= vectorCount) {
 					TRACE("wrote descriptor chain (%ld bytes, no"
 						" more vectors)\n", actualLength);
@@ -2388,7 +2388,7 @@ OHCI::_WriteIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor,
 
 
 size_t
-OHCI::_ReadDescriptorChain(ohci_general_td *topDescriptor, iovec *vector,
+OHCI::_ReadDescriptorChain(ohci_general_td *topDescriptor, generic_io_vec *vector,
 	size_t vectorCount)
 {
 	ohci_general_td *current = topDescriptor;
@@ -2410,19 +2410,19 @@ OHCI::_ReadDescriptorChain(ohci_general_td *topDescriptor, iovec *vector,
 
 		while (true) {
 			size_t length = min_c(bufferSize - bufferOffset,
-				vector[vectorIndex].iov_len - vectorOffset);
+				vector[vectorIndex].length - vectorOffset);
 
 			TRACE("copying %ld bytes to vectorOffset %ld from"
 				" bufferOffset %ld at index %ld of %ld\n", length, vectorOffset,
 				bufferOffset, vectorIndex, vectorCount);
-			memcpy((uint8 *)vector[vectorIndex].iov_base + vectorOffset,
+			memcpy((uint8 *)vector[vectorIndex].base + vectorOffset,
 				(uint8 *)current->buffer_logical + bufferOffset, length);
 
 			actualLength += length;
 			vectorOffset += length;
 			bufferOffset += length;
 
-			if (vectorOffset >= vector[vectorIndex].iov_len) {
+			if (vectorOffset >= vector[vectorIndex].length) {
 				if (++vectorIndex >= vectorCount) {
 					TRACE("read descriptor chain (%ld bytes, no more vectors)\n",
 						actualLength);
@@ -2448,7 +2448,7 @@ OHCI::_ReadDescriptorChain(ohci_general_td *topDescriptor, iovec *vector,
 
 void
 OHCI::_ReadIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor,
-	iovec *vector, size_t vectorCount)
+	generic_io_vec *vector, size_t vectorCount)
 {
 	ohci_isochronous_td *current = topDescriptor;
 	size_t actualLength = 0;
@@ -2462,19 +2462,19 @@ OHCI::_ReadIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor,
 		if (current->buffer_logical != NULL && bufferSize > 0) {
 			while (true) {
 				size_t length = min_c(bufferSize - bufferOffset,
-					vector[vectorIndex].iov_len - vectorOffset);
+					vector[vectorIndex].length - vectorOffset);
 
 				TRACE("copying %ld bytes to vectorOffset %ld from bufferOffset"
 					" %ld at index %ld of %ld\n", length, vectorOffset,
 					bufferOffset, vectorIndex, vectorCount);
-				memcpy((uint8 *)vector[vectorIndex].iov_base + vectorOffset,
+				memcpy((uint8 *)vector[vectorIndex].base + vectorOffset,
 					(uint8 *)current->buffer_logical + bufferOffset, length);
 
 				actualLength += length;
 				vectorOffset += length;
 				bufferOffset += length;
 
-				if (vectorOffset >= vector[vectorIndex].iov_len) {
+				if (vectorOffset >= vector[vectorIndex].length) {
 					if (++vectorIndex >= vectorCount) {
 						TRACE("read descriptor chain (%ld bytes, "
 							"no more vectors)\n", actualLength);

src/add-ons/kernel/busses/usb/ohci.h

@@ -135,17 +135,17 @@ static	int32						_FinishThread(void *data);
 
 		size_t						_WriteDescriptorChain(
 										ohci_general_td *topDescriptor,
-										iovec *vector, size_t vectorCount);
+										generic_io_vec *vector, size_t vectorCount);
 		size_t						_ReadDescriptorChain(
 										ohci_general_td *topDescriptor,
-										iovec *vector, size_t vectorCount);
+										generic_io_vec *vector, size_t vectorCount);
 
 		size_t						_WriteIsochronousDescriptorChain(
 										ohci_isochronous_td *topDescriptor,
-										iovec *vector, size_t vectorCount);
+										generic_io_vec *vector, size_t vectorCount);
 		void						_ReadIsochronousDescriptorChain(
 										ohci_isochronous_td *topDescriptor,
-										iovec *vector, size_t vectorCount);
+										generic_io_vec *vector, size_t vectorCount);
 
 		size_t						_ReadActualLength(
 										ohci_general_td *topDescriptor);

src/add-ons/kernel/busses/usb/uhci.cpp

@@ -930,7 +930,7 @@ UHCI::CheckDebugTransfer(Transfer *transfer)
 		uint8 lastDataToggle = 0;
 		if (transfer->TransferPipe()->Direction() == Pipe::In) {
 			// data to read out
-			iovec *vector = transfer->Vector();
+			generic_io_vec *vector = transfer->Vector();
 			size_t vectorCount = transfer->VectorCount();
 
 			ReadDescriptorChain(transferData->first_descriptor,
@@ -1091,9 +1091,9 @@ UHCI::SubmitRequest(Transfer *transfer)
 		return B_NO_MEMORY;
 	}
 
-	iovec vector;
-	vector.iov_base = requestData;
-	vector.iov_len = sizeof(usb_request_data);
+	generic_io_vec vector;
+	vector.base = (generic_addr_t)requestData;
+	vector.length = sizeof(usb_request_data);
 	WriteDescriptorChain(setupDescriptor, &vector, 1);
 
 	statusDescriptor->status |= TD_CONTROL_IOC;
@@ -1311,7 +1311,7 @@ UHCI::SubmitIsochronous(Transfer *transfer)
 
 	// If direction is out set every descriptor data
 	if (!directionIn) {
-		iovec *vector = transfer->Vector();
+		generic_io_vec *vector = transfer->Vector();
 		WriteIsochronousDescriptorChain(isoRequest,
 			isochronousData->packet_count, vector);
 	} else {
@@ -1613,7 +1613,7 @@ UHCI::FinishTransfers()
 					uint8 lastDataToggle = 0;
 					if (transfer->data_descriptor && transfer->incoming) {
 						// data to read out
-						iovec *vector = transfer->transfer->Vector();
+						generic_io_vec *vector = transfer->transfer->Vector();
 						size_t vectorCount = transfer->transfer->VectorCount();
 
 						transfer->transfer->PrepareKernelAccess();
@@ -1788,7 +1788,7 @@ UHCI::FinishIsochronousTransfers()
 					// remove the descriptors.
 				if (transfer && transfer->is_active) {
 					if (current->token & TD_TOKEN_IN) {
-						iovec *vector = transfer->transfer->Vector();
+						generic_io_vec *vector = transfer->transfer->Vector();
 						transfer->transfer->PrepareKernelAccess();
 						ReadIsochronousDescriptorChain(transfer, vector);
 					}
@@ -2276,7 +2276,7 @@ UHCI::LinkDescriptors(uhci_td *first, uhci_td *second)
 
 
 size_t
-UHCI::WriteDescriptorChain(uhci_td *topDescriptor, iovec *vector,
+UHCI::WriteDescriptorChain(uhci_td *topDescriptor, generic_io_vec *vector,
 	size_t vectorCount)
 {
 	uhci_td *current = topDescriptor;
@@ -2291,19 +2291,19 @@ UHCI::WriteDescriptorChain(uhci_td *topDescriptor, iovec *vector,
 
 		while (true) {
 			size_t length = min_c(current->buffer_size - bufferOffset,
-				vector[vectorIndex].iov_len - vectorOffset);
+				vector[vectorIndex].length - vectorOffset);
 
 			TRACE("copying %ld bytes to bufferOffset %ld from"
 				" vectorOffset %ld at index %ld of %ld\n", length, bufferOffset,
 				vectorOffset, vectorIndex, vectorCount);
 			memcpy((uint8 *)current->buffer_log + bufferOffset,
-				(uint8 *)vector[vectorIndex].iov_base + vectorOffset, length);
+				(uint8 *)vector[vectorIndex].base + vectorOffset, length);
 
 			actualLength += length;
 			vectorOffset += length;
 			bufferOffset += length;
 
-			if (vectorOffset >= vector[vectorIndex].iov_len) {
+			if (vectorOffset >= vector[vectorIndex].length) {
 				if (++vectorIndex >= vectorCount) {
 					TRACE("wrote descriptor chain (%ld bytes, no more vectors)\n",
 						actualLength);
@@ -2331,7 +2331,7 @@ UHCI::WriteDescriptorChain(uhci_td *topDescriptor, iovec *vector,
 
 
 size_t
-UHCI::ReadDescriptorChain(uhci_td *topDescriptor, iovec *vector,
+UHCI::ReadDescriptorChain(uhci_td *topDescriptor, generic_io_vec *vector,
 	size_t vectorCount, uint8 *lastDataToggle)
 {
 	uint8 dataToggle = 0;
@@ -2350,19 +2350,19 @@ UHCI::ReadDescriptorChain(uhci_td *topDescriptor, iovec *vector,
 
 		while (true) {
 			size_t length = min_c(bufferSize - bufferOffset,
-				vector[vectorIndex].iov_len - vectorOffset);
+				vector[vectorIndex].length - vectorOffset);
 
 			TRACE("copying %ld bytes to vectorOffset %ld from"
 				" bufferOffset %ld at index %ld of %ld\n", length, vectorOffset,
 				bufferOffset, vectorIndex, vectorCount);
-			memcpy((uint8 *)vector[vectorIndex].iov_base + vectorOffset,
+			memcpy((uint8 *)vector[vectorIndex].base + vectorOffset,
 				(uint8 *)current->buffer_log + bufferOffset, length);
 
 			actualLength += length;
 			vectorOffset += length;
 			bufferOffset += length;
 
-			if (vectorOffset >= vector[vectorIndex].iov_len) {
+			if (vectorOffset >= vector[vectorIndex].length) {
 				if (++vectorIndex >= vectorCount) {
 					TRACE("read descriptor chain (%ld bytes, no more vectors)\n",
 						actualLength);
@@ -2421,13 +2421,13 @@ UHCI::ReadActualLength(uhci_td *topDescriptor, uint8 *lastDataToggle)
 
 void
 UHCI::WriteIsochronousDescriptorChain(uhci_td **isoRequest, uint32 packetCount,
-	iovec *vector)
+	generic_io_vec *vector)
 {
 	size_t vectorOffset = 0;
 	for (uint32 i = 0; i < packetCount; i++) {
 		size_t bufferSize = isoRequest[i]->buffer_size;
 		memcpy((uint8 *)isoRequest[i]->buffer_log,
-			(uint8 *)vector->iov_base + vectorOffset, bufferSize);
+			(uint8 *)vector->base + vectorOffset, bufferSize);
 		vectorOffset += bufferSize;
 	}
 }
@@ -2435,7 +2435,7 @@ UHCI::WriteIsochronousDescriptorChain(uhci_td **isoRequest, uint32 packetCount,
 
 void
 UHCI::ReadIsochronousDescriptorChain(isochronous_transfer_data *transfer,
-	iovec *vector)
+	generic_io_vec *vector)
 {
 	size_t vectorOffset = 0;
 	usb_isochronous_data *isochronousData
@@ -2456,7 +2456,7 @@ UHCI::ReadIsochronousDescriptorChain(isochronous_transfer_data *transfer,
 			vectorOffset += bufferSize;
 			continue;
 		}
-		memcpy((uint8 *)vector->iov_base + vectorOffset,
+		memcpy((uint8 *)vector->base + vectorOffset,
 			(uint8 *)current->buffer_log, bufferSize);
 
 		vectorOffset += bufferSize;

src/add-ons/kernel/busses/usb/uhci.h

@@ -184,19 +184,19 @@ static int32						FinishIsochronousThread(void *data);
 										uhci_td *second);
 
 		size_t						WriteDescriptorChain(uhci_td *topDescriptor,
-										iovec *vector, size_t vectorCount);
+										generic_io_vec *vector, size_t vectorCount);
 		size_t						ReadDescriptorChain(uhci_td *topDescriptor,
-										iovec *vector, size_t vectorCount,
+										generic_io_vec *vector, size_t vectorCount,
 										uint8 *lastDataToggle);
 		size_t						ReadActualLength(uhci_td *topDescriptor,
 										uint8 *lastDataToggle);
 		void						WriteIsochronousDescriptorChain(
 										uhci_td **isoRequest,
 										uint32 packetCount,
-										iovec *vector);
+										generic_io_vec *vector);
 		void						ReadIsochronousDescriptorChain(
 										isochronous_transfer_data *transfer,
-										iovec *vector);
+										generic_io_vec *vector);
 
 		// Register functions
 inline	void						WriteReg8(uint32 reg, uint8 value);

src/add-ons/kernel/busses/usb/xhci.cpp

@@ -878,7 +878,7 @@ XHCI::SubmitControlRequest(Transfer *transfer)
 		if (!directionIn) {
 			transfer->PrepareKernelAccess();
 			memcpy(descriptor->buffers[0],
-				(uint8 *)transfer->Vector()[0].iov_base, requestData->Length);
+				(uint8 *)transfer->Vector()[0].base, requestData->Length);
 		}
 
 		index++;
@@ -1427,18 +1427,18 @@ XHCI::FreeDescriptor(xhci_td *descriptor)
 
 
 size_t
-XHCI::WriteDescriptor(xhci_td *descriptor, iovec *vector, size_t vectorCount)
+XHCI::WriteDescriptor(xhci_td *descriptor, generic_io_vec *vector, size_t vectorCount)
 {
 	size_t written = 0;
 
 	size_t bufIdx = 0, bufUsed = 0;
 	for (size_t vecIdx = 0; vecIdx < vectorCount; vecIdx++) {
-		size_t length = vector[vecIdx].iov_len;
+		size_t length = vector[vecIdx].length;
 
 		while (length > 0 && bufIdx < descriptor->buffer_count) {
 			size_t toCopy = min_c(length, descriptor->buffer_size - bufUsed);
 			memcpy((uint8 *)descriptor->buffers[bufIdx] + bufUsed,
-				(uint8 *)vector[vecIdx].iov_base + (vector[vecIdx].iov_len - length),
+				(uint8 *)vector[vecIdx].base + (vector[vecIdx].length - length),
 				toCopy);
 
 			written += toCopy;
@@ -1457,17 +1457,17 @@ XHCI::WriteDescriptor(xhci_td *descriptor, iovec *vector, size_t vectorCount)
 
 
 size_t
-XHCI::ReadDescriptor(xhci_td *descriptor, iovec *vector, size_t vectorCount)
+XHCI::ReadDescriptor(xhci_td *descriptor, generic_io_vec *vector, size_t vectorCount)
 {
 	size_t read = 0;
 
 	size_t bufIdx = 0, bufUsed = 0;
 	for (size_t vecIdx = 0; vecIdx < vectorCount; vecIdx++) {
-		size_t length = vector[vecIdx].iov_len;
+		size_t length = vector[vecIdx].length;
 
 		while (length > 0 && bufIdx < descriptor->buffer_count) {
 			size_t toCopy = min_c(length, descriptor->buffer_size - bufUsed);
-			memcpy((uint8 *)vector[vecIdx].iov_base + (vector[vecIdx].iov_len - length),
+			memcpy((uint8 *)vector[vecIdx].base + (vector[vecIdx].length - length),
 				(uint8 *)descriptor->buffers[bufIdx] + bufUsed, toCopy);
 
 			read += toCopy;

src/add-ons/kernel/busses/usb/xhci.h

@@ -162,9 +162,9 @@ private:
 			void				FreeDescriptor(xhci_td *descriptor);
 
 			size_t				WriteDescriptor(xhci_td *descriptor,
-									iovec *vector, size_t vectorCount);
+									generic_io_vec *vector, size_t vectorCount);
 			size_t				ReadDescriptor(xhci_td *descriptor,
-									iovec *vector, size_t vectorCount);
+									generic_io_vec *vector, size_t vectorCount);
 
 			status_t			_LinkDescriptorForPipe(xhci_td *descriptor,
 									xhci_endpoint *endpoint);