i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

USB: Use generic_io_vec in Transfer.

Browse Source 
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]>
This commit is contained in:
Augustin Cavalier
2023-05-30 17:54:28 +00:00
committed by waddlesplash
parent 65cdc13e7d
commit 99626c2908
11 changed files with 119 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/bus_managers/usb/Pipe.cpp
+2 -1
View File
@@ -235,8 +235,9 @@ BulkPipe::QueueBulkV(iovec *vector, size_t vectorCount,
Transfer *transfer = new(std::nothrow) Transfer(this); Transfer *transfer = new(std::nothrow) Transfer(this);
if (!transfer) if (!transfer)
return B_NO_MEMORY; return B_NO_MEMORY;
if (physical)
return B_NOT_SUPPORTED;
transfer->SetPhysical(physical);
transfer->SetVector(vector, vectorCount); transfer->SetVector(vector, vectorCount);
transfer->SetCallback(callback, callbackCookie); transfer->SetCallback(callback, callbackCookie);
src/add-ons/kernel/bus_managers/usb/Transfer.cpp
+30 -32
View File
@@ -63,9 +63,10 @@ Transfer::SetIsochronousData(usb_isochronous_data *data)
void void
Transfer::SetData(uint8 *data, size_t dataLength) Transfer::SetData(uint8 *data, size_t dataLength)
{ {
fPhysical = false;
fBaseAddress = data; fBaseAddress = data;
fData.iov_base = data; fData.base = (generic_addr_t)data;
fData.iov_len = dataLength; fData.length = dataLength;
if (data && dataLength > 0) if (data && dataLength > 0)
fVectorCount = 1; fVectorCount = 1;
@@ -80,24 +81,21 @@ Transfer::SetData(uint8 *data, size_t dataLength)
} }
void
Transfer::SetPhysical(bool physical)
{
fPhysical = physical;
}
void void
Transfer::SetVector(iovec *vector, size_t vectorCount) Transfer::SetVector(iovec *vector, size_t vectorCount)
{ {
fVector = new(std::nothrow) iovec[vectorCount]; fPhysical = false;
memcpy(fVector, vector, vectorCount * sizeof(iovec)); 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; fVectorCount = vectorCount;
fBaseAddress = fVector[0].iov_base; fBaseAddress = vector[0].iov_base;
size_t length = 0; size_t length = 0;
for (size_t i = 0; i < fVectorCount && length <= USB_MAX_FRAGMENT_SIZE; i++) 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; fFragmented = length > USB_MAX_FRAGMENT_SIZE;
} }
@@ -108,7 +106,7 @@ Transfer::FragmentLength() const
{ {
size_t length = 0; size_t length = 0;
for (size_t i = 0; i < fVectorCount; i++) for (size_t i = 0; i < fVectorCount; i++)
length += fVector[i].iov_len; length += fVector[i].length;
if (length > USB_MAX_FRAGMENT_SIZE) if (length > USB_MAX_FRAGMENT_SIZE)
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; size_t length = USB_MAX_FRAGMENT_SIZE;
for (size_t i = 0; i < fVectorCount; i++) { for (size_t i = 0; i < fVectorCount; i++) {
if (fVector[i].iov_len <= length) { if (fVector[i].length <= length) {
length -= fVector[i].iov_len; length -= fVector[i].length;
fVector[i].iov_len = 0; fVector[i].length = 0;
continue; continue;
} }
fVector[i].iov_base = (uint8 *)fVector[i].iov_base + length; fVector[i].base = fVector[i].base + length;
fVector[i].iov_len -= length; fVector[i].length -= length;
break; break;
} }
@@ -148,10 +146,10 @@ Transfer::InitKernelAccess()
// be possible in the kernel space finisher thread unless we // be possible in the kernel space finisher thread unless we
// get the proper area id for the space we need and then clone it // get the proper area id for the space we need and then clone it
// before reading from or writing to it. // before reading from or writing to it.
iovec *vector = fVector; generic_io_vec *vector = fVector;
for (size_t i = 0; i < fVectorCount; i++) { for (size_t i = 0; i < fVectorCount; i++) {
if (IS_USER_ADDRESS(vector[i].iov_base)) { if (IS_USER_ADDRESS(vector[i].base)) {
fUserArea = area_for(vector[i].iov_base); fUserArea = area_for((void*)vector[i].base);
if (fUserArea < B_OK) { if (fUserArea < B_OK) {
TRACE_ERROR("failed to find area for user space buffer!\n"); TRACE_ERROR("failed to find area for user space buffer!\n");
return B_BAD_ADDRESS; return B_BAD_ADDRESS;
@@ -171,10 +169,10 @@ Transfer::InitKernelAccess()
} }
for (size_t i = 0; i < fVectorCount; i++) { 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 if (vector[i].base > areaInfo.size
|| (size_t)vector[i].iov_base + vector[i].iov_len > areaInfo.size) { || (vector[i].base + vector[i].length) > areaInfo.size) {
TRACE_ERROR("data buffer spans across multiple areas!\n"); TRACE_ERROR("data buffer spans across multiple areas!\n");
return B_BAD_ADDRESS; return B_BAD_ADDRESS;
} }
@@ -200,7 +198,7 @@ Transfer::PrepareKernelAccess()
return fClonedArea; return fClonedArea;
for (size_t i = 0; i < fVectorCount; i++) 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; return B_OK;
} }
@@ -244,11 +242,11 @@ Transfer::_CalculateBandwidth()
// Direction doesn't matter for highspeed // Direction doesn't matter for highspeed
if (type & USB_OBJECT_ISO_PIPE) if (type & USB_OBJECT_ISO_PIPE)
bandwidthNS = (uint16)((38 * 8 * 2.083) 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); + USB_BW_HOST_DELAY);
else else
bandwidthNS = (uint16)((55 * 8 * 2.083) 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); + USB_BW_HOST_DELAY);
break; break;
} }
@@ -258,11 +256,11 @@ Transfer::_CalculateBandwidth()
if (type & USB_OBJECT_ISO_PIPE) if (type & USB_OBJECT_ISO_PIPE)
bandwidthNS = (uint16) bandwidthNS = (uint16)
(((fPipe->Direction() == Pipe::In) ? 7268 : 6265) (((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); + USB_BW_HOST_DELAY);
else else
bandwidthNS = (uint16)(9107 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); + USB_BW_HOST_DELAY);
break; break;
} }
@@ -270,11 +268,11 @@ Transfer::_CalculateBandwidth()
{ {
if (fPipe->Direction() == Pipe::In) if (fPipe->Direction() == Pipe::In)
bandwidthNS = (uint16) (64060 + (2 * USB_BW_SETUP_LOW_SPEED_PORT_DELAY) 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); + USB_BW_HOST_DELAY);
else else
bandwidthNS = (uint16)(64107 + (2 * USB_BW_SETUP_LOW_SPEED_PORT_DELAY) 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); + USB_BW_HOST_DELAY);
break; break;
} }
src/add-ons/kernel/bus_managers/usb/usb_private.h
+7 -8
View File
@@ -16,6 +16,7 @@
#include "usbspec_private.h" #include "usbspec_private.h"
#include <lock.h> #include <lock.h>
#include <util/Vector.h> #include <util/Vector.h>
#include <util/iovec_support.h>
#define TRACE_OUTPUT(x, y, z...) \ #define TRACE_OUTPUT(x, y, z...) \
@@ -714,15 +715,13 @@ public:
void SetData(uint8 *buffer, size_t length); void SetData(uint8 *buffer, size_t length);
uint8 * Data() const uint8 * Data() const
{ return (uint8 *)fData.iov_base; } { return fPhysical ? NULL : (uint8 *)fData.base; }
size_t DataLength() const { return fData.iov_len; } size_t DataLength() const { return fData.length; }
void SetPhysical(bool physical);
bool IsPhysical() const { return fPhysical; } bool IsPhysical() const { return fPhysical; }
void SetVector(iovec *vector, void SetVector(iovec *vector, size_t vectorCount);
size_t vectorCount); generic_io_vec * Vector() { return fVector; }
iovec * Vector() { return fVector; }
size_t VectorCount() const { return fVectorCount; } size_t VectorCount() const { return fVectorCount; }
uint16 Bandwidth() const { return fBandwidth; } uint16 Bandwidth() const { return fBandwidth; }
@@ -752,8 +751,8 @@ private:
// Data that is related to the transfer // Data that is related to the transfer
Pipe * fPipe; Pipe * fPipe;
iovec fData; generic_io_vec fData;
iovec * fVector; generic_io_vec * fVector;
size_t fVectorCount; size_t fVectorCount;
void * fBaseAddress; void * fBaseAddress;
bool fPhysical; bool fPhysical;
src/add-ons/kernel/busses/usb/ehci.cpp
+20 -20
View File
@@ -1019,7 +1019,7 @@ EHCI::CheckDebugTransfer(Transfer *transfer)
bool nextDataToggle = false; bool nextDataToggle = false;
if (transferData->data_descriptor != NULL && transferData->incoming) { if (transferData->data_descriptor != NULL && transferData->incoming) {
// data to read out // data to read out
iovec *vector = transfer->Vector(); generic_io_vec *vector = transfer->Vector();
size_t vectorCount = transfer->VectorCount(); size_t vectorCount = transfer->VectorCount();
ReadDescriptorChain(transferData->data_descriptor, ReadDescriptorChain(transferData->data_descriptor,
@@ -2004,7 +2004,7 @@ EHCI::FinishTransfers()
bool nextDataToggle = false; bool nextDataToggle = false;
if (transfer->data_descriptor && transfer->incoming) { if (transfer->data_descriptor && transfer->incoming) {
// data to read out // data to read out
iovec *vector = transfer->transfer->Vector(); generic_io_vec *vector = transfer->transfer->Vector();
size_t vectorCount = transfer->transfer->VectorCount(); size_t vectorCount = transfer->transfer->VectorCount();
callbackStatus = transfer->transfer->PrepareKernelAccess(); callbackStatus = transfer->transfer->PrepareKernelAccess();
if (callbackStatus == B_OK) { if (callbackStatus == B_OK) {
@@ -2445,9 +2445,9 @@ EHCI::FillQueueWithRequest(Transfer *transfer, ehci_qh *queueHead,
return B_NO_MEMORY; return B_NO_MEMORY;
} }
iovec vector; generic_io_vec vector;
vector.iov_base = requestData; vector.base = (generic_addr_t)requestData;
vector.iov_len = sizeof(usb_request_data); vector.length = sizeof(usb_request_data);
WriteDescriptorChain(setupDescriptor, &vector, 1); WriteDescriptorChain(setupDescriptor, &vector, 1);
ehci_qtd *strayDescriptor = queueHead->stray_log; ehci_qtd *strayDescriptor = queueHead->stray_log;
@@ -2784,7 +2784,7 @@ EHCI::UnlinkSITDescriptors(ehci_sitd *sitd, ehci_sitd **last)
size_t size_t
EHCI::WriteDescriptorChain(ehci_qtd *topDescriptor, iovec *vector, EHCI::WriteDescriptorChain(ehci_qtd *topDescriptor, generic_io_vec *vector,
size_t vectorCount) size_t vectorCount)
{ {
ehci_qtd *current = topDescriptor; ehci_qtd *current = topDescriptor;
@@ -2799,16 +2799,16 @@ EHCI::WriteDescriptorChain(ehci_qtd *topDescriptor, iovec *vector,
while (true) { while (true) {
size_t length = min_c(current->buffer_size - bufferOffset, size_t length = min_c(current->buffer_size - bufferOffset,
vector[vectorIndex].iov_len - vectorOffset); vector[vectorIndex].length - vectorOffset);
memcpy((uint8 *)current->buffer_log + bufferOffset, memcpy((uint8 *)current->buffer_log + bufferOffset,
(uint8 *)vector[vectorIndex].iov_base + vectorOffset, length); (uint8 *)vector[vectorIndex].base + vectorOffset, length);
actualLength += length; actualLength += length;
vectorOffset += length; vectorOffset += length;
bufferOffset += length; bufferOffset += length;
if (vectorOffset >= vector[vectorIndex].iov_len) { if (vectorOffset >= vector[vectorIndex].length) {
if (++vectorIndex >= vectorCount) { if (++vectorIndex >= vectorCount) {
TRACE("wrote descriptor chain (%ld bytes, no more vectors)" TRACE("wrote descriptor chain (%ld bytes, no more vectors)"
"\n", actualLength); "\n", actualLength);
@@ -2836,7 +2836,7 @@ EHCI::WriteDescriptorChain(ehci_qtd *topDescriptor, iovec *vector,
size_t size_t
EHCI::ReadDescriptorChain(ehci_qtd *topDescriptor, iovec *vector, EHCI::ReadDescriptorChain(ehci_qtd *topDescriptor, generic_io_vec *vector,
size_t vectorCount, bool *nextDataToggle) size_t vectorCount, bool *nextDataToggle)
{ {
uint32 dataToggle = 0; uint32 dataToggle = 0;
@@ -2857,16 +2857,16 @@ EHCI::ReadDescriptorChain(ehci_qtd *topDescriptor, iovec *vector,
while (true) { while (true) {
size_t length = min_c(bufferSize - bufferOffset, 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); (uint8 *)current->buffer_log + bufferOffset, length);
actualLength += length; actualLength += length;
vectorOffset += length; vectorOffset += length;
bufferOffset += length; bufferOffset += length;
if (vectorOffset >= vector[vectorIndex].iov_len) { if (vectorOffset >= vector[vectorIndex].length) {
if (++vectorIndex >= vectorCount) { if (++vectorIndex >= vectorCount) {
TRACE("read descriptor chain (%ld bytes, no more vectors)" TRACE("read descriptor chain (%ld bytes, no more vectors)"
"\n", actualLength); "\n", actualLength);
@@ -2923,7 +2923,7 @@ EHCI::ReadActualLength(ehci_qtd *topDescriptor, bool *nextDataToggle)
size_t size_t
EHCI::WriteIsochronousDescriptorChain(isochronous_transfer_data *transfer, EHCI::WriteIsochronousDescriptorChain(isochronous_transfer_data *transfer,
uint32 packetCount, iovec *vector) uint32 packetCount, generic_io_vec *vector)
{ {
// TODO implement // TODO implement
return 0; return 0;
@@ -2933,7 +2933,7 @@ EHCI::WriteIsochronousDescriptorChain(isochronous_transfer_data *transfer,
size_t size_t
EHCI::ReadIsochronousDescriptorChain(isochronous_transfer_data *transfer) 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 vectorCount = transfer->transfer->VectorCount();
size_t vectorOffset = 0; size_t vectorOffset = 0;
size_t vectorIndex = 0; size_t vectorIndex = 0;
@@ -2971,14 +2971,14 @@ EHCI::ReadIsochronousDescriptorChain(isochronous_transfer_data *transfer)
size_t skipSize = packetSize - bufferSize; size_t skipSize = packetSize - bufferSize;
while (bufferSize > 0) { while (bufferSize > 0) {
size_t length = min_c(bufferSize, size_t length = min_c(bufferSize,
vector[vectorIndex].iov_len - vectorOffset); vector[vectorIndex].length - vectorOffset);
memcpy((uint8 *)vector[vectorIndex].iov_base + vectorOffset, memcpy((uint8 *)vector[vectorIndex].base + vectorOffset,
(uint8 *)transfer->buffer_log + bufferOffset, length); (uint8 *)transfer->buffer_log + bufferOffset, length);
offset += length; offset += length;
vectorOffset += length; vectorOffset += length;
bufferSize -= length; bufferSize -= length;
if (vectorOffset >= vector[vectorIndex].iov_len) { if (vectorOffset >= vector[vectorIndex].length) {
if (++vectorIndex >= vectorCount) { if (++vectorIndex >= vectorCount) {
TRACE("read isodescriptor chain (%ld bytes, no more " TRACE("read isodescriptor chain (%ld bytes, no more "
"vectors)\n", totalLength); "vectors)\n", totalLength);
@@ -2992,10 +2992,10 @@ EHCI::ReadIsochronousDescriptorChain(isochronous_transfer_data *transfer)
// skip to next packet offset // skip to next packet offset
while (skipSize > 0) { while (skipSize > 0) {
size_t length = min_c(skipSize, size_t length = min_c(skipSize,
vector[vectorIndex].iov_len - vectorOffset); vector[vectorIndex].length - vectorOffset);
vectorOffset += length; vectorOffset += length;
skipSize -= length; skipSize -= length;
if (vectorOffset >= vector[vectorIndex].iov_len) { if (vectorOffset >= vector[vectorIndex].length) {
if (++vectorIndex >= vectorCount) { if (++vectorIndex >= vectorCount) {
TRACE("read isodescriptor chain (%ld bytes, no more " TRACE("read isodescriptor chain (%ld bytes, no more "
"vectors)\n", totalLength); "vectors)\n", totalLength);
src/add-ons/kernel/busses/usb/ehci.h
+3 -3
View File
@@ -178,16 +178,16 @@ static int32 FinishIsochronousThread(void *data);
size_t WriteDescriptorChain( size_t WriteDescriptorChain(
ehci_qtd *topDescriptor, ehci_qtd *topDescriptor,
iovec *vector, size_t vectorCount); generic_io_vec *vector, size_t vectorCount);
size_t ReadDescriptorChain(ehci_qtd *topDescriptor, size_t ReadDescriptorChain(ehci_qtd *topDescriptor,
iovec *vector, size_t vectorCount, generic_io_vec *vector, size_t vectorCount,
bool *nextDataToggle); bool *nextDataToggle);
size_t ReadActualLength(ehci_qtd *topDescriptor, size_t ReadActualLength(ehci_qtd *topDescriptor,
bool *nextDataToggle); bool *nextDataToggle);
size_t WriteIsochronousDescriptorChain( size_t WriteIsochronousDescriptorChain(
isochronous_transfer_data *transfer, isochronous_transfer_data *transfer,
uint32 packetCount, uint32 packetCount,
iovec *vector); generic_io_vec *vector);
size_t ReadIsochronousDescriptorChain( size_t ReadIsochronousDescriptorChain(
isochronous_transfer_data *transfer); isochronous_transfer_data *transfer);
src/add-ons/kernel/busses/usb/ohci.cpp
+21 -21
View File
@@ -1261,7 +1261,7 @@ OHCI::_FinishTransfers()
if (callbackStatus == B_OK) { if (callbackStatus == B_OK) {
if (transfer->data_descriptor && transfer->incoming) { if (transfer->data_descriptor && transfer->incoming) {
// data to read out // data to read out
iovec *vector = transfer->transfer->Vector(); generic_io_vec *vector = transfer->transfer->Vector();
size_t vectorCount = transfer->transfer->VectorCount(); size_t vectorCount = transfer->transfer->VectorCount();
transfer->transfer->PrepareKernelAccess(); transfer->transfer->PrepareKernelAccess();
@@ -1430,7 +1430,7 @@ OHCI::_FinishIsochronousTransfer(transfer_data *transfer,
if (callbackStatus == B_OK && actualLength > 0) { if (callbackStatus == B_OK && actualLength > 0) {
if (transfer->data_descriptor && transfer->incoming) { if (transfer->data_descriptor && transfer->incoming) {
// data to read out // data to read out
iovec *vector = transfer->transfer->Vector(); generic_io_vec *vector = transfer->transfer->Vector();
size_t vectorCount = transfer->transfer->VectorCount(); size_t vectorCount = transfer->transfer->VectorCount();
transfer->transfer->PrepareKernelAccess(); transfer->transfer->PrepareKernelAccess();
@@ -1482,9 +1482,9 @@ OHCI::_SubmitRequest(Transfer *transfer)
| OHCI_TD_TOGGLE_1 | OHCI_TD_TOGGLE_1
| OHCI_TD_SET_DELAY_INTERRUPT(OHCI_TD_INTERRUPT_IMMEDIATE); | OHCI_TD_SET_DELAY_INTERRUPT(OHCI_TD_INTERRUPT_IMMEDIATE);
iovec vector; generic_io_vec vector;
vector.iov_base = requestData; vector.base = (generic_addr_t)requestData;
vector.iov_len = sizeof(usb_request_data); vector.length = sizeof(usb_request_data);
_WriteDescriptorChain(setupDescriptor, &vector, 1); _WriteDescriptorChain(setupDescriptor, &vector, 1);
status_t result; status_t result;
@@ -2278,7 +2278,7 @@ OHCI::_FreeIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor)
size_t size_t
OHCI::_WriteDescriptorChain(ohci_general_td *topDescriptor, iovec *vector, OHCI::_WriteDescriptorChain(ohci_general_td *topDescriptor, generic_io_vec *vector,
size_t vectorCount) size_t vectorCount)
{ {
ohci_general_td *current = topDescriptor; ohci_general_td *current = topDescriptor;
@@ -2293,19 +2293,19 @@ OHCI::_WriteDescriptorChain(ohci_general_td *topDescriptor, iovec *vector,
while (true) { while (true) {
size_t length = min_c(current->buffer_size - bufferOffset, 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" TRACE("copying %ld bytes to bufferOffset %ld from"
" vectorOffset %ld at index %ld of %ld\n", length, bufferOffset, " vectorOffset %ld at index %ld of %ld\n", length, bufferOffset,
vectorOffset, vectorIndex, vectorCount); vectorOffset, vectorIndex, vectorCount);
memcpy((uint8 *)current->buffer_logical + bufferOffset, memcpy((uint8 *)current->buffer_logical + bufferOffset,
(uint8 *)vector[vectorIndex].iov_base + vectorOffset, length); (uint8 *)vector[vectorIndex].base + vectorOffset, length);
actualLength += length; actualLength += length;
vectorOffset += length; vectorOffset += length;
bufferOffset += length; bufferOffset += length;
if (vectorOffset >= vector[vectorIndex].iov_len) { if (vectorOffset >= vector[vectorIndex].length) {
if (++vectorIndex >= vectorCount) { if (++vectorIndex >= vectorCount) {
TRACE("wrote descriptor chain (%ld bytes, no" TRACE("wrote descriptor chain (%ld bytes, no"
" more vectors)\n", actualLength); " more vectors)\n", actualLength);
@@ -2334,7 +2334,7 @@ OHCI::_WriteDescriptorChain(ohci_general_td *topDescriptor, iovec *vector,
size_t size_t
OHCI::_WriteIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor, OHCI::_WriteIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor,
iovec *vector, size_t vectorCount) generic_io_vec *vector, size_t vectorCount)
{ {
ohci_isochronous_td *current = topDescriptor; ohci_isochronous_td *current = topDescriptor;
size_t actualLength = 0; size_t actualLength = 0;
@@ -2348,19 +2348,19 @@ OHCI::_WriteIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor,
while (true) { while (true) {
size_t length = min_c(current->buffer_size - bufferOffset, 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" TRACE("copying %ld bytes to bufferOffset %ld from"
" vectorOffset %ld at index %ld of %ld\n", length, bufferOffset, " vectorOffset %ld at index %ld of %ld\n", length, bufferOffset,
vectorOffset, vectorIndex, vectorCount); vectorOffset, vectorIndex, vectorCount);
memcpy((uint8 *)current->buffer_logical + bufferOffset, memcpy((uint8 *)current->buffer_logical + bufferOffset,
(uint8 *)vector[vectorIndex].iov_base + vectorOffset, length); (uint8 *)vector[vectorIndex].base + vectorOffset, length);
actualLength += length; actualLength += length;
vectorOffset += length; vectorOffset += length;
bufferOffset += length; bufferOffset += length;
if (vectorOffset >= vector[vectorIndex].iov_len) { if (vectorOffset >= vector[vectorIndex].length) {
if (++vectorIndex >= vectorCount) { if (++vectorIndex >= vectorCount) {
TRACE("wrote descriptor chain (%ld bytes, no" TRACE("wrote descriptor chain (%ld bytes, no"
" more vectors)\n", actualLength); " more vectors)\n", actualLength);
@@ -2388,7 +2388,7 @@ OHCI::_WriteIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor,
size_t size_t
OHCI::_ReadDescriptorChain(ohci_general_td *topDescriptor, iovec *vector, OHCI::_ReadDescriptorChain(ohci_general_td *topDescriptor, generic_io_vec *vector,
size_t vectorCount) size_t vectorCount)
{ {
ohci_general_td *current = topDescriptor; ohci_general_td *current = topDescriptor;
@@ -2410,19 +2410,19 @@ OHCI::_ReadDescriptorChain(ohci_general_td *topDescriptor, iovec *vector,
while (true) { while (true) {
size_t length = min_c(bufferSize - bufferOffset, size_t length = min_c(bufferSize - bufferOffset,
vector[vectorIndex].iov_len - vectorOffset); vector[vectorIndex].length - vectorOffset);
TRACE("copying %ld bytes to vectorOffset %ld from" TRACE("copying %ld bytes to vectorOffset %ld from"
" bufferOffset %ld at index %ld of %ld\n", length, vectorOffset, " bufferOffset %ld at index %ld of %ld\n", length, vectorOffset,
bufferOffset, vectorIndex, vectorCount); bufferOffset, vectorIndex, vectorCount);
memcpy((uint8 *)vector[vectorIndex].iov_base + vectorOffset, memcpy((uint8 *)vector[vectorIndex].base + vectorOffset,
(uint8 *)current->buffer_logical + bufferOffset, length); (uint8 *)current->buffer_logical + bufferOffset, length);
actualLength += length; actualLength += length;
vectorOffset += length; vectorOffset += length;
bufferOffset += length; bufferOffset += length;
if (vectorOffset >= vector[vectorIndex].iov_len) { if (vectorOffset >= vector[vectorIndex].length) {
if (++vectorIndex >= vectorCount) { if (++vectorIndex >= vectorCount) {
TRACE("read descriptor chain (%ld bytes, no more vectors)\n", TRACE("read descriptor chain (%ld bytes, no more vectors)\n",
actualLength); actualLength);
@@ -2448,7 +2448,7 @@ OHCI::_ReadDescriptorChain(ohci_general_td *topDescriptor, iovec *vector,
void void
OHCI::_ReadIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor, OHCI::_ReadIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor,
iovec *vector, size_t vectorCount) generic_io_vec *vector, size_t vectorCount)
{ {
ohci_isochronous_td *current = topDescriptor; ohci_isochronous_td *current = topDescriptor;
size_t actualLength = 0; size_t actualLength = 0;
@@ -2462,19 +2462,19 @@ OHCI::_ReadIsochronousDescriptorChain(ohci_isochronous_td *topDescriptor,
if (current->buffer_logical != NULL && bufferSize > 0) { if (current->buffer_logical != NULL && bufferSize > 0) {
while (true) { while (true) {
size_t length = min_c(bufferSize - bufferOffset, 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" TRACE("copying %ld bytes to vectorOffset %ld from bufferOffset"
" %ld at index %ld of %ld\n", length, vectorOffset, " %ld at index %ld of %ld\n", length, vectorOffset,
bufferOffset, vectorIndex, vectorCount); bufferOffset, vectorIndex, vectorCount);
memcpy((uint8 *)vector[vectorIndex].iov_base + vectorOffset, memcpy((uint8 *)vector[vectorIndex].base + vectorOffset,
(uint8 *)current->buffer_logical + bufferOffset, length); (uint8 *)current->buffer_logical + bufferOffset, length);
actualLength += length; actualLength += length;
vectorOffset += length; vectorOffset += length;
bufferOffset += length; bufferOffset += length;
if (vectorOffset >= vector[vectorIndex].iov_len) { if (vectorOffset >= vector[vectorIndex].length) {
if (++vectorIndex >= vectorCount) { if (++vectorIndex >= vectorCount) {
TRACE("read descriptor chain (%ld bytes, " TRACE("read descriptor chain (%ld bytes, "
"no more vectors)\n", actualLength); "no more vectors)\n", actualLength);
src/add-ons/kernel/busses/usb/ohci.h
+4 -4
View File
@@ -135,17 +135,17 @@ static int32 _FinishThread(void *data);
size_t _WriteDescriptorChain( size_t _WriteDescriptorChain(
ohci_general_td *topDescriptor, ohci_general_td *topDescriptor,
iovec *vector, size_t vectorCount); generic_io_vec *vector, size_t vectorCount);
size_t _ReadDescriptorChain( size_t _ReadDescriptorChain(
ohci_general_td *topDescriptor, ohci_general_td *topDescriptor,
iovec *vector, size_t vectorCount); generic_io_vec *vector, size_t vectorCount);
size_t _WriteIsochronousDescriptorChain( size_t _WriteIsochronousDescriptorChain(
ohci_isochronous_td *topDescriptor, ohci_isochronous_td *topDescriptor,
iovec *vector, size_t vectorCount); generic_io_vec *vector, size_t vectorCount);
void _ReadIsochronousDescriptorChain( void _ReadIsochronousDescriptorChain(
ohci_isochronous_td *topDescriptor, ohci_isochronous_td *topDescriptor,
iovec *vector, size_t vectorCount); generic_io_vec *vector, size_t vectorCount);
size_t _ReadActualLength( size_t _ReadActualLength(
ohci_general_td *topDescriptor); ohci_general_td *topDescriptor);
src/add-ons/kernel/busses/usb/uhci.cpp
+19 -19
View File
@@ -930,7 +930,7 @@ UHCI::CheckDebugTransfer(Transfer *transfer)
uint8 lastDataToggle = 0; uint8 lastDataToggle = 0;
if (transfer->TransferPipe()->Direction() == Pipe::In) { if (transfer->TransferPipe()->Direction() == Pipe::In) {
// data to read out // data to read out
iovec *vector = transfer->Vector(); generic_io_vec *vector = transfer->Vector();
size_t vectorCount = transfer->VectorCount(); size_t vectorCount = transfer->VectorCount();
ReadDescriptorChain(transferData->first_descriptor, ReadDescriptorChain(transferData->first_descriptor,
@@ -1091,9 +1091,9 @@ UHCI::SubmitRequest(Transfer *transfer)
return B_NO_MEMORY; return B_NO_MEMORY;
} }
iovec vector; generic_io_vec vector;
vector.iov_base = requestData; vector.base = (generic_addr_t)requestData;
vector.iov_len = sizeof(usb_request_data); vector.length = sizeof(usb_request_data);
WriteDescriptorChain(setupDescriptor, &vector, 1); WriteDescriptorChain(setupDescriptor, &vector, 1);
statusDescriptor->status |= TD_CONTROL_IOC; statusDescriptor->status |= TD_CONTROL_IOC;
@@ -1311,7 +1311,7 @@ UHCI::SubmitIsochronous(Transfer *transfer)
// If direction is out set every descriptor data // If direction is out set every descriptor data
if (!directionIn) { if (!directionIn) {
iovec *vector = transfer->Vector(); generic_io_vec *vector = transfer->Vector();
WriteIsochronousDescriptorChain(isoRequest, WriteIsochronousDescriptorChain(isoRequest,
isochronousData->packet_count, vector); isochronousData->packet_count, vector);
} else { } else {
@@ -1613,7 +1613,7 @@ UHCI::FinishTransfers()
uint8 lastDataToggle = 0; uint8 lastDataToggle = 0;
if (transfer->data_descriptor && transfer->incoming) { if (transfer->data_descriptor && transfer->incoming) {
// data to read out // data to read out
iovec *vector = transfer->transfer->Vector(); generic_io_vec *vector = transfer->transfer->Vector();
size_t vectorCount = transfer->transfer->VectorCount(); size_t vectorCount = transfer->transfer->VectorCount();
transfer->transfer->PrepareKernelAccess(); transfer->transfer->PrepareKernelAccess();
@@ -1788,7 +1788,7 @@ UHCI::FinishIsochronousTransfers()
// remove the descriptors. // remove the descriptors.
if (transfer && transfer->is_active) { if (transfer && transfer->is_active) {
if (current->token & TD_TOKEN_IN) { if (current->token & TD_TOKEN_IN) {
iovec *vector = transfer->transfer->Vector(); generic_io_vec *vector = transfer->transfer->Vector();
transfer->transfer->PrepareKernelAccess(); transfer->transfer->PrepareKernelAccess();
ReadIsochronousDescriptorChain(transfer, vector); ReadIsochronousDescriptorChain(transfer, vector);
} }
@@ -2276,7 +2276,7 @@ UHCI::LinkDescriptors(uhci_td *first, uhci_td *second)
size_t size_t
UHCI::WriteDescriptorChain(uhci_td *topDescriptor, iovec *vector, UHCI::WriteDescriptorChain(uhci_td *topDescriptor, generic_io_vec *vector,
size_t vectorCount) size_t vectorCount)
{ {
uhci_td *current = topDescriptor; uhci_td *current = topDescriptor;
@@ -2291,19 +2291,19 @@ UHCI::WriteDescriptorChain(uhci_td *topDescriptor, iovec *vector,
while (true) { while (true) {
size_t length = min_c(current->buffer_size - bufferOffset, 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" TRACE("copying %ld bytes to bufferOffset %ld from"
" vectorOffset %ld at index %ld of %ld\n", length, bufferOffset, " vectorOffset %ld at index %ld of %ld\n", length, bufferOffset,
vectorOffset, vectorIndex, vectorCount); vectorOffset, vectorIndex, vectorCount);
memcpy((uint8 *)current->buffer_log + bufferOffset, memcpy((uint8 *)current->buffer_log + bufferOffset,
(uint8 *)vector[vectorIndex].iov_base + vectorOffset, length); (uint8 *)vector[vectorIndex].base + vectorOffset, length);
actualLength += length; actualLength += length;
vectorOffset += length; vectorOffset += length;
bufferOffset += length; bufferOffset += length;
if (vectorOffset >= vector[vectorIndex].iov_len) { if (vectorOffset >= vector[vectorIndex].length) {
if (++vectorIndex >= vectorCount) { if (++vectorIndex >= vectorCount) {
TRACE("wrote descriptor chain (%ld bytes, no more vectors)\n", TRACE("wrote descriptor chain (%ld bytes, no more vectors)\n",
actualLength); actualLength);
@@ -2331,7 +2331,7 @@ UHCI::WriteDescriptorChain(uhci_td *topDescriptor, iovec *vector,
size_t size_t
UHCI::ReadDescriptorChain(uhci_td *topDescriptor, iovec *vector, UHCI::ReadDescriptorChain(uhci_td *topDescriptor, generic_io_vec *vector,
size_t vectorCount, uint8 *lastDataToggle) size_t vectorCount, uint8 *lastDataToggle)
{ {
uint8 dataToggle = 0; uint8 dataToggle = 0;
@@ -2350,19 +2350,19 @@ UHCI::ReadDescriptorChain(uhci_td *topDescriptor, iovec *vector,
while (true) { while (true) {
size_t length = min_c(bufferSize - bufferOffset, size_t length = min_c(bufferSize - bufferOffset,
vector[vectorIndex].iov_len - vectorOffset); vector[vectorIndex].length - vectorOffset);
TRACE("copying %ld bytes to vectorOffset %ld from" TRACE("copying %ld bytes to vectorOffset %ld from"
" bufferOffset %ld at index %ld of %ld\n", length, vectorOffset, " bufferOffset %ld at index %ld of %ld\n", length, vectorOffset,
bufferOffset, vectorIndex, vectorCount); bufferOffset, vectorIndex, vectorCount);
memcpy((uint8 *)vector[vectorIndex].iov_base + vectorOffset, memcpy((uint8 *)vector[vectorIndex].base + vectorOffset,
(uint8 *)current->buffer_log + bufferOffset, length); (uint8 *)current->buffer_log + bufferOffset, length);
actualLength += length; actualLength += length;
vectorOffset += length; vectorOffset += length;
bufferOffset += length; bufferOffset += length;
if (vectorOffset >= vector[vectorIndex].iov_len) { if (vectorOffset >= vector[vectorIndex].length) {
if (++vectorIndex >= vectorCount) { if (++vectorIndex >= vectorCount) {
TRACE("read descriptor chain (%ld bytes, no more vectors)\n", TRACE("read descriptor chain (%ld bytes, no more vectors)\n",
actualLength); actualLength);
@@ -2421,13 +2421,13 @@ UHCI::ReadActualLength(uhci_td *topDescriptor, uint8 *lastDataToggle)
void void
UHCI::WriteIsochronousDescriptorChain(uhci_td **isoRequest, uint32 packetCount, UHCI::WriteIsochronousDescriptorChain(uhci_td **isoRequest, uint32 packetCount,
iovec *vector) generic_io_vec *vector)
{ {
size_t vectorOffset = 0; size_t vectorOffset = 0;
for (uint32 i = 0; i < packetCount; i++) { for (uint32 i = 0; i < packetCount; i++) {
size_t bufferSize = isoRequest[i]->buffer_size; size_t bufferSize = isoRequest[i]->buffer_size;
memcpy((uint8 *)isoRequest[i]->buffer_log, memcpy((uint8 *)isoRequest[i]->buffer_log,
(uint8 *)vector->iov_base + vectorOffset, bufferSize); (uint8 *)vector->base + vectorOffset, bufferSize);
vectorOffset += bufferSize; vectorOffset += bufferSize;
} }
} }
@@ -2435,7 +2435,7 @@ UHCI::WriteIsochronousDescriptorChain(uhci_td **isoRequest, uint32 packetCount,
void void
UHCI::ReadIsochronousDescriptorChain(isochronous_transfer_data *transfer, UHCI::ReadIsochronousDescriptorChain(isochronous_transfer_data *transfer,
iovec *vector) generic_io_vec *vector)
{ {
size_t vectorOffset = 0; size_t vectorOffset = 0;
usb_isochronous_data *isochronousData usb_isochronous_data *isochronousData
@@ -2456,7 +2456,7 @@ UHCI::ReadIsochronousDescriptorChain(isochronous_transfer_data *transfer,
vectorOffset += bufferSize; vectorOffset += bufferSize;
continue; continue;
} }
memcpy((uint8 *)vector->iov_base + vectorOffset, memcpy((uint8 *)vector->base + vectorOffset,
(uint8 *)current->buffer_log, bufferSize); (uint8 *)current->buffer_log, bufferSize);
vectorOffset += bufferSize; vectorOffset += bufferSize;
src/add-ons/kernel/busses/usb/uhci.h
+4 -4
View File
@@ -184,19 +184,19 @@ static int32 FinishIsochronousThread(void *data);
uhci_td *second); uhci_td *second);
size_t WriteDescriptorChain(uhci_td *topDescriptor, size_t WriteDescriptorChain(uhci_td *topDescriptor,
iovec *vector, size_t vectorCount); generic_io_vec *vector, size_t vectorCount);
size_t ReadDescriptorChain(uhci_td *topDescriptor, size_t ReadDescriptorChain(uhci_td *topDescriptor,
iovec *vector, size_t vectorCount, generic_io_vec *vector, size_t vectorCount,
uint8 *lastDataToggle); uint8 *lastDataToggle);
size_t ReadActualLength(uhci_td *topDescriptor, size_t ReadActualLength(uhci_td *topDescriptor,
uint8 *lastDataToggle); uint8 *lastDataToggle);
void WriteIsochronousDescriptorChain( void WriteIsochronousDescriptorChain(
uhci_td **isoRequest, uhci_td **isoRequest,
uint32 packetCount, uint32 packetCount,
iovec *vector); generic_io_vec *vector);
void ReadIsochronousDescriptorChain( void ReadIsochronousDescriptorChain(
isochronous_transfer_data *transfer, isochronous_transfer_data *transfer,
iovec *vector); generic_io_vec *vector);
// Register functions // Register functions
inline void WriteReg8(uint32 reg, uint8 value); inline void WriteReg8(uint32 reg, uint8 value);
src/add-ons/kernel/busses/usb/xhci.cpp
+7 -7
View File
@@ -878,7 +878,7 @@ XHCI::SubmitControlRequest(Transfer *transfer)
if (!directionIn) { if (!directionIn) {
transfer->PrepareKernelAccess(); transfer->PrepareKernelAccess();
memcpy(descriptor->buffers[0], memcpy(descriptor->buffers[0],
(uint8 *)transfer->Vector()[0].iov_base, requestData->Length); (uint8 *)transfer->Vector()[0].base, requestData->Length);
} }
index++; index++;
@@ -1427,18 +1427,18 @@ XHCI::FreeDescriptor(xhci_td *descriptor)
size_t 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 written = 0;
size_t bufIdx = 0, bufUsed = 0; size_t bufIdx = 0, bufUsed = 0;
for (size_t vecIdx = 0; vecIdx < vectorCount; vecIdx++) { 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) { while (length > 0 && bufIdx < descriptor->buffer_count) {
size_t toCopy = min_c(length, descriptor->buffer_size - bufUsed); size_t toCopy = min_c(length, descriptor->buffer_size - bufUsed);
memcpy((uint8 *)descriptor->buffers[bufIdx] + 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); toCopy);
written += toCopy; written += toCopy;
@@ -1457,17 +1457,17 @@ XHCI::WriteDescriptor(xhci_td *descriptor, iovec *vector, size_t vectorCount)
size_t 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 read = 0;
size_t bufIdx = 0, bufUsed = 0; size_t bufIdx = 0, bufUsed = 0;
for (size_t vecIdx = 0; vecIdx < vectorCount; vecIdx++) { 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) { while (length > 0 && bufIdx < descriptor->buffer_count) {
size_t toCopy = min_c(length, descriptor->buffer_size - bufUsed); 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); (uint8 *)descriptor->buffers[bufIdx] + bufUsed, toCopy);
read += toCopy; read += toCopy;
src/add-ons/kernel/busses/usb/xhci.h
+2 -2
View File
@@ -162,9 +162,9 @@ private:
void FreeDescriptor(xhci_td *descriptor); void FreeDescriptor(xhci_td *descriptor);
size_t WriteDescriptor(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, size_t ReadDescriptor(xhci_td *descriptor,
iovec *vector, size_t vectorCount); generic_io_vec *vector, size_t vectorCount);
status_t _LinkDescriptorForPipe(xhci_td *descriptor, status_t _LinkDescriptorForPipe(xhci_td *descriptor,
xhci_endpoint *endpoint); xhci_endpoint *endpoint);