Aren
/
haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* Prepare usb_raw.h for eventually being made public. Prefixed enums values 

with B_USB_* and the command union is now usb_raw_command.
* Changed usb_raw and the BUSB* classes accordingly.
* Moved the raw_device struct into usb_raw.cpp as suggested by Francois as it
  was the only thing usb_raw_private.h defined.
* Removed usb_raw_private.h again because of the above.

git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24861 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Michael Lotz 2008-04-08 07:53:43 +00:00
parent 5822847842
commit bfbbfedc5f
8 changed files with 176 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

172
src/add-ons/kernel/drivers/bus/usb/usb_raw.cpp
View File

@ -8,14 +8,13 @@
#include <KernelExport.h>
#include <Drivers.h>
#include <lock.h>
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include "usb_raw.h"
#include "usb_raw_private.h"
#include "BeOSCompatibility.h"
//#define TRACE_USB_RAW
#ifdef TRACE_USB_RAW
#define TRACE(x) dprintf x
@ -23,10 +22,21 @@
#define TRACE(x) /* nothing */
#endif
#define DRIVER_NAME "usb_raw"
#define DEVICE_NAME "bus/usb/raw"
#define DRIVER_VERSION 0x0015
typedef struct {
usb_device device;
benaphore lock;
uint32 reference_count;
char name[32];
void *link;
sem_id notify;
status_t status;
size_t actual_length;
} raw_device;
int32 api_version = B_CUR_DRIVER_API_VERSION;
static usb_module_info *gUSBModule = NULL;
@ -175,22 +185,22 @@ usb_raw_callback(void *cookie, status_t status, void *data, size_t actualLength)
switch (status) {
case B_OK:
device->status = RAW_STATUS_SUCCESS;
device->status = B_USB_RAW_STATUS_SUCCESS;
break;
case B_TIMED_OUT:
device->status = RAW_STATUS_TIMEOUT;
device->status = B_USB_RAW_STATUS_TIMEOUT;
break;
case B_CANCELED:
device->status = RAW_STATUS_ABORTED;
device->status = B_USB_RAW_STATUS_ABORTED;
break;
case B_DEV_CRC_ERROR:
device->status = RAW_STATUS_CRC_ERROR;
device->status = B_USB_RAW_STATUS_CRC_ERROR;
break;
case B_DEV_STALLED:
device->status = RAW_STATUS_STALLED;
device->status = B_USB_RAW_STATUS_STALLED;
break;
default:
device->status = RAW_STATUS_FAILED;
device->status = B_USB_RAW_STATUS_FAILED;
break;
}
@ -204,199 +214,199 @@ usb_raw_ioctl(void *cookie, uint32 op, void *buffer, size_t length)
{
TRACE((DRIVER_NAME": ioctl\n"));
raw_device *device = (raw_device *)cookie;
raw_command *command = (raw_command *)buffer;
usb_raw_command *command = (usb_raw_command *)buffer;
if (device->device == 0)
return B_DEV_NOT_READY;
switch (op) {
case RAW_COMMAND_GET_VERSION: {
command->version.status = DRIVER_VERSION;
case B_USB_RAW_COMMAND_GET_VERSION: {
command->version.status = B_USB_RAW_PROTOCOL_VERSION;
return B_OK;
}
case RAW_COMMAND_GET_DEVICE_DESCRIPTOR: {
case B_USB_RAW_COMMAND_GET_DEVICE_DESCRIPTOR: {
const usb_device_descriptor *deviceDescriptor =
gUSBModule->get_device_descriptor(device->device);
if (!deviceDescriptor) {
command->device.status = RAW_STATUS_ABORTED;
command->device.status = B_USB_RAW_STATUS_ABORTED;
return B_OK;
}
memcpy(command->device.descriptor, deviceDescriptor,
sizeof(usb_device_descriptor));
command->device.status = RAW_STATUS_SUCCESS;
command->device.status = B_USB_RAW_STATUS_SUCCESS;
return B_OK;
}
case RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR: {
case B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR: {
const usb_configuration_info *configurationInfo =
gUSBModule->get_nth_configuration(device->device,
command->config.config_index);
if (!configurationInfo) {
command->config.status = RAW_STATUS_INVALID_CONFIGURATION;
command->config.status = B_USB_RAW_STATUS_INVALID_CONFIGURATION;
return B_OK;
}
memcpy(command->config.descriptor, configurationInfo->descr,
sizeof(usb_configuration_descriptor));
command->config.status = RAW_STATUS_SUCCESS;
command->config.status = B_USB_RAW_STATUS_SUCCESS;
return B_OK;
}
case RAW_COMMAND_GET_INTERFACE_DESCRIPTOR: {
case B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR: {
const usb_configuration_info *configurationInfo =
gUSBModule->get_nth_configuration(device->device,
command->interface.config_index);
if (!configurationInfo) {
command->interface.status = RAW_STATUS_INVALID_CONFIGURATION;
command->interface.status = B_USB_RAW_STATUS_INVALID_CONFIGURATION;
return B_OK;
}
if (command->interface.interface_index >= configurationInfo->interface_count) {
command->interface.status = RAW_STATUS_INVALID_INTERFACE;
command->interface.status = B_USB_RAW_STATUS_INVALID_INTERFACE;
return B_OK;
}
const usb_interface_info *interfaceInfo =
configurationInfo->interface[command->interface.interface_index].active;
if (!interfaceInfo) {
command->interface.status = RAW_STATUS_ABORTED;
command->interface.status = B_USB_RAW_STATUS_ABORTED;
return B_OK;
}
memcpy(command->interface.descriptor, interfaceInfo->descr,
sizeof(usb_interface_descriptor));
command->interface.status = RAW_STATUS_SUCCESS;
command->interface.status = B_USB_RAW_STATUS_SUCCESS;
return B_OK;
}
case RAW_COMMAND_GET_ALT_INTERFACE_COUNT: {
case B_USB_RAW_COMMAND_GET_ALT_INTERFACE_COUNT: {
const usb_configuration_info *configurationInfo =
gUSBModule->get_nth_configuration(device->device,
command->alternate.config_index);
if (!configurationInfo) {
command->alternate.status = RAW_STATUS_INVALID_CONFIGURATION;
command->alternate.status = B_USB_RAW_STATUS_INVALID_CONFIGURATION;
return B_OK;
}
if (command->alternate.interface_index >= configurationInfo->interface_count) {
command->alternate.status = RAW_STATUS_INVALID_INTERFACE;
command->alternate.status = B_USB_RAW_STATUS_INVALID_INTERFACE;
return B_OK;
}
*command->alternate.alternate_count
= configurationInfo->interface[command->alternate.interface_index].alt_count;
command->alternate.status = RAW_STATUS_SUCCESS;
command->alternate.status = B_USB_RAW_STATUS_SUCCESS;
return B_OK;
}
case RAW_COMMAND_GET_ALT_INTERFACE_DESCRIPTOR: {
case B_USB_RAW_COMMAND_GET_ALT_INTERFACE_DESCRIPTOR: {
const usb_configuration_info *configurationInfo =
gUSBModule->get_nth_configuration(device->device,
command->alternate.config_index);
if (!configurationInfo) {
command->alternate.status = RAW_STATUS_INVALID_CONFIGURATION;
command->alternate.status = B_USB_RAW_STATUS_INVALID_CONFIGURATION;
return B_OK;
}
if (command->alternate.interface_index >= configurationInfo->interface_count) {
command->alternate.status = RAW_STATUS_INVALID_INTERFACE;
command->alternate.status = B_USB_RAW_STATUS_INVALID_INTERFACE;
return B_OK;
}
const usb_interface_list *interfaceList =
&configurationInfo->interface[command->alternate.interface_index];
if (command->alternate.alternate_index >= interfaceList->alt_count) {
command->alternate.status = RAW_STATUS_INVALID_INTERFACE;
command->alternate.status = B_USB_RAW_STATUS_INVALID_INTERFACE;
return B_OK;
}
memcpy(command->alternate.descriptor,
&interfaceList->alt[command->alternate.alternate_index],
sizeof(usb_interface_descriptor));
command->alternate.status = RAW_STATUS_SUCCESS;
command->alternate.status = B_USB_RAW_STATUS_SUCCESS;
return B_OK;
}
case RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR: {
case B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR: {
const usb_configuration_info *configurationInfo =
gUSBModule->get_nth_configuration(device->device,
command->endpoint.config_index);
if (!configurationInfo) {
command->endpoint.status = RAW_STATUS_INVALID_CONFIGURATION;
command->endpoint.status = B_USB_RAW_STATUS_INVALID_CONFIGURATION;
return B_OK;
}
if (command->endpoint.interface_index >= configurationInfo->interface_count) {
command->endpoint.status = RAW_STATUS_INVALID_INTERFACE;
command->endpoint.status = B_USB_RAW_STATUS_INVALID_INTERFACE;
return B_OK;
}
const usb_interface_info *interfaceInfo =
configurationInfo->interface[command->endpoint.interface_index].active;
if (!interfaceInfo) {
command->endpoint.status = RAW_STATUS_ABORTED;
command->endpoint.status = B_USB_RAW_STATUS_ABORTED;
return B_OK;
}
if (command->endpoint.endpoint_index >= interfaceInfo->endpoint_count) {
command->endpoint.status = RAW_STATUS_INVALID_ENDPOINT;
command->endpoint.status = B_USB_RAW_STATUS_INVALID_ENDPOINT;
return B_OK;
}
memcpy(command->endpoint.descriptor,
interfaceInfo->endpoint[command->endpoint.endpoint_index].descr,
sizeof(usb_endpoint_descriptor));
command->endpoint.status = RAW_STATUS_SUCCESS;
command->endpoint.status = B_USB_RAW_STATUS_SUCCESS;
return B_OK;
}
case RAW_COMMAND_GET_GENERIC_DESCRIPTOR: {
case B_USB_RAW_COMMAND_GET_GENERIC_DESCRIPTOR: {
const usb_configuration_info *configurationInfo =
gUSBModule->get_nth_configuration(device->device,
command->generic.config_index);
if (!configurationInfo) {
command->generic.status = RAW_STATUS_INVALID_CONFIGURATION;
command->generic.status = B_USB_RAW_STATUS_INVALID_CONFIGURATION;
return B_OK;
}
if (command->generic.interface_index >= configurationInfo->interface_count) {
command->generic.status = RAW_STATUS_INVALID_INTERFACE;
command->generic.status = B_USB_RAW_STATUS_INVALID_INTERFACE;
return B_OK;
}
const usb_interface_info *interfaceInfo =
configurationInfo->interface[command->generic.interface_index].active;
if (!interfaceInfo) {
command->generic.status = RAW_STATUS_ABORTED;
command->generic.status = B_USB_RAW_STATUS_ABORTED;
return B_OK;
}
if (command->generic.generic_index >= interfaceInfo->generic_count) {
// ToDo: add RAW_STATUS_INVALID_GENERIC
command->generic.status = RAW_STATUS_INVALID_ENDPOINT;
// ToDo: add B_USB_RAW_STATUS_INVALID_GENERIC
command->generic.status = B_USB_RAW_STATUS_INVALID_ENDPOINT;
return B_OK;
}
usb_descriptor *descriptor = interfaceInfo->generic[command->generic.generic_index];
if (!descriptor) {
command->generic.status = RAW_STATUS_ABORTED;
command->generic.status = B_USB_RAW_STATUS_ABORTED;
return B_OK;
}
if (descriptor->generic.length > command->generic.length) {
command->generic.status = RAW_STATUS_NO_MEMORY;
command->generic.status = B_USB_RAW_STATUS_NO_MEMORY;
return B_OK;
}
memcpy(command->generic.descriptor, descriptor,
descriptor->generic.length);
command->generic.status = RAW_STATUS_SUCCESS;
command->generic.status = B_USB_RAW_STATUS_SUCCESS;
return B_OK;
}
case RAW_COMMAND_GET_STRING_DESCRIPTOR: {
case B_USB_RAW_COMMAND_GET_STRING_DESCRIPTOR: {
size_t actualLength = 0;
uint8 firstTwoBytes[2];
@ -405,7 +415,7 @@ usb_raw_ioctl(void *cookie, uint32 op, void *buffer, size_t length)
firstTwoBytes, 2, &actualLength) < B_OK
|| actualLength != 2
|| firstTwoBytes[1] != USB_DESCRIPTOR_STRING) {
command->string.status = RAW_STATUS_ABORTED;
command->string.status = B_USB_RAW_STATUS_ABORTED;
command->string.length = 0;
return B_OK;
}
@ -413,7 +423,7 @@ usb_raw_ioctl(void *cookie, uint32 op, void *buffer, size_t length)
uint8 stringLength = MIN(firstTwoBytes[0], command->string.length);
char *string = (char *)malloc(stringLength);
if (!string) {
command->string.status = RAW_STATUS_ABORTED;
command->string.status = B_USB_RAW_STATUS_ABORTED;
command->string.length = 0;
return B_NO_MEMORY;
}
@ -422,20 +432,20 @@ usb_raw_ioctl(void *cookie, uint32 op, void *buffer, size_t length)
USB_DESCRIPTOR_STRING, command->string.string_index, 0,
string, stringLength, &actualLength) < B_OK
|| actualLength != stringLength) {
command->string.status = RAW_STATUS_ABORTED;
command->string.status = B_USB_RAW_STATUS_ABORTED;
command->string.length = 0;
free(string);
return B_OK;
}
memcpy(command->string.descriptor, string, stringLength);
command->string.status = RAW_STATUS_SUCCESS;
command->string.status = B_USB_RAW_STATUS_SUCCESS;
command->string.length = stringLength;
free(string);
return B_OK;
}
case RAW_COMMAND_GET_DESCRIPTOR: {
case B_USB_RAW_COMMAND_GET_DESCRIPTOR: {
size_t actualLength = 0;
uint8 firstTwoBytes[2];
@ -445,7 +455,7 @@ usb_raw_ioctl(void *cookie, uint32 op, void *buffer, size_t length)
&actualLength) < B_OK
|| actualLength != 2
|| firstTwoBytes[1] != command->descriptor.type) {
command->descriptor.status = RAW_STATUS_ABORTED;
command->descriptor.status = B_USB_RAW_STATUS_ABORTED;
command->descriptor.length = 0;
return B_OK;
}
@ -453,7 +463,7 @@ usb_raw_ioctl(void *cookie, uint32 op, void *buffer, size_t length)
uint8 length = MIN(firstTwoBytes[0], command->descriptor.length);
uint8 *buffer = (uint8 *)malloc(length);
if (!buffer) {
command->descriptor.status = RAW_STATUS_ABORTED;
command->descriptor.status = B_USB_RAW_STATUS_ABORTED;
command->descriptor.length = 0;
return B_NO_MEMORY;
}
@ -463,77 +473,77 @@ usb_raw_ioctl(void *cookie, uint32 op, void *buffer, size_t length)
command->descriptor.language_id, buffer, length,
&actualLength) < B_OK
|| actualLength != length) {
command->descriptor.status = RAW_STATUS_ABORTED;
command->descriptor.status = B_USB_RAW_STATUS_ABORTED;
command->descriptor.length = 0;
free(buffer);
return B_OK;
}
memcpy(command->descriptor.data, buffer, length);
command->descriptor.status = RAW_STATUS_SUCCESS;
command->descriptor.status = B_USB_RAW_STATUS_SUCCESS;
command->descriptor.length = length;
free(buffer);
return B_OK;
}
case RAW_COMMAND_SET_CONFIGURATION: {
case B_USB_RAW_COMMAND_SET_CONFIGURATION: {
const usb_configuration_info *configurationInfo =
gUSBModule->get_nth_configuration(device->device,
command->config.config_index);
if (!configurationInfo) {
command->config.status = RAW_STATUS_INVALID_CONFIGURATION;
command->config.status = B_USB_RAW_STATUS_INVALID_CONFIGURATION;
return B_OK;
}
if (gUSBModule->set_configuration(device->device,
configurationInfo) < B_OK) {
command->config.status = RAW_STATUS_FAILED;
command->config.status = B_USB_RAW_STATUS_FAILED;
return B_OK;
}
command->config.status = RAW_STATUS_SUCCESS;
command->config.status = B_USB_RAW_STATUS_SUCCESS;
return B_OK;
}
case RAW_COMMAND_SET_ALT_INTERFACE: {
case B_USB_RAW_COMMAND_SET_ALT_INTERFACE: {
const usb_configuration_info *configurationInfo =
gUSBModule->get_nth_configuration(device->device,
command->alternate.config_index);
if (!configurationInfo) {
command->alternate.status = RAW_STATUS_INVALID_CONFIGURATION;
command->alternate.status = B_USB_RAW_STATUS_INVALID_CONFIGURATION;
return B_OK;
}
if (command->alternate.interface_index >= configurationInfo->interface_count) {
command->alternate.status = RAW_STATUS_INVALID_INTERFACE;
command->alternate.status = B_USB_RAW_STATUS_INVALID_INTERFACE;
return B_OK;
}
const usb_interface_list *interfaceList =
&configurationInfo->interface[command->alternate.interface_index];
if (command->alternate.alternate_index >= interfaceList->alt_count) {
command->alternate.status = RAW_STATUS_INVALID_INTERFACE;
command->alternate.status = B_USB_RAW_STATUS_INVALID_INTERFACE;
return B_OK;
}
if (gUSBModule->set_alt_interface(device->device,
&interfaceList->alt[command->alternate.alternate_index]) < B_OK) {
command->alternate.status = RAW_STATUS_FAILED;
command->alternate.status = B_USB_RAW_STATUS_FAILED;
return B_OK;
}
command->alternate.status = RAW_STATUS_SUCCESS;
command->alternate.status = B_USB_RAW_STATUS_SUCCESS;
return B_OK;
}
case RAW_COMMAND_CONTROL_TRANSFER: {
case B_USB_RAW_COMMAND_CONTROL_TRANSFER: {
benaphore_lock(&device->lock);
if (gUSBModule->queue_request(device->device,
command->control.request_type, command->control.request,
command->control.value, command->control.index,
command->control.length, command->control.data,
usb_raw_callback, device) < B_OK) {
command->control.status = RAW_STATUS_FAILED;
command->control.status = B_USB_RAW_STATUS_FAILED;
command->control.length = 0;
benaphore_unlock(&device->lock);
return B_OK;
@ -546,48 +556,48 @@ usb_raw_ioctl(void *cookie, uint32 op, void *buffer, size_t length)
return B_OK;
}
case RAW_COMMAND_INTERRUPT_TRANSFER:
case RAW_COMMAND_BULK_TRANSFER:
case RAW_COMMAND_ISOCHRONOUS_TRANSFER: {
case B_USB_RAW_COMMAND_INTERRUPT_TRANSFER:
case B_USB_RAW_COMMAND_BULK_TRANSFER:
case B_USB_RAW_COMMAND_ISOCHRONOUS_TRANSFER: {
const usb_configuration_info *configurationInfo =
gUSBModule->get_configuration(device->device);
if (!configurationInfo) {
command->transfer.status = RAW_STATUS_INVALID_CONFIGURATION;
command->transfer.status = B_USB_RAW_STATUS_INVALID_CONFIGURATION;
return B_OK;
}
if (command->transfer.interface >= configurationInfo->interface_count) {
command->transfer.status = RAW_STATUS_INVALID_INTERFACE;
command->transfer.status = B_USB_RAW_STATUS_INVALID_INTERFACE;
return B_OK;
}
const usb_interface_info *interfaceInfo =
configurationInfo->interface[command->transfer.interface].active;
if (!interfaceInfo) {
command->transfer.status = RAW_STATUS_ABORTED;
command->transfer.status = B_USB_RAW_STATUS_ABORTED;
return B_OK;
}
if (command->transfer.endpoint >= interfaceInfo->endpoint_count) {
command->transfer.status = RAW_STATUS_INVALID_ENDPOINT;
command->transfer.status = B_USB_RAW_STATUS_INVALID_ENDPOINT;
return B_OK;
}
const usb_endpoint_info *endpointInfo =
&interfaceInfo->endpoint[command->transfer.endpoint];
if (!endpointInfo->handle) {
command->transfer.status = RAW_STATUS_INVALID_ENDPOINT;
command->transfer.status = B_USB_RAW_STATUS_INVALID_ENDPOINT;
return B_OK;
}
benaphore_lock(&device->lock);
status_t status;
if (op == RAW_COMMAND_INTERRUPT_TRANSFER) {
if (op == B_USB_RAW_COMMAND_INTERRUPT_TRANSFER) {
status = gUSBModule->queue_interrupt(endpointInfo->handle,
command->transfer.data, command->transfer.length,
usb_raw_callback, device);
} else if (op == RAW_COMMAND_BULK_TRANSFER) {
} else if (op == B_USB_RAW_COMMAND_BULK_TRANSFER) {
status = gUSBModule->queue_bulk(endpointInfo->handle,
command->transfer.data, command->transfer.length,
usb_raw_callback, device);
@ -600,7 +610,7 @@ usb_raw_ioctl(void *cookie, uint32 op, void *buffer, size_t length)
}
if (status < B_OK) {
command->transfer.status = RAW_STATUS_FAILED;
command->transfer.status = B_USB_RAW_STATUS_FAILED;
command->transfer.length = 0;
benaphore_unlock(&device->lock);
return B_OK;

71
src/add-ons/kernel/drivers/bus/usb/usb_raw.h
View File

@ -1,9 +1,6 @@
/*
* Copyright 2006-2008, Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Michael Lotz <mmlr@mlotz.ch>
*/
#ifndef _USB_RAW_H_
@ -11,48 +8,50 @@
#include <USB3.h>
#define B_USB_RAW_PROTOCOL_VERSION 0x0015
typedef enum {
RAW_COMMAND_GET_VERSION = 0x1000,
B_USB_RAW_COMMAND_GET_VERSION = 0x1000,
RAW_COMMAND_GET_DEVICE_DESCRIPTOR = 0x2000,
RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR,
RAW_COMMAND_GET_INTERFACE_DESCRIPTOR,
RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR,
RAW_COMMAND_GET_STRING_DESCRIPTOR,
RAW_COMMAND_GET_GENERIC_DESCRIPTOR,
RAW_COMMAND_GET_ALT_INTERFACE_COUNT,
RAW_COMMAND_GET_ALT_INTERFACE_DESCRIPTOR,
B_USB_RAW_COMMAND_GET_DEVICE_DESCRIPTOR = 0x2000,
B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR,
B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR,
B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR,
B_USB_RAW_COMMAND_GET_STRING_DESCRIPTOR,
B_USB_RAW_COMMAND_GET_GENERIC_DESCRIPTOR,
B_USB_RAW_COMMAND_GET_ALT_INTERFACE_COUNT,
B_USB_RAW_COMMAND_GET_ALT_INTERFACE_DESCRIPTOR,
RAW_COMMAND_SET_CONFIGURATION = 0x3000,
RAW_COMMAND_SET_FEATURE,
RAW_COMMAND_CLEAR_FEATURE,
RAW_COMMAND_GET_STATUS,
RAW_COMMAND_GET_DESCRIPTOR,
RAW_COMMAND_SET_ALT_INTERFACE,
B_USB_RAW_COMMAND_SET_CONFIGURATION = 0x3000,
B_USB_RAW_COMMAND_SET_FEATURE,
B_USB_RAW_COMMAND_CLEAR_FEATURE,
B_USB_RAW_COMMAND_GET_STATUS,
B_USB_RAW_COMMAND_GET_DESCRIPTOR,
B_USB_RAW_COMMAND_SET_ALT_INTERFACE,
RAW_COMMAND_CONTROL_TRANSFER = 0x4000,
RAW_COMMAND_INTERRUPT_TRANSFER,
RAW_COMMAND_BULK_TRANSFER,
RAW_COMMAND_ISOCHRONOUS_TRANSFER
} raw_command_id;
B_USB_RAW_COMMAND_CONTROL_TRANSFER = 0x4000,
B_USB_RAW_COMMAND_INTERRUPT_TRANSFER,
B_USB_RAW_COMMAND_BULK_TRANSFER,
B_USB_RAW_COMMAND_ISOCHRONOUS_TRANSFER
} usb_raw_command_id;
typedef enum {
RAW_STATUS_SUCCESS = 0,
B_USB_RAW_STATUS_SUCCESS = 0,
RAW_STATUS_FAILED,
RAW_STATUS_ABORTED,
RAW_STATUS_STALLED,
RAW_STATUS_CRC_ERROR,
RAW_STATUS_TIMEOUT,
B_USB_RAW_STATUS_FAILED,
B_USB_RAW_STATUS_ABORTED,
B_USB_RAW_STATUS_STALLED,
B_USB_RAW_STATUS_CRC_ERROR,
B_USB_RAW_STATUS_TIMEOUT,
RAW_STATUS_INVALID_CONFIGURATION,
RAW_STATUS_INVALID_INTERFACE,
RAW_STATUS_INVALID_ENDPOINT,
RAW_STATUS_INVALID_STRING,
B_USB_RAW_STATUS_INVALID_CONFIGURATION,
B_USB_RAW_STATUS_INVALID_INTERFACE,
B_USB_RAW_STATUS_INVALID_ENDPOINT,
B_USB_RAW_STATUS_INVALID_STRING,
RAW_STATUS_NO_MEMORY
} raw_command_status;
B_USB_RAW_STATUS_NO_MEMORY
} usb_raw_command_status;
typedef union {
@ -147,6 +146,6 @@ typedef union {
usb_iso_packet_descriptor *packet_descriptors;
uint32 packet_count;
} isochronous;
} raw_command;
} usb_raw_command;
#endif // _USB_RAW_H_

28
src/add-ons/kernel/drivers/bus/usb/usb_raw_private.h
View File

@ -1,28 +0,0 @@
/*
* Copyright 2008, Haiku Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*
* Authors:
* Michael Lotz <mmlr@mlotz.ch>
*/
#ifndef _USB_RAW_PRIVATE_H_
#define _USB_RAW_PRIVATE_H_
#include <lock.h>
#include <USB3.h>
typedef struct {
usb_device device;
benaphore lock;
uint32 reference_count;
char name[32];
void *link;
sem_id notify;
status_t status;
size_t actual_length;
} raw_device;
#endif // _USB_RAW_PRIVATE_H_

7
src/kits/device/USBConfiguration.cpp
View File

@ -19,13 +19,12 @@ BUSBConfiguration::BUSBConfiguration(BUSBDevice *device, uint32 index, int rawFD
fInterfaces(NULL),
fConfigurationString(NULL)
{
raw_command command;
usb_raw_command command;
command.config.descriptor = &fDescriptor;
command.config.config_index = fIndex;
if (ioctl(fRawFD, RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR, &command, sizeof(command))
|| command.config.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_CONFIGURATION_DESCRIPTOR, &command,
sizeof(command)) || command.config.status != B_USB_RAW_STATUS_SUCCESS)
memset(&fDescriptor, 0, sizeof(fDescriptor));
}
fInterfaces = new BUSBInterface *[fDescriptor.number_interfaces];
for (uint32 i = 0; i < fDescriptor.number_interfaces; i++)

38
src/kits/device/USBDevice.cpp
View File

@ -55,16 +55,16 @@ BUSBDevice::SetTo(const char *path)
return B_ERROR;
}
raw_command command;
if (ioctl(fRawFD, RAW_COMMAND_GET_VERSION, &command, sizeof(command))
|| command.version.status != 0x0015) {
usb_raw_command command;
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_VERSION, &command, sizeof(command))
|| command.version.status != B_USB_RAW_PROTOCOL_VERSION) {
Unset();
return B_ERROR;
}
command.device.descriptor = &fDescriptor;
if (ioctl(fRawFD, RAW_COMMAND_GET_DEVICE_DESCRIPTOR, &command, sizeof(command))
|| command.device.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_DEVICE_DESCRIPTOR, &command,
sizeof(command)) || command.device.status != B_USB_RAW_STATUS_SUCCESS) {
Unset();
return B_ERROR;
}
@ -244,15 +244,14 @@ BUSBDevice::GetStringDescriptor(uint32 index,
if (!descriptor)
return B_BAD_VALUE;
raw_command command;
usb_raw_command command;
command.string.descriptor = descriptor;
command.string.string_index = index;
command.string.length = length;
if (ioctl(fRawFD, RAW_COMMAND_GET_STRING_DESCRIPTOR, &command, sizeof(command))
|| command.string.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_STRING_DESCRIPTOR, &command,
sizeof(command)) || command.string.status != B_USB_RAW_STATUS_SUCCESS)
return 0;
}
return command.string.length;
}
@ -288,17 +287,16 @@ BUSBDevice::GetDescriptor(uint8 type, uint8 index, uint16 languageID,
if (length > 0 && data == NULL)
return B_BAD_VALUE;
raw_command command;
usb_raw_command command;
command.descriptor.type = type;
command.descriptor.index = index;
command.descriptor.language_id = languageID;
command.descriptor.data = data;
command.descriptor.length = length;
if (ioctl(fRawFD, RAW_COMMAND_GET_DESCRIPTOR, &command, sizeof(command))
|| command.descriptor.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_DESCRIPTOR, &command,
sizeof(command)) || command.descriptor.status != B_USB_RAW_STATUS_SUCCESS)
return 0;
}
return command.descriptor.length;
}
@ -334,13 +332,12 @@ BUSBDevice::SetConfiguration(const BUSBConfiguration *configuration)
if (!configuration || configuration->Index() >= fDescriptor.num_configurations)
return B_BAD_VALUE;
raw_command command;
usb_raw_command command;
command.config.config_index = configuration->Index();
if (ioctl(fRawFD, RAW_COMMAND_SET_CONFIGURATION, &command, sizeof(command))
|| command.config.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_SET_CONFIGURATION, &command,
sizeof(command)) || command.config.status != B_USB_RAW_STATUS_SUCCESS)
return B_ERROR;
}
fActiveConfiguration = configuration->Index();
return B_OK;
@ -354,7 +351,7 @@ BUSBDevice::ControlTransfer(uint8 requestType, uint8 request, uint16 value,
if (length > 0 && data == NULL)
return B_BAD_VALUE;
raw_command command;
usb_raw_command command;
command.control.request_type = requestType;
command.control.request = request;
command.control.value = value;
@ -362,10 +359,9 @@ BUSBDevice::ControlTransfer(uint8 requestType, uint8 request, uint16 value,
command.control.length = length;
command.control.data = data;
if (ioctl(fRawFD, RAW_COMMAND_CONTROL_TRANSFER, &command, sizeof(command))
|| command.control.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_CONTROL_TRANSFER, &command,
sizeof(command)) || command.control.status != B_USB_RAW_STATUS_SUCCESS)
return B_ERROR;
}
return command.control.length;
}

