/*
* 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_ADB_API_LEGACY_H_
#define ANDROID_USB_API_ADB_API_LEGACY_H_
/** \file
This file consists of declarations of constants and structures required
for supporting communications of this API with a legacy (custom) USB
driver.
*/
// Enables compillation for "straight" C
#ifdef __cplusplus
#define EXTERN_C extern "C"
#else
#define EXTERN_C extern
typedef int bool;
#define true 1
#define false 0
#endif
/// Name for the default bulk read pipe
#define DEVICE_BULK_READ_PIPE_NAME L"BulkRead"
/// Name for the default bulk write pipe
#define DEVICE_BULK_WRITE_PIPE_NAME L"BulkWrite"
/// Prefix for an index-based pipe name
#define DEVICE_PIPE_NAME_PREFIX L"PIPE_"
/** \name IOCTL codes for the driver
*/
///@{
/// Control code for IOCTL that gets USB_DEVICE_DESCRIPTOR
#define ADB_CTL_GET_USB_DEVICE_DESCRIPTOR 10
/// Control code for IOCTL that gets USB_CONFIGURATION_DESCRIPTOR
#define ADB_CTL_GET_USB_CONFIGURATION_DESCRIPTOR 11
/// Control code for IOCTL that gets USB_INTERFACE_DESCRIPTOR
#define ADB_CTL_GET_USB_INTERFACE_DESCRIPTOR 12
/// Control code for IOCTL that gets endpoint information
#define ADB_CTL_GET_ENDPOINT_INFORMATION 13
/// Control code for bulk read IOCTL
#define ADB_CTL_BULK_READ 14
/// Control code for bulk write IOCTL
#define ADB_CTL_BULK_WRITE 15
/// Control code for IOCTL that gets device serial number
#define ADB_CTL_GET_SERIAL_NUMBER 16
/// IOCTL that gets USB_DEVICE_DESCRIPTOR
#define ADB_IOCTL_GET_USB_DEVICE_DESCRIPTOR \
CTL_CODE(FILE_DEVICE_UNKNOWN, \
ADB_CTL_GET_USB_DEVICE_DESCRIPTOR, \
METHOD_BUFFERED, \
FILE_READ_ACCESS)
/// IOCTL that gets USB_CONFIGURATION_DESCRIPTOR
#define ADB_IOCTL_GET_USB_CONFIGURATION_DESCRIPTOR \
CTL_CODE(FILE_DEVICE_UNKNOWN, \
ADB_CTL_GET_USB_CONFIGURATION_DESCRIPTOR, \
METHOD_BUFFERED, \
FILE_READ_ACCESS)
/// IOCTL that gets USB_INTERFACE_DESCRIPTOR
#define ADB_IOCTL_GET_USB_INTERFACE_DESCRIPTOR \
CTL_CODE(FILE_DEVICE_UNKNOWN, \
ADB_CTL_GET_USB_INTERFACE_DESCRIPTOR, \
METHOD_BUFFERED, \
FILE_READ_ACCESS)
/// IOCTL that gets endpoint information
#define ADB_IOCTL_GET_ENDPOINT_INFORMATION \
CTL_CODE(FILE_DEVICE_UNKNOWN, \
ADB_CTL_GET_ENDPOINT_INFORMATION, \
METHOD_BUFFERED, \
FILE_READ_ACCESS)
/// Bulk read IOCTL
#define ADB_IOCTL_BULK_READ \
CTL_CODE(FILE_DEVICE_UNKNOWN, \
ADB_CTL_BULK_READ, \
METHOD_OUT_DIRECT, \
FILE_READ_ACCESS)
// For bulk write IOCTL we send request data in the form of AdbBulkTransfer
// structure and output buffer is just ULONG that receives number of bytes
// actually written. Since both of these are tiny we can use buffered I/O
// for this IOCTL.
/// Bulk write IOCTL
#define ADB_IOCTL_BULK_WRITE \
CTL_CODE(FILE_DEVICE_UNKNOWN, \
ADB_CTL_BULK_WRITE, \
METHOD_BUFFERED, \
FILE_WRITE_ACCESS)
/// IOCTL that gets device serial number
#define ADB_IOCTL_GET_SERIAL_NUMBER \
CTL_CODE(FILE_DEVICE_UNKNOWN, \
ADB_CTL_GET_SERIAL_NUMBER, \
METHOD_BUFFERED, \
FILE_READ_ACCESS)
///@}
/** Structure AdbQueryEndpointInformation formats input for
ADB_IOCTL_GET_ENDPOINT_INFORMATION IOCTL request
*/
struct AdbQueryEndpointInformation {
/// Zero-based endpoint index for which information is queried.
/// See ADB_QUERY_BULK_xxx_ENDPOINT_INDEX for shortcuts.
UCHAR endpoint_index;
};
/** Structure AdbBulkTransfer formats parameters for ADB_CTL_BULK_READ and
ADB_CTL_BULK_WRITE IOCTL requests.
*/
struct AdbBulkTransfer {
/// Time in milliseconds to complete this request
ULONG time_out;
/// Size of the data to transfer. This parameter is used only for
/// ADB_CTL_BULK_WRITE request. For ADB_CTL_BULK_READ requests transfer
/// size is defined by the output buffer size.
ULONG transfer_size;
/// Initializes statically allocated structure
__forceinline AdbBulkTransfer() {
time_out = 0;
transfer_size = 0;
for_x64 = 0;
}
/// Provides access to protected write_buffer field
void* GetWriteBuffer() {
return write_buffer;
}
/// Provides access to protected write_buffer field
const void* GetWriteBuffer() const {
return write_buffer;
}
/// Sets write_buffer field.
void SetWriteBuffer(void* buffer) {
// For 32-bit we must zero out high 32 bit of the address, so 64-bit
// driver will see valid address when accessing 64-bit write_buffer.
for_x64 = 0;
write_buffer = buffer;
}
protected:
/// Pointer to the actual buffer for ADB_CTL_BULK_WRITE request. This field
/// is not used in ADB_CTL_BULK_READ request. Note that in order to support
/// compatibility between 32-bit and 64-bit versions of both, driver and
/// application we must sizeof this field to the max pointer sizeof (which
/// is 64 bit in our case). The idea is that if IOCTL was issued by a 64-bit
/// process to a 64-bit driver, write_buffer will be valid 64-bit pointer to
/// the write buffer. Same is true for 32-bit app talking to 32-bit driver.
/// If, however, a 32-bit app is talking to 64-bit driver, then write_buffer
/// initialized by 32-bit app will contain 32-bit address, which will be
/// correctly picked up ("extended") by 64-bit driver. Since when setting
/// this field by a 32-bit app requires some extra work (see SetWriteBuffer)
/// we hide this field, making it accessible only throug the accessor
/// methods (Get/SetWriteBuffer).
union {
void* write_buffer;
__int64 for_x64;
};
};
#endif // ANDROID_USB_API_ADB_API_LEGACY_H_