diff options
Diffstat (limited to 'src/sdbwinusbapi')
| -rw-r--r-- | src/sdbwinusbapi/BUILDME.TXT | 7 | ||||
| -rw-r--r-- | src/sdbwinusbapi/MAKEFILE | 22 | ||||
| -rw-r--r-- | src/sdbwinusbapi/Resource.h | 34 | ||||
| -rw-r--r-- | src/sdbwinusbapi/SOURCES | 91 | ||||
| -rw-r--r-- | src/sdbwinusbapi/SdbWinUsbApi.cpp | 62 | ||||
| -rw-r--r-- | src/sdbwinusbapi/SdbWinUsbApi.def | 5 | ||||
| -rw-r--r-- | src/sdbwinusbapi/SdbWinUsbApi.rc | 111 | ||||
| -rw-r--r-- | src/sdbwinusbapi/sdb_winusb_endpoint_object.cpp | 169 | ||||
| -rw-r--r-- | src/sdbwinusbapi/sdb_winusb_endpoint_object.h | 155 | ||||
| -rw-r--r-- | src/sdbwinusbapi/sdb_winusb_interface.cpp | 340 | ||||
| -rw-r--r-- | src/sdbwinusbapi/sdb_winusb_interface.h | 205 | ||||
| -rw-r--r-- | src/sdbwinusbapi/sdb_winusb_io_completion.cpp | 98 | ||||
| -rw-r--r-- | src/sdbwinusbapi/sdb_winusb_io_completion.h | 118 | ||||
| -rw-r--r-- | src/sdbwinusbapi/stdafx.cpp | 21 | ||||
| -rw-r--r-- | src/sdbwinusbapi/stdafx.h | 78 |
15 files changed, 1516 insertions, 0 deletions
diff --git a/src/sdbwinusbapi/BUILDME.TXT b/src/sdbwinusbapi/BUILDME.TXT new file mode 100644 index 0000000..b130472 --- /dev/null +++ b/src/sdbwinusbapi/BUILDME.TXT @@ -0,0 +1,7 @@ +In order to build SdbWinUsbApi.dll you will need to install Windows Driver Kit, +which can be obtained from Microsoft. Assuming that WDK is installed, you +need to set one of the WDK's build environments, "cd" back into this directory, +and execute "build -cbeEIFZ" to clean and rebuild this project, or you can +execute "build -befEIF" to do a minimal build. +Note that you need to build SdbWinApi.dll (..\api) before you build +SdbWinUsbApi.dll, as it depends on SdbWinApi.lib library. diff --git a/src/sdbwinusbapi/MAKEFILE b/src/sdbwinusbapi/MAKEFILE new file mode 100644 index 0000000..87a1295 --- /dev/null +++ b/src/sdbwinusbapi/MAKEFILE @@ -0,0 +1,22 @@ +# +# Copyright (C) 2009 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. +# + +# +# DO NOT EDIT THIS FILE!!! Edit .\sources. if you want to add a new source +# file to this component. This file merely indirects to the real make file +# that is shared by all the components of NT OS/2 +# +!INCLUDE $(NTMAKEENV)\makefile.def diff --git a/src/sdbwinusbapi/Resource.h b/src/sdbwinusbapi/Resource.h new file mode 100644 index 0000000..7d883c7 --- /dev/null +++ b/src/sdbwinusbapi/Resource.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2009 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. + */ + +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by SdbWinApi.rc +// + +#define IDS_PROJNAME 100 +#define IDR_SDBWINAPI 101 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 201 +#define _APS_NEXT_COMMAND_VALUE 32768 +#define _APS_NEXT_CONTROL_VALUE 201 +#define _APS_NEXT_SYMED_VALUE 102 +#endif +#endif diff --git a/src/sdbwinusbapi/SOURCES b/src/sdbwinusbapi/SOURCES new file mode 100644 index 0000000..90be2c1 --- /dev/null +++ b/src/sdbwinusbapi/SOURCES @@ -0,0 +1,91 @@ +# +# Copyright (C) 2009 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. +# + +TARGETNAME = SdbWinUsbApi +TARGETPATH = obj +TARGETTYPE = DYNLINK + +UMTYPE = windows +DLLDEF = SdbWinUsbApi.def + +# Use statically linked atl libraries: +# - atls.lib for free build +# - atlsd.lib for checked build +USE_STATIC_ATL = 1 +# Use ATL v. 7.1 +ATL_VER = 71 +# Use STL v. 6.0 +USE_STL = 1 +STL_VER = 60 +# Use multithreaded libraries +USE_LIBCMT = 1 + +# Include directories +INCLUDES = $(DDK_INC_PATH); \ + $(SDK_INC_PATH); \ + $(CRT_INC_PATH); \ + $(SDK_INC_PATH)\crt; \ + $(CRT_INC_PATH)\atl71; \ + $(SDK_INC_PATH)\crt\stl60 + +# Common target libraries +TARGETLIBS = $(SDK_LIB_PATH)\ole32.lib \ + $(SDK_LIB_PATH)\Advapi32.lib \ + $(SDK_LIB_PATH)\Kernel32.lib \ + $(SDK_LIB_PATH)\User32.lib \ + $(SDK_LIB_PATH)\oleaut32.lib \ + $(SDK_LIB_PATH)\wbemuuid.lib \ + $(SDK_LIB_PATH)\uuid.lib \ + $(SDK_LIB_PATH)\setupapi.lib \ + $(SDK_LIB_PATH)\usbd.lib \ + $(SDK_LIB_PATH)\winusb.lib \ + ..\sdbwinapi\obj$(BUILD_ALT_DIR)\i386\SdbWinApi.lib + +!IF "$(DDKBUILDENV)" == "fre" +# Libraries for release (free) builds +TARGETLIBS = $(TARGETLIBS) $(ATL_LIB_PATH)\atls.lib +!ELSE +# Libraries for debug (checked) builds +TARGETLIBS = $(TARGETLIBS) $(ATL_LIB_PATH)\atlsd.lib +!ENDIF + +# Common C defines +C_DEFINES= $(C_DEFINES) -DSDBWINUSB_EXPORTS -D_UNICODE \ + -DUNICODE -DWIN32 -D_WINDOWS -D_USRDLL -D_WINDLL + +!IF "$(DDKBUILDENV)" == "fre" +# C defines for release (free) builds +C_DEFINES = $(C_DEFINES) -DNDEBUG +!ELSE +# C defines for debug (checked) builds +C_DEFINES = $(C_DEFINES) -D_DEBUG +!ENDIF + +# Turn on all warnings, and treat warnings as errors +MSC_WARNING_LEVEL = /W4 /Wp64 /WX +# Common C defines +USER_C_FLAGS = $(USER_C_FLAGS) /FD /EHsc /wd4100 /wd4200 /wd4702 /nologo +# Set precompiled header information +PRECOMPILED_CXX = 1 +PRECOMPILED_INCLUDE = stdafx.h +PRECOMPILED_SOURCEFILE = stdafx.cpp + +# Define source files for SdbWinUsbApi.dll +SOURCES = sdb_winusb_endpoint_object.cpp \ + sdb_winusb_interface.cpp \ + sdb_winusb_io_completion.cpp \ + SdbWinUsbApi.cpp \ + SdbWinUsbApi.rc diff --git a/src/sdbwinusbapi/SdbWinUsbApi.cpp b/src/sdbwinusbapi/SdbWinUsbApi.cpp new file mode 100644 index 0000000..e656e94 --- /dev/null +++ b/src/sdbwinusbapi/SdbWinUsbApi.cpp @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2009 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. + */ + +// SdbWinUsbApi.cpp : Implementation of DLL Exports. + +#include "stdafx.h" +#include "sdb_winusb_interface.h" + +class CSdbWinApiModule : public CAtlDllModuleT< CSdbWinApiModule > { +public: +}; + +CSdbWinApiModule _AtlModule; + +// DLL Entry Point +extern "C" BOOL WINAPI DllMain(HINSTANCE instance, + DWORD reason, + LPVOID reserved) { + return _AtlModule.DllMain(reason, reserved); +} + +/** \brief Instantiates interface instance that uses WinUsb API to communicate + with USB driver. + + This is the only exported routine from this DLL. This routine instantiates an + object of SdbWinUsbInterfaceObject on request from SdbWinApi.dll when it is + detected that underlying USB driver is WinUsb.sys. + @param[in] interface_name Name of the interface. + @return SdbInterfaceObject - casted instance of SdbWinUsbInterfaceObject + object on success, or NULL on failure with GetLastError providing + information on an error that occurred. +*/ +extern "C" __declspec(dllexport) +SdbInterfaceObject* __cdecl InstantiateSdbWinUsbInterface( + const wchar_t* interface_name) { + // Validate parameter. + if (NULL == interface_name) { + return NULL; + } + + // Instantiate requested object. + try { + return new SdbWinUsbInterfaceObject(interface_name); + } catch (...) { + // We expect only OOM exceptions here. + SetLastError(ERROR_OUTOFMEMORY); + return NULL; + } +} diff --git a/src/sdbwinusbapi/SdbWinUsbApi.def b/src/sdbwinusbapi/SdbWinUsbApi.def new file mode 100644 index 0000000..06aac0b --- /dev/null +++ b/src/sdbwinusbapi/SdbWinUsbApi.def @@ -0,0 +1,5 @@ +; SdbWinUsbApi.def : Declares the module parameters. + +LIBRARY "SdbWinUsbApi.DLL" + +EXPORTS diff --git a/src/sdbwinusbapi/SdbWinUsbApi.rc b/src/sdbwinusbapi/SdbWinUsbApi.rc new file mode 100644 index 0000000..d19be52 --- /dev/null +++ b/src/sdbwinusbapi/SdbWinUsbApi.rc @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2009 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. + */ + +//Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "winres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE 9, 1 +#pragma code_page(1252) +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""winres.h""\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + +#ifndef _MAC +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 2,0,0,0 + PRODUCTVERSION 2,0,0,0 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904e4" + BEGIN + VALUE "CompanyName", "Google, inc" + VALUE "FileDescription", "Android SDB API (WinUsb)" + VALUE "FileVersion", "2.0.0.0" + VALUE "LegalCopyright", "Copyright (C) 2006 The Android Open Source Project" + VALUE "InternalName", "SdbWinUsbApi.dll" + VALUE "OriginalFilename", "SdbWinUsbApi.dll" + VALUE "ProductName", "Android SDK" + VALUE "ProductVersion", "2.0.0.0" + VALUE "OLESelfRegister", "" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x0409, 1252 + END +END + +#endif // !_MAC + +///////////////////////////////////////////////////////////////////////////// +// +// String Table +// + +STRINGTABLE +BEGIN + IDS_PROJNAME "SdbWinUsbApi" +END + +//////////////////////////////////////////////////////////////////////////// + + +#endif + +#ifndef APSTUDIO_INVOKED +#endif // not APSTUDIO_INVOKED diff --git a/src/sdbwinusbapi/sdb_winusb_endpoint_object.cpp b/src/sdbwinusbapi/sdb_winusb_endpoint_object.cpp new file mode 100644 index 0000000..8b5e891 --- /dev/null +++ b/src/sdbwinusbapi/sdb_winusb_endpoint_object.cpp @@ -0,0 +1,169 @@ +/* + * Copyright (C) 2009 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 class SdbWinUsbEndpointObject that + encapsulates a handle opened to a WinUsb endpoint on our device. +*/ + +#include "stdafx.h" +#include "sdb_winusb_endpoint_object.h" +#include "sdb_winusb_io_completion.h" + +SdbWinUsbEndpointObject::SdbWinUsbEndpointObject( + SdbWinUsbInterfaceObject* parent_interf, + UCHAR endpoint_id, + UCHAR endpoint_index) + : SdbEndpointObject(parent_interf, endpoint_id, endpoint_index) { +} + +SdbWinUsbEndpointObject::~SdbWinUsbEndpointObject() { +} + +LONG SdbWinUsbEndpointObject::Release() { + ATLASSERT(ref_count_ > 0); + LONG ret = InterlockedDecrement(&ref_count_); + ATLASSERT(ret >= 0); + if (0 == ret) { + LastReferenceReleased(); + delete this; + } + return ret; +} + +SDBAPIHANDLE SdbWinUsbEndpointObject::CommonAsyncReadWrite( + bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + HANDLE event_handle, + ULONG time_out) { + if (!SetTimeout(time_out)) + return false; + + // Create completion i/o object + SdbIOCompletion* sdb_io_completion = NULL; + + try { + sdb_io_completion = new SdbWinUsbIOCompletion(this, + bytes_to_transfer, + event_handle); + } catch (... ) { + SetLastError(ERROR_OUTOFMEMORY); + return NULL; + } + + // Create a handle for it + SDBAPIHANDLE ret = sdb_io_completion->CreateHandle(); + ULONG transferred = 0; + if (NULL != ret) { + BOOL res = TRUE; + // Go the read / write file way + res = is_read ? + WinUsb_ReadPipe(parent_winusb_interface()->winusb_handle(), + endpoint_id(), + reinterpret_cast<PUCHAR>(buffer), + bytes_to_transfer, + &transferred, + sdb_io_completion->overlapped()) : + WinUsb_WritePipe(parent_winusb_interface()->winusb_handle(), + endpoint_id(), + reinterpret_cast<PUCHAR>(buffer), + bytes_to_transfer, + &transferred, + sdb_io_completion->overlapped()); + + if (NULL != bytes_transferred) + *bytes_transferred = transferred; + + ULONG error = GetLastError(); + if (!res && (ERROR_IO_PENDING != error)) { + // I/O failed immediatelly. We need to close i/o completion object + // before we return NULL to the caller. + sdb_io_completion->CloseHandle(); + ret = NULL; + SetLastError(error); + } + } + + // Offseting 'new' + sdb_io_completion->Release(); + + return ret; +} + +bool SdbWinUsbEndpointObject::CommonSyncReadWrite(bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + ULONG time_out) { + if (!SetTimeout(time_out)) + return false; + + // This is synchronous I/O. Since we always open I/O items for + // overlapped I/O we're obligated to always provide OVERLAPPED + // structure to read / write routines. Prepare it now. + OVERLAPPED overlapped; + ZeroMemory(&overlapped, sizeof(overlapped)); + overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); + + BOOL ret = TRUE; + ULONG transferred = 0; + // Go the read / write file way + ret = is_read ? + WinUsb_ReadPipe(parent_winusb_interface()->winusb_handle(), + endpoint_id(), + reinterpret_cast<PUCHAR>(buffer), + bytes_to_transfer, + &transferred, + &overlapped) : + WinUsb_WritePipe(parent_winusb_interface()->winusb_handle(), + endpoint_id(), + reinterpret_cast<PUCHAR>(buffer), + bytes_to_transfer, + &transferred, + &overlapped); + + // Lets see the result + if (!ret && (ERROR_IO_PENDING != GetLastError())) { + // I/O failed. + if (NULL != overlapped.hEvent) + ::CloseHandle(overlapped.hEvent); + return false; + } + + // Lets wait till I/O completes + ret = WinUsb_GetOverlappedResult(parent_winusb_interface()->winusb_handle(), &overlapped, + &transferred, TRUE); + if (ret && (NULL != bytes_transferred)) { + *bytes_transferred = transferred; + } + + if (NULL != overlapped.hEvent) + ::CloseHandle(overlapped.hEvent); + + return ret ? true : false; +} + +bool SdbWinUsbEndpointObject::SetTimeout(ULONG timeout) { + if (!WinUsb_SetPipePolicy(parent_winusb_interface()->winusb_handle(), + endpoint_id(), PIPE_TRANSFER_TIMEOUT, + sizeof(ULONG), &timeout)) { + return false; + } + + return true; +} diff --git a/src/sdbwinusbapi/sdb_winusb_endpoint_object.h b/src/sdbwinusbapi/sdb_winusb_endpoint_object.h new file mode 100644 index 0000000..bd7b38b --- /dev/null +++ b/src/sdbwinusbapi/sdb_winusb_endpoint_object.h @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2009 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. + */ + +#ifndef ANDROID_USB_API_SDB_WINUSB_ENDPOINT_OBJECT_H__ +#define ANDROID_USB_API_SDB_WINUSB_ENDPOINT_OBJECT_H__ +/** \file + This file consists of declaration of class SdbWinUsbEndpointObject that + encapsulates a handle opened to a WinUsb endpoint on our device. +*/ + +#include "..\sdbwinapi\sdb_endpoint_object.h" +#include "sdb_winusb_interface.h" + +/** Class SdbWinUsbEndpointObject encapsulates a handle opened to an endpoint on + our device. +*/ +class SdbWinUsbEndpointObject : public SdbEndpointObject { + public: + /** \brief Constructs the object + + @param[in] interface Parent WinUsb interface for this object. + @param[in] endpoint_id Endpoint ID (endpoint address) on the device. + @param[in] endpoint_index Zero-based endpoint index in the interface's + array of endpoints. + */ + SdbWinUsbEndpointObject(SdbWinUsbInterfaceObject* parent_interf, + UCHAR endpoint_id, + UCHAR endpoint_index); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbWinUsbEndpointObject(); + + // + // Virtual overrides + // + + public: + /** \brief Releases the object. + + If refcount drops to zero as the result of this release, the object is + destroyed in this method. As a general rule, objects must not be touched + after this method returns even if returned value is not zero. We override + this method in order to make sure that objects of this class are deleted + in contect of the DLL they were created in. The problem is that since + objects of this class were created in context of SdbWinUsbApi module, they + are allocated from the heap assigned to that module. Now, if these objects + are deleted outside of SdbWinUsbApi module, this will lead to the heap + corruption in the module that deleted these objects. Since all objects of + this class are deleted in the Release method only, by overriding it we make + sure that we free memory in the context of the module where it was + allocated. + @return Value of the reference counter after object is released in this + method. + */ + virtual LONG Release(); + + // + // Abstract overrides + // + + protected: + /** \brief Common code for async read / write + + @param[in] is_read Read or write selector. + @param[in,out] buffer Pointer to the buffer for read / write. + @param[in] bytes_to_transfer Number of bytes to be read / written. + @param[out] bytes_transferred Number of bytes read / written. Can be NULL. + @param[in] event_handle Event handle that should be signaled when async I/O + completes. Can be NULL. If it's not NULL this handle will be used to + initialize OVERLAPPED structure for this I/O. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value in this parameter means that there is no + timeout set for this I/O. + @return A handle to IO completion object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. + */ + virtual SDBAPIHANDLE CommonAsyncReadWrite(bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + HANDLE event_handle, + ULONG time_out); + + /** \brief Common code for sync read / write + + @param[in] is_read Read or write selector. + @param[in,out] buffer Pointer to the buffer for read / write. + @param[in] bytes_to_transfer Number of bytes to be read / written. + @param[out] bytes_transferred Number of bytes read / written. Can be NULL. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value in this parameter means that there is no + timeout set for this I/O. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool CommonSyncReadWrite(bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + ULONG time_out); + + // + // Operations + // + + protected: + /** \brief Sets read / write operation timeout. + + @param[in] timeout Timeout value in milliseconds to use for current read + or write operation. Zero value passed in this parameters indicate + not timeout at all. Note that timeout that is set with this method is + global per endpoint (pipe). I.e. once set, it will be used against + all read / write operations performed on this endpoint, untill + another call to this method modifies it. This is a WinUsb design + flaw. Microsoft is aware of this and (hopefuly) future versions of + WinUsb framework will accept a timeout parameter in WinUsb_Read/Write + routines. For the purposes of SDB this flaw doesn't apperar to be an + issue, since we use single-threaded synchronous read / writes, so + there is no conflict in setting per-endpoint timeouts. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool SetTimeout(ULONG timeout); + + public: + /// Gets parent WinUsb interface + SdbWinUsbInterfaceObject* parent_winusb_interface() const { + return reinterpret_cast<SdbWinUsbInterfaceObject*>(parent_interface()); + } + + /// Gets parent interface WinUsb handle + WINUSB_INTERFACE_HANDLE winusb_handle() const { + return parent_winusb_interface()->winusb_handle(); + } +}; + +#endif // ANDROID_USB_API_SDB_WINUSB_ENDPOINT_OBJECT_H__ diff --git a/src/sdbwinusbapi/sdb_winusb_interface.cpp b/src/sdbwinusbapi/sdb_winusb_interface.cpp new file mode 100644 index 0000000..3fcdce7 --- /dev/null +++ b/src/sdbwinusbapi/sdb_winusb_interface.cpp @@ -0,0 +1,340 @@ +/* + * Copyright (C) 2009 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 class SdbWinUsbInterfaceObject + that encapsulates an interface on our USB device that is accessible + via WinUsb API. +*/ + +#include "stdafx.h" +#include "sdb_winusb_interface.h" +#include "sdb_winusb_endpoint_object.h" + +SdbWinUsbInterfaceObject::SdbWinUsbInterfaceObject(const wchar_t* interf_name) + : SdbInterfaceObject(interf_name), + usb_device_handle_(INVALID_HANDLE_VALUE), + winusb_handle_(NULL), + interface_number_(0xFF), + def_read_endpoint_(0xFF), + read_endpoint_id_(0xFF), + def_write_endpoint_(0xFF), + write_endpoint_id_(0xFF) { +} + +SdbWinUsbInterfaceObject::~SdbWinUsbInterfaceObject() { + ATLASSERT(NULL == winusb_handle_); + ATLASSERT(INVALID_HANDLE_VALUE == usb_device_handle_); +} + +LONG SdbWinUsbInterfaceObject::Release() { + ATLASSERT(ref_count_ > 0); + LONG ret = InterlockedDecrement(&ref_count_); + ATLASSERT(ret >= 0); + if (0 == ret) { + LastReferenceReleased(); + delete this; + } + return ret; +} + +SDBAPIHANDLE SdbWinUsbInterfaceObject::CreateHandle() { + // Open USB device for this inteface Note that WinUsb API + // requires the handle to be opened for overlapped I/O. + usb_device_handle_ = CreateFile(interface_name().c_str(), + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, OPEN_EXISTING, + FILE_FLAG_OVERLAPPED, NULL); + if (INVALID_HANDLE_VALUE == usb_device_handle_) + return NULL; + + // Initialize WinUSB API for this interface + if (!WinUsb_Initialize(usb_device_handle_, &winusb_handle_)) + return NULL; + + // Cache current interface number that will be used in + // WinUsb_Xxx calls performed on this interface. + if (!WinUsb_GetCurrentAlternateSetting(winusb_handle(), &interface_number_)) + return false; + + // Cache interface properties + unsigned long bytes_written; + + // Cache USB device descriptor + if (!WinUsb_GetDescriptor(winusb_handle(), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0, + reinterpret_cast<PUCHAR>(&usb_device_descriptor_), + sizeof(usb_device_descriptor_), &bytes_written)) { + return false; + } + + // Cache USB configuration descriptor + if (!WinUsb_GetDescriptor(winusb_handle(), USB_CONFIGURATION_DESCRIPTOR_TYPE, + 0, 0, + reinterpret_cast<PUCHAR>(&usb_config_descriptor_), + sizeof(usb_config_descriptor_), &bytes_written)) { + return false; + } + + // Cache USB interface descriptor + if (!WinUsb_QueryInterfaceSettings(winusb_handle(), interface_number(), + &usb_interface_descriptor_)) { + return false; + } + + // Save indexes and IDs for bulk read / write endpoints. We will use them to + // convert SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX and + // SDB_QUERY_BULK_READ_ENDPOINT_INDEX into actual endpoint indexes and IDs. + for (UCHAR endpoint = 0; endpoint < usb_interface_descriptor_.bNumEndpoints; + endpoint++) { + // Get endpoint information + WINUSB_PIPE_INFORMATION pipe_info; + if (!WinUsb_QueryPipe(winusb_handle(), interface_number(), endpoint, + &pipe_info)) { + return false; + } + + if (UsbdPipeTypeBulk == pipe_info.PipeType) { + // This is a bulk endpoint. Cache its index and ID. + if (0 != (pipe_info.PipeId & USB_ENDPOINT_DIRECTION_MASK)) { + // Use this endpoint as default bulk read endpoint + ATLASSERT(0xFF == def_read_endpoint_); + def_read_endpoint_ = endpoint; + read_endpoint_id_ = pipe_info.PipeId; + } else { + // Use this endpoint as default bulk write endpoint + ATLASSERT(0xFF == def_write_endpoint_); + def_write_endpoint_ = endpoint; + write_endpoint_id_ = pipe_info.PipeId; + } + } + } + + return SdbInterfaceObject::CreateHandle(); +} + +bool SdbWinUsbInterfaceObject::CloseHandle() { + if (NULL != winusb_handle_) { + WinUsb_Free(winusb_handle_); + winusb_handle_ = NULL; + } + if (INVALID_HANDLE_VALUE != usb_device_handle_) { + ::CloseHandle(usb_device_handle_); + usb_device_handle_ = INVALID_HANDLE_VALUE; + } + + return SdbInterfaceObject::CloseHandle(); +} + +bool SdbWinUsbInterfaceObject::GetSerialNumber(void* buffer, + unsigned long* buffer_char_size, + bool ansi) { + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + if (NULL == buffer_char_size) { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + // Calculate serial number string size. Note that WinUsb_GetDescriptor + // API will not return number of bytes needed to store serial number + // string. So we will have to start with a reasonably large preallocated + // buffer and then loop through WinUsb_GetDescriptor calls, doubling up + // string buffer size every time ERROR_INSUFFICIENT_BUFFER is returned. + union { + // Preallocate reasonably sized buffer on the stack. + char small_buffer[64]; + USB_STRING_DESCRIPTOR initial_ser_num; + }; + USB_STRING_DESCRIPTOR* ser_num = &initial_ser_num; + // Buffer byte size + unsigned long ser_num_size = sizeof(small_buffer); + // After successful call to WinUsb_GetDescriptor will contain serial + // number descriptor size. + unsigned long bytes_written; + while (!WinUsb_GetDescriptor(winusb_handle(), USB_STRING_DESCRIPTOR_TYPE, + usb_device_descriptor_.iSerialNumber, + 0x0409, // English (US) + reinterpret_cast<PUCHAR>(ser_num), + ser_num_size, &bytes_written)) { + // Any error other than ERROR_INSUFFICIENT_BUFFER is terminal here. + if (ERROR_INSUFFICIENT_BUFFER != GetLastError()) { + if (ser_num != &initial_ser_num) + delete[] reinterpret_cast<char*>(ser_num); + return false; + } + + // Double up buffer size and reallocate string buffer + ser_num_size *= 2; + if (ser_num != &initial_ser_num) + delete[] reinterpret_cast<char*>(ser_num); + try { + ser_num = + reinterpret_cast<USB_STRING_DESCRIPTOR*>(new char[ser_num_size]); + } catch (...) { + SetLastError(ERROR_OUTOFMEMORY); + return false; + } + } + + // Serial number string length + unsigned long str_len = (ser_num->bLength - + FIELD_OFFSET(USB_STRING_DESCRIPTOR, bString)) / + sizeof(wchar_t); + + // Lets see if requested buffer is big enough to fit the string + if ((NULL == buffer) || (*buffer_char_size < (str_len + 1))) { + // Requested buffer is too small. + if (ser_num != &initial_ser_num) + delete[] reinterpret_cast<char*>(ser_num); + *buffer_char_size = str_len + 1; + SetLastError(ERROR_INSUFFICIENT_BUFFER); + return false; + } + + bool ret = true; + if (ansi) { + // We need to convert name from wide char to ansi string + if (0 != WideCharToMultiByte(CP_ACP, 0, ser_num->bString, + static_cast<int>(str_len), + reinterpret_cast<PSTR>(buffer), + static_cast<int>(*buffer_char_size), + NULL, NULL)) { + // Zero-terminate output string. + reinterpret_cast<char*>(buffer)[str_len] = '\0'; + } else { + ret = false; + } + } else { + // For wide char output just copy string buffer, + // and zero-terminate output string. + CopyMemory(buffer, ser_num->bString, bytes_written); + reinterpret_cast<wchar_t*>(buffer)[str_len] = L'\0'; + } + + if (ser_num != &initial_ser_num) + delete[] reinterpret_cast<char*>(ser_num); + + return ret; +} + +bool SdbWinUsbInterfaceObject::GetEndpointInformation( + UCHAR endpoint_index, + SdbEndpointInformation* info) { + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + if (NULL == info) { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + // Get actual endpoint index for predefined read / write endpoints. + if (SDB_QUERY_BULK_READ_ENDPOINT_INDEX == endpoint_index) { + endpoint_index = def_read_endpoint_; + } else if (SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX == endpoint_index) { + endpoint_index = def_write_endpoint_; + } + + // Query endpoint information + WINUSB_PIPE_INFORMATION pipe_info; + if (!WinUsb_QueryPipe(winusb_handle(), interface_number(), endpoint_index, + &pipe_info)) { + return false; + } + + // Save endpoint information into output. + info->max_packet_size = pipe_info.MaximumPacketSize; + info->max_transfer_size = 0xFFFFFFFF; + info->endpoint_address = pipe_info.PipeId; + info->polling_interval = pipe_info.Interval; + info->setting_index = interface_number(); + switch (pipe_info.PipeType) { + case UsbdPipeTypeControl: + info->endpoint_type = SdbEndpointTypeControl; + break; + + case UsbdPipeTypeIsochronous: + info->endpoint_type = SdbEndpointTypeIsochronous; + break; + + case UsbdPipeTypeBulk: + info->endpoint_type = SdbEndpointTypeBulk; + break; + + case UsbdPipeTypeInterrupt: + info->endpoint_type = SdbEndpointTypeInterrupt; + break; + + default: + info->endpoint_type = SdbEndpointTypeInvalid; + break; + } + + return true; +} + +SDBAPIHANDLE SdbWinUsbInterfaceObject::OpenEndpoint( + UCHAR endpoint_index, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode) { + // Convert index into id + UCHAR endpoint_id; + + if ((SDB_QUERY_BULK_READ_ENDPOINT_INDEX == endpoint_index) || + (def_read_endpoint_ == endpoint_index)) { + endpoint_id = read_endpoint_id_; + endpoint_index = def_read_endpoint_; + } else if ((SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX == endpoint_index) || + (def_write_endpoint_ == endpoint_index)) { + endpoint_id = write_endpoint_id_; + endpoint_index = def_write_endpoint_; + } else { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + return OpenEndpoint(endpoint_id, endpoint_index); +} + +SDBAPIHANDLE SdbWinUsbInterfaceObject::OpenEndpoint(UCHAR endpoint_id, + UCHAR endpoint_index) { + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + SdbEndpointObject* sdb_endpoint = NULL; + + try { + sdb_endpoint = + new SdbWinUsbEndpointObject(this, endpoint_id, endpoint_index); + } catch (...) { + SetLastError(ERROR_OUTOFMEMORY); + return NULL; + } + + SDBAPIHANDLE ret = sdb_endpoint->CreateHandle(); + + sdb_endpoint->Release(); + + return ret; +} diff --git a/src/sdbwinusbapi/sdb_winusb_interface.h b/src/sdbwinusbapi/sdb_winusb_interface.h new file mode 100644 index 0000000..6a37996 --- /dev/null +++ b/src/sdbwinusbapi/sdb_winusb_interface.h @@ -0,0 +1,205 @@ +/* + * Copyright (C) 2009 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. + */ + +#ifndef ANDROID_USB_API_SDB_WINUSB_INTERFACE_H__ +#define ANDROID_USB_API_SDB_WINUSB_INTERFACE_H__ +/** \file + This file consists of declaration of class SdbWinUsbInterfaceObject + that encapsulates an interface on our USB device that is accessible + via WinUsb API. +*/ + +#include "..\sdbwinapi\sdb_interface.h" + +/** \brief Encapsulates an interface on our USB device that is accessible + via WinUsb API. +*/ +class SdbWinUsbInterfaceObject : public SdbInterfaceObject { + public: + /** \brief Constructs the object. + + @param[in] interf_name Name of the interface + */ + explicit SdbWinUsbInterfaceObject(const wchar_t* interf_name); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbWinUsbInterfaceObject(); + + // + // Virtual overrides + // + + public: + /** \brief Releases the object. + + If refcount drops to zero as the result of this release, the object is + destroyed in this method. As a general rule, objects must not be touched + after this method returns even if returned value is not zero. We override + this method in order to make sure that objects of this class are deleted + in contect of the DLL they were created in. The problem is that since + objects of this class were created in context of SdbWinUsbApi module, they + are allocated from the heap assigned to that module. Now, if these objects + are deleted outside of SdbWinUsbApi module, this will lead to the heap + corruption in the module that deleted these objects. Since all objects of + this class are deleted in the Release method only, by overriding it we make + sure that we free memory in the context of the module where it was + allocated. + @return Value of the reference counter after object is released in this + method. + */ + virtual LONG Release(); + + /** \brief Creates handle to this object. + + In this call a handle for this object is generated and object is added + to the SdbObjectHandleMap. We override this method in order to initialize + WinUsb API for the given interface. + @return A handle to this object on success or NULL on an error. + If NULL is returned GetLastError() provides extended error + information. ERROR_GEN_FAILURE is set if an attempt was + made to create already opened object. + */ + virtual SDBAPIHANDLE CreateHandle(); + + /** \brief This method is called when handle to this object gets closed. + + In this call object is deleted from the SdbObjectHandleMap. We override + this method in order close WinUsb handle created in CreateHandle method + of this class. + @return true on success or false if object is already closed. If + false is returned GetLastError() provides extended error + information. + */ + virtual bool CloseHandle(); + + // + // Abstract overrides + // + + public: + /** \brief Gets serial number for interface's device. + + @param[out] buffer Buffer for the serail number string. Can be NULL in + which case buffer_char_size will contain number of characters + required for the string. + @param[in,out] buffer_char_size On the way in supplies size (in characters) + of the buffer. On the way out, if method failed and GetLastError + reports ERROR_INSUFFICIENT_BUFFER, will contain number of characters + required for the name. + @param[in] ansi If true the name will be returned as single character + string. Otherwise name will be returned as wide character string. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetSerialNumber(void* buffer, + unsigned long* buffer_char_size, + bool ansi); + + /** \brief Gets information about an endpoint on this interface. + + @param[in] endpoint_index Zero-based endpoint index. There are two + shortcuts for this parameter: SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX + and SDB_QUERY_BULK_READ_ENDPOINT_INDEX that provide infor about + (default?) bulk write and read endpoints respectively. + @param[out] info Upon successful completion will have endpoint information. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetEndpointInformation(UCHAR endpoint_index, + SdbEndpointInformation* info); + + /** \brief Opens an endpoint on this interface. + + @param[in] endpoint_index Zero-based endpoint index. There are two + shortcuts for this parameter: SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX + and SDB_QUERY_BULK_READ_ENDPOINT_INDEX that provide infor about + (default?) bulk write and read endpoints respectively. + @param[in] access_type Desired access type. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always read / write access. + @param[in] sharing_mode Desired share mode. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always shared for read / write. + @return Handle to the opened endpoint object or NULL on failure. + If NULL is returned GetLastError() provides extended information + about the error that occurred. + */ + virtual SDBAPIHANDLE OpenEndpoint(UCHAR endpoint_index, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode); + + // + // Operations + // + + protected: + /** \brief Opens an endpoint on this interface. + + @param[in] endpoint_id Endpoint (pipe) address on the device. + @param[in] endpoint_index Zero-based endpoint index. + @return Handle to the opened endpoint object or NULL on failure. + If NULL is returned GetLastError() provides extended information + about the error that occurred. + */ + SDBAPIHANDLE OpenEndpoint(UCHAR endpoint_id, UCHAR endpoint_index); + + public: + /// Gets handle to the USB device + HANDLE usb_device_handle() const { + return usb_device_handle_; + } + + /// Gets interface handle used by WinUSB API + WINUSB_INTERFACE_HANDLE winusb_handle() const { + return winusb_handle_; + } + + /// Gets current interface number. + UCHAR interface_number() const { + return interface_number_; + } + + protected: + /// Handle to the USB device + HANDLE usb_device_handle_; + + /// Interface handle used by WinUSB API + WINUSB_INTERFACE_HANDLE winusb_handle_; + + /// Current interface number. This value is obtained via call to + /// WinUsb_GetCurrentAlternateSetting and is used in WinUsb_Xxx + /// calls that require interface number. + UCHAR interface_number_; + + /// Index for the default bulk read endpoint + UCHAR def_read_endpoint_; + + /// ID for the default bulk read endpoint + UCHAR read_endpoint_id_; + + /// Index for the default bulk write endpoint + UCHAR def_write_endpoint_; + + /// ID for the default bulk write endpoint + UCHAR write_endpoint_id_; +}; + +#endif // ANDROID_USB_API_SDB_WINUSB_INTERFACE_H__ diff --git a/src/sdbwinusbapi/sdb_winusb_io_completion.cpp b/src/sdbwinusbapi/sdb_winusb_io_completion.cpp new file mode 100644 index 0000000..283f689 --- /dev/null +++ b/src/sdbwinusbapi/sdb_winusb_io_completion.cpp @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2009 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 class SdbWinUsbIOCompletion that + encapsulates a wrapper around OVERLAPPED Win32 structure returned from + asynchronous I/O requests issued via WinUsb API. +*/ + +#include "stdafx.h" +#include "sdb_winusb_io_completion.h" + +SdbWinUsbIOCompletion::SdbWinUsbIOCompletion( + SdbWinUsbEndpointObject* parent_io_obj, + ULONG expected_trans_size, + HANDLE event_hndl) + : SdbIOCompletion(parent_io_obj, expected_trans_size, event_hndl) { +} + +SdbWinUsbIOCompletion::~SdbWinUsbIOCompletion() { +} + +LONG SdbWinUsbIOCompletion::Release() { + ATLASSERT(ref_count_ > 0); + LONG ret = InterlockedDecrement(&ref_count_); + ATLASSERT(ret >= 0); + if (0 == ret) { + LastReferenceReleased(); + delete this; + } + return ret; +} + +bool SdbWinUsbIOCompletion::GetOvelappedIoResult(LPOVERLAPPED ovl_data, + ULONG* bytes_transferred, + bool wait) { + if (NULL != bytes_transferred) { + *bytes_transferred = 0; + } + + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + ULONG transfer; + bool ret = WinUsb_GetOverlappedResult( + parent_winusb_io_object()->winusb_handle(), + overlapped(), + &transfer, + wait ? TRUE : FALSE) ? true : false; + + // TODO: This is bizzare but I've seen it happening + // that GetOverlappedResult with wait set to true returns "prematurely", + // with wrong transferred bytes value and GetLastError reporting + // ERROR_IO_PENDING. So, lets give it an up to a 20 ms loop! + ULONG error = GetLastError(); + + if (wait && ret && (0 == transfer) && (0 != expected_transfer_size_) && + ((ERROR_IO_INCOMPLETE == error) || (ERROR_IO_PENDING == error))) { + for (int trying = 0; trying < 10; trying++) { + Sleep(2); + ret = WinUsb_GetOverlappedResult( + parent_winusb_io_object()->winusb_handle(), + overlapped(), + &transfer, + wait ? TRUE : FALSE) ? true : false; + error = GetLastError(); + if (!ret || (0 != transfer) || + ((ERROR_IO_INCOMPLETE != error) && (ERROR_IO_PENDING != error))) { + break; + } + } + } + + if (NULL != ovl_data) { + CopyMemory(ovl_data, overlapped(), sizeof(OVERLAPPED)); + } + + if (NULL != bytes_transferred) { + *bytes_transferred = transfer; + } + + return ret; +} diff --git a/src/sdbwinusbapi/sdb_winusb_io_completion.h b/src/sdbwinusbapi/sdb_winusb_io_completion.h new file mode 100644 index 0000000..e75a7b2 --- /dev/null +++ b/src/sdbwinusbapi/sdb_winusb_io_completion.h @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2009 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. + */ + +#ifndef ANDROID_USB_API_SDB_WINUSB_IO_COMPLETION_H__ +#define ANDROID_USB_API_SDB_WINUSB_IO_COMPLETION_H__ +/** \file + This file consists of declaration of class SdbWinUsbIOCompletion that + encapsulates a wrapper around OVERLAPPED Win32 structure returned from + asynchronous I/O requests issued via WinUsb API. +*/ + +#include "..\sdbwinapi\sdb_io_completion.h" +#include "sdb_winusb_endpoint_object.h" + +/** \brief Encapsulates encapsulates a wrapper around OVERLAPPED Win32 + structure returned from asynchronous I/O requests issued via WinUsb API. + + A handle to this object is returned to the caller of each successful + asynchronous I/O request. Just like all other handles this handle + must be closed after it's no longer needed. +*/ +class SdbWinUsbIOCompletion : public SdbIOCompletion { + public: + /** \brief Constructs the object + + @param[in] parent_io_obj Parent WinUsb I/O object that created this + instance. + @param[in] expected_trans_size Number of bytes expected to be transferred + with the I/O. + @param[in] event_hndl Event handle that should be signaled when I/O + completes. Can be NULL. If it's not NULL this handle will be + used to initialize OVERLAPPED structure for this object. + */ + SdbWinUsbIOCompletion(SdbWinUsbEndpointObject* parent_io_obj, + ULONG expected_trans_size, + HANDLE event_hndl); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbWinUsbIOCompletion(); + + // + // Virtual overrides + // + + public: + /** \brief Releases the object. + + If refcount drops to zero as the result of this release, the object is + destroyed in this method. As a general rule, objects must not be touched + after this method returns even if returned value is not zero. We override + this method in order to make sure that objects of this class are deleted + in contect of the DLL they were created in. The problem is that since + objects of this class were created in context of SdbWinUsbApi module, they + are allocated from the heap assigned to that module. Now, if these objects + are deleted outside of SdbWinUsbApi module, this will lead to the heap + corruption in the module that deleted these objects. Since all objects of + this class are deleted in the Release method only, by overriding it we make + sure that we free memory in the context of the module where it was + allocated. + @return Value of the reference counter after object is released in this + method. + */ + virtual LONG Release(); + + // + // Abstract overrides + // + + public: + /** \brief Gets overlapped I/O result + + This method uses WinUsb_GetOverlappedResult to get results of the + overlapped I/O operation. + @param[out] ovl_data Buffer for the copy of this object's OVERLAPPED + structure. Can be NULL. + @param[out] bytes_transferred Pointer to a variable that receives the + number of bytes that were actually transferred by a read or write + operation. See SDK doc on GetOvelappedResult for more information. + Unlike regular GetOvelappedResult call this parameter can be NULL. + @param[in] wait If this parameter is true, the method does not return + until the operation has been completed. If this parameter is false + and the operation is still pending, the method returns false and + the GetLastError function returns ERROR_IO_INCOMPLETE. + @return true if I/O has been completed or false on failure or if request + is not yet completed. If false is returned GetLastError() provides + extended error information. If GetLastError returns + ERROR_IO_INCOMPLETE it means that I/O is not yet completed. + */ + virtual bool GetOvelappedIoResult(LPOVERLAPPED ovl_data, + ULONG* bytes_transferred, + bool wait); + + public: + /// Gets WinUsb parent object + SdbWinUsbEndpointObject* parent_winusb_io_object() const { + return reinterpret_cast<SdbWinUsbEndpointObject*>(parent_io_object()); + } +}; + +#endif // ANDROID_USB_API_SDB_WINUSB_IO_COMPLETION_H__ diff --git a/src/sdbwinusbapi/stdafx.cpp b/src/sdbwinusbapi/stdafx.cpp new file mode 100644 index 0000000..83c6e13 --- /dev/null +++ b/src/sdbwinusbapi/stdafx.cpp @@ -0,0 +1,21 @@ +/* + * Copyright (C) 2009 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. + */ + +// stdafx.cpp : source file that includes just the standard includes +// SdbWinUsbApi.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" diff --git a/src/sdbwinusbapi/stdafx.h b/src/sdbwinusbapi/stdafx.h new file mode 100644 index 0000000..88cd963 --- /dev/null +++ b/src/sdbwinusbapi/stdafx.h @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2009 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 + Visual Studio generated include file for standard system include files, or + project specific include files that are used frequently, but are changed + infrequently. +*/ + +#pragma once + +#ifndef STRICT +#define STRICT +#endif + +// Modify the following defines if you have to target a platform prior to the ones specified below. +// Refer to MSDN for the latest info on corresponding values for different platforms. +#ifndef WINVER // Allow use of features specific to Windows 95 and Windows NT 4 or later. +#define WINVER 0x0500 // Change this to the appropriate value to target Windows 98 and Windows 2000 or later. +#endif + +#ifndef _WIN32_WINNT // Allow use of features specific to Windows NT 4 or later. +#define _WIN32_WINNT 0x0500 // Change this to the appropriate value to target Windows 2000 or later. +#endif + +#ifndef _WIN32_WINDOWS // Allow use of features specific to Windows 98 or later. +#define _WIN32_WINDOWS 0x0500 // Change this to the appropriate value to target Windows Me or later. +#endif + +#ifndef _WIN32_IE // Allow use of features specific to IE 4.0 or later. +#define _WIN32_IE 0x0501 // Change this to the appropriate value to target IE 5.0 or later. +#endif + +// These defines prevent the MS header files from ejecting #pragma comment +// statements with the manifest information of the used ATL, STL, and CRT +#define _ATL_NOFORCE_MANIFEST +#define _STL_NOFORCE_MANIFEST +#define _CRT_NOFORCE_MANIFEST + +#define _ATL_APARTMENT_THREADED +#define _ATL_NO_AUTOMATIC_NAMESPACE + +#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // some CString constructors will be explicit + +// turns off ATL's hiding of some common and often safely ignored warning messages +#define _ATL_ALL_WARNINGS + +// #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include <windows.h> +#pragma warning(disable: 4702) +#pragma warning(disable: 4201) +#include <atlbase.h> +#include <winioctl.h> +#include <setupapi.h> +#include <vector> +#include <map> +#include <string> +#pragma warning(default: 4201) +#pragma warning(disable: 4200) +#include <winusb.h> + +#include "resource.h" + +using namespace ATL; |