35
src/kits/device/USBEndpoint.cpp
View File

@ -17,15 +17,14 @@ BUSBEndpoint::BUSBEndpoint(BUSBInterface *interface, uint32 index, int rawFD)
fIndex(index),
fRawFD(rawFD)
{
raw_command command;
usb_raw_command command;
command.endpoint.descriptor = &fDescriptor;
command.endpoint.config_index = fInterface->Configuration()->Index();
command.endpoint.interface_index = fInterface->Index();
command.endpoint.endpoint_index = fIndex;
if (ioctl(fRawFD, RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR, &command, sizeof(command))
|| command.config.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ENDPOINT_DESCRIPTOR, &command,
sizeof(command)) || command.config.status != B_USB_RAW_STATUS_SUCCESS)
memset(&fDescriptor, 0, sizeof(fDescriptor));
}
}
@ -132,7 +131,7 @@ BUSBEndpoint::ControlTransfer(uint8 requestType, uint8 request, uint16 value,
if (length > 0 && data == NULL)
return B_BAD_VALUE;
raw_command command;
usb_raw_command command;
command.control.request_type = requestType;
command.control.request = request;
command.control.value = value;
@ -140,10 +139,9 @@ BUSBEndpoint::ControlTransfer(uint8 requestType, uint8 request, uint16 value,
command.control.length = length;
command.control.data = data;
if (ioctl(fRawFD, RAW_COMMAND_CONTROL_TRANSFER, &command, sizeof(command))
|| command.control.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_CONTROL_TRANSFER, &command,
sizeof(command)) || command.control.status != B_USB_RAW_STATUS_SUCCESS)
return B_ERROR;
}
return command.control.length;
}
@ -155,16 +153,15 @@ BUSBEndpoint::InterruptTransfer(void *data, size_t length) const
if (length > 0 && data == NULL)
return B_BAD_VALUE;
raw_command command;
usb_raw_command command;
command.transfer.interface = fInterface->Index();
command.transfer.endpoint = fIndex;
command.transfer.data = data;
command.transfer.length = length;
if (ioctl(fRawFD, RAW_COMMAND_INTERRUPT_TRANSFER, &command, sizeof(command))
|| command.transfer.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_INTERRUPT_TRANSFER, &command,
sizeof(command)) || command.transfer.status != B_USB_RAW_STATUS_SUCCESS)
return B_ERROR;
}
return command.transfer.length;
}
@ -176,16 +173,15 @@ BUSBEndpoint::BulkTransfer(void *data, size_t length) const
if (length > 0 && data == NULL)
return B_BAD_VALUE;
raw_command command;
usb_raw_command command;
command.transfer.interface = fInterface->Index();
command.transfer.endpoint = fIndex;
command.transfer.data = data;
command.transfer.length = length;
if (ioctl(fRawFD, RAW_COMMAND_BULK_TRANSFER, &command, sizeof(command))
|| command.transfer.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_BULK_TRANSFER, &command,
sizeof(command)) || command.transfer.status != B_USB_RAW_STATUS_SUCCESS)
return B_ERROR;
}
return command.transfer.length;
}
@ -198,7 +194,7 @@ BUSBEndpoint::IsochronousTransfer(void *data, size_t length,
if (length > 0 && data == NULL)
return B_BAD_VALUE;
raw_command command;
usb_raw_command command;
command.isochronous.interface = fInterface->Index();
command.isochronous.endpoint = fIndex;
command.isochronous.data = data;
@ -206,10 +202,9 @@ BUSBEndpoint::IsochronousTransfer(void *data, size_t length,
command.isochronous.packet_descriptors = packetDescriptors;
command.isochronous.packet_count = packetCount;
if (ioctl(fRawFD, RAW_COMMAND_ISOCHRONOUS_TRANSFER, &command, sizeof(command))
|| command.isochronous.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_ISOCHRONOUS_TRANSFER, &command,
sizeof(command)) || command.isochronous.status != B_USB_RAW_STATUS_SUCCESS)
return B_ERROR;
}
return command.isochronous.length;
}

34
src/kits/device/USBInterface.cpp
View File

@ -110,16 +110,15 @@ BUSBInterface::OtherDescriptorAt(uint32 index, usb_descriptor *descriptor,
if (length > 0 && descriptor == NULL)
return B_BAD_VALUE;
raw_command command;
usb_raw_command command;
command.generic.descriptor = descriptor;
command.generic.config_index = fConfiguration->Index();
command.generic.interface_index = fIndex;
command.generic.length = length;
command.generic.generic_index = index;
if (ioctl(fRawFD, RAW_COMMAND_GET_GENERIC_DESCRIPTOR, &command, sizeof(command))
|| command.generic.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_GENERIC_DESCRIPTOR, &command,
sizeof(command)) || command.generic.status != B_USB_RAW_STATUS_SUCCESS)
return B_ERROR;
}
return B_OK;
}
@ -146,14 +145,13 @@ uint32
BUSBInterface::CountAlternates() const
{
uint32 alternateCount;
raw_command command;
usb_raw_command command;
command.alternate.alternate_count = &alternateCount;
command.alternate.config_index = fConfiguration->Index();
command.alternate.interface_index = fIndex;
if (ioctl(fRawFD, RAW_COMMAND_GET_ALT_INTERFACE_COUNT, &command, sizeof(command))
|| command.alternate.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ALT_INTERFACE_COUNT, &command,
sizeof(command)) || command.alternate.status != B_USB_RAW_STATUS_SUCCESS)
return 1;
}
return alternateCount;
}
@ -167,13 +165,13 @@ BUSBInterface::AlternateAt(uint32 alternateIndex)
if (descriptor == NULL)
return NULL;
raw_command command;
usb_raw_command command;
command.alternate.descriptor = descriptor;
command.alternate.config_index = fConfiguration->Index();
command.alternate.interface_index = fIndex;
command.alternate.alternate_index = alternateIndex;
if (ioctl(fRawFD, RAW_COMMAND_GET_ALT_INTERFACE_DESCRIPTOR, &command,
sizeof(command)) || command.alternate.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_ALT_INTERFACE_DESCRIPTOR, &command,
sizeof(command)) || command.alternate.status != B_USB_RAW_STATUS_SUCCESS) {
delete descriptor;
return NULL;
}
@ -185,14 +183,13 @@ BUSBInterface::AlternateAt(uint32 alternateIndex)
status_t
BUSBInterface::SetAlternate(uint32 alternateIndex)
{
raw_command command;
usb_raw_command command;
command.alternate.config_index = fConfiguration->Index();
command.alternate.interface_index = fIndex;
command.alternate.alternate_index = alternateIndex;
if (ioctl(fRawFD, RAW_COMMAND_SET_ALT_INTERFACE, &command, sizeof(command))
|| command.alternate.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_SET_ALT_INTERFACE, &command,
sizeof(command)) || command.alternate.status != B_USB_RAW_STATUS_SUCCESS)
return B_ERROR;
}
_UpdateDescriptorAndEndpoints();
return B_OK;
@ -202,14 +199,13 @@ BUSBInterface::SetAlternate(uint32 alternateIndex)
void
BUSBInterface::_UpdateDescriptorAndEndpoints()
{
raw_command command;
usb_raw_command command;
command.interface.descriptor = &fDescriptor;
command.interface.config_index = fConfiguration->Index();
command.interface.interface_index = fIndex;
if (ioctl(fRawFD, RAW_COMMAND_GET_INTERFACE_DESCRIPTOR, &command, sizeof(command))
|| command.interface.status != RAW_STATUS_SUCCESS) {
if (ioctl(fRawFD, B_USB_RAW_COMMAND_GET_INTERFACE_DESCRIPTOR, &command,
sizeof(command)) || command.interface.status != B_USB_RAW_STATUS_SUCCESS)
memset(&fDescriptor, 0, sizeof(fDescriptor));
}
if (fEndpoints) {
// Delete old endpoints

1
src/kits/device/USBRoster.cpp
View File

@ -7,7 +7,6 @@
*/
#include <USBKit.h>
#include <usb_raw.h>
#include <Directory.h>
#include <Entry.h>
#include <Looper.h>