1/* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#ifndef ANDROID_USB_API_ADB_API_LEGACY_H_ 18#define ANDROID_USB_API_ADB_API_LEGACY_H_ 19/** \file 20 This file consists of declarations of constants and structures required 21 for supporting communications of this API with a legacy (custom) USB 22 driver. 23*/ 24 25// Enables compillation for "straight" C 26#ifdef __cplusplus 27 #define EXTERN_C extern "C" 28#else 29 #define EXTERN_C extern 30 typedef int bool; 31 #define true 1 32 #define false 0 33#endif 34 35/// Name for the default bulk read pipe 36#define DEVICE_BULK_READ_PIPE_NAME L"BulkRead" 37 38/// Name for the default bulk write pipe 39#define DEVICE_BULK_WRITE_PIPE_NAME L"BulkWrite" 40 41/// Prefix for an index-based pipe name 42#define DEVICE_PIPE_NAME_PREFIX L"PIPE_" 43 44/** \name IOCTL codes for the driver 45*/ 46///@{ 47 48/// Control code for IOCTL that gets USB_DEVICE_DESCRIPTOR 49#define ADB_CTL_GET_USB_DEVICE_DESCRIPTOR 10 50 51/// Control code for IOCTL that gets USB_CONFIGURATION_DESCRIPTOR 52#define ADB_CTL_GET_USB_CONFIGURATION_DESCRIPTOR 11 53 54/// Control code for IOCTL that gets USB_INTERFACE_DESCRIPTOR 55#define ADB_CTL_GET_USB_INTERFACE_DESCRIPTOR 12 56 57/// Control code for IOCTL that gets endpoint information 58#define ADB_CTL_GET_ENDPOINT_INFORMATION 13 59 60/// Control code for bulk read IOCTL 61#define ADB_CTL_BULK_READ 14 62 63/// Control code for bulk write IOCTL 64#define ADB_CTL_BULK_WRITE 15 65 66/// Control code for IOCTL that gets device serial number 67#define ADB_CTL_GET_SERIAL_NUMBER 16 68 69/// IOCTL that gets USB_DEVICE_DESCRIPTOR 70#define ADB_IOCTL_GET_USB_DEVICE_DESCRIPTOR \ 71 CTL_CODE(FILE_DEVICE_UNKNOWN, \ 72 ADB_CTL_GET_USB_DEVICE_DESCRIPTOR, \ 73 METHOD_BUFFERED, \ 74 FILE_READ_ACCESS) 75 76/// IOCTL that gets USB_CONFIGURATION_DESCRIPTOR 77#define ADB_IOCTL_GET_USB_CONFIGURATION_DESCRIPTOR \ 78 CTL_CODE(FILE_DEVICE_UNKNOWN, \ 79 ADB_CTL_GET_USB_CONFIGURATION_DESCRIPTOR, \ 80 METHOD_BUFFERED, \ 81 FILE_READ_ACCESS) 82 83/// IOCTL that gets USB_INTERFACE_DESCRIPTOR 84#define ADB_IOCTL_GET_USB_INTERFACE_DESCRIPTOR \ 85 CTL_CODE(FILE_DEVICE_UNKNOWN, \ 86 ADB_CTL_GET_USB_INTERFACE_DESCRIPTOR, \ 87 METHOD_BUFFERED, \ 88 FILE_READ_ACCESS) 89 90/// IOCTL that gets endpoint information 91#define ADB_IOCTL_GET_ENDPOINT_INFORMATION \ 92 CTL_CODE(FILE_DEVICE_UNKNOWN, \ 93 ADB_CTL_GET_ENDPOINT_INFORMATION, \ 94 METHOD_BUFFERED, \ 95 FILE_READ_ACCESS) 96 97/// Bulk read IOCTL 98#define ADB_IOCTL_BULK_READ \ 99 CTL_CODE(FILE_DEVICE_UNKNOWN, \ 100 ADB_CTL_BULK_READ, \ 101 METHOD_OUT_DIRECT, \ 102 FILE_READ_ACCESS) 103 104// For bulk write IOCTL we send request data in the form of AdbBulkTransfer 105// structure and output buffer is just ULONG that receives number of bytes 106// actually written. Since both of these are tiny we can use buffered I/O 107// for this IOCTL. 108/// Bulk write IOCTL 109#define ADB_IOCTL_BULK_WRITE \ 110 CTL_CODE(FILE_DEVICE_UNKNOWN, \ 111 ADB_CTL_BULK_WRITE, \ 112 METHOD_BUFFERED, \ 113 FILE_WRITE_ACCESS) 114 115/// IOCTL that gets device serial number 116#define ADB_IOCTL_GET_SERIAL_NUMBER \ 117 CTL_CODE(FILE_DEVICE_UNKNOWN, \ 118 ADB_CTL_GET_SERIAL_NUMBER, \ 119 METHOD_BUFFERED, \ 120 FILE_READ_ACCESS) 121 122///@} 123 124/** Structure AdbQueryEndpointInformation formats input for 125 ADB_IOCTL_GET_ENDPOINT_INFORMATION IOCTL request 126*/ 127struct AdbQueryEndpointInformation { 128 /// Zero-based endpoint index for which information is queried. 129 /// See ADB_QUERY_BULK_xxx_ENDPOINT_INDEX for shortcuts. 130 UCHAR endpoint_index; 131}; 132 133/** Structure AdbBulkTransfer formats parameters for ADB_CTL_BULK_READ and 134 ADB_CTL_BULK_WRITE IOCTL requests. 135*/ 136struct AdbBulkTransfer { 137 /// Time in milliseconds to complete this request 138 ULONG time_out; 139 140 /// Size of the data to transfer. This parameter is used only for 141 /// ADB_CTL_BULK_WRITE request. For ADB_CTL_BULK_READ requests transfer 142 /// size is defined by the output buffer size. 143 ULONG transfer_size; 144 145 /// Initializes statically allocated structure 146 __forceinline AdbBulkTransfer() { 147 time_out = 0; 148 transfer_size = 0; 149 for_x64 = 0; 150 } 151 152 /// Provides access to protected write_buffer field 153 void* GetWriteBuffer() { 154 return write_buffer; 155 } 156 157 /// Provides access to protected write_buffer field 158 const void* GetWriteBuffer() const { 159 return write_buffer; 160 } 161 162 /// Sets write_buffer field. 163 void SetWriteBuffer(void* buffer) { 164 // For 32-bit we must zero out high 32 bit of the address, so 64-bit 165 // driver will see valid address when accessing 64-bit write_buffer. 166 for_x64 = 0; 167 write_buffer = buffer; 168 } 169 170protected: 171 /// Pointer to the actual buffer for ADB_CTL_BULK_WRITE request. This field 172 /// is not used in ADB_CTL_BULK_READ request. Note that in order to support 173 /// compatibility between 32-bit and 64-bit versions of both, driver and 174 /// application we must sizeof this field to the max pointer sizeof (which 175 /// is 64 bit in our case). The idea is that if IOCTL was issued by a 64-bit 176 /// process to a 64-bit driver, write_buffer will be valid 64-bit pointer to 177 /// the write buffer. Same is true for 32-bit app talking to 32-bit driver. 178 /// If, however, a 32-bit app is talking to 64-bit driver, then write_buffer 179 /// initialized by 32-bit app will contain 32-bit address, which will be 180 /// correctly picked up ("extended") by 64-bit driver. Since when setting 181 /// this field by a 32-bit app requires some extra work (see SetWriteBuffer) 182 /// we hide this field, making it accessible only throug the accessor 183 /// methods (Get/SetWriteBuffer). 184 union { 185 void* write_buffer; 186 __int64 for_x64; 187 }; 188}; 189 190#endif // ANDROID_USB_API_ADB_API_LEGACY_H_ 191