1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef CHROME_BROWSER_USB_USB_DEVICE_HANDLE_H_
6 #define CHROME_BROWSER_USB_USB_DEVICE_HANDLE_H_
11 #include "base/memory/ref_counted.h"
12 #include "base/strings/string16.h"
13 #include "base/synchronization/lock.h"
14 #include "base/threading/thread_checker.h"
15 #include "chrome/browser/usb/usb_interface.h"
16 #include "content/public/browser/browser_thread.h"
17 #include "net/base/completion_callback.h"
18 #include "net/base/io_buffer.h"
20 struct libusb_device_handle;
21 struct libusb_iso_packet_descriptor;
22 struct libusb_transfer;
24 typedef libusb_device_handle* PlatformUsbDeviceHandle;
25 typedef libusb_iso_packet_descriptor* PlatformUsbIsoPacketDescriptor;
26 typedef libusb_transfer* PlatformUsbTransferHandle;
29 class UsbConfigDescriptor;
31 class UsbInterfaceDescriptor;
34 class MessageLoopProxy;
41 enum UsbTransferStatus {
42 USB_TRANSFER_COMPLETED = 0,
45 USB_TRANSFER_CANCELLED,
47 USB_TRANSFER_DISCONNECT,
48 USB_TRANSFER_OVERFLOW,
49 USB_TRANSFER_LENGTH_SHORT,
52 typedef base::Callback<void(UsbTransferStatus, scoped_refptr<net::IOBuffer>,
53 size_t)> UsbTransferCallback;
55 // UsbDeviceHandle class provides basic I/O related functionalities.
56 class UsbDeviceHandle : public base::RefCountedThreadSafe<UsbDeviceHandle> {
58 enum TransferRequestType { STANDARD, CLASS, VENDOR, RESERVED };
59 enum TransferRecipient { DEVICE, INTERFACE, ENDPOINT, OTHER };
61 scoped_refptr<UsbDevice> device() const;
62 PlatformUsbDeviceHandle handle() const { return handle_; }
64 // Notifies UsbDevice to drop the reference of this object; cancels all the
66 // It is possible that the object has no other reference after this call. So
67 // if it is called using a raw pointer, it could be invalidated.
68 // The platform device handle will be closed when UsbDeviceHandle destructs.
71 // Device manipulation operations. These methods are blocking and must be
72 // called on FILE thread.
73 virtual bool ClaimInterface(const int interface_number);
74 virtual bool ReleaseInterface(const int interface_number);
75 virtual bool SetInterfaceAlternateSetting(
76 const int interface_number,
77 const int alternate_setting);
78 virtual bool ResetDevice();
79 virtual bool GetSerial(base::string16* serial);
81 // Async IO. Can be called on any thread.
82 virtual void ControlTransfer(const UsbEndpointDirection direction,
83 const TransferRequestType request_type,
84 const TransferRecipient recipient,
88 net::IOBuffer* buffer,
90 const unsigned int timeout,
91 const UsbTransferCallback& callback);
93 virtual void BulkTransfer(const UsbEndpointDirection direction,
95 net::IOBuffer* buffer,
97 const unsigned int timeout,
98 const UsbTransferCallback& callback);
100 virtual void InterruptTransfer(const UsbEndpointDirection direction,
101 const uint8 endpoint,
102 net::IOBuffer* buffer,
104 const unsigned int timeout,
105 const UsbTransferCallback& callback);
107 virtual void IsochronousTransfer(const UsbEndpointDirection direction,
108 const uint8 endpoint,
109 net::IOBuffer* buffer,
111 const unsigned int packets,
112 const unsigned int packet_length,
113 const unsigned int timeout,
114 const UsbTransferCallback& callback);
117 friend class base::RefCountedThreadSafe<UsbDeviceHandle>;
118 friend class UsbDevice;
120 // This constructor is called by UsbDevice.
121 UsbDeviceHandle(scoped_refptr<UsbContext> context,
122 UsbDevice* device, PlatformUsbDeviceHandle handle,
123 scoped_refptr<UsbConfigDescriptor> interfaces);
125 // This constructor variant is for use in testing only.
127 virtual ~UsbDeviceHandle();
132 friend void HandleTransferCompletion(PlatformUsbTransferHandle handle);
134 class InterfaceClaimer;
137 // Refresh endpoint_map_ after ClaimInterface, ReleaseInterface and
138 // SetInterfaceAlternateSetting.
139 void RefreshEndpointMap();
141 // Look up the claimed interface by endpoint. Return NULL if the interface
142 // of the endpoint is not found.
143 scoped_refptr<InterfaceClaimer> GetClaimedInterfaceForEndpoint(
144 unsigned char endpoint);
146 // Submits a transfer and starts tracking it. Retains the buffer and copies
147 // the completion callback until the transfer finishes, whereupon it invokes
148 // the callback then releases the buffer.
149 void SubmitTransfer(PlatformUsbTransferHandle handle,
150 UsbTransferType transfer_type,
151 net::IOBuffer* buffer,
153 scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
154 const UsbTransferCallback& callback);
156 // Invokes the callbacks associated with a given transfer, and removes it from
157 // the in-flight transfer set.
158 void TransferComplete(PlatformUsbTransferHandle transfer);
160 // Informs the object to drop internal references.
161 void InternalClose();
163 PlatformUsbDeviceHandle handle_;
165 scoped_refptr<UsbConfigDescriptor> interfaces_;
167 typedef std::map<int, scoped_refptr<InterfaceClaimer> > ClaimedInterfaceMap;
168 ClaimedInterfaceMap claimed_interfaces_;
170 typedef std::map<PlatformUsbTransferHandle, Transfer> TransferMap;
171 TransferMap transfers_;
173 // A map from endpoints to interfaces
174 typedef std::map<int, int> EndpointMap;
175 EndpointMap endpoint_map_;
177 // Retain the UsbContext so that the platform context will not be destroyed
178 // before this handle.
179 scoped_refptr<UsbContext> context_;
181 base::ThreadChecker thread_checker_;
183 DISALLOW_COPY_AND_ASSIGN(UsbDeviceHandle);
186 #endif // CHROME_BROWSER_USB_USB_DEVICE_HANDLE_H_