diff options
Diffstat (limited to 'host/windows/usb/api/adb_api.cpp')
| -rw-r--r-- | host/windows/usb/api/adb_api.cpp | 508 |
1 files changed, 508 insertions, 0 deletions
diff --git a/host/windows/usb/api/adb_api.cpp b/host/windows/usb/api/adb_api.cpp new file mode 100644 index 000000000..50356c794 --- /dev/null +++ b/host/windows/usb/api/adb_api.cpp @@ -0,0 +1,508 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** \file + This file consists of implementation of rotines that are exported + from this DLL. +*/ + +#include "stdafx.h" +#include "adb_api.h" +#include "adb_object_handle.h" +#include "adb_interface_enum.h" +#include "adb_interface.h" +#include "adb_endpoint_object.h" +#include "adb_io_completion.h" +#include "adb_helper_routines.h" + +ADBAPIHANDLE AdbEnumInterfaces(GUID class_id, + bool exclude_not_present, + bool exclude_removed, + bool active_only) { + AdbInterfaceEnumObject* enum_obj = NULL; + ADBAPIHANDLE ret = NULL; + + try { + // Instantiate and initialize enum object + enum_obj = new AdbInterfaceEnumObject(); + + if (enum_obj->InitializeEnum(class_id, + exclude_not_present, + exclude_removed, + active_only)) { + // After successful initialization we can create handle. + ret = enum_obj->CreateHandle(); + } + } catch (...) { + SetLastError(ERROR_OUTOFMEMORY); + } + + if (NULL != enum_obj) + enum_obj->Release(); + + return ret; +} + +bool AdbNextInterface(ADBAPIHANDLE adb_handle, + AdbInterfaceInfo* info, + unsigned long* size) { + if (NULL == size) { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + // Lookup AdbInterfaceEnumObject object for the handle + AdbInterfaceEnumObject* adb_ienum_object = + LookupObject<AdbInterfaceEnumObject>(adb_handle); + if (NULL == adb_ienum_object) + return false; + + // Everything is verified. Pass it down to the object + bool ret = adb_ienum_object->Next(info, size); + + adb_ienum_object->Release(); + + return ret; +} + +bool AdbResetInterfaceEnum(ADBAPIHANDLE adb_handle) { + // Lookup AdbInterfaceEnumObject object for the handle + AdbInterfaceEnumObject* adb_ienum_object = + LookupObject<AdbInterfaceEnumObject>(adb_handle); + if (NULL == adb_ienum_object) + return false; + + // Everything is verified. Pass it down to the object + bool ret = adb_ienum_object->Reset(); + + adb_ienum_object->Release(); + + return ret; +} + +ADBWIN_API ADBAPIHANDLE AdbCreateInterfaceByName( + const wchar_t* interface_name) { + AdbInterfaceObject* obj = NULL; + ADBAPIHANDLE ret = NULL; + + try { + // Instantiate object + obj = new AdbInterfaceObject(interface_name); + + // Create handle for it + ret = obj->CreateHandle(); + } catch (...) { + SetLastError(ERROR_OUTOFMEMORY); + } + + if (NULL != obj) + obj->Release(); + + return ret; +} + +ADBAPIHANDLE AdbCreateInterface(GUID class_id, + unsigned short vendor_id, + unsigned short product_id, + unsigned char interface_id) { + // Enumerate all active interfaces for the given class + AdbEnumInterfaceArray interfaces; + + if (!EnumerateDeviceInterfaces(class_id, + DIGCF_DEVICEINTERFACE | DIGCF_PRESENT, + true, + true, + &interfaces)) { + return NULL; + } + + if (interfaces.empty()) { + SetLastError(ERROR_DEVICE_NOT_AVAILABLE); + return NULL; + } + + // Now iterate over active interfaces looking for the name match. + // The name is formatted as such: + // "\\\\?\\usb#vid_xxxx&pid_xxxx&mi_xx#123456789abcdef#{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" + // where + // vid_xxxx is for the vendor id (xxxx are hex for the given vendor id), + // pid_xxxx is for the product id (xxxx are hex for the given product id) + // mi_xx is for the interface id (xx are hex for the given interface id) + // EnumerateDeviceInterfaces will guarantee that returned interface names + // will have our class id at the end of the name (those last XXXes in the + // format). So, we only need to match the beginning of the name + wchar_t match_name[64]; + if (0xFF == interface_id) { + // No interface id for the name. + swprintf(match_name, L"\\\\?\\usb#vid_%04x&pid_%04x#", + vendor_id, product_id); + } else { + // With interface id for the name. + swprintf(match_name, L"\\\\?\\usb#vid_%04x&pid_%04x&mi_%02x#", + vendor_id, product_id, interface_id); + } + size_t match_len = wcslen(match_name); + + for (AdbEnumInterfaceArray::iterator it = interfaces.begin(); + it != interfaces.end(); it++) { + const AdbInstanceEnumEntry& next_interface = *it; + if (0 == wcsnicmp(match_name, + next_interface.device_name().c_str(), + match_len)) { + // Found requested interface among active interfaces. + return AdbCreateInterfaceByName(next_interface.device_name().c_str()); + } + } + + SetLastError(ERROR_DEVICE_NOT_AVAILABLE); + return NULL; +} + +bool AdbGetInterfaceName(ADBAPIHANDLE adb_interface, + void* buffer, + unsigned long* buffer_char_size, + bool ansi) { + // Lookup interface object for the handle + AdbInterfaceObject* adb_object = + LookupObject<AdbInterfaceObject>(adb_interface); + + if (NULL != adb_object) { + // Dispatch call to the found object + bool ret = adb_object->GetInterfaceName(buffer, buffer_char_size, ansi); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool AdbGetSerialNumber(ADBAPIHANDLE adb_interface, + void* buffer, + unsigned long* buffer_char_size, + bool ansi) { + // Lookup interface object for the handle + AdbInterfaceObject* adb_object = + LookupObject<AdbInterfaceObject>(adb_interface); + + if (NULL != adb_object) { + // Dispatch call to the found object + bool ret = adb_object->GetSerialNumber(buffer, buffer_char_size, ansi); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool AdbGetUsbDeviceDescriptor(ADBAPIHANDLE adb_interface, + USB_DEVICE_DESCRIPTOR* desc) { + // Lookup interface object for the handle + AdbInterfaceObject* adb_object = + LookupObject<AdbInterfaceObject>(adb_interface); + + if (NULL != adb_object) { + // Dispatch close to the found object + bool ret = adb_object->GetUsbDeviceDescriptor(desc); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool AdbGetUsbConfigurationDescriptor(ADBAPIHANDLE adb_interface, + USB_CONFIGURATION_DESCRIPTOR* desc) { + // Lookup interface object for the handle + AdbInterfaceObject* adb_object = + LookupObject<AdbInterfaceObject>(adb_interface); + + if (NULL != adb_object) { + // Dispatch close to the found object + bool ret = adb_object->GetUsbConfigurationDescriptor(desc); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool AdbGetUsbInterfaceDescriptor(ADBAPIHANDLE adb_interface, + USB_INTERFACE_DESCRIPTOR* desc) { + // Lookup interface object for the handle + AdbInterfaceObject* adb_object = + LookupObject<AdbInterfaceObject>(adb_interface); + + if (NULL != adb_object) { + // Dispatch close to the found object + bool ret = adb_object->GetUsbInterfaceDescriptor(desc); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool AdbGetEndpointInformation(ADBAPIHANDLE adb_interface, + UCHAR endpoint_index, + AdbEndpointInformation* info) { + // Lookup interface object for the handle + AdbInterfaceObject* adb_object = + LookupObject<AdbInterfaceObject>(adb_interface); + + if (NULL != adb_object) { + // Dispatch close to the found object + bool ret = adb_object->GetEndpointInformation(endpoint_index, info); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool AdbGetDefaultBulkReadEndpointInformation(ADBAPIHANDLE adb_interface, + AdbEndpointInformation* info) { + return AdbGetEndpointInformation(adb_interface, + ADB_QUERY_BULK_READ_ENDPOINT_INDEX, + info); +} + +bool AdbGetDefaultBulkWriteEndpointInformation(ADBAPIHANDLE adb_interface, + AdbEndpointInformation* info) { + return AdbGetEndpointInformation(adb_interface, + ADB_QUERY_BULK_WRITE_ENDPOINT_INDEX, + info); +} + +ADBAPIHANDLE AdbOpenEndpoint(ADBAPIHANDLE adb_interface, + unsigned char endpoint_index, + AdbOpenAccessType access_type, + AdbOpenSharingMode sharing_mode) { + // Lookup interface object for the handle + AdbInterfaceObject* adb_object = + LookupObject<AdbInterfaceObject>(adb_interface); + + if (NULL != adb_object) { + // Dispatch close to the found object + ADBAPIHANDLE ret = + adb_object->OpenEndpoint(endpoint_index, access_type, sharing_mode); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } +} + +ADBAPIHANDLE AdbOpenDefaultBulkReadEndpoint(ADBAPIHANDLE adb_interface, + AdbOpenAccessType access_type, + AdbOpenSharingMode sharing_mode) { + return AdbOpenEndpoint(adb_interface, + ADB_QUERY_BULK_READ_ENDPOINT_INDEX, + access_type, + sharing_mode); +} + +ADBAPIHANDLE AdbOpenDefaultBulkWriteEndpoint(ADBAPIHANDLE adb_interface, + AdbOpenAccessType access_type, + AdbOpenSharingMode sharing_mode) { + return AdbOpenEndpoint(adb_interface, + ADB_QUERY_BULK_WRITE_ENDPOINT_INDEX, + access_type, + sharing_mode); +} + +ADBAPIHANDLE AdbGetEndpointInterface(ADBAPIHANDLE adb_endpoint) { + // Lookup endpoint object for the handle + AdbEndpointObject* adb_object = + LookupObject<AdbEndpointObject>(adb_endpoint); + + if (NULL != adb_object) { + // Dispatch the call to the found object + ADBAPIHANDLE ret = adb_object->GetParentInterfaceHandle(); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } +} + +bool AdbQueryInformationEndpoint(ADBAPIHANDLE adb_endpoint, + AdbEndpointInformation* info) { + // Lookup endpoint object for the handle + AdbEndpointObject* adb_object = + LookupObject<AdbEndpointObject>(adb_endpoint); + + if (NULL != adb_object) { + // Dispatch the call to the found object + bool ret = adb_object->GetEndpointInformation(info); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +ADBAPIHANDLE AdbReadEndpointAsync(ADBAPIHANDLE adb_endpoint, + void* buffer, + unsigned long bytes_to_read, + unsigned long* bytes_read, + unsigned long time_out, + HANDLE event_handle) { + // Lookup endpoint object for the handle + AdbEndpointObject* adb_object = + LookupObject<AdbEndpointObject>(adb_endpoint); + + if (NULL != adb_object) { + // Dispatch the call to the found object + ADBAPIHANDLE ret = adb_object->AsyncRead(buffer, + bytes_to_read, + bytes_read, + event_handle, + time_out); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } +} + +ADBAPIHANDLE AdbWriteEndpointAsync(ADBAPIHANDLE adb_endpoint, + void* buffer, + unsigned long bytes_to_write, + unsigned long* bytes_written, + unsigned long time_out, + HANDLE event_handle) { + // Lookup endpoint object for the handle + AdbEndpointObject* adb_object = + LookupObject<AdbEndpointObject>(adb_endpoint); + + if (NULL != adb_object) { + // Dispatch the call to the found object + ADBAPIHANDLE ret = adb_object->AsyncWrite(buffer, + bytes_to_write, + bytes_written, + event_handle, + time_out); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool AdbReadEndpointSync(ADBAPIHANDLE adb_endpoint, + void* buffer, + unsigned long bytes_to_read, + unsigned long* bytes_read, + unsigned long time_out) { + // Lookup endpoint object for the handle + AdbEndpointObject* adb_object = + LookupObject<AdbEndpointObject>(adb_endpoint); + + if (NULL != adb_object) { + // Dispatch the call to the found object + bool ret = + adb_object->SyncRead(buffer, bytes_to_read, bytes_read, time_out); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } +} + +bool AdbWriteEndpointSync(ADBAPIHANDLE adb_endpoint, + void* buffer, + unsigned long bytes_to_write, + unsigned long* bytes_written, + unsigned long time_out) { + // Lookup endpoint object for the handle + AdbEndpointObject* adb_object = + LookupObject<AdbEndpointObject>(adb_endpoint); + + if (NULL != adb_object) { + // Dispatch the call to the found object + bool ret = + adb_object->SyncWrite(buffer, bytes_to_write, bytes_written, time_out); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool AdbGetOvelappedIoResult(ADBAPIHANDLE adb_io_completion, + LPOVERLAPPED overlapped, + unsigned long* bytes_transferred, + bool wait) { + // Lookup endpoint object for the handle + AdbIOCompletion* adb_object = + LookupObject<AdbIOCompletion>(adb_io_completion); + + if (NULL != adb_object) { + // Dispatch the call to the found object + bool ret = + adb_object->GetOvelappedIoResult(overlapped, bytes_transferred, wait); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool AdbHasOvelappedIoComplated(ADBAPIHANDLE adb_io_completion) { + // Lookup endpoint object for the handle + AdbIOCompletion* adb_object = + LookupObject<AdbIOCompletion>(adb_io_completion); + + if (NULL != adb_object) { + // Dispatch the call to the found object + bool ret = + adb_object->IsCompleted(); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return true; + } +} + +bool AdbCloseHandle(ADBAPIHANDLE adb_handle) { + // Lookup object for the handle + AdbObjectHandle* adb_object = AdbObjectHandle::Lookup(adb_handle); + + if (NULL != adb_object) { + // Dispatch close to the found object + bool ret = adb_object->CloseHandle(); + adb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} |