#include "urbdrc_types.h"
#include "data_transfer.h"
-
-static void
-usb_process_get_port_status(IUDEVICE * pdev, uint8 * OutputBuffer)
+static void usb_process_get_port_status(IUDEVICE* pdev, uint8* OutputBuffer)
{
int bcdUSB = pdev->query_device_descriptor(pdev, BCD_USB);
- switch (bcdUSB){
+
+ switch (bcdUSB)
+ {
case USB_v1_0:
data_write_uint32(OutputBuffer, 0x303);
break;
+
case USB_v1_1:
data_write_uint32(OutputBuffer, 0x103);
break;
+
case USB_v2_0:
data_write_uint32(OutputBuffer, 0x503);
break;
+
default:
data_write_uint32(OutputBuffer, 0x503);
break;
}
}
-
#if ISOCH_FIFO
-static int
-func_check_isochronous_fds(IUDEVICE * pdev)
+
+static int func_check_isochronous_fds(IUDEVICE* pdev)
{
- ISOCH_CALLBACK_QUEUE * isoch_queue = NULL;
- ISOCH_CALLBACK_DATA * isoch = NULL;
- URBDRC_CHANNEL_CALLBACK * callback;
- uint32 size_temp, process_times = 2;
- uint8 * data_temp;
int ret = 0;
+ uint8* data_temp;
+ uint32 size_temp, process_times = 2;
+ ISOCH_CALLBACK_QUEUE* isoch_queue = NULL;
+ ISOCH_CALLBACK_DATA* isoch = NULL;
+ URBDRC_CHANNEL_CALLBACK* callback;
- isoch_queue = (ISOCH_CALLBACK_QUEUE *)pdev->get_isoch_queue(pdev);
+ isoch_queue = (ISOCH_CALLBACK_QUEUE*) pdev->get_isoch_queue(pdev);
while (process_times)
{
process_times--;
+
if (isoch_queue == NULL || !pdev)
return -1;
+
pthread_mutex_lock(&isoch_queue->isoch_loading);
+
if (isoch_queue->head == NULL)
{
pthread_mutex_unlock(&isoch_queue->isoch_loading);
{
isoch = isoch_queue->head;
}
+
if (!isoch || !isoch->out_data)
{
pthread_mutex_unlock(&isoch_queue->isoch_loading);
}
else
{
- callback = (URBDRC_CHANNEL_CALLBACK *)isoch->callback;
+ callback = (URBDRC_CHANNEL_CALLBACK*) isoch->callback;
size_temp = isoch->out_size;
data_temp = isoch->out_data;
ret = isoch_queue->unregister_data(isoch_queue, isoch);
+
if (!ret)
LLOGLN(0, ("isoch_queue_unregister_data: Not found isoch data!!\n"));
+
pthread_mutex_unlock(&isoch_queue->isoch_loading);
if (pdev && !pdev->isSigToEnd(pdev))
{
- callback->channel->Write(callback->channel, size_temp,
- data_temp, NULL);
+ callback->channel->Write(callback->channel, size_temp, data_temp, NULL);
zfree(data_temp);
}
-
}
-
}
+
return 0;
}
+
#endif
-static int
-urbdrc_process_register_request_callback(URBDRC_CHANNEL_CALLBACK * callback,
- uint8 * data,
- uint32 data_sizem,
- IUDEVMAN * udevman,
- uint32 UsbDevice)
+static int urbdrc_process_register_request_callback(URBDRC_CHANNEL_CALLBACK* callback,
+ uint8* data, uint32 data_sizem, IUDEVMAN* udevman, uint32 UsbDevice)
{
- IUDEVICE * pdev;
- uint32 NumRequestCompletion = 0;
- uint32 RequestCompletion = 0;
+ IUDEVICE* pdev;
+ uint32 NumRequestCompletion = 0;
+ uint32 RequestCompletion = 0;
LLOGLN(urbdrc_debug, ("urbdrc_process_register_request_callback"));
pdev = udevman->get_udevice_by_UsbDevice(udevman, UsbDevice);
+
if (pdev == NULL)
return 0;
else /** Unregister the device */
{
data_read_uint32(data + 0, RequestCompletion);
+
if (1)//(pdev->get_ReqCompletion(pdev) == RequestCompletion)
{
/** The wrong driver may also receive this message, So we
return 0;
}
-static int
-urbdrc_process_cancel_request(uint8 * data, uint32 data_sizem,
- IUDEVMAN * udevman,
- uint32 UsbDevice)
+static int urbdrc_process_cancel_request(uint8* data, uint32 data_sizem, IUDEVMAN* udevman, uint32 UsbDevice)
{
IUDEVICE* pdev;
- uint32 CancelId;
- int error = 0;
+ uint32 CancelId;
+ int error = 0;
data_read_uint32(data + 0, CancelId); /** RequestId */
LLOGLN(urbdrc_debug, ("urbdrc_process_cancel_request: id 0x%x", CancelId));
pdev = udevman->get_udevice_by_UsbDevice(udevman, UsbDevice);
+
if (pdev == NULL)
return 0;
return error;
}
-static int
-urbdrc_process_retract_device_request(uint8 * data, uint32 data_sizem,
- IUDEVMAN * udevman,
- uint32 UsbDevice)
+static int urbdrc_process_retract_device_request(uint8* data, uint32 data_sizem, IUDEVMAN* udevman, uint32 UsbDevice)
{
uint32 Reason;
LLOGLN(urbdrc_debug, ("urbdrc_process_retract_device_request"));
LLOGLN(urbdrc_debug, ("UsbRetractReason_BlockedByPolicy: now it is not support"));
return -1;
break;
+
default:
LLOGLN(urbdrc_debug, ("urbdrc_process_retract_device_request: Unknown Reason %d", Reason));
return -1;
return 0;
}
-static int
-urbdrc_process_io_control(URBDRC_CHANNEL_CALLBACK * callback, uint8 * data,
- uint32 data_sizem,
- uint32 MessageId,
- IUDEVMAN * udevman,
- uint32 UsbDevice)
+static int urbdrc_process_io_control(URBDRC_CHANNEL_CALLBACK* callback, uint8* data,
+ uint32 data_sizem, uint32 MessageId, IUDEVMAN * udevman, uint32 UsbDevice)
{
- IUDEVICE * pdev;
- uint32 out_size;
- uint32 InterfaceId;
- uint32 IoControlCode;
- uint32 InputBufferSize;
- uint32 OutputBufferSize;
- uint32 RequestId;
- uint32 usbd_status = USBD_STATUS_SUCCESS;
- uint8 * OutputBuffer;
- uint8 * out_data;
- int i, offset, success = 0;
+ IUDEVICE* pdev;
+ uint32 out_size;
+ uint32 InterfaceId;
+ uint32 IoControlCode;
+ uint32 InputBufferSize;
+ uint32 OutputBufferSize;
+ uint32 RequestId;
+ uint32 usbd_status = USBD_STATUS_SUCCESS;
+ uint8* OutputBuffer;
+ uint8* out_data;
+ int i, offset, success = 0;
LLOGLN(urbdrc_debug, ("urbdrc_process__io_control"));
data_read_uint32(data + 12 + InputBufferSize, RequestId);
pdev = udevman->get_udevice_by_UsbDevice(udevman, UsbDevice);
+
if (pdev == NULL)
return 0;
InterfaceId = ((STREAM_ID_PROXY<<30) | pdev->get_ReqCompletion(pdev));
-
/** process */
OutputBuffer = (uint8 *)malloc(OutputBufferSize);
memset(OutputBuffer, 0, OutputBufferSize);
- switch (IoControlCode){
+ switch (IoControlCode)
+ {
case IOCTL_INTERNAL_USB_SUBMIT_URB: /** 0x00220003 */
LLOGLN(urbdrc_debug, ("ioctl: IOCTL_INTERNAL_USB_SUBMIT_URB"));
printf(" Function IOCTL_INTERNAL_USB_SUBMIT_URB: Unchecked\n");
break;
+
case IOCTL_INTERNAL_USB_RESET_PORT: /** 0x00220007 */
LLOGLN(urbdrc_debug, ("ioctl: IOCTL_INTERNAL_USB_RESET_PORT"));
break;
+
case IOCTL_INTERNAL_USB_GET_PORT_STATUS: /** 0x00220013 */
LLOGLN(urbdrc_debug, ("ioctl: IOCTL_INTERNAL_USB_GET_PORT_STATUS"));
- success = pdev->query_device_port_status(pdev, &usbd_status,
- &OutputBufferSize,
- OutputBuffer);
+ success = pdev->query_device_port_status(pdev, &usbd_status, &OutputBufferSize, OutputBuffer);
if (success)
{
usb_process_get_port_status(pdev, OutputBuffer);
OutputBufferSize = 4;
}
+
LLOGLN(urbdrc_debug, ("PORT STATUS(fake!):0x%02x%02x%02x%02x",
OutputBuffer[3], OutputBuffer[2], OutputBuffer[1], OutputBuffer[0]));
}
break;
+
case IOCTL_INTERNAL_USB_CYCLE_PORT: /** 0x0022001F */
LLOGLN(urbdrc_debug, ("ioctl: IOCTL_INTERNAL_USB_CYCLE_PORT"));
printf(" Function IOCTL_INTERNAL_USB_CYCLE_PORT: Unchecked\n");
break;
+
case IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION: /** 0x00220027 */
LLOGLN(urbdrc_debug, ("ioctl: IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION"));
printf(" Function IOCTL_INTERNAL_USB_SUBMIT_IDLE_NOTIFICATION: Unchecked\n");
break;
+
default:
LLOGLN(urbdrc_debug, ("urbdrc_process_io_control: unknown IoControlCode 0x%X", IoControlCode));
return -1;
break;
}
-
offset = 28;
out_size = offset + OutputBufferSize;
out_data = (uint8 *) malloc(out_size);
memset(out_data, 0, out_size);
- data_write_uint32(out_data + 0, InterfaceId); /** interface */
- data_write_uint32(out_data + 4, MessageId); /** message id */
- data_write_uint32(out_data + 8, IOCONTROL_COMPLETION); /** function id */
- data_write_uint32(out_data + 12, RequestId); /** RequestId */
- data_write_uint32(out_data + 16, USBD_STATUS_SUCCESS); /** HResult */
- data_write_uint32(out_data + 20, OutputBufferSize); /** Information */
- data_write_uint32(out_data + 24, OutputBufferSize); /** OutputBufferSize */
-
- for (i=0;i<OutputBufferSize;i++){
+ data_write_uint32(out_data + 0, InterfaceId); /** interface */
+ data_write_uint32(out_data + 4, MessageId); /** message id */
+ data_write_uint32(out_data + 8, IOCONTROL_COMPLETION); /** function id */
+ data_write_uint32(out_data + 12, RequestId); /** RequestId */
+ data_write_uint32(out_data + 16, USBD_STATUS_SUCCESS); /** HResult */
+ data_write_uint32(out_data + 20, OutputBufferSize); /** Information */
+ data_write_uint32(out_data + 24, OutputBufferSize); /** OutputBufferSize */
+
+ for (i=0;i<OutputBufferSize;i++)
+ {
data_write_uint8(out_data + offset, OutputBuffer[i]); /** OutputBuffer */
offset += 1;
}
+
if (!pdev->isSigToEnd(pdev))
callback->channel->Write(callback->channel, out_size, out_data, NULL);
return 0;
}
-static int
-urbdrc_process_internal_io_control(URBDRC_CHANNEL_CALLBACK * callback, uint8 * data,
- uint32 data_sizem,
- uint32 MessageId,
- IUDEVMAN * udevman,
- uint32 UsbDevice)
+static int urbdrc_process_internal_io_control(URBDRC_CHANNEL_CALLBACK* callback, uint8* data,
+ uint32 data_sizem, uint32 MessageId, IUDEVMAN* udevman, uint32 UsbDevice)
{
IUDEVICE* pdev;
+ uint8* out_data;
uint32 out_size, IoControlCode, InterfaceId, InputBufferSize;
uint32 OutputBufferSize, RequestId, frames;
- uint8 * out_data;
data_read_uint32(data + 0, IoControlCode);
data_read_uint32(data + 12, RequestId);
pdev = udevman->get_udevice_by_UsbDevice(udevman, UsbDevice);
+
if (pdev == NULL)
return 0;
+
InterfaceId = ((STREAM_ID_PROXY<<30) | pdev->get_ReqCompletion(pdev));
/** Fixme: Currently this is a false bustime... */
out_size = 32;
out_data = (uint8 *) malloc(out_size);
memset(out_data, 0, out_size);
- data_write_uint32(out_data + 0, InterfaceId); /** interface */
- data_write_uint32(out_data + 4, MessageId); /** message id */
- data_write_uint32(out_data + 8, IOCONTROL_COMPLETION); /** function id */
- data_write_uint32(out_data + 12, RequestId); /** RequestId */
- data_write_uint32(out_data + 16, 0); /** HResult */
- data_write_uint32(out_data + 20, 4); /** Information */
- data_write_uint32(out_data + 24, 4); /** OutputBufferSize */
- data_write_uint32(out_data + 28, frames); /** OutputBuffer */
-
+ data_write_uint32(out_data + 0, InterfaceId); /** interface */
+ data_write_uint32(out_data + 4, MessageId); /** message id */
+ data_write_uint32(out_data + 8, IOCONTROL_COMPLETION); /** function id */
+ data_write_uint32(out_data + 12, RequestId); /** RequestId */
+ data_write_uint32(out_data + 16, 0); /** HResult */
+ data_write_uint32(out_data + 20, 4); /** Information */
+ data_write_uint32(out_data + 24, 4); /** OutputBufferSize */
+ data_write_uint32(out_data + 28, frames); /** OutputBuffer */
if (!pdev->isSigToEnd(pdev))
callback->channel->Write(callback->channel, out_size, out_data, NULL);
return 0;
}
-static int
-urbdrc_process_query_device_text(URBDRC_CHANNEL_CALLBACK * callback,
- uint8 * data,
- uint32 data_sizem,
- uint32 MessageId,
- IUDEVMAN * udevman,
- uint32 UsbDevice)
+static int urbdrc_process_query_device_text(URBDRC_CHANNEL_CALLBACK* callback, uint8* data,
+ uint32 data_sizem, uint32 MessageId, IUDEVMAN* udevman, uint32 UsbDevice)
{
- IUDEVICE * pdev;
- uint32 out_size;
- uint32 InterfaceId;
- uint32 TextType;
- uint32 LocaleId;
- uint32 bufferSize = 1024;
- uint8 * out_data;
- uint8 DeviceDescription[bufferSize];
- int out_offset;
+ IUDEVICE* pdev;
+ uint32 out_size;
+ uint32 InterfaceId;
+ uint32 TextType;
+ uint32 LocaleId;
+ uint32 bufferSize = 1024;
+ uint8* out_data;
+ uint8 DeviceDescription[bufferSize];
+ int out_offset;
LLOGLN(urbdrc_debug, ("urbdrc_process_query_device_text"));
data_read_uint32(data + 4, LocaleId);
pdev = udevman->get_udevice_by_UsbDevice(udevman, UsbDevice);
+
if (pdev == NULL)
return 0;
- pdev->control_query_device_text(
- pdev,
- TextType,
- LocaleId,
- &bufferSize,
- DeviceDescription);
-
+ pdev->control_query_device_text(pdev, TextType, LocaleId, &bufferSize, DeviceDescription);
- InterfaceId = ((STREAM_ID_STUB<<30) | UsbDevice);
+ InterfaceId = ((STREAM_ID_STUB << 30) | UsbDevice);
out_offset = 16;
out_size = out_offset + bufferSize;
- if(bufferSize != 0)
+
+ if (bufferSize != 0)
out_size += 2;
- out_data = (uint8 *) malloc(out_size);
+
+ out_data = (uint8*) malloc(out_size);
memset(out_data, 0, out_size);
- data_write_uint32(out_data + 0, InterfaceId); /** interface */
- data_write_uint32(out_data + 4, MessageId); /** message id */
- if (bufferSize != 0) {
- data_write_uint32(out_data + 8, (bufferSize/2)+1); /** cchDeviceDescription */
+
+ data_write_uint32(out_data + 0, InterfaceId); /** interface */
+ data_write_uint32(out_data + 4, MessageId); /** message id */
+
+ if (bufferSize != 0)
+ {
+ data_write_uint32(out_data + 8, (bufferSize/2)+1); /** cchDeviceDescription */
out_offset = 12;
memcpy(out_data + out_offset, DeviceDescription, bufferSize);
out_offset += bufferSize;
}
else
{
- data_write_uint32(out_data + 8, 0); /** cchDeviceDescription */
+ data_write_uint32(out_data + 8, 0); /** cchDeviceDescription */
out_offset = 12;
}
return 0;
}
-
-
-static void
-func_select_all_interface_for_msconfig(IUDEVICE * pdev, MSUSB_CONFIG_DESCRIPTOR * MsConfig)
+static void func_select_all_interface_for_msconfig(IUDEVICE* pdev, MSUSB_CONFIG_DESCRIPTOR* MsConfig)
{
- MSUSB_INTERFACE_DESCRIPTOR ** MsInterfaces = MsConfig->MsInterfaces;
+ int inum;
+ MSUSB_INTERFACE_DESCRIPTOR** MsInterfaces = MsConfig->MsInterfaces;
uint8 InterfaceNumber, AlternateSetting;
uint32 NumInterfaces = MsConfig->NumInterfaces;
- int inum;
for (inum = 0; inum < NumInterfaces; inum++)
{
}
}
-
-
-static int
-urb_select_configuration(URBDRC_CHANNEL_CALLBACK * callback, uint8 * data,
- uint32 data_sizem,
- uint32 MessageId,
- IUDEVMAN * udevman,
- uint32 UsbDevice,
- int transferDir)
+static int urb_select_configuration(URBDRC_CHANNEL_CALLBACK* callback, uint8* data,
+ uint32 data_sizem, uint32 MessageId, IUDEVMAN* udevman, uint32 UsbDevice, int transferDir)
{
MSUSB_CONFIG_DESCRIPTOR * MsConfig = NULL;
- IUDEVICE * pdev = NULL;
- uint32 out_size, InterfaceId, RequestId, NumInterfaces, usbd_status = 0;
- uint8 ConfigurationDescriptorIsValid;
- uint8 * out_data;
- int MsOutSize = 0, offset = 0;
+ IUDEVICE* pdev = NULL;
+ uint32 out_size, InterfaceId, RequestId, NumInterfaces, usbd_status = 0;
+ uint8 ConfigurationDescriptorIsValid;
+ uint8* out_data;
+ int MsOutSize = 0, offset = 0;
- if (transferDir == 0){
+ if (transferDir == 0)
+ {
printf("urb_select_configuration: not support transfer out\n");
return -1;
}
pdev = udevman->get_udevice_by_UsbDevice(udevman, UsbDevice);
+
if (pdev == NULL)
return 0;
return 0;
}
-
-static int
-urb_select_interface(URBDRC_CHANNEL_CALLBACK * callback, uint8 * data,
- uint32 data_sizem,
- uint32 MessageId,
- IUDEVMAN * udevman,
- uint32 UsbDevice,
- int transferDir)
+static int urb_select_interface(URBDRC_CHANNEL_CALLBACK* callback, uint8* data, uint32 data_sizem,
+ uint32 MessageId, IUDEVMAN* udevman, uint32 UsbDevice, int transferDir)
{
- MSUSB_CONFIG_DESCRIPTOR * MsConfig;
- MSUSB_INTERFACE_DESCRIPTOR * MsInterface;
- IUDEVICE * pdev;
- uint32 out_size, InterfaceId, RequestId, ConfigurationHandle;
- uint32 OutputBufferSize;
- uint8 InterfaceNumber;
- uint8 * out_data;
- int out_offset, interface_size;
+ MSUSB_CONFIG_DESCRIPTOR* MsConfig;
+ MSUSB_INTERFACE_DESCRIPTOR* MsInterface;
+ IUDEVICE* pdev;
+ uint32 out_size, InterfaceId, RequestId, ConfigurationHandle;
+ uint32 OutputBufferSize;
+ uint8 InterfaceNumber;
+ uint8* out_data;
+ int out_offset, interface_size;
- if (transferDir == 0){
+ if (transferDir == 0)
+ {
printf("urb_select_interface: not support transfer out\n");
return -1;
}
pdev = udevman->get_udevice_by_UsbDevice(udevman, UsbDevice);
+
if (pdev == NULL)
return 0;
- InterfaceId = ((STREAM_ID_PROXY<<30) | pdev->get_ReqCompletion(pdev));
+ InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
data_read_uint32(data + 0, RequestId);
data_read_uint32(data + 4, ConfigurationHandle);
- out_offset = 8;
+ out_offset = 8;
MsInterface = msusb_msinterface_read(data + out_offset, data_sizem - out_offset, &out_offset);
interface_size = 16 + (MsInterface->NumberOfPipes * 20);
out_size = 36 + interface_size ;
- out_data = (uint8 *) malloc(out_size);
+ out_data = (uint8*) malloc(out_size);
memset(out_data, 0, out_size);
+
data_write_uint32(out_data + 0, InterfaceId); /** interface */
data_write_uint32(out_data + 4, MessageId); /** message id */
data_write_uint32(out_data + 8, URB_COMPLETION_NO_DATA); /** function id */
callback->channel->Write(callback->channel, out_size, out_data, NULL);
zfree(out_data);
+
return 0;
}
-
-
-static int
-urb_control_transfer(URBDRC_CHANNEL_CALLBACK * callback, uint8 * data,
- uint32 data_sizem,
- uint32 MessageId,
- IUDEVMAN * udevman,
- uint32 UsbDevice,
- int transferDir,
- int External)
+static int urb_control_transfer(URBDRC_CHANNEL_CALLBACK* callback, uint8* data,
+ uint32 data_sizem, uint32 MessageId, IUDEVMAN* udevman, uint32 UsbDevice, int transferDir, int External)
{
- IUDEVICE * pdev;
- uint32 out_size, RequestId, InterfaceId, EndpointAddress, PipeHandle;
- uint32 TransferFlags, OutputBufferSize, usbd_status, Timeout;
- uint8 bmRequestType, Request;
- uint16 Value, Index, length;
- uint8 * buffer;
- uint8 * out_data;
- int offset, ret;
+ IUDEVICE* pdev;
+ uint32 out_size, RequestId, InterfaceId, EndpointAddress, PipeHandle;
+ uint32 TransferFlags, OutputBufferSize, usbd_status, Timeout;
+ uint8 bmRequestType, Request;
+ uint16 Value, Index, length;
+ uint8* buffer;
+ uint8* out_data;
+ int offset, ret;
pdev = udevman->get_udevice_by_UsbDevice(udevman, UsbDevice);
+
if (pdev == NULL)
return 0;
- InterfaceId = ((STREAM_ID_PROXY<<30) | pdev->get_ReqCompletion(pdev));
+ InterfaceId = ((STREAM_ID_PROXY << 30) | pdev->get_ReqCompletion(pdev));
data_read_uint32(data + 0, RequestId);
data_read_uint32(data + 4, PipeHandle);
data_read_uint32(data + 8, TransferFlags); /** TransferFlags */
EndpointAddress = (PipeHandle & 0x000000ff);
offset = 12;
Timeout = 2000;
+
switch (External)
{
case URB_CONTROL_TRANSFER_EXTERNAL:
case URB_CONTROL_TRANSFER_NONEXTERNAL:
break;
}
+
/** SetupPacket 8 bytes */
data_read_uint8(data + offset, bmRequestType);
data_read_uint8(data + offset + 1, Request);
data_read_uint32(data + offset + 8, OutputBufferSize);
offset += 12;
- if (length != OutputBufferSize){
+ if (length != OutputBufferSize)
+ {
LLOGLN(urbdrc_debug, ("urb_control_transfer ERROR: buf != length"));
return -1;
}
callback->channel->Write(callback->channel, out_size, out_data, NULL);
zfree(out_data);
+
return 0;
}
-
-static int
-urb_bulk_or_interrupt_transfer(URBDRC_CHANNEL_CALLBACK * callback,
- uint8 * data,
- uint32 data_sizem,
- uint32 MessageId,
- IUDEVMAN * udevman,
- uint32 UsbDevice,
- int transferDir)
+static int urb_bulk_or_interrupt_transfer(URBDRC_CHANNEL_CALLBACK* callback, uint8* data,
+ uint32 data_sizem, uint32 MessageId, IUDEVMAN* udevman, uint32 UsbDevice, int transferDir)
{
IUDEVICE * pdev;
uint32 out_size, RequestId, InterfaceId, EndpointAddress, PipeHandle;
int urbdrc_debug = 0;
-static int
-func_hardware_id_format(IUDEVICE * pdev, char (*HardwareIds)[DEVICE_HARDWARE_ID_SIZE])
+static int func_hardware_id_format(IUDEVICE* pdev, char (*HardwareIds)[DEVICE_HARDWARE_ID_SIZE])
{
char str[DEVICE_HARDWARE_ID_SIZE];
int idVendor, idProduct, bcdDevice;
return 0;
}
-
-static int
-func_compat_id_format(IUDEVICE *pdev, char (*CompatibilityIds)[DEVICE_COMPATIBILITY_ID_SIZE])
+static int func_compat_id_format(IUDEVICE *pdev, char (*CompatibilityIds)[DEVICE_COMPATIBILITY_ID_SIZE])
{
char str[DEVICE_COMPATIBILITY_ID_SIZE];
int bDeviceClass, bDeviceSubClass, bDeviceProtocol;
bDeviceSubClass = pdev->query_device_descriptor(pdev, B_DEVICE_SUBCLASS);
bDeviceProtocol = pdev->query_device_descriptor(pdev, B_DEVICE_PROTOCOL);
- if(!(pdev->isCompositeDevice(pdev))){
+ if(!(pdev->isCompositeDevice(pdev)))
+ {
sprintf(str, "USB\\Class_%02X", bDeviceClass);
strcpy(CompatibilityIds[2], str);
sprintf(str, "%s&SubClass_%02X", str, bDeviceSubClass);
sprintf(str, "%s&Prot_%02X", str, bDeviceProtocol);
strcpy(CompatibilityIds[0], str);
}
- else{
+ else
+ {
sprintf(str, "USB\\DevClass_00");
strcpy(CompatibilityIds[2], str);
sprintf(str, "%s&SubClass_00", str);
return 0;
}
-
-static void
-func_close_udevice(USB_SEARCHMAN * searchman, IUDEVICE * pdev)
+static void func_close_udevice(USB_SEARCHMAN* searchman, IUDEVICE* pdev)
{
- URBDRC_PLUGIN * urbdrc = searchman->urbdrc;
int idVendor = 0;
int idProduct = 0;
+ URBDRC_PLUGIN* urbdrc = searchman->urbdrc;
pdev->SigToEnd(pdev);
idVendor = pdev->query_device_descriptor(pdev, ID_VENDOR);
idProduct = pdev->query_device_descriptor(pdev, ID_PRODUCT);
- searchman->add(searchman, (uint16)idVendor, (uint16)idProduct);
+ searchman->add(searchman, (uint16) idVendor, (uint16) idProduct);
pdev->cancel_all_transfer_request(pdev);
pdev->wait_action_completion(pdev);
#if ISOCH_FIFO
- /* free isoch queue */
- ISOCH_CALLBACK_QUEUE* isoch_queue = pdev->get_isoch_queue(pdev);
- if (isoch_queue)
- isoch_queue->free(isoch_queue);
+ {
+ /* free isoch queue */
+ ISOCH_CALLBACK_QUEUE* isoch_queue = pdev->get_isoch_queue(pdev);
+
+ if (isoch_queue)
+ isoch_queue->free(isoch_queue);
+ }
#endif
urbdrc->udevman->unregister_udevice(urbdrc->udevman,
pdev->get_bus_number(pdev),
pdev->get_dev_number(pdev));
- //searchman->show(searchman);
}
-
-static int
-fun_device_string_send_set(char * out_data, int out_offset, char * str)
+static int fun_device_string_send_set(char* out_data, int out_offset, char* str)
{
int i = 0;
int offset = 0;
i++;
offset += 2;
}
+
data_write_uint16(out_data + out_offset + offset, 0x0000); /* add "\0" */
offset += 2;
+
return offset + out_offset;
}
-
-static int
-func_container_id_generate(IUDEVICE * pdev, char * strContainerId)
+static int func_container_id_generate(IUDEVICE* pdev, char* strContainerId)
{
- char containerId[17];
char *p, *path;
+ char containerId[17];
int idVendor, idProduct;
idVendor = pdev->query_device_descriptor(pdev, ID_VENDOR);
idProduct = pdev->query_device_descriptor(pdev, ID_PRODUCT);
+
path = pdev->getPath(pdev);
+
if (strlen(path) > 8)
p = (path + strlen(path)) - 8;
else
p = path;
sprintf(containerId, "%04X%04X%s", idVendor, idProduct, p);
+
/* format */
sprintf(strContainerId,
"{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
return 0;
}
-
-static int
-func_instance_id_generate(IUDEVICE * pdev, char *strInstanceId)
+static int func_instance_id_generate(IUDEVICE* pdev, char* strInstanceId)
{
char instanceId[17];
memset(instanceId, 0, 17);
sprintf(instanceId, "\\%s", pdev->getPath(pdev));
+
/* format */
sprintf(strInstanceId,
"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
return 0;
}
-
#if ISOCH_FIFO
-static void
-func_lock_isoch_mutex(TRANSFER_DATA* transfer_data)
+
+static void func_lock_isoch_mutex(TRANSFER_DATA* transfer_data)
{
- IUDEVMAN * udevman = transfer_data->udevman;
+ int noAck = 0;
IUDEVICE* pdev;
uint32 FunctionId;
uint32 RequestField;
uint16 URB_Function;
- int noAck = 0;
+ IUDEVMAN* udevman = transfer_data->udevman;
if (transfer_data->cbSize >= 8)
{
data_read_uint32(transfer_data->pBuffer + 4, FunctionId);
+
if ((FunctionId == TRANSFER_IN_REQUEST ||
FunctionId == TRANSFER_OUT_REQUEST) &&
transfer_data->cbSize >= 16)
{
data_read_uint16(transfer_data->pBuffer + 14, URB_Function);
+
if (URB_Function == URB_FUNCTION_ISOCH_TRANSFER &&
transfer_data->cbSize >= 20)
{
if (!noAck)
{
- pdev = udevman->get_udevice_by_UsbDevice(udevman,
- transfer_data->UsbDevice);
+ pdev = udevman->get_udevice_by_UsbDevice(udevman, transfer_data->UsbDevice);
pdev->lock_fifo_isoch(pdev);
}
}
}
}
}
-#endif
+#endif
-static int
-urbdrc_process_capability_request(URBDRC_CHANNEL_CALLBACK * callback,
- char * data, uint32 data_sizem, uint32 MessageId)
+static int urbdrc_process_capability_request(URBDRC_CHANNEL_CALLBACK* callback, char* data, uint32 data_sizem, uint32 MessageId)
{
uint32 InterfaceId;
uint32 Version;
out_size = 16;
out_data = (char *) malloc(out_size);
memset(out_data, 0, out_size);
- data_write_uint32(out_data + 0, InterfaceId); /* interface id */
- data_write_uint32(out_data + 4, MessageId); /* message id */
- data_write_uint32(out_data + 8, Version); /* usb protocol version */
- data_write_uint32(out_data + 12, 0x00000000); /* HRESULT */
- callback->channel->Write(callback->channel, out_size, (uint8 *)out_data, NULL);
+ data_write_uint32(out_data + 0, InterfaceId); /* interface id */
+ data_write_uint32(out_data + 4, MessageId); /* message id */
+ data_write_uint32(out_data + 8, Version); /* usb protocol version */
+ data_write_uint32(out_data + 12, 0x00000000); /* HRESULT */
+ callback->channel->Write(callback->channel, out_size, (uint8*) out_data, NULL);
zfree(out_data);
return 0;
}
-static int
-urbdrc_process_channel_create(URBDRC_CHANNEL_CALLBACK * callback, char * data,
- uint32 data_sizem,
- uint32 MessageId)
+static int urbdrc_process_channel_create(URBDRC_CHANNEL_CALLBACK* callback, char* data, uint32 data_sizem, uint32 MessageId)
{
uint32 InterfaceId;
uint32 out_size;
uint32 MajorVersion;
uint32 MinorVersion;
uint32 Capabilities;
- char * out_data;
+ char* out_data;
LLOGLN(10, ("urbdrc_process_channel_create"));
data_read_uint32(data + 0, MajorVersion);
out_size = 24;
out_data = (char *) malloc(out_size);
memset(out_data, 0, out_size);
- data_write_uint32(out_data + 0, InterfaceId); /* interface id */
- data_write_uint32(out_data + 4, MessageId); /* message id */
- data_write_uint32(out_data + 8, CHANNEL_CREATED); /* function id */
+ data_write_uint32(out_data + 0, InterfaceId); /* interface id */
+ data_write_uint32(out_data + 4, MessageId); /* message id */
+ data_write_uint32(out_data + 8, CHANNEL_CREATED); /* function id */
data_write_uint32(out_data + 12, MajorVersion);
data_write_uint32(out_data + 16, MinorVersion);
- data_write_uint32(out_data + 20, Capabilities); /* capabilities version */
+ data_write_uint32(out_data + 20, Capabilities); /* capabilities version */
callback->channel->Write(callback->channel, out_size, (uint8 *)out_data, NULL);
zfree(out_data);
return 0;
}
-
-static int
-urdbrc_send_virtual_channel_add(IWTSVirtualChannel * channel, uint32 MessageId)
+static int urdbrc_send_virtual_channel_add(IWTSVirtualChannel* channel, uint32 MessageId)
{
uint32 out_size;
uint32 InterfaceId;
- char * out_data;
+ char* out_data;
LLOGLN(10, ("urdbrc_send_virtual_channel_add"));
out_size = 12;
out_data = (char *) malloc(out_size);
memset(out_data, 0, out_size);
- data_write_uint32(out_data + 0, InterfaceId); /* interface */
- data_write_uint32(out_data + 4, MessageId); /* message id */
- data_write_uint32(out_data + 8, ADD_VIRTUAL_CHANNEL); /* function id */
+ data_write_uint32(out_data + 0, InterfaceId); /* interface */
+ data_write_uint32(out_data + 4, MessageId); /* message id */
+ data_write_uint32(out_data + 8, ADD_VIRTUAL_CHANNEL); /* function id */
- channel->Write(channel, out_size, (uint8 *)out_data, NULL);
+ channel->Write(channel, out_size, (uint8*) out_data, NULL);
zfree(out_data);
return 0;
}
-
-
-static int
-urdbrc_send_usb_device_add(URBDRC_CHANNEL_CALLBACK * callback, IUDEVICE* pdev)
+static int urdbrc_send_usb_device_add(URBDRC_CHANNEL_CALLBACK* callback, IUDEVICE* pdev)
{
- uint32 InterfaceId;
- char HardwareIds[2][DEVICE_HARDWARE_ID_SIZE];
- char CompatibilityIds[3][DEVICE_COMPATIBILITY_ID_SIZE];
- char * out_data;
- char strContainerId[DEVICE_CONTAINER_STR_SIZE];
- char strInstanceId[DEVICE_INSTANCE_STR_SIZE];
- char * composite_str = "USB\\COMPOSITE";
- int size, out_offset, cchCompatIds, bcdUSB;
+ char* out_data;
+ uint32 InterfaceId;
+ char HardwareIds[2][DEVICE_HARDWARE_ID_SIZE];
+ char CompatibilityIds[3][DEVICE_COMPATIBILITY_ID_SIZE];
+ char strContainerId[DEVICE_CONTAINER_STR_SIZE];
+ char strInstanceId[DEVICE_INSTANCE_STR_SIZE];
+ char* composite_str = "USB\\COMPOSITE";
+ int size, out_offset, cchCompatIds, bcdUSB;
LLOGLN(10, ("urdbrc_send_usb_device_add"));
InterfaceId = ((STREAM_ID_PROXY<<30) | CLIENT_DEVICE_SINK);
/* USB kernel driver detach!! */
pdev->detach_kernel_driver(pdev);
+
#if ISOCH_FIFO
/* create/initial isoch queue */
pdev->set_isoch_queue(pdev, (void *)isoch_queue_new());
func_instance_id_generate(pdev, strInstanceId);
func_container_id_generate(pdev, strContainerId);
- cchCompatIds = strlen(CompatibilityIds[0])+1 +
- strlen(CompatibilityIds[1])+1 +
- strlen(CompatibilityIds[2])+2;
+ cchCompatIds = strlen(CompatibilityIds[0]) + 1 +
+ strlen(CompatibilityIds[1]) + 1 +
+ strlen(CompatibilityIds[2]) + 2;
- if(pdev->isCompositeDevice(pdev))
+ if (pdev->isCompositeDevice(pdev))
cchCompatIds += strlen(composite_str)+1;
out_offset = 24;
size = 24;
- size += (strlen(strInstanceId)+1)*2 +
- (strlen(HardwareIds[0])+1)*2 + 4 +
- (strlen(HardwareIds[1])+1)*2 + 2 +
- 4 + (cchCompatIds)*2 +
- (strlen(strContainerId)+1)*2 + 4 + 28;
- out_data = (char *) malloc(size);
+ size += (strlen(strInstanceId)+1) * 2 +
+ (strlen(HardwareIds[0]) + 1) * 2 + 4 +
+ (strlen(HardwareIds[1]) + 1) * 2 + 2 +
+ 4 + (cchCompatIds) * 2 +
+ (strlen(strContainerId) + 1) * 2 + 4 + 28;
+
+ out_data = (char*) malloc(size);
memset(out_data, 0, size);
- data_write_uint32(out_data + 0, InterfaceId); /* interface */
- data_write_uint32(out_data + 4, 0); /* message id */
- data_write_uint32(out_data + 8, ADD_DEVICE); /* function id */
- data_write_uint32(out_data + 12, 0x00000001); /* NumUsbDevice */
- data_write_uint32(out_data + 16, pdev->get_UsbDevice(pdev)); /* UsbDevice */
- data_write_uint32(out_data + 20, 0x00000025); /* cchDeviceInstanceId */
+
+ data_write_uint32(out_data + 0, InterfaceId); /* interface */
+ data_write_uint32(out_data + 4, 0); /* message id */
+ data_write_uint32(out_data + 8, ADD_DEVICE); /* function id */
+ data_write_uint32(out_data + 12, 0x00000001); /* NumUsbDevice */
+ data_write_uint32(out_data + 16, pdev->get_UsbDevice(pdev)); /* UsbDevice */
+ data_write_uint32(out_data + 20, 0x00000025); /* cchDeviceInstanceId */
out_offset = fun_device_string_send_set(out_data, out_offset, strInstanceId);
- data_write_uint32(out_data + out_offset, 0x00000036); /* cchHwIds */
+ data_write_uint32(out_data + out_offset, 0x00000036); /* cchHwIds */
out_offset += 4;
/* HardwareIds 1 */
out_offset = fun_device_string_send_set(out_data, out_offset, HardwareIds[0]);
/* HardwareIds 2 */
out_offset = fun_device_string_send_set(out_data, out_offset, HardwareIds[1]);
- data_write_uint16(out_data + out_offset, 0x0000); /* add "\0" */
+ data_write_uint16(out_data + out_offset, 0x0000); /* add "\0" */
out_offset += 2;
- data_write_uint32(out_data + out_offset, cchCompatIds); /* cchCompatIds */
+ data_write_uint32(out_data + out_offset, cchCompatIds); /* cchCompatIds */
out_offset += 4;
/* CompatibilityIds 1 */
out_offset = fun_device_string_send_set(out_data, out_offset, CompatibilityIds[0]);
/* CompatibilityIds 3 */
out_offset = fun_device_string_send_set(out_data, out_offset, CompatibilityIds[2]);
- if(pdev->isCompositeDevice(pdev))
+ if (pdev->isCompositeDevice(pdev))
out_offset = fun_device_string_send_set(out_data, out_offset, composite_str);
- data_write_uint16(out_data + out_offset, 0x0000); /* add "\0" */
+ data_write_uint16(out_data + out_offset, 0x0000); /* add "\0" */
out_offset += 2;
- data_write_uint32(out_data + out_offset, 0x00000027); /* cchContainerId */
+ data_write_uint32(out_data + out_offset, 0x00000027); /* cchContainerId */
out_offset += 4;
/* ContainerId */
out_offset = fun_device_string_send_set(out_data, out_offset, strContainerId);
/* USB_DEVICE_CAPABILITIES 28 bytes */
- data_write_uint32(out_data + out_offset, 0x0000001c); /* CbSize */
- data_write_uint32(out_data + out_offset + 4, 2); /* UsbBusInterfaceVersion, 0 ,1 or 2 */
- data_write_uint32(out_data + out_offset + 8, 0x600); /* USBDI_Version, 0x500 or 0x600 */
+ data_write_uint32(out_data + out_offset, 0x0000001c); /* CbSize */
+ data_write_uint32(out_data + out_offset + 4, 2); /* UsbBusInterfaceVersion, 0 ,1 or 2 */
+ data_write_uint32(out_data + out_offset + 8, 0x600); /* USBDI_Version, 0x500 or 0x600 */
+
/* Supported_USB_Version, 0x110,0x110 or 0x200(usb2.0) */
bcdUSB = pdev->query_device_descriptor(pdev, BCD_USB);
data_write_uint32(out_data + out_offset + 12, bcdUSB);
- data_write_uint32(out_data + out_offset + 16, 0x00000000); /* HcdCapabilities, MUST always be zero */
+ data_write_uint32(out_data + out_offset + 16, 0x00000000); /* HcdCapabilities, MUST always be zero */
+
if (bcdUSB < 0x200)
- data_write_uint32(out_data + out_offset + 20, 0x00000000); /* DeviceIsHighSpeed */
+ data_write_uint32(out_data + out_offset + 20, 0x00000000); /* DeviceIsHighSpeed */
else
- data_write_uint32(out_data + out_offset + 20, 0x00000001); /* DeviceIsHighSpeed */
- data_write_uint32(out_data + out_offset + 24, 0x50); /* NoAckIsochWriteJitterBufferSizeInMs, >=10 or <=512 */
+ data_write_uint32(out_data + out_offset + 20, 0x00000001); /* DeviceIsHighSpeed */
+
+ data_write_uint32(out_data + out_offset + 24, 0x50); /* NoAckIsochWriteJitterBufferSizeInMs, >=10 or <=512 */
out_offset += 28;
callback->channel->Write(callback->channel, out_offset, (uint8 *)out_data, NULL);
return 0;
}
-
-static int
-urbdrc_exchange_capabilities(URBDRC_CHANNEL_CALLBACK * callback,
- char * pBuffer,
- uint32 cbSize)
+static int urbdrc_exchange_capabilities(URBDRC_CHANNEL_CALLBACK* callback, char* pBuffer, uint32 cbSize)
{
uint32 MessageId;
uint32 FunctionId;
switch (FunctionId)
{
case RIM_EXCHANGE_CAPABILITY_REQUEST:
- error = urbdrc_process_capability_request(callback,
- pBuffer + 8,
- cbSize - 8,
- MessageId);
+ error = urbdrc_process_capability_request(callback, pBuffer + 8, cbSize - 8, MessageId);
break;
+
default:
LLOGLN(10, ("urbdrc_exchange_capabilities: unknown FunctionId 0x%X", FunctionId));
error = 1;
break;
}
+
return error;
}
-
-
-static void *
-urbdrc_search_usb_device(void * arg)
+static void* urbdrc_search_usb_device(void* arg)
{
USB_SEARCHMAN* searchman = (USB_SEARCHMAN*) arg;
URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*) searchman->urbdrc;
IUDEVMAN* udevman = urbdrc->udevman;
- IWTSVirtualChannelManager * channel_mgr;
- IWTSVirtualChannel * dvc_channel;
+ IWTSVirtualChannelManager* channel_mgr;
+ IWTSVirtualChannel* dvc_channel;
USB_SEARCHDEV* sdev;
- IUDEVICE * pdev = NULL;
- struct wait_obj * listobj[2];
- struct wait_obj * mon_fd;
+ IUDEVICE* pdev = NULL;
+ struct wait_obj* listobj[2];
+ struct wait_obj* mon_fd;
int numobj, timeout;
int busnum, devnum;
int success = 0, error, on_close = 0, found = 0;
channel_mgr = urbdrc->listener_callback->channel_mgr;
/* init usb monitor */
- struct udev *udev;
- struct udev_device *dev;
- struct udev_monitor *mon;
+ struct udev* udev;
+ struct udev_device* dev;
+ struct udev_monitor* mon;
udev = udev_new();
- if (!udev) {
+
+ if (!udev)
+ {
printf("Can't create udev\n");
return 0;
}
mon = udev_monitor_new_from_netlink(udev, "udev");
udev_monitor_filter_add_match_subsystem_devtype(mon, "usb", "usb_device");
udev_monitor_enable_receiving(mon);
+
/* Get the file descriptor (fd) for the monitor.
This fd will get passed to select() */
mon_fd = wait_obj_new_with_fd((void*) (size_t) udev_monitor_get_fd(mon));
listobj[1] = mon_fd;
numobj = 2;
wait_obj_select(listobj, numobj, -1);
+
if (wait_obj_is_set(searchman->term_event))
{
sem_post(&searchman->sem_term);
if (wait_obj_is_set(mon_fd))
{
dev = udev_monitor_receive_device(mon);
- if (dev) {
- const char * action = udev_device_get_action(dev);
+
+ if (dev)
+ {
+ const char* action = udev_device_get_action(dev);
+
if (strcmp(action, "add") == 0)
{
int idVendor, idProduct;
success = 0;
found = 0;
- idVendor = strtol(
- udev_device_get_sysattr_value(dev, "idVendor"), NULL, 16);
- idProduct = strtol(
- udev_device_get_sysattr_value(dev, "idProduct"), NULL, 16);
+
+ idVendor = strtol(udev_device_get_sysattr_value(dev, "idVendor"), NULL, 16);
+ idProduct = strtol(udev_device_get_sysattr_value(dev, "idProduct"), NULL, 16);
+
if (idVendor < 0 || idProduct < 0)
{
udev_device_unref(dev);
dvc_channel = channel_mgr->FindChannelById(channel_mgr,
urbdrc->first_channel_id);
+
searchman->rewind(searchman);
+
while(dvc_channel && searchman->has_next(searchman))
{
sdev = searchman->get_next(searchman);
+
if (sdev->idVendor == idVendor &&
sdev->idProduct == idProduct)
{
}
if (found)
- success = udevman->register_udevice(udevman,
- busnum,
- devnum,
- searchman->UsbDevice,
- 0,
- 0,
- UDEVMAN_FLAG_ADD_BY_ADDR);
+ {
+ success = udevman->register_udevice(udevman, busnum, devnum,
+ searchman->UsbDevice, 0, 0, UDEVMAN_FLAG_ADD_BY_ADDR);
+ }
+
if (success)
{
searchman->UsbDevice++;
+
/* when we send the usb device add request,
* we will detach the device driver at same
* time. But, if the time of detach the
* the system will crash. workaround: we
* wait it for some time to avoid system
* crash. */
+
listobj[0] = searchman->term_event;
numobj = 1;
timeout = 4000; /* milliseconds */
+
wait_obj_select(listobj, numobj, timeout);
+
if (wait_obj_is_set(searchman->term_event))
{
wait_obj_free(mon_fd);
sem_post(&searchman->sem_term);
return 0;
}
+
error = urdbrc_send_virtual_channel_add(dvc_channel, 0);
+
if (found == 1)
- searchman->remove(searchman, sdev->idVendor,
- sdev->idProduct);
+ searchman->remove(searchman, sdev->idVendor, sdev->idProduct);
}
}
else if (strcmp(action, "remove") == 0)
usleep(500000);
udevman->loading_lock(udevman);
udevman->rewind(udevman);
+
while(udevman->has_next(udevman))
{
pdev = udevman->get_next(udevman);
- if (pdev->get_bus_number(pdev) == busnum &&
- pdev->get_dev_number(pdev) == devnum)
+
+ if (pdev->get_bus_number(pdev) == busnum && pdev->get_dev_number(pdev) == devnum)
{
- dvc_channel = channel_mgr->FindChannelById(channel_mgr,
- pdev->get_channel_id(pdev));
- if (dvc_channel == NULL){
- LLOGLN(0, ("SEARCH: dvc_channel %d is NULL!!",
- pdev->get_channel_id(pdev)));
+ dvc_channel = channel_mgr->FindChannelById(channel_mgr, pdev->get_channel_id(pdev));
+
+ if (dvc_channel == NULL)
+ {
+ LLOGLN(0, ("SEARCH: dvc_channel %d is NULL!!", pdev->get_channel_id(pdev)));
func_close_udevice(searchman, pdev);
break;
}
dvc_channel->Write(dvc_channel, 0, NULL, NULL);
pdev->SigToEnd(pdev);
}
+
on_close = 1;
break;
}
}
+
udevman->loading_unlock(udevman);
listobj[0] = searchman->term_event;
numobj = 1;
timeout = 3000; /* milliseconds */
+
wait_obj_select(listobj, numobj, timeout);
+
if (wait_obj_is_set(searchman->term_event))
{
wait_obj_free(mon_fd);
return 0;
}
- if(pdev && on_close && dvc_channel && pdev->isSigToEnd(pdev) &&
- !(pdev->isChannelClosed(pdev)))
+ if(pdev && on_close && dvc_channel && pdev->isSigToEnd(pdev) && !(pdev->isChannelClosed(pdev)))
{
on_close = 0;
dvc_channel->Close(dvc_channel);
}
}
+
udev_device_unref(dev);
}
else {
return 0;
}
-
-void *
-urbdrc_new_device_create(void * arg)
+void* urbdrc_new_device_create(void * arg)
{
TRANSFER_DATA* transfer_data = (TRANSFER_DATA*) arg;
- URBDRC_CHANNEL_CALLBACK * callback = transfer_data->callback;
- IWTSVirtualChannelManager * channel_mgr;
- URBDRC_PLUGIN * urbdrc = transfer_data->urbdrc;
- USB_SEARCHMAN * searchman = urbdrc->searchman;
- uint8 * pBuffer = transfer_data->pBuffer;
- //uint32 cbSize = transfer_data->cbSize;
- IUDEVMAN * udevman = transfer_data->udevman;
- IUDEVICE * pdev = NULL;
- uint32 ChannelId = 0;
- uint32 MessageId;
- uint32 FunctionId;
+ URBDRC_CHANNEL_CALLBACK* callback = transfer_data->callback;
+ IWTSVirtualChannelManager* channel_mgr;
+ URBDRC_PLUGIN* urbdrc = transfer_data->urbdrc;
+ USB_SEARCHMAN* searchman = urbdrc->searchman;
+ uint8* pBuffer = transfer_data->pBuffer;
+ IUDEVMAN* udevman = transfer_data->udevman;
+ IUDEVICE* pdev = NULL;
+ uint32 ChannelId = 0;
+ uint32 MessageId;
+ uint32 FunctionId;
int i = 0, found = 0;
channel_mgr = urbdrc->listener_callback->channel_mgr;
data_read_uint32(pBuffer + 4, FunctionId);
int error = 0;
- switch (urbdrc->vchannel_status){
+
+ switch (urbdrc->vchannel_status)
+ {
case INIT_CHANNEL_IN:
urbdrc->first_channel_id = ChannelId;
searchman->start(searchman, urbdrc_search_usb_device);
- for(i=0; i < udevman->get_device_num(udevman); i++)
- {
+ for (i = 0; i < udevman->get_device_num(udevman); i++)
error = urdbrc_send_virtual_channel_add(callback->channel, MessageId);
- }
+
urbdrc->vchannel_status = INIT_CHANNEL_OUT;
break;
- case INIT_CHANNEL_OUT:
+
+ case INIT_CHANNEL_OUT:
udevman->loading_lock(udevman);
udevman->rewind(udevman);
- while(udevman->has_next(udevman)){
+
+ while(udevman->has_next(udevman))
+ {
pdev = udevman->get_next(udevman);
+
if (!pdev->isAlreadySend(pdev))
{
found = 1;
* the device driver at same time. But, if the time of detach the
* driver and attach driver is too close, the system will crash.
* workaround: we wait it for some time to avoid system crash. */
+
error = pdev->wait_for_detach(pdev);
+
if (error >= 0)
urdbrc_send_usb_device_add(callback, pdev);
}
break;
+
default:
LLOGLN(0, ("urbdrc_new_device_create: vchannel_status unknown value %d",
urbdrc->vchannel_status));
return 0;
}
-
-
-static int
-urbdrc_process_channel_notification(URBDRC_CHANNEL_CALLBACK * callback,
- char * pBuffer, uint32 cbSize)
+static int urbdrc_process_channel_notification(URBDRC_CHANNEL_CALLBACK* callback, char* pBuffer, uint32 cbSize)
{
- URBDRC_PLUGIN * urbdrc = (URBDRC_PLUGIN *) callback->plugin;
+ int i, error = 0;
uint32 MessageId;
uint32 FunctionId;
- int i, error = 0;
+ URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*) callback->plugin;
data_read_uint32(pBuffer + 0, MessageId);
data_read_uint32(pBuffer + 4, FunctionId);
case CHANNEL_CREATED:
error = urbdrc_process_channel_create(callback, pBuffer + 8, cbSize - 8, MessageId);
break;
+
case RIMCALL_RELEASE:
LLOGLN(10, ("urbdrc_process_channel_notification: recv RIMCALL_RELEASE"));
pthread_t thread;
transfer_data->urbdrc = urbdrc;
transfer_data->cbSize = cbSize;
transfer_data->pBuffer = (uint8 *)malloc((cbSize));
+
for (i = 0; i < (cbSize); i++)
{
transfer_data->pBuffer[i] = pBuffer[i];
pthread_create(&thread, 0, urbdrc_new_device_create, transfer_data);
pthread_detach(thread);
break;
+
default:
LLOGLN(10, ("urbdrc_process_channel_notification: unknown FunctionId 0x%X", FunctionId));
error = 1;
return error;
}
+static int urbdrc_on_data_received(IWTSVirtualChannelCallback* pChannelCallback, uint32 cbSize, uint8* Buffer)
+{
+ URBDRC_CHANNEL_CALLBACK* callback = (URBDRC_CHANNEL_CALLBACK*) pChannelCallback;
+ URBDRC_PLUGIN* urbdrc;
+ IUDEVMAN* udevman;
+ uint32 InterfaceTemp;
+ uint32 InterfaceId;
+ uint32 Mask;
+ int error = 0;
+ char* pBuffer = (char*) Buffer;
+
+ if (callback == NULL)
+ return 0;
+ if (callback->plugin == NULL)
+ return 0;
+ urbdrc = (URBDRC_PLUGIN*) callback->plugin;
-static int
-urbdrc_on_data_received(IWTSVirtualChannelCallback * pChannelCallback,
- uint32 cbSize,
- uint8 * Buffer)
-{
- URBDRC_CHANNEL_CALLBACK * callback = (URBDRC_CHANNEL_CALLBACK *) pChannelCallback;
- URBDRC_PLUGIN * urbdrc;
- IUDEVMAN * udevman;
- uint32 InterfaceTemp;
- uint32 InterfaceId;
- uint32 Mask;
- int error = 0;
- char * pBuffer = (char *) Buffer;
-
- if (callback == NULL) return 0;
- if (callback->plugin == NULL) return 0;
- urbdrc = (URBDRC_PLUGIN *) callback->plugin;
- if (urbdrc->udevman == NULL) return 0;
- udevman = (IUDEVMAN *) urbdrc->udevman;
+ if (urbdrc->udevman == NULL)
+ return 0;
+
+ udevman = (IUDEVMAN*) urbdrc->udevman;
data_read_uint32(pBuffer + 0, InterfaceTemp);
InterfaceId = (InterfaceTemp & 0x0fffffff);
case CAPABILITIES_NEGOTIATOR:
error = urbdrc_exchange_capabilities(callback, pBuffer + 4, cbSize - 4);
break;
+
case SERVER_CHANNEL_NOTIFICATION:
error = urbdrc_process_channel_notification(callback, pBuffer + 4, cbSize - 4);
break;
+
default:
LLOGLN(10, ("urbdrc_on_data_received: InterfaceId 0x%X Start matching devices list", InterfaceId));
- pthread_t thread;
- TRANSFER_DATA* transfer_data;
+ pthread_t thread;
+ TRANSFER_DATA* transfer_data;
+
+ transfer_data = (TRANSFER_DATA*) malloc(sizeof(TRANSFER_DATA));
- transfer_data = (TRANSFER_DATA*)malloc(sizeof(TRANSFER_DATA));
if (transfer_data == NULL)
printf("transfer_data is NULL!!");
+
transfer_data->callback = callback;
transfer_data->urbdrc = urbdrc;
transfer_data->udevman = udevman;
#endif
error = pthread_create(&thread, 0, urbdrc_process_udev_data_transfer, transfer_data);
+
if (error < 0)
LLOGLN(0, ("Create Data Transfer Thread got error = %d", error));
else
pthread_detach(thread);
- //urbdrc_process_udev_data_transfer(transfer_data);
-
break;
}
return 0;
}
-static int
-urbdrc_on_close(IWTSVirtualChannelCallback * pChannelCallback)
+static int urbdrc_on_close(IWTSVirtualChannelCallback * pChannelCallback)
{
- URBDRC_CHANNEL_CALLBACK * callback = (URBDRC_CHANNEL_CALLBACK *) pChannelCallback;
- URBDRC_PLUGIN * urbdrc = (URBDRC_PLUGIN *) callback->plugin;
- IUDEVMAN * udevman = (IUDEVMAN *) urbdrc->udevman;
- USB_SEARCHMAN * searchman = (USB_SEARCHMAN*) urbdrc->searchman;
- IUDEVICE * pdev = NULL;
+ URBDRC_CHANNEL_CALLBACK* callback = (URBDRC_CHANNEL_CALLBACK*) pChannelCallback;
+ URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*) callback->plugin;
+ IUDEVMAN* udevman = (IUDEVMAN*) urbdrc->udevman;
+ USB_SEARCHMAN* searchman = (USB_SEARCHMAN*) urbdrc->searchman;
+ IUDEVICE* pdev = NULL;
uint32 ChannelId = 0;
int found = 0;
udevman->loading_lock(udevman);
udevman->rewind(udevman);
+
while(udevman->has_next(udevman))
{
pdev = udevman->get_next(udevman);
+
if (pdev->get_channel_id(pdev) == ChannelId)
{
found = 1;
break;
}
}
+
udevman->loading_unlock(udevman);
+
if (found && pdev && !(pdev->isChannelClosed(pdev)))
{
pdev->setChannelClosed(pdev);
return 0;
}
-static int
-urbdrc_on_new_channel_connection(IWTSListenerCallback * pListenerCallback,
- IWTSVirtualChannel * pChannel,
- uint8 * pData,
- int * pbAccept,
- IWTSVirtualChannelCallback ** ppCallback)
+static int urbdrc_on_new_channel_connection(IWTSListenerCallback* pListenerCallback,
+ IWTSVirtualChannel * pChannel, uint8* pData, int* pbAccept, IWTSVirtualChannelCallback** ppCallback)
{
- URBDRC_LISTENER_CALLBACK * listener_callback = (URBDRC_LISTENER_CALLBACK *) pListenerCallback;
- URBDRC_CHANNEL_CALLBACK * callback;
+ URBDRC_LISTENER_CALLBACK* listener_callback = (URBDRC_LISTENER_CALLBACK*) pListenerCallback;
+ URBDRC_CHANNEL_CALLBACK* callback;
LLOGLN(10, ("urbdrc_on_new_channel_connection:"));
- callback = (URBDRC_CHANNEL_CALLBACK *) malloc(sizeof(URBDRC_CHANNEL_CALLBACK));
+ callback = (URBDRC_CHANNEL_CALLBACK*) malloc(sizeof(URBDRC_CHANNEL_CALLBACK));
callback->iface.OnDataReceived = urbdrc_on_data_received;
callback->iface.OnClose = urbdrc_on_close;
callback->plugin = listener_callback->plugin;
callback->channel_mgr = listener_callback->channel_mgr;
callback->channel = pChannel;
- *ppCallback = (IWTSVirtualChannelCallback *) callback;
+ *ppCallback = (IWTSVirtualChannelCallback*) callback;
+
return 0;
}
-static int
-urbdrc_plugin_initialize(IWTSPlugin * pPlugin, IWTSVirtualChannelManager * pChannelMgr)
+static int urbdrc_plugin_initialize(IWTSPlugin* pPlugin, IWTSVirtualChannelManager* pChannelMgr)
{
- URBDRC_PLUGIN * urbdrc = (URBDRC_PLUGIN *) pPlugin;
- IUDEVMAN * udevman = NULL;
+ URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*) pPlugin;
+ IUDEVMAN* udevman = NULL;
USB_SEARCHMAN * searchman = NULL;
LLOGLN(10, ("urbdrc_plugin_initialize:"));
- urbdrc->listener_callback = (URBDRC_LISTENER_CALLBACK *) malloc(sizeof(URBDRC_LISTENER_CALLBACK));
+ urbdrc->listener_callback = (URBDRC_LISTENER_CALLBACK*) malloc(sizeof(URBDRC_LISTENER_CALLBACK));
memset(urbdrc->listener_callback, 0, sizeof(URBDRC_LISTENER_CALLBACK));
urbdrc->listener_callback->iface.OnNewChannelConnection = urbdrc_on_new_channel_connection;
/* Init searchman */
udevman = urbdrc->udevman;
- searchman = searchman_new((void *)urbdrc, udevman->get_defUsbDevice(udevman));
+ searchman = searchman_new((void*) urbdrc, udevman->get_defUsbDevice(udevman));
urbdrc->searchman = searchman;
return pChannelMgr->CreateListener(pChannelMgr, "URBDRC", 0,
(IWTSListenerCallback *) urbdrc->listener_callback, NULL);
}
-static int
-urbdrc_plugin_terminated(IWTSPlugin * pPlugin)
+static int urbdrc_plugin_terminated(IWTSPlugin* pPlugin)
{
- URBDRC_PLUGIN * urbdrc = (URBDRC_PLUGIN *) pPlugin;
- IUDEVMAN* udevman = urbdrc->udevman;
- USB_SEARCHMAN* searchman = urbdrc->searchman;
+ URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*) pPlugin;
+ IUDEVMAN* udevman = urbdrc->udevman;
+ USB_SEARCHMAN* searchman = urbdrc->searchman;
LLOGLN(10, ("urbdrc_plugin_terminated:"));
{
/* close searchman */
searchman->close(searchman);
+
/* free searchman */
if (searchman->strated)
{
ts.tv_nsec = 0;
sem_timedwait(&searchman->sem_term, &ts);
}
+
searchman->free(searchman);
searchman = NULL;
}
if (urbdrc->listener_callback)
zfree(urbdrc->listener_callback);
+
if(urbdrc)
zfree(urbdrc);
+
return 0;
}
-
-static void
-urbdrc_register_udevman_plugin(IWTSPlugin* pPlugin, IUDEVMAN* udevman)
+static void urbdrc_register_udevman_plugin(IWTSPlugin* pPlugin, IUDEVMAN* udevman)
{
URBDRC_PLUGIN* urbdrc = (URBDRC_PLUGIN*) pPlugin;
urbdrc->udevman = udevman;
}
-
-
-static int
-urbdrc_load_udevman_plugin(IWTSPlugin* pPlugin, const char* name, RDP_PLUGIN_DATA* data)
+static int urbdrc_load_udevman_plugin(IWTSPlugin* pPlugin, const char* name, RDP_PLUGIN_DATA* data)
{
char* fullname;
PFREERDP_URBDRC_DEVICE_ENTRY entry;
return true;
}
-
-
-
-static int
-urbdrc_process_plugin_data(IWTSPlugin* pPlugin, RDP_PLUGIN_DATA* data)
+static int urbdrc_process_plugin_data(IWTSPlugin* pPlugin, RDP_PLUGIN_DATA* data)
{
boolean ret;
return true;
}
-
-int
-DVCPluginEntry(IDRDYNVC_ENTRY_POINTS * pEntryPoints)
+int DVCPluginEntry(IDRDYNVC_ENTRY_POINTS* pEntryPoints)
{
int error = 0;
URBDRC_PLUGIN* urbdrc;
urbdrc->vchannel_status = INIT_CHANNEL_IN;
urbdrc_debug = 10;
+
if (data->data[2] && strstr((char *)data->data[2], "debug"))
urbdrc_debug = 0;
return error;
}
-
projects / platform / upstream / freerdp.git / commitdiff