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

usb: coding style cleanup.

Browse Source 
* Removed a few superfluous comments, too.
This commit is contained in:
Axel Dörfler
2014-05-22 18:33:26 +02:00
parent ee6a0b91b2
commit 1152f83ddc
1 changed files with 197 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/bus_managers/usb/Device.cpp
+197 -196
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2003-2006, Haiku Inc. All rights reserved. * Copyright 2003-2014, Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
* *
* Authors: * Authors:
@@ -7,29 +7,31 @@
* Niels S. Reedijk * Niels S. Reedijk
*/ */
#include "usb_private.h" #include "usb_private.h"
Device::Device(Object *parent, int8 hubAddress, uint8 hubPort, Device::Device(Object* parent, int8 hubAddress, uint8 hubPort,
usb_device_descriptor &desc, int8 deviceAddress, usb_speed speed, usb_device_descriptor& desc, int8 deviceAddress, usb_speed speed,
bool isRootHub, void *controllerCookie) bool isRootHub, void* controllerCookie)
: Object(parent), :
fDeviceDescriptor(desc), Object(parent),
fInitOK(false), fDeviceDescriptor(desc),
fAvailable(true), fInitOK(false),
fIsRootHub(isRootHub), fAvailable(true),
fConfigurations(NULL), fIsRootHub(isRootHub),
fCurrentConfiguration(NULL), fConfigurations(NULL),
fSpeed(speed), fCurrentConfiguration(NULL),
fDeviceAddress(deviceAddress), fSpeed(speed),
fHubAddress(hubAddress), fDeviceAddress(deviceAddress),
fHubPort(hubPort), fHubAddress(hubAddress),
fControllerCookie(controllerCookie) fHubPort(hubPort),
fControllerCookie(controllerCookie)
{ {
TRACE("creating device\n"); TRACE("creating device\n");
fDefaultPipe = new(std::nothrow) ControlPipe(this); fDefaultPipe = new(std::nothrow) ControlPipe(this);
if (!fDefaultPipe) { if (fDefaultPipe == NULL) {
TRACE_ERROR("could not allocate default pipe\n"); TRACE_ERROR("could not allocate default pipe\n");
return; return;
} }
@@ -41,7 +43,7 @@ Device::Device(Object *parent, int8 hubAddress, uint8 hubPort,
// We already have a part of it, but we want it all // We already have a part of it, but we want it all
size_t actualLength; size_t actualLength;
status_t status = GetDescriptor(USB_DESCRIPTOR_DEVICE, 0, 0, status_t status = GetDescriptor(USB_DESCRIPTOR_DEVICE, 0, 0,
(void *)&fDeviceDescriptor, sizeof(fDeviceDescriptor), &actualLength); (void*)&fDeviceDescriptor, sizeof(fDeviceDescriptor), &actualLength);
if (status < B_OK || actualLength != sizeof(fDeviceDescriptor)) { if (status < B_OK || actualLength != sizeof(fDeviceDescriptor)) {
TRACE_ERROR("error while getting the device descriptor\n"); TRACE_ERROR("error while getting the device descriptor\n");
@@ -65,7 +67,7 @@ Device::Device(Object *parent, int8 hubAddress, uint8 hubPort,
TRACE("\tnum_configurations:..%d\n", fDeviceDescriptor.num_configurations); TRACE("\tnum_configurations:..%d\n", fDeviceDescriptor.num_configurations);
// Get the configurations // Get the configurations
fConfigurations = (usb_configuration_info *)malloc( fConfigurations = (usb_configuration_info*)malloc(
fDeviceDescriptor.num_configurations * sizeof(usb_configuration_info)); fDeviceDescriptor.num_configurations * sizeof(usb_configuration_info));
if (fConfigurations == NULL) { if (fConfigurations == NULL) {
TRACE_ERROR("out of memory during config creations!\n"); TRACE_ERROR("out of memory during config creations!\n");
@@ -77,32 +79,37 @@ Device::Device(Object *parent, int8 hubAddress, uint8 hubPort,
for (int32 i = 0; i < fDeviceDescriptor.num_configurations; i++) { for (int32 i = 0; i < fDeviceDescriptor.num_configurations; i++) {
usb_configuration_descriptor configDescriptor; usb_configuration_descriptor configDescriptor;
status = GetDescriptor(USB_DESCRIPTOR_CONFIGURATION, i, 0, status = GetDescriptor(USB_DESCRIPTOR_CONFIGURATION, i, 0,
(void *)&configDescriptor, sizeof(usb_configuration_descriptor), (void*)&configDescriptor, sizeof(usb_configuration_descriptor),
&actualLength); &actualLength);
if (status < B_OK || actualLength != sizeof(usb_configuration_descriptor)) { if (status < B_OK
|| actualLength != sizeof(usb_configuration_descriptor)) {
TRACE_ERROR("error fetching configuration %" B_PRId32 "\n", i); TRACE_ERROR("error fetching configuration %" B_PRId32 "\n", i);
return; return;
} }
TRACE("configuration %" B_PRId32 "\n", i); TRACE("configuration %" B_PRId32 "\n", i);
TRACE("\tlength:..............%d\n", configDescriptor.length); TRACE("\tlength:..............%d\n", configDescriptor.length);
TRACE("\tdescriptor_type:.....0x%02x\n", configDescriptor.descriptor_type); TRACE("\tdescriptor_type:.....0x%02x\n",
configDescriptor.descriptor_type);
TRACE("\ttotal_length:........%d\n", configDescriptor.total_length); TRACE("\ttotal_length:........%d\n", configDescriptor.total_length);
TRACE("\tnumber_interfaces:...%d\n", configDescriptor.number_interfaces); TRACE("\tnumber_interfaces:...%d\n",
TRACE("\tconfiguration_value:.0x%02x\n", configDescriptor.configuration_value); configDescriptor.number_interfaces);
TRACE("\tconfiguration:.......0x%02x\n", configDescriptor.configuration); TRACE("\tconfiguration_value:.0x%02x\n",
configDescriptor.configuration_value);
TRACE("\tconfiguration:.......0x%02x\n",
configDescriptor.configuration);
TRACE("\tattributes:..........0x%02x\n", configDescriptor.attributes); TRACE("\tattributes:..........0x%02x\n", configDescriptor.attributes);
TRACE("\tmax_power:...........%d\n", configDescriptor.max_power); TRACE("\tmax_power:...........%d\n", configDescriptor.max_power);
uint8 *configData = (uint8 *)malloc(configDescriptor.total_length); uint8* configData = (uint8*)malloc(configDescriptor.total_length);
if (configData == NULL) { if (configData == NULL) {
TRACE_ERROR("out of memory when reading config\n"); TRACE_ERROR("out of memory when reading config\n");
return; return;
} }
status = GetDescriptor(USB_DESCRIPTOR_CONFIGURATION, i, 0, status = GetDescriptor(USB_DESCRIPTOR_CONFIGURATION, i, 0,
(void *)configData, configDescriptor.total_length, &actualLength); (void*)configData, configDescriptor.total_length, &actualLength);
if (status < B_OK || actualLength != configDescriptor.total_length) { if (status < B_OK || actualLength != configDescriptor.total_length) {
TRACE_ERROR("error fetching full configuration" TRACE_ERROR("error fetching full configuration"
@@ -112,11 +119,11 @@ Device::Device(Object *parent, int8 hubAddress, uint8 hubPort,
return; return;
} }
usb_configuration_descriptor *configuration usb_configuration_descriptor* configuration
= (usb_configuration_descriptor *)configData; = (usb_configuration_descriptor*)configData;
fConfigurations[i].descr = configuration; fConfigurations[i].descr = configuration;
fConfigurations[i].interface_count = configuration->number_interfaces; fConfigurations[i].interface_count = configuration->number_interfaces;
fConfigurations[i].interface = (usb_interface_list *)malloc( fConfigurations[i].interface = (usb_interface_list*)malloc(
configuration->number_interfaces * sizeof(usb_interface_list)); configuration->number_interfaces * sizeof(usb_interface_list));
if (fConfigurations[i].interface == NULL) { if (fConfigurations[i].interface == NULL) {
TRACE_ERROR("out of memory when creating interfaces\n"); TRACE_ERROR("out of memory when creating interfaces\n");
@@ -126,36 +133,49 @@ Device::Device(Object *parent, int8 hubAddress, uint8 hubPort,
memset(fConfigurations[i].interface, 0, memset(fConfigurations[i].interface, 0,
configuration->number_interfaces * sizeof(usb_interface_list)); configuration->number_interfaces * sizeof(usb_interface_list));
usb_interface_info *currentInterface = NULL; usb_interface_info* currentInterface = NULL;
uint32 descriptorStart = sizeof(usb_configuration_descriptor); uint32 descriptorStart = sizeof(usb_configuration_descriptor);
while (descriptorStart < actualLength) { while (descriptorStart < actualLength) {
switch (configData[descriptorStart + 1]) { switch (configData[descriptorStart + 1]) {
case USB_DESCRIPTOR_INTERFACE: { case USB_DESCRIPTOR_INTERFACE:
{
TRACE("got interface descriptor\n"); TRACE("got interface descriptor\n");
usb_interface_descriptor *interfaceDescriptor usb_interface_descriptor* interfaceDescriptor
= (usb_interface_descriptor *)&configData[descriptorStart]; = (usb_interface_descriptor*)&configData[
TRACE("\tlength:.............%d\n", interfaceDescriptor->length); descriptorStart];
TRACE("\tdescriptor_type:....0x%02x\n", interfaceDescriptor->descriptor_type); TRACE("\tlength:.............%d\n",
TRACE("\tinterface_number:...%d\n", interfaceDescriptor->interface_number); interfaceDescriptor->length);
TRACE("\talternate_setting:..%d\n", interfaceDescriptor->alternate_setting); TRACE("\tdescriptor_type:....0x%02x\n",
TRACE("\tnum_endpoints:......%d\n", interfaceDescriptor->num_endpoints); interfaceDescriptor->descriptor_type);
TRACE("\tinterface_class:....0x%02x\n", interfaceDescriptor->interface_class); TRACE("\tinterface_number:...%d\n",
TRACE("\tinterface_subclass:.0x%02x\n", interfaceDescriptor->interface_subclass); interfaceDescriptor->interface_number);
TRACE("\tinterface_protocol:.0x%02x\n", interfaceDescriptor->interface_protocol); TRACE("\talternate_setting:..%d\n",
TRACE("\tinterface:..........%d\n", interfaceDescriptor->interface); interfaceDescriptor->alternate_setting);
TRACE("\tnum_endpoints:......%d\n",
interfaceDescriptor->num_endpoints);
TRACE("\tinterface_class:....0x%02x\n",
interfaceDescriptor->interface_class);
TRACE("\tinterface_subclass:.0x%02x\n",
interfaceDescriptor->interface_subclass);
TRACE("\tinterface_protocol:.0x%02x\n",
interfaceDescriptor->interface_protocol);
TRACE("\tinterface:..........%d\n",
interfaceDescriptor->interface);
if (interfaceDescriptor->interface_number >= fConfigurations[i].interface_count) { if (interfaceDescriptor->interface_number
interfaceDescriptor->interface_number = fConfigurations[i].interface_count - 1; >= fConfigurations[i].interface_count) {
interfaceDescriptor->interface_number
= fConfigurations[i].interface_count - 1;
TRACE_ERROR("Corrected invalid interface_number!\n"); TRACE_ERROR("Corrected invalid interface_number!\n");
} }
usb_interface_list *interfaceList usb_interface_list* interfaceList = &fConfigurations[i]
= &fConfigurations[i].interface[interfaceDescriptor->interface_number]; .interface[interfaceDescriptor->interface_number];
/* Allocate this alternate */ // Allocate this alternate
interfaceList->alt_count++; interfaceList->alt_count++;
usb_interface_info *newAlternates usb_interface_info* newAlternates
= (usb_interface_info *)realloc(interfaceList->alt, = (usb_interface_info*)realloc(interfaceList->alt,
interfaceList->alt_count * sizeof(usb_interface_info)); interfaceList->alt_count * sizeof(usb_interface_info));
if (newAlternates == NULL) { if (newAlternates == NULL) {
TRACE_ERROR("out of memory allocating" TRACE_ERROR("out of memory allocating"
@@ -166,19 +186,19 @@ Device::Device(Object *parent, int8 hubAddress, uint8 hubPort,
interfaceList->alt = newAlternates; interfaceList->alt = newAlternates;
/* Set active interface always to the first one */ // Set active interface always to the first one
interfaceList->active = interfaceList->alt; interfaceList->active = interfaceList->alt;
/* Setup this alternate */ // Setup this alternate
usb_interface_info *interfaceInfo = usb_interface_info* interfaceInfo
&interfaceList->alt[interfaceList->alt_count - 1]; = &interfaceList->alt[interfaceList->alt_count - 1];
interfaceInfo->descr = interfaceDescriptor; interfaceInfo->descr = interfaceDescriptor;
interfaceInfo->endpoint_count = 0; interfaceInfo->endpoint_count = 0;
interfaceInfo->endpoint = NULL; interfaceInfo->endpoint = NULL;
interfaceInfo->generic_count = 0; interfaceInfo->generic_count = 0;
interfaceInfo->generic = NULL; interfaceInfo->generic = NULL;
Interface *interface = new(std::nothrow) Interface(this, Interface* interface = new(std::nothrow) Interface(this,
interfaceDescriptor->interface_number); interfaceDescriptor->interface_number);
if (interface == NULL) { if (interface == NULL) {
TRACE_ERROR("failed to allocate" TRACE_ERROR("failed to allocate"
@@ -191,39 +211,44 @@ Device::Device(Object *parent, int8 hubAddress, uint8 hubPort,
break; break;
} }
case USB_DESCRIPTOR_ENDPOINT: { case USB_DESCRIPTOR_ENDPOINT:
{
TRACE("got endpoint descriptor\n"); TRACE("got endpoint descriptor\n");
usb_endpoint_descriptor *endpointDescriptor usb_endpoint_descriptor* endpointDescriptor
= (usb_endpoint_descriptor *)&configData[descriptorStart]; = (usb_endpoint_descriptor*)&configData[descriptorStart];
TRACE("\tlength:.............%d\n", endpointDescriptor->length); TRACE("\tlength:.............%d\n",
TRACE("\tdescriptor_type:....0x%02x\n", endpointDescriptor->descriptor_type); endpointDescriptor->length);
TRACE("\tendpoint_address:...0x%02x\n", endpointDescriptor->endpoint_address); TRACE("\tdescriptor_type:....0x%02x\n",
TRACE("\tattributes:.........0x%02x\n", endpointDescriptor->attributes); endpointDescriptor->descriptor_type);
TRACE("\tmax_packet_size:....%d\n", endpointDescriptor->max_packet_size); TRACE("\tendpoint_address:...0x%02x\n",
TRACE("\tinterval:...........%d\n", endpointDescriptor->interval); endpointDescriptor->endpoint_address);
TRACE("\tattributes:.........0x%02x\n",
endpointDescriptor->attributes);
TRACE("\tmax_packet_size:....%d\n",
endpointDescriptor->max_packet_size);
TRACE("\tinterval:...........%d\n",
endpointDescriptor->interval);
if (!currentInterface) if (currentInterface == NULL)
break; break;
/* allocate this endpoint */ // Allocate this endpoint
currentInterface->endpoint_count++; currentInterface->endpoint_count++;
usb_endpoint_info *newEndpoints usb_endpoint_info* newEndpoints = (usb_endpoint_info*)
= (usb_endpoint_info *)realloc( realloc(currentInterface->endpoint,
currentInterface->endpoint, currentInterface->endpoint_count
currentInterface->endpoint_count * sizeof(usb_endpoint_info));
* sizeof(usb_endpoint_info));
if (newEndpoints == NULL) { if (newEndpoints == NULL) {
TRACE_ERROR("out of memory allocating" TRACE_ERROR("out of memory allocating new endpoint\n");
" new endpoint\n");
currentInterface->endpoint_count--; currentInterface->endpoint_count--;
return; return;
} }
currentInterface->endpoint = newEndpoints; currentInterface->endpoint = newEndpoints;
/* setup this endpoint */ // Setup this endpoint
usb_endpoint_info *endpointInfo = usb_endpoint_info* endpointInfo = &currentInterface
&currentInterface->endpoint[currentInterface->endpoint_count - 1]; ->endpoint[currentInterface->endpoint_count - 1];
endpointInfo->descr = endpointDescriptor; endpointInfo->descr = endpointDescriptor;
endpointInfo->handle = 0; endpointInfo->handle = 0;
break; break;
@@ -231,20 +256,22 @@ Device::Device(Object *parent, int8 hubAddress, uint8 hubPort,
default: default:
TRACE("got generic descriptor\n"); TRACE("got generic descriptor\n");
usb_generic_descriptor *genericDescriptor usb_generic_descriptor* genericDescriptor
= (usb_generic_descriptor *)&configData[descriptorStart]; = (usb_generic_descriptor*)&configData[descriptorStart];
TRACE("\tlength:.............%d\n", genericDescriptor->length); TRACE("\tlength:.............%d\n",
TRACE("\tdescriptor_type:....0x%02x\n", genericDescriptor->descriptor_type); genericDescriptor->length);
TRACE("\tdescriptor_type:....0x%02x\n",
genericDescriptor->descriptor_type);
if (!currentInterface) if (currentInterface == NULL)
break; break;
/* allocate this descriptor */ // Allocate this descriptor
currentInterface->generic_count++; currentInterface->generic_count++;
usb_descriptor **newGenerics = (usb_descriptor **)realloc( usb_descriptor** newGenerics = (usb_descriptor**)realloc(
currentInterface->generic, currentInterface->generic,
currentInterface->generic_count currentInterface->generic_count
* sizeof(usb_descriptor *)); * sizeof(usb_descriptor*));
if (newGenerics == NULL) { if (newGenerics == NULL) {
TRACE_ERROR("out of memory allocating" TRACE_ERROR("out of memory allocating"
" generic descriptor\n"); " generic descriptor\n");
@@ -254,9 +281,10 @@ Device::Device(Object *parent, int8 hubAddress, uint8 hubPort,
currentInterface->generic = newGenerics; currentInterface->generic = newGenerics;
/* add this descriptor */ // Add this descriptor
currentInterface->generic[currentInterface->generic_count - 1] = currentInterface->generic[
(usb_descriptor *)genericDescriptor; currentInterface->generic_count - 1]
= (usb_descriptor*)genericDescriptor;
break; break;
} }
@@ -266,7 +294,7 @@ Device::Device(Object *parent, int8 hubAddress, uint8 hubPort,
// Set default configuration // Set default configuration
TRACE("setting default configuration\n"); TRACE("setting default configuration\n");
if (SetConfigurationAt(0) < B_OK) { if (SetConfigurationAt(0) != B_OK) {
TRACE_ERROR("failed to set default configuration\n"); TRACE_ERROR("failed to set default configuration\n");
return; return;
} }
@@ -291,7 +319,7 @@ Device::~Device()
// Free all allocated resources // Free all allocated resources
for (int32 i = 0; i < fDeviceDescriptor.num_configurations; i++) { for (int32 i = 0; i < fDeviceDescriptor.num_configurations; i++) {
usb_configuration_info *configuration = &fConfigurations[i]; usb_configuration_info* configuration = &fConfigurations[i];
if (configuration == NULL) if (configuration == NULL)
continue; continue;
@@ -300,13 +328,13 @@ Device::~Device()
continue; continue;
for (size_t j = 0; j < configuration->interface_count; j++) { for (size_t j = 0; j < configuration->interface_count; j++) {
usb_interface_list *interfaceList = &configuration->interface[j]; usb_interface_list* interfaceList = &configuration->interface[j];
if (interfaceList->alt == NULL) if (interfaceList->alt == NULL)
continue; continue;
for (size_t k = 0; k < interfaceList->alt_count; k++) { for (size_t k = 0; k < interfaceList->alt_count; k++) {
usb_interface_info *interface = &interfaceList->alt[k]; usb_interface_info* interface = &interfaceList->alt[k];
delete (Interface *)GetStack()->GetObject(interface->handle); delete (Interface*)GetStack()->GetObject(interface->handle);
free(interface->endpoint); free(interface->endpoint);
free(interface->generic); free(interface->generic);
} }
@@ -332,11 +360,11 @@ Device::InitCheck()
status_t status_t
Device::Changed(change_item **changeList, bool added) Device::Changed(change_item** changeList, bool added)
{ {
fAvailable = added; fAvailable = added;
change_item *changeItem = new(std::nothrow) change_item; change_item* changeItem = new(std::nothrow) change_item;
if (!changeItem) if (changeItem == NULL)
return B_NO_MEMORY; return B_NO_MEMORY;
changeItem->added = added; changeItem->added = added;
@@ -349,31 +377,26 @@ Device::Changed(change_item **changeList, bool added)
status_t status_t
Device::GetDescriptor(uint8 descriptorType, uint8 index, uint16 languageID, Device::GetDescriptor(uint8 descriptorType, uint8 index, uint16 languageID,
void *data, size_t dataLength, size_t *actualLength) void* data, size_t dataLength, size_t* actualLength)
{ {
if (!fAvailable) if (!fAvailable)
return B_ERROR; return B_ERROR;
return fDefaultPipe->SendRequest( return fDefaultPipe->SendRequest(
USB_REQTYPE_DEVICE_IN | USB_REQTYPE_STANDARD, // type USB_REQTYPE_DEVICE_IN | USB_REQTYPE_STANDARD,
USB_REQUEST_GET_DESCRIPTOR, // request USB_REQUEST_GET_DESCRIPTOR, (descriptorType << 8) | index,
(descriptorType << 8) | index, // value languageID, dataLength, data, dataLength, actualLength);
languageID, // index
dataLength, // length
data, // buffer
dataLength, // buffer length
actualLength); // actual length
} }
const usb_configuration_info * const usb_configuration_info*
Device::Configuration() const Device::Configuration() const
{ {
return fCurrentConfiguration; return fCurrentConfiguration;
} }
const usb_configuration_info * const usb_configuration_info*
Device::ConfigurationAt(uint8 index) const Device::ConfigurationAt(uint8 index) const
{ {
if (index >= fDeviceDescriptor.num_configurations) if (index >= fDeviceDescriptor.num_configurations)
@@ -384,14 +407,14 @@ Device::ConfigurationAt(uint8 index) const
status_t status_t
Device::SetConfiguration(const usb_configuration_info *configuration) Device::SetConfiguration(const usb_configuration_info* configuration)
{ {
if (!configuration) if (!configuration)
return Unconfigure(true); return Unconfigure(true);
for (uint8 i = 0; i < fDeviceDescriptor.num_configurations; i++) { for (uint8 i = 0; i < fDeviceDescriptor.num_configurations; i++) {
if (configuration->descr->configuration_value if (configuration->descr->configuration_value
== fConfigurations[i].descr->configuration_value) == fConfigurations[i].descr->configuration_value)
return SetConfigurationAt(i); return SetConfigurationAt(i);
} }
@@ -414,15 +437,9 @@ Device::SetConfigurationAt(uint8 index)
// Tell the device to set the configuration // Tell the device to set the configuration
status_t result = fDefaultPipe->SendRequest( status_t result = fDefaultPipe->SendRequest(
USB_REQTYPE_DEVICE_OUT | USB_REQTYPE_STANDARD, // type USB_REQTYPE_DEVICE_OUT | USB_REQTYPE_STANDARD,
USB_REQUEST_SET_CONFIGURATION, // request USB_REQUEST_SET_CONFIGURATION,
fConfigurations[index].descr->configuration_value, // value fConfigurations[index].descr->configuration_value, 0, 0, NULL, 0, NULL);
0, // index
0, // length
NULL, // buffer
0, // buffer length
NULL); // actual length
if (result < B_OK) if (result < B_OK)
return result; return result;
@@ -446,30 +463,31 @@ Device::InitEndpoints(int32 interfaceIndex)
if (interfaceIndex >= 0 && j != (size_t)interfaceIndex) if (interfaceIndex >= 0 && j != (size_t)interfaceIndex)
continue; continue;
usb_interface_info *interfaceInfo = fCurrentConfiguration->interface[j].active; usb_interface_info* interfaceInfo
= fCurrentConfiguration->interface[j].active;
for (size_t i = 0; i < interfaceInfo->endpoint_count; i++) { for (size_t i = 0; i < interfaceInfo->endpoint_count; i++) {
usb_endpoint_info *endpoint = &interfaceInfo->endpoint[i]; usb_endpoint_info* endpoint = &interfaceInfo->endpoint[i];
Pipe *pipe = NULL; Pipe* pipe = NULL;
Pipe::pipeDirection direction = Pipe::Out; Pipe::pipeDirection direction = Pipe::Out;
if (endpoint->descr->endpoint_address & 0x80) if ((endpoint->descr->endpoint_address & 0x80) != 0)
direction = Pipe::In; direction = Pipe::In;
switch (endpoint->descr->attributes & 0x03) { switch (endpoint->descr->attributes & 0x03) {
case USB_ENDPOINT_ATTR_CONTROL: /* Control Endpoint */ case USB_ENDPOINT_ATTR_CONTROL: // Control Endpoint
pipe = new(std::nothrow) ControlPipe(this); pipe = new(std::nothrow) ControlPipe(this);
direction = Pipe::Default; direction = Pipe::Default;
break; break;
case USB_ENDPOINT_ATTR_ISOCHRONOUS: /* Isochronous Endpoint */ case USB_ENDPOINT_ATTR_ISOCHRONOUS: // Isochronous Endpoint
pipe = new(std::nothrow) IsochronousPipe(this); pipe = new(std::nothrow) IsochronousPipe(this);
break; break;
case USB_ENDPOINT_ATTR_BULK: /* Bulk Endpoint */ case USB_ENDPOINT_ATTR_BULK: // Bulk Endpoint
pipe = new(std::nothrow) BulkPipe(this); pipe = new(std::nothrow) BulkPipe(this);
break; break;
case USB_ENDPOINT_ATTR_INTERRUPT: /* Interrupt Endpoint */ case USB_ENDPOINT_ATTR_INTERRUPT: // Interrupt Endpoint
pipe = new(std::nothrow) InterruptPipe(this); pipe = new(std::nothrow) InterruptPipe(this);
break; break;
} }
@@ -493,21 +511,14 @@ Device::InitEndpoints(int32 interfaceIndex)
status_t status_t
Device::Unconfigure(bool atDeviceLevel) Device::Unconfigure(bool atDeviceLevel)
{ {
// if we only want to destroy our open pipes before setting // If we only want to destroy our open pipes before setting
// another configuration unconfigure will be called with // another configuration unconfigure will be called with
// atDevice = false. otherwise we explicitly want to unconfigure // atDevice = false. otherwise we explicitly want to unconfigure
// the device and have to send it the corresponding request. // the device and have to send it the corresponding request.
if (atDeviceLevel && fAvailable) { if (atDeviceLevel && fAvailable) {
status_t result = fDefaultPipe->SendRequest( status_t result = fDefaultPipe->SendRequest(
USB_REQTYPE_DEVICE_OUT | USB_REQTYPE_STANDARD, // type USB_REQTYPE_DEVICE_OUT | USB_REQTYPE_STANDARD,
USB_REQUEST_SET_CONFIGURATION, // request USB_REQUEST_SET_CONFIGURATION, 0, 0, 0, NULL, 0, NULL);
0, // value
0, // index
0, // length
NULL, // buffer
0, // buffer length
NULL); // actual length
if (result < B_OK) if (result < B_OK)
return result; return result;
@@ -526,20 +537,22 @@ Device::Unconfigure(bool atDeviceLevel)
void void
Device::ClearEndpoints(int32 interfaceIndex) Device::ClearEndpoints(int32 interfaceIndex)
{ {
if (fCurrentConfiguration == NULL || fCurrentConfiguration->interface == NULL) if (fCurrentConfiguration == NULL
|| fCurrentConfiguration->interface == NULL)
return; return;
for (size_t j = 0; j < fCurrentConfiguration->interface_count; j++) { for (size_t j = 0; j < fCurrentConfiguration->interface_count; j++) {
if (interfaceIndex >= 0 && j != (size_t)interfaceIndex) if (interfaceIndex >= 0 && j != (size_t)interfaceIndex)
continue; continue;
usb_interface_info *interfaceInfo = fCurrentConfiguration->interface[j].active; usb_interface_info* interfaceInfo
= fCurrentConfiguration->interface[j].active;
if (interfaceInfo == NULL || interfaceInfo->endpoint == NULL) if (interfaceInfo == NULL || interfaceInfo->endpoint == NULL)
continue; continue;
for (size_t i = 0; i < interfaceInfo->endpoint_count; i++) { for (size_t i = 0; i < interfaceInfo->endpoint_count; i++) {
usb_endpoint_info *endpoint = &interfaceInfo->endpoint[i]; usb_endpoint_info* endpoint = &interfaceInfo->endpoint[i];
delete (Pipe *)GetStack()->GetObject(endpoint->handle); delete (Pipe*)GetStack()->GetObject(endpoint->handle);
endpoint->handle = 0; endpoint->handle = 0;
} }
} }
@@ -547,20 +560,14 @@ Device::ClearEndpoints(int32 interfaceIndex)
status_t status_t
Device::SetAltInterface(const usb_interface_info *interface) Device::SetAltInterface(const usb_interface_info* interface)
{ {
uint8 interfaceNumber = interface->descr->interface_number; uint8 interfaceNumber = interface->descr->interface_number;
// Tell the device to set the alternate settings // Tell the device to set the alternate settings
status_t result = fDefaultPipe->SendRequest( status_t result = fDefaultPipe->SendRequest(
USB_REQTYPE_INTERFACE_OUT | USB_REQTYPE_STANDARD, // type USB_REQTYPE_INTERFACE_OUT | USB_REQTYPE_STANDARD,
USB_REQUEST_SET_INTERFACE, // request USB_REQUEST_SET_INTERFACE,
interface->descr->alternate_setting, // value interface->descr->alternate_setting, interfaceNumber, 0, NULL, 0, NULL);
interfaceNumber, // index
0, // length
NULL, // buffer
0, // buffer length
NULL);
if (result < B_OK) if (result < B_OK)
return result; return result;
@@ -568,7 +575,7 @@ Device::SetAltInterface(const usb_interface_info *interface)
ClearEndpoints(interfaceNumber); ClearEndpoints(interfaceNumber);
// Update the active pointer of the interface list // Update the active pointer of the interface list
usb_interface_list *interfaceList usb_interface_list* interfaceList
= &fCurrentConfiguration->interface[interfaceNumber]; = &fCurrentConfiguration->interface[interfaceNumber];
interfaceList->active interfaceList->active
= &interfaceList->alt[interface->descr->alternate_setting]; = &interfaceList->alt[interface->descr->alternate_setting];
@@ -578,7 +585,8 @@ Device::SetAltInterface(const usb_interface_info *interface)
return result; return result;
} }
const usb_device_descriptor *
const usb_device_descriptor*
Device::DeviceDescriptor() const Device::DeviceDescriptor() const
{ {
return &fDeviceDescriptor; return &fDeviceDescriptor;
@@ -586,9 +594,9 @@ Device::DeviceDescriptor() const
status_t status_t
Device::ReportDevice(usb_support_descriptor *supportDescriptors, Device::ReportDevice(usb_support_descriptor* supportDescriptors,
uint32 supportDescriptorCount, const usb_notify_hooks *hooks, uint32 supportDescriptorCount, const usb_notify_hooks* hooks,
usb_driver_cookie **cookies, bool added, bool recursive) usb_driver_cookie** cookies, bool added, bool recursive)
{ {
TRACE("reporting device\n"); TRACE("reporting device\n");
bool supported = false; bool supported = false;
@@ -597,31 +605,42 @@ Device::ReportDevice(usb_support_descriptor *supportDescriptors,
for (uint32 i = 0; !supported && i < supportDescriptorCount; i++) { for (uint32 i = 0; !supported && i < supportDescriptorCount; i++) {
if ((supportDescriptors[i].vendor != 0 if ((supportDescriptors[i].vendor != 0
&& fDeviceDescriptor.vendor_id != supportDescriptors[i].vendor) && fDeviceDescriptor.vendor_id != supportDescriptors[i].vendor)
|| (supportDescriptors[i].product != 0 || (supportDescriptors[i].product != 0
&& fDeviceDescriptor.product_id != supportDescriptors[i].product)) && fDeviceDescriptor.product_id
!= supportDescriptors[i].product))
continue; continue;
if ((supportDescriptors[i].dev_class == 0 if ((supportDescriptors[i].dev_class == 0
|| fDeviceDescriptor.device_class == supportDescriptors[i].dev_class) || fDeviceDescriptor.device_class
== supportDescriptors[i].dev_class)
&& (supportDescriptors[i].dev_subclass == 0 && (supportDescriptors[i].dev_subclass == 0
|| fDeviceDescriptor.device_subclass == supportDescriptors[i].dev_subclass) || fDeviceDescriptor.device_subclass
== supportDescriptors[i].dev_subclass)
&& (supportDescriptors[i].dev_protocol == 0 && (supportDescriptors[i].dev_protocol == 0
|| fDeviceDescriptor.device_protocol == supportDescriptors[i].dev_protocol)) { || fDeviceDescriptor.device_protocol
== supportDescriptors[i].dev_protocol)) {
supported = true; supported = true;
} }
// we have to check all interfaces for matching class/subclass/protocol // we have to check all interfaces for matching class/subclass/protocol
for (uint32 j = 0; !supported && j < fDeviceDescriptor.num_configurations; j++) { for (uint32 j = 0;
for (uint32 k = 0; !supported && k < fConfigurations[j].interface_count; k++) { !supported && j < fDeviceDescriptor.num_configurations; j++) {
for (uint32 l = 0; !supported && l < fConfigurations[j].interface[k].alt_count; l++) { for (uint32 k = 0;
usb_interface_descriptor *descriptor = fConfigurations[j].interface[k].alt[l].descr; !supported && k < fConfigurations[j].interface_count; k++) {
for (uint32 l = 0; !supported
&& l < fConfigurations[j].interface[k].alt_count; l++) {
usb_interface_descriptor* descriptor
= fConfigurations[j].interface[k].alt[l].descr;
if ((supportDescriptors[i].dev_class == 0 if ((supportDescriptors[i].dev_class == 0
|| descriptor->interface_class == supportDescriptors[i].dev_class) || descriptor->interface_class
== supportDescriptors[i].dev_class)
&& (supportDescriptors[i].dev_subclass == 0 && (supportDescriptors[i].dev_subclass == 0
|| descriptor->interface_subclass == supportDescriptors[i].dev_subclass) || descriptor->interface_subclass
== supportDescriptors[i].dev_subclass)
&& (supportDescriptors[i].dev_protocol == 0 && (supportDescriptors[i].dev_protocol == 0
|| descriptor->interface_protocol == supportDescriptors[i].dev_protocol)) { || descriptor->interface_protocol
== supportDescriptors[i].dev_protocol)) {
supported = true; supported = true;
} }
} }
@@ -641,7 +660,7 @@ Device::ReportDevice(usb_support_descriptor *supportDescriptors,
usb_id id = USBID(); usb_id id = USBID();
if (added) { if (added) {
usb_driver_cookie *cookie = new(std::nothrow) usb_driver_cookie; usb_driver_cookie* cookie = new(std::nothrow) usb_driver_cookie;
if (hooks->device_added(id, &cookie->cookie) >= B_OK) { if (hooks->device_added(id, &cookie->cookie) >= B_OK) {
cookie->device = id; cookie->device = id;
cookie->link = *cookies; cookie->link = *cookies;
@@ -649,16 +668,16 @@ Device::ReportDevice(usb_support_descriptor *supportDescriptors,
} else } else
delete cookie; delete cookie;
} else { } else {
usb_driver_cookie **pointer = cookies; usb_driver_cookie** pointer = cookies;
usb_driver_cookie *cookie = *cookies; usb_driver_cookie* cookie = *cookies;
while (cookie) { while (cookie != NULL) {
if (cookie->device == id) if (cookie->device == id)
break; break;
pointer = &cookie->link; pointer = &cookie->link;
cookie = cookie->link; cookie = cookie->link;
} }
if (!cookie) { if (cookie == NULL) {
// the device is supported, but there is no cookie. this most // the device is supported, but there is no cookie. this most
// probably means that the device_added hook above failed. // probably means that the device_added hook above failed.
return B_OK; return B_OK;
@@ -674,13 +693,13 @@ Device::ReportDevice(usb_support_descriptor *supportDescriptors,
status_t status_t
Device::BuildDeviceName(char *string, uint32 *index, size_t bufferSize, Device::BuildDeviceName(char* string, uint32* index, size_t bufferSize,
Device *device) Device* device)
{ {
if (!Parent() || (Parent()->Type() & USB_OBJECT_HUB) == 0) if (!Parent() || (Parent()->Type() & USB_OBJECT_HUB) == 0)
return B_ERROR; return B_ERROR;
((Hub *)Parent())->BuildDeviceName(string, index, bufferSize, this); ((Hub*)Parent())->BuildDeviceName(string, index, bufferSize, this);
return B_OK; return B_OK;
} }
@@ -694,13 +713,7 @@ Device::SetFeature(uint16 selector)
TRACE("set feature %u\n", selector); TRACE("set feature %u\n", selector);
return fDefaultPipe->SendRequest( return fDefaultPipe->SendRequest(
USB_REQTYPE_STANDARD | USB_REQTYPE_DEVICE_OUT, USB_REQTYPE_STANDARD | USB_REQTYPE_DEVICE_OUT,
USB_REQUEST_SET_FEATURE, USB_REQUEST_SET_FEATURE, selector, 0, 0, NULL, 0, NULL);
selector,
0,
0,
NULL,
0,
NULL);
} }
@@ -713,18 +726,12 @@ Device::ClearFeature(uint16 selector)
TRACE("clear feature %u\n", selector); TRACE("clear feature %u\n", selector);
return fDefaultPipe->SendRequest( return fDefaultPipe->SendRequest(
USB_REQTYPE_STANDARD | USB_REQTYPE_DEVICE_OUT, USB_REQTYPE_STANDARD | USB_REQTYPE_DEVICE_OUT,
USB_REQUEST_CLEAR_FEATURE, USB_REQUEST_CLEAR_FEATURE, selector, 0, 0, NULL, 0, NULL);
selector,
0,
0,
NULL,
0,
NULL);
} }
status_t status_t
Device::GetStatus(uint16 *status) Device::GetStatus(uint16* status)
{ {
if (!fAvailable) if (!fAvailable)
return B_ERROR; return B_ERROR;
@@ -732,11 +739,5 @@ Device::GetStatus(uint16 *status)
TRACE("get status\n"); TRACE("get status\n");
return fDefaultPipe->SendRequest( return fDefaultPipe->SendRequest(
USB_REQTYPE_STANDARD | USB_REQTYPE_DEVICE_IN, USB_REQTYPE_STANDARD | USB_REQTYPE_DEVICE_IN,
USB_REQUEST_GET_STATUS, USB_REQUEST_GET_STATUS, 0, 0, 2, (void*)status, 2, NULL);
0,
0,
2,
(void *)status,
2,
NULL);
} }