1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "libusb_adapter.h"
17
18 #include <iostream>
19 #include <map>
20 #include <cerrno>
21 #include <cstdio>
22 #include <climits>
23 #include <limits>
24 #include <fcntl.h>
25 #include <pthread.h>
26 #include <unistd.h>
27 #include <shared_mutex>
28 #include <sys/types.h>
29 #include <sys/mman.h>
30 #include <hdf_base.h>
31 #include <hdf_log.h>
32
33 #include "accesstoken_kit.h"
34 #include "hap_token_info.h"
35 #include "ipc_skeleton.h"
36 #include "osal_mem.h"
37 #include "securec.h"
38 #include "usbd_wrapper.h"
39 #include "hitrace_meter.h"
40
41 namespace OHOS {
42 namespace HDI {
43 namespace Usb {
44 namespace V1_2 {
45 namespace {
46 constexpr uint8_t LIBUSB_MAX_INTERFACEID = 0x80;
47 constexpr int32_t USB_MAX_INTERFACES = 32;
48 constexpr int32_t READ_BUF_SIZE = 8192;
49 constexpr int32_t USB_MAX_DESCRIPTOR_SIZE = 256;
50 constexpr uint16_t ENGLISH_US_LANGUAGE_ID = 0x0409;
51 constexpr int32_t USB_ENDPOINT_DIR_MASK = 0x80;
52 constexpr int32_t USB_ENDPOINT_DIR_OUT = 0;
53 constexpr int32_t USB_ENDPOINT_DIR_IN = 0x80;
54 constexpr int32_t MAX_CONTROL_BUFF_SIZE = 1024;
55 constexpr uint32_t INTERRUPT_READ_BUF_SIZE = 128;
56 constexpr int32_t DISPLACEMENT_NUMBER = 8;
57 constexpr uint32_t LIBUSB_PATH_LENGTH = 64;
58 constexpr uint64_t MAX_TOTAL_SIZE = 520447;
59 constexpr int32_t API_VERSION_ID_18 = 18;
60 constexpr int32_t API_VERSION_ID_20 = 20;
61 constexpr int32_t LIBUSB_IO_ERROR = -1;
62 constexpr int32_t LIBUSB_IO_ERROR_INVALID = 0;
63 constexpr uint32_t ACT_DEVUP = 0;
64 constexpr uint32_t ACT_DEVDOWN = 1;
65 constexpr uint8_t ENDPOINTID = 128;
66 constexpr const char* USB_DEV_FS_PATH = "/dev/bus/usb";
67 constexpr const char* LIBUSB_DEVICE_MMAP_PATH = "/data/service/el1/public/usb/";
68 constexpr uint32_t MIN_NUM_OF_ISO_PACKAGE = 1;
69 constexpr uint32_t SHIFT_32 = 32;
70 const uint8_t INVALID_NUM = 222;
71 static libusb_context *g_libusb_context = nullptr;
72 static std::shared_ptr<LibusbAdapter> g_LibusbAdapter = std::make_shared<LibusbAdapter>();
73 struct CurrentUsbSetting {
74 int32_t configurationIndex = -1;
75 int32_t interfaceNumber = -1;
76 int32_t alternateSetting = -1;
77 };
78 struct HandleCount {
79 libusb_device_handle* handle = nullptr;
80 int32_t count = 0;
81 };
82 std::map<uint32_t, HandleCount> g_handleMap;
83 std::map<uint32_t, std::map<int32_t, std::vector<uint8_t>>> g_InterfaceIdMap;
84 std::map<libusb_device_handle*, CurrentUsbSetting> g_deviceSettingsMap;
85 std::map<uint32_t, int32_t> g_usbOpenFdMap;
86 std::shared_mutex g_mapMutexInterfaceIdMap;
87 std::shared_mutex g_mapMutexDeviceSettingsMap;
88 std::shared_mutex g_mapMutexContext;
89 std::shared_mutex g_mapMutexUsbOpenFdMap;
90 std::shared_mutex g_mapMutexHandleMap;
91 static LibusbAsyncManager g_asyncManager;
92 static LibusbBulkManager g_bulkManager;
93 #define USB_CTRL_SET_TIMEOUT 5000
94
ToDdkDeviceId(int32_t busNum,int32_t devNum)95 static uint64_t ToDdkDeviceId(int32_t busNum, int32_t devNum)
96 {
97 return (static_cast<uint64_t>(busNum) << SHIFT_32) + devNum;
98 }
99 } // namespace
100
101 std::list<sptr<V2_0::IUsbdSubscriber>> LibusbAdapter::subscribers_;
102 sptr<V1_2::LibUsbSaSubscriber> LibusbAdapter::libUsbSaSubscriber_ {nullptr};
103
GetInstance()104 std::shared_ptr<LibusbAdapter> LibusbAdapter::GetInstance()
105 {
106 return g_LibusbAdapter;
107 }
108
LibusbAdapter()109 LibusbAdapter::LibusbAdapter()
110 {
111 HDF_LOGI("%{public}s libusbadapter constructer", __func__);
112 LibUSBInit();
113 if (!eventThread.joinable()) {
114 isRunning = true;
115 eventThread = std::thread(&LibusbAdapter::LibusbEventHandling, this);
116 }
117 }
118
~LibusbAdapter()119 LibusbAdapter::~LibusbAdapter()
120 {
121 LibUSBExit();
122 }
123
GetApiVersion(int32_t & apiVersion)124 void GetApiVersion(int32_t &apiVersion)
125 {
126 uint32_t callerToken = IPCSkeleton::GetCallingTokenID();
127 OHOS::Security::AccessToken::HapTokenInfo info;
128 int32_t ret = OHOS::Security::AccessToken::AccessTokenKit::GetHapTokenInfo(callerToken, info);
129 if (ret < HDF_SUCCESS) {
130 HDF_LOGE("%{public}s: get hapInfo failed", __func__);
131 return;
132 }
133 apiVersion = info.apiVersion;
134 }
135
LibUSBInit()136 int32_t LibusbAdapter::LibUSBInit()
137 {
138 HDF_LOGI("%{public}s enter", __func__);
139 if (g_libusb_context != nullptr) {
140 HDF_LOGI("%{public}s g_libusb_context is initialized", __func__);
141 return HDF_SUCCESS;
142 }
143 std::unique_lock<std::shared_mutex> lock(g_mapMutexContext);
144 int32_t ret = libusb_init(&g_libusb_context);
145 if (ret < 0) {
146 HDF_LOGE("%{public}s libusb_init is error", __func__);
147 return HDF_FAILURE;
148 }
149 HDF_LOGI("%{public}s leave", __func__);
150 return HDF_SUCCESS;
151 }
152
LibUSBExit()153 void LibusbAdapter::LibUSBExit()
154 {
155 HDF_LOGI("%{public}s enter", __func__);
156 std::unique_lock<std::shared_mutex> lock(g_mapMutexContext);
157 if (g_libusb_context != nullptr) {
158 libusb_exit(g_libusb_context);
159 g_libusb_context = nullptr;
160 }
161 isRunning = false;
162 if (eventThread.joinable()) {
163 eventThread.join();
164 }
165 HDF_LOGI("%{public}s leave", __func__);
166 }
167
GetUsbDevice(const UsbDev & dev,libusb_device ** device)168 int32_t LibusbAdapter::GetUsbDevice(const UsbDev &dev, libusb_device **device)
169 {
170 HDF_LOGD("%{public}s enter", __func__);
171 if (dev.busNum == 0 || dev.devAddr == 0) {
172 HDF_LOGE("%{public}s Invalid parameter", __func__);
173 return HDF_DEV_ERR_NO_DEVICE;
174 }
175 if (g_libusb_context == nullptr) {
176 HDF_LOGE("%{public}s: g_libusb_context is nullptr", __func__);
177 return HDF_FAILURE;
178 }
179 libusb_device **devs = nullptr;
180 ssize_t count = libusb_get_device_list(g_libusb_context, &devs);
181 if (count <= 0 || devs == nullptr) {
182 HDF_LOGE("%{public}s: No device", __func__);
183 return HDF_DEV_ERR_NO_DEVICE;
184 }
185 for (ssize_t i = 0; i < count; i++) {
186 uint8_t devDusNum = libusb_get_bus_number(devs[i]);
187 uint8_t devDevAddr = libusb_get_device_address(devs[i]);
188 if (devDusNum == dev.busNum && devDevAddr == dev.devAddr) {
189 *device = devs[i];
190 libusb_free_device_list(devs, 1);
191 HDF_LOGD("%{public}s success leave", __func__);
192 return HDF_SUCCESS;
193 }
194 }
195 libusb_free_device_list(devs, 1);
196 HDF_LOGE("%{public}s: Search device does not exist leave", __func__);
197 return HDF_DEV_ERR_NO_DEVICE;
198 }
199
FindHandleByDev(const UsbDev & dev,libusb_device_handle ** handle)200 int32_t LibusbAdapter::FindHandleByDev(const UsbDev &dev, libusb_device_handle **handle)
201 {
202 HDF_LOGD("%{public}s enter", __func__);
203 std::shared_lock<std::shared_mutex> lock(g_mapMutexHandleMap);
204 uint32_t result = (static_cast<uint32_t>(dev.busNum) << DISPLACEMENT_NUMBER) |
205 static_cast<uint32_t>(dev.devAddr);
206 auto it = g_handleMap.find(result);
207 if (it != g_handleMap.end()) {
208 *handle = it->second.handle;
209 HDF_LOGI("%{public}s Search handle success leave", __func__);
210 return HDF_SUCCESS;
211 }
212 HDF_LOGE("%{public}s Search handle failed leave", __func__);
213 return HDF_DEV_ERR_NO_DEVICE;
214 }
215
DeleteSettingsMap(libusb_device_handle * handle)216 void LibusbAdapter::DeleteSettingsMap(libusb_device_handle* handle)
217 {
218 HDF_LOGD("%{public}s enter", __func__);
219 {
220 std::unique_lock<std::shared_mutex> lock(g_mapMutexDeviceSettingsMap);
221 auto entry = g_deviceSettingsMap.find(handle);
222 if (entry != g_deviceSettingsMap.end()) {
223 g_deviceSettingsMap.erase(entry);
224 }
225 }
226 HDF_LOGD("%{public}s leave", __func__);
227 }
228
OpenDevice(const UsbDev & dev)229 int32_t LibusbAdapter::OpenDevice(const UsbDev &dev)
230 {
231 HDF_LOGI("%{public}s enter", __func__);
232 int32_t ret = LibUSBInit();
233 if (ret != HDF_SUCCESS) {
234 HDF_LOGE("%{public}s:LibUSBInit is failed, ret=%{public}d", __func__, ret);
235 return HDF_FAILURE;
236 }
237 libusb_device *device = nullptr;
238 ret = GetUsbDevice(dev, &device);
239 if (ret != HDF_SUCCESS || device == nullptr) {
240 HDF_LOGE("%{public}s:GetUsbDevice is failed ret=%{public}d", __func__, ret);
241 return HDF_DEV_ERR_NO_DEVICE;
242 }
243
244 libusb_device_handle* devHandle = nullptr;
245 uint32_t result = (static_cast<uint32_t>(dev.busNum) << DISPLACEMENT_NUMBER) |
246 static_cast<uint32_t>(dev.devAddr);
247 ret = FindHandleByDev(dev, &devHandle);
248 if (ret != HDF_SUCCESS || devHandle == nullptr) {
249 ret = libusb_open(device, &devHandle);
250 if (ret != HDF_SUCCESS || devHandle == nullptr) {
251 HDF_LOGE("%{public}s:Opening device failed ret = %{public}d", __func__, ret);
252 return HDF_FAILURE;
253 }
254 std::unique_lock<std::shared_mutex> lock(g_mapMutexHandleMap);
255 g_handleMap[result] = {devHandle, 1};
256 } else {
257 std::unique_lock<std::shared_mutex> lock(g_mapMutexHandleMap);
258 auto it = g_handleMap.find(result);
259 if (it != g_handleMap.end() && (it->second.handle != nullptr)) {
260 it->second.count++;
261 }
262 }
263 TransferInit(dev);
264 BulkTransferInit(dev);
265 int32_t currentConfig = -1;
266 ret = GetCurrentConfiguration(devHandle, currentConfig);
267 if (ret != HDF_SUCCESS) {
268 HDF_LOGE("%{public}s: GetCurrentConfiguration failed", __func__);
269 return HDF_FAILURE;
270 }
271 std::unique_lock<std::shared_mutex> lock(g_mapMutexDeviceSettingsMap);
272 g_deviceSettingsMap[devHandle].configurationIndex = currentConfig;
273 if (!eventThread.joinable()) {
274 isRunning = true;
275 eventThread = std::thread(&LibusbAdapter::LibusbEventHandling, this);
276 }
277 HDF_LOGI("%{public}s succeeded", __func__);
278 return HDF_SUCCESS;
279 }
280
CloseDevice(const UsbDev & dev)281 int32_t LibusbAdapter::CloseDevice(const UsbDev &dev)
282 {
283 HDF_LOGI("%{public}s enter", __func__);
284 libusb_device_handle *devHandle = nullptr;
285 int32_t ret = FindHandleByDev(dev, &devHandle);
286 if (ret != HDF_SUCCESS || devHandle == nullptr) {
287 HDF_LOGE("%{public}s:FindHandleByDev is failed ret=%{public}d", __func__, ret);
288 return HDF_FAILURE;
289 }
290 uint32_t result = (static_cast<uint32_t>(dev.busNum) << DISPLACEMENT_NUMBER) |
291 static_cast<uint32_t>(dev.devAddr);
292 std::unique_lock<std::shared_mutex> lock(g_mapMutexHandleMap);
293 auto info = g_handleMap.find(result);
294 if (info == g_handleMap.end()) {
295 HDF_LOGE("%{public}s:Failed to find the handle", __func__);
296 return HDF_FAILURE;
297 }
298 info->second.count--;
299 HDF_LOGI("%{public}s Number of devices that are opened=%{public}d", __func__, info->second.count);
300 if (info->second.count == 0 && (info->second.handle != nullptr)) {
301 {
302 std::unique_lock<std::shared_mutex> lock(g_mapMutexUsbOpenFdMap);
303 auto it = g_usbOpenFdMap.find(result);
304 if (it != g_usbOpenFdMap.end()) {
305 close(it->second);
306 g_usbOpenFdMap.erase(it);
307 }
308 }
309 {
310 std::unique_lock<std::shared_mutex> lock(g_mapMutexInterfaceIdMap);
311 auto InterfaceIt = g_InterfaceIdMap.find(result);
312 if (InterfaceIt != g_InterfaceIdMap.end()) {
313 g_InterfaceIdMap.erase(result);
314 }
315 }
316 DeleteSettingsMap(devHandle);
317 libusb_close(devHandle);
318 TransferRelease(dev);
319 BulkTransferRelease(dev);
320 g_handleMap.erase(info);
321 }
322 HDF_LOGI("%{public}s leave", __func__);
323 return HDF_SUCCESS;
324 }
325
ResetDevice(const UsbDev & dev)326 int32_t LibusbAdapter::ResetDevice(const UsbDev &dev)
327 {
328 HDF_LOGI("%{public}s enter", __func__);
329 libusb_device_handle *devHandle = nullptr;
330 int32_t ret = FindHandleByDev(dev, &devHandle);
331 if (ret != HDF_SUCCESS || devHandle == nullptr) {
332 HDF_LOGE("%{public}s: FindHandleByDev failed ret=%{public}d", __func__, ret);
333 return HDF_FAILURE;
334 }
335 ret = libusb_reset_device(devHandle);
336 if (ret < 0) {
337 HDF_LOGE("%{public}s: Failed to reset device, ret=%{public}d", __func__, ret);
338 return HDF_FAILURE;
339 }
340 HDF_LOGI("%{public}s leave", __func__);
341 return HDF_SUCCESS;
342 }
343
GetDeviceDescriptor(const UsbDev & dev,std::vector<uint8_t> & descriptor)344 int32_t LibusbAdapter::GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor)
345 {
346 HDF_LOGI("%{public}s enter", __func__);
347 struct libusb_device_descriptor desc;
348 libusb_device *device = nullptr;
349 int32_t ret = GetUsbDevice(dev, &device);
350 if (ret != HDF_SUCCESS || device == nullptr) {
351 HDF_LOGE("%{public}s: GetUsbDevice is failed ret=%{public}d", __func__, ret);
352 return HDF_DEV_ERR_NO_DEVICE;
353 }
354 ret = libusb_get_device_descriptor(device, &desc);
355 if (ret != HDF_SUCCESS) {
356 HDF_LOGE("%{public}s: libusb_get_device_descriptor is failed ret=%{public}d", __func__, ret);
357 return ret;
358 }
359 descriptor.resize(desc.bLength);
360 ret = memcpy_s(descriptor.data(), descriptor.size(), &desc, desc.bLength);
361 if (ret != EOK) {
362 HDF_LOGE("%{public}s: memcpy_s failed", __func__);
363 return HDF_FAILURE;
364 }
365 HDF_LOGI("%{public}s leave", __func__);
366 return HDF_SUCCESS;
367 }
368
GetConfigDescriptor(const UsbDev & dev,uint8_t descId,std::vector<uint8_t> & descriptor)369 int32_t LibusbAdapter::GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor)
370 {
371 HDF_LOGI("%{public}s enter", __func__);
372 libusb_device *device = nullptr;
373 int32_t ret = GetUsbDevice(dev, &device);
374 if (ret != HDF_SUCCESS || device == nullptr) {
375 HDF_LOGE("%{public}s: GetConfigDescriptor Find device failed", __func__);
376 return HDF_FAILURE;
377 }
378
379 ret = GetConfigDescriptor(device, descId, descriptor);
380 if (ret != HDF_SUCCESS) {
381 HDF_LOGE("%{public}s: Failed to copy configuration descriptor", __func__);
382 return HDF_FAILURE;
383 }
384 HDF_LOGI("%{public}s is success leave", __func__);
385 return HDF_SUCCESS;
386 }
387
GetDeviceFileDescriptor(const UsbDev & dev,int32_t & fd)388 int32_t LibusbAdapter::GetDeviceFileDescriptor(const UsbDev &dev, int32_t &fd)
389 {
390 HDF_LOGI("%{public}s enter", __func__);
391 libusb_device *device = nullptr;
392 int32_t ret = GetUsbDevice(dev, &device);
393 if (ret != HDF_SUCCESS || device == nullptr) {
394 HDF_LOGE("Search device does not exist, ret=%{public}d", ret);
395 return HDF_FAILURE;
396 }
397 libusb_device_handle *devHandle = nullptr;
398 ret = FindHandleByDev(dev, &devHandle);
399 if (ret != HDF_SUCCESS || devHandle == nullptr) {
400 HDF_LOGE("%{public}s: FindHandleByDev is failed, ret=%{public}d", __func__, ret);
401 return HDF_FAILURE;
402 }
403 uint32_t result = (static_cast<uint32_t>(dev.busNum) << DISPLACEMENT_NUMBER) |
404 static_cast<uint32_t>(dev.devAddr);
405 {
406 std::shared_lock<std::shared_mutex> lock(g_mapMutexUsbOpenFdMap);
407 auto info = g_usbOpenFdMap.find(result);
408 if (info != g_usbOpenFdMap.end()) {
409 fd = info->second;
410 HDF_LOGI("%{public}s open is already on, fd: %{public}d", __func__, info->second);
411 return HDF_SUCCESS;
412 }
413 }
414 char path[LIBUSB_PATH_LENGTH] = {"\0"};
415 ret = sprintf_s(path, sizeof(path), "%s/%03u/%03u", USB_DEV_FS_PATH, dev.busNum, dev.devAddr);
416 if (ret < 0) {
417 HDF_LOGE("%{public}s: sprintf_s path failed, ret:%{public}d", __func__, ret);
418 return ret;
419 }
420 int32_t fileFd = open(path, O_RDWR);
421 if (fileFd < 0) {
422 HDF_LOGE("%{public}s: open device failed errno = %{public}d %{public}s", __func__, errno, strerror(errno));
423 return HDF_FAILURE;
424 }
425 fd = fileFd;
426 {
427 std::unique_lock<std::shared_mutex> lock(g_mapMutexUsbOpenFdMap);
428 g_usbOpenFdMap[result] = fd;
429 }
430 HDF_LOGI("%{public}s leave", __func__);
431 return HDF_SUCCESS;
432 }
433
SetConfig(const UsbDev & dev,uint8_t configIndex)434 int32_t LibusbAdapter::SetConfig(const UsbDev &dev, uint8_t configIndex)
435 {
436 HDF_LOGI("%{public}s:enter", __func__);
437 libusb_device_handle *devHandle = nullptr;
438 int32_t ret = FindHandleByDev(dev, &devHandle);
439 if (ret != HDF_SUCCESS || devHandle == nullptr) {
440 HDF_LOGE("%{public}s: Find UsbHandle failed, ret=%{public}d", __func__, ret);
441 return HDF_FAILURE;
442 }
443 int configIdOld = 0;
444 ret = libusb_get_configuration(devHandle, &configIdOld);
445 if (ret != LIBUSB_SUCCESS) {
446 HDF_LOGE("%{public}s: Failed to get current configuration ret:%{public}d", __func__, ret);
447 return HDF_ERR_IO;
448 }
449 std::unique_lock<std::shared_mutex> lock(g_mapMutexDeviceSettingsMap);
450 auto it = g_deviceSettingsMap.find(devHandle);
451 if (it == g_deviceSettingsMap.end()) {
452 HDF_LOGE("No device handle found");
453 return HDF_FAILURE;
454 }
455 if (configIdOld == configIndex) {
456 HDF_LOGE("%{public}s: setConfiguration success, configIndex:%{public}d configIdOld:%{public}d", __func__,
457 configIndex, configIdOld);
458 it->second.configurationIndex = static_cast<int32_t>(configIndex);
459 return HDF_SUCCESS;
460 }
461 ret = libusb_set_configuration(devHandle, configIndex);
462 if (ret != HDF_SUCCESS) {
463 HDF_LOGE("%{public}s: setConfiguration failed ret:%{public}d", __func__, ret);
464 return HDF_ERR_IO;
465 }
466 g_deviceSettingsMap[devHandle].configurationIndex = static_cast<int32_t>(configIndex);
467 HDF_LOGI("%{public}s: leave", __func__);
468 return HDF_SUCCESS;
469 }
470
GetConfig(const UsbDev & dev,uint8_t & configIndex)471 int32_t LibusbAdapter::GetConfig(const UsbDev &dev, uint8_t &configIndex)
472 {
473 HDF_LOGI("%{public}s enter", __func__);
474 libusb_device_handle *devHandle = nullptr;
475 libusb_device *device = nullptr;
476 int32_t ret = GetUsbDevice(dev, &device);
477 if (ret != HDF_SUCCESS || device == nullptr) {
478 HDF_LOGE("%{public}s: Find device failed, ret=%{public}d", __func__, ret);
479 return HDF_FAILURE;
480 }
481 ret = FindHandleByDev(dev, &devHandle);
482 if (ret != HDF_SUCCESS || devHandle == nullptr) {
483 HDF_LOGE("%{public}s: Find UsbHandle failed, ret=%{public}d", __func__, ret);
484 return HDF_FAILURE;
485 }
486 int tampconfigIndex = static_cast<int>(configIndex);
487 ret = libusb_get_configuration(devHandle, &tampconfigIndex);
488 if (ret != HDF_SUCCESS) {
489 HDF_LOGE("%{public}s: Find configIndex failed", __func__);
490 return HDF_FAILURE;
491 }
492 configIndex = static_cast<uint8_t>(tampconfigIndex);
493 HDF_LOGI("%{public}s leave", __func__);
494 return ret;
495 }
496
ManageInterface(const UsbDev & dev,uint8_t interfaceId,bool disable)497 int32_t LibusbAdapter::ManageInterface(const UsbDev &dev, uint8_t interfaceId, bool disable)
498 {
499 HDF_LOGI("%{public}s enter", __func__);
500 libusb_device *device = nullptr;
501 int32_t ret = GetUsbDevice(dev, &device);
502 if (ret != HDF_SUCCESS || device == nullptr) {
503 HDF_LOGE("%{public}s: GetUsbDevice failed, ret=%{public}d", __func__, ret);
504 return HDF_DEV_ERR_NO_DEVICE;
505 }
506 if (interfaceId >= USB_MAX_INTERFACES) {
507 HDF_LOGE("%{public}s:interfaceId larger then max num", __func__);
508 return HDF_ERR_INVALID_PARAM;
509 }
510 libusb_device_handle *devHandle = nullptr;
511 ret = FindHandleByDev(dev, &devHandle);
512 if (ret != HDF_SUCCESS || devHandle == nullptr) {
513 HDF_LOGE("%{public}s: FindHandleByDev failed, ret=%{public}d", __func__, ret);
514 return HDF_FAILURE;
515 }
516 if (disable) {
517 ret = libusb_detach_kernel_driver(devHandle, interfaceId);
518 } else {
519 ret = libusb_attach_kernel_driver(devHandle, interfaceId);
520 }
521 if (ret == LIBUSB_ERROR_NOT_FOUND || ret == LIBUSB_ERROR_BUSY) {
522 ret = libusb_set_auto_detach_kernel_driver(devHandle, disable);
523 }
524 if (ret == LIBUSB_ERROR_NO_DEVICE || ret == LIBUSB_ERROR_NOT_SUPPORTED) {
525 HDF_LOGE("%{public}s: ManageInterface failed, busNum=%{public}u, devAddr=%{public}u",
526 __func__, dev.busNum, dev.devAddr);
527 return HDF_FAILURE;
528 }
529 HDF_LOGI("%{public}s leave ret=%{public}d", __func__, ret);
530
531 return (ret >= 0) ? HDF_SUCCESS : HDF_FAILURE;
532 }
533
ReleaseInterface(const UsbDev & dev,uint8_t interfaceId)534 int32_t LibusbAdapter::ReleaseInterface(const UsbDev &dev, uint8_t interfaceId)
535 {
536 HDF_LOGI("%{public}s enter", __func__);
537 libusb_device_handle *devHandle = nullptr;
538 int32_t ret = FindHandleByDev(dev, &devHandle);
539 if (ret != HDF_SUCCESS || devHandle == nullptr) {
540 HDF_LOGE("%{public}s: FindHandleByDev failed, ret=%{public}d", __func__, ret);
541 return HDF_FAILURE;
542 }
543
544 if (interfaceId >= USB_MAX_INTERFACES) {
545 HDF_LOGE("%{public}s: interfaceId failed busNum:%{public}u devAddr:%{public}u interfaceId:%{public}u",
546 __func__, dev.busNum, dev.devAddr, interfaceId);
547 return HDF_FAILURE;
548 }
549 ret = RemoveInterfaceFromMap(dev, devHandle, interfaceId);
550 if (ret != HDF_SUCCESS) {
551 HDF_LOGE("%{public}s: RemoveInterfaceFromMap failed", __func__);
552 return HDF_FAILURE;
553 }
554 ret = libusb_release_interface(devHandle, interfaceId);
555 if (ret < HDF_SUCCESS) {
556 HDF_LOGE("%{public}s: libusb_release_interface failed, ret=%{public}d", __func__, ret);
557 return HDF_FAILURE;
558 }
559 if (!CheckDeviceAndConfiguration(devHandle)) {
560 HDF_LOGE("CheckDeviceAndConfiguration failed");
561 return HDF_FAILURE;
562 }
563 {
564 std::unique_lock<std::shared_mutex> lock(g_mapMutexDeviceSettingsMap);
565 g_deviceSettingsMap[devHandle].interfaceNumber = -1;
566 g_deviceSettingsMap[devHandle].alternateSetting = -1;
567 }
568 HDF_LOGI("%{public}s leave", __func__);
569 return HDF_SUCCESS;
570 }
571
BulkTransferRead(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,std::vector<uint8_t> & data)572 int32_t LibusbAdapter::BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout,
573 std::vector<uint8_t> &data)
574 {
575 HDF_LOGI("%{public}s enter", __func__);
576 if (pipe.intfId >= LIBUSB_MAX_INTERFACEID) {
577 HDF_LOGE("interfaceId is invalid");
578 return HDF_ERR_INVALID_PARAM;
579 }
580 uint8_t tbuf[READ_BUF_SIZE] = {'\0'};
581 uint32_t tsize = READ_BUF_SIZE;
582 int actlength = 0;
583 libusb_device_handle *devHandle = nullptr;
584 StartTrace(HITRACE_TAG_USB, "FindHandleByDev");
585 int32_t ret = FindHandleByDev(dev, &devHandle);
586 FinishTrace(HITRACE_TAG_USB);
587 if (ret != HDF_SUCCESS || devHandle == nullptr) {
588 HDF_LOGE("%{public}s: FindHandleByDev failed, ret=%{public}d", __func__, ret);
589 return HDF_FAILURE;
590 }
591 StartTrace(HITRACE_TAG_USB, "libusb_bulk_transfer");
592 ret = libusb_bulk_transfer(devHandle, pipe.endpointId, tbuf, tsize, &actlength, timeout);
593 FinishTrace(HITRACE_TAG_USB);
594 if (ret < 0) {
595 HDF_LOGE("%{public}s: libusb_bulk_transfer is error ret=%{public}d", __func__, ret);
596 return HDF_FAILURE;
597 }
598
599 if (actlength > 0) {
600 data.assign(tbuf, tbuf + actlength);
601 ret = HDF_SUCCESS;
602 }
603 HDF_LOGI("%{public}s leave", __func__);
604 return ret;
605 }
606
BulkTransferReadwithLength(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,int32_t length,std::vector<uint8_t> & data)607 int32_t LibusbAdapter::BulkTransferReadwithLength(const UsbDev &dev,
608 const UsbPipe &pipe, int32_t timeout, int32_t length, std::vector<uint8_t> &data)
609 {
610 HDF_LOGI("%{public}s enter", __func__);
611 if (pipe.intfId >= LIBUSB_MAX_INTERFACEID) {
612 HDF_LOGE("%{public}s interfaceId is invalid", __func__);
613 return HDF_ERR_INVALID_PARAM;
614 }
615 if (length <= 0) {
616 HDF_LOGE("%{public}s: invalid length param, length: %{public}d.", __func__, length);
617 return HDF_ERR_INVALID_PARAM;
618 }
619
620 libusb_device_handle* devHandle = nullptr;
621 libusb_endpoint_descriptor* endpointDes = nullptr;
622 StartTrace(HITRACE_TAG_USB, "GetEndpointDesc");
623 int32_t ret = GetEndpointDesc(dev, pipe, &endpointDes, &devHandle);
624 FinishTrace(HITRACE_TAG_USB);
625 if (ret != HDF_SUCCESS || devHandle == nullptr) {
626 HDF_LOGE("%{public}s:GetEndpointDesc failed ret:%{public}d", __func__, ret);
627 return ret;
628 }
629 if (!IsInterfaceIdByUsbDev(dev, pipe.intfId)) {
630 HDF_LOGE("%{public}s: IsInterfaceIdByUsbDev failed", __func__);
631 return HDF_FAILURE;
632 }
633 std::vector<uint8_t> buffer(length);
634 int32_t transferred = 0;
635 StartTrace(HITRACE_TAG_USB, "libusb_bulk_transfer");
636 ret = libusb_bulk_transfer(devHandle, (pipe.endpointId | LIBUSB_ENDPOINT_IN), (unsigned char *)buffer.data(),
637 length, &transferred, timeout);
638 FinishTrace(HITRACE_TAG_USB);
639 if (ret < 0) {
640 if (ret == LIBUSB_IO_ERROR) {
641 HDF_LOGD("%{public}s: pipe.intfId=%{public}d", __func__, pipe.intfId);
642 return LIBUSB_IO_ERROR_INVALID;
643 }
644 HDF_LOGE("%{public}s: libusb_bulk_transfer failed, ret: %{public}d",
645 __func__, ret);
646 return ret;
647 }
648 if (transferred > 0) {
649 data.assign(buffer.begin(), buffer.begin() + transferred);
650 ret = HDF_SUCCESS;
651 }
652 HDF_LOGI("%{public}s leave", __func__);
653 return ret;
654 }
655
BulkTransferWrite(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,const std::vector<uint8_t> & data)656 int32_t LibusbAdapter::BulkTransferWrite(
657 const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, const std::vector<uint8_t> &data)
658 {
659 HDF_LOGI("%{public}s enter", __func__);
660 if (pipe.intfId >= LIBUSB_MAX_INTERFACEID) {
661 HDF_LOGE("%{public}s interfaceId is invalid", __func__);
662 return HDF_ERR_INVALID_PARAM;
663 }
664 int32_t actlength = 0;
665 libusb_device_handle* devHandle = nullptr;
666 libusb_endpoint_descriptor* endpointDes = nullptr;
667 StartTrace(HITRACE_TAG_USB, "GetEndpointDesc");
668 int32_t ret = GetEndpointDesc(dev, pipe, &endpointDes, &devHandle);
669 FinishTrace(HITRACE_TAG_USB);
670 if (ret != HDF_SUCCESS || devHandle == nullptr) {
671 HDF_LOGE("%{public}s:GetEndpointDesc failed ret:%{public}d", __func__, ret);
672 return ret;
673 }
674 if (!IsInterfaceIdByUsbDev(dev, pipe.intfId)) {
675 HDF_LOGE("%{public}s: IsInterfaceIdByUsbDev failed", __func__);
676 return HDF_FAILURE;
677 }
678 StartTrace(HITRACE_TAG_USB, "libusb_bulk_transfer");
679 ret = libusb_bulk_transfer(devHandle, pipe.endpointId, (unsigned char *)data.data(), data.size(),
680 &actlength, timeout);
681 FinishTrace(HITRACE_TAG_USB);
682 if (ret < 0) {
683 if (ret == LIBUSB_IO_ERROR) {
684 HDF_LOGE("%{public}s: pipe.intfId=%{public}d", __func__, pipe.intfId);
685 return LIBUSB_IO_ERROR_INVALID;
686 }
687 HDF_LOGE("%{public}s: libusb_bulk_transfer is error ret=%{public}d", __func__, ret);
688 return HDF_FAILURE;
689 }
690 HDF_LOGI("%{public}s leave", __func__);
691 return ret;
692 }
693
IsoTransferRead(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,std::vector<uint8_t> & data)694 int32_t LibusbAdapter::IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe,
695 int32_t timeout, std::vector<uint8_t> &data)
696 {
697 HDF_LOGI("%{public}s enter", __func__);
698 if (pipe.intfId >= LIBUSB_MAX_INTERFACEID) {
699 HDF_LOGE("%{public}s interfaceId is invalid", __func__);
700 return HDF_FAILURE;
701 }
702 uint8_t tbuf[READ_BUF_SIZE] = {0};
703 uint32_t tsize = READ_BUF_SIZE;
704 int32_t actlength = 0;
705 libusb_device_handle *devHandle = nullptr;
706 StartTrace(HITRACE_TAG_USB, "FindHandleByDev");
707 int32_t ret = FindHandleByDev(dev, &devHandle);
708 FinishTrace(HITRACE_TAG_USB);
709 if (ret != HDF_SUCCESS || devHandle == nullptr) {
710 HDF_LOGE("%{public}s: FindHandleByDev failed, ret=%{public}d", __func__, ret);
711 return HDF_FAILURE;
712 }
713 StartTrace(HITRACE_TAG_USB, "libusb_bulk_transfer");
714 ret = libusb_bulk_transfer(devHandle, pipe.endpointId, tbuf, tsize, &actlength, timeout);
715 FinishTrace(HITRACE_TAG_USB);
716 if (ret < 0) {
717 HDF_LOGE("%{public}s: libusb_bulk_transfer is error ret=%{public}d", __func__, ret);
718 return HDF_FAILURE;
719 }
720
721 if (actlength > 0) {
722 data.assign(tbuf, tbuf + actlength);
723 ret = HDF_SUCCESS;
724 }
725 HDF_LOGI("%{public}s leave", __func__);
726 return ret;
727 }
728
IsoTransferWrite(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,const std::vector<uint8_t> & data)729 int32_t LibusbAdapter::IsoTransferWrite(
730 const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, const std::vector<uint8_t> &data)
731 {
732 HDF_LOGI("%{public}s enter", __func__);
733 if (pipe.intfId >= LIBUSB_MAX_INTERFACEID) {
734 HDF_LOGE("%{public}s interfaceId is invalid", __func__);
735 return HDF_FAILURE;
736 }
737 int32_t actlength = static_cast<int32_t>(data.size());
738 libusb_device_handle *devHandle = nullptr;
739 StartTrace(HITRACE_TAG_USB, "FindHandleByDev");
740 int32_t ret = FindHandleByDev(dev, &devHandle);
741 FinishTrace(HITRACE_TAG_USB);
742 if (ret != HDF_SUCCESS || devHandle == nullptr) {
743 HDF_LOGE("%{public}s: FindHandleByDev failed, ret=%{public}d", __func__, ret);
744 return HDF_FAILURE;
745 }
746 StartTrace(HITRACE_TAG_USB, "libusb_bulk_transfer");
747 ret = libusb_bulk_transfer(devHandle, pipe.endpointId, (unsigned char *)data.data(),
748 data.size(), &actlength, timeout);
749 FinishTrace(HITRACE_TAG_USB);
750 if (ret < 0) {
751 HDF_LOGE("%{public}s: libusb_bulk_transfer is error ", __func__);
752 return HDF_FAILURE;
753 }
754 HDF_LOGI("%{public}s leave", __func__);
755 return ret;
756 }
757
SetInterface(const UsbDev & dev,uint8_t interfaceId,uint8_t altIndex)758 int32_t LibusbAdapter::SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex)
759 {
760 HDF_LOGI("%{public}s enter", __func__);
761 libusb_device_handle *devHandle = nullptr;
762 int32_t ret = FindHandleByDev(dev, &devHandle);
763 if (ret != HDF_SUCCESS || devHandle == nullptr) {
764 HDF_LOGE("%{public}s: FindHandleByDev failed, ret=%{public}d", __func__, ret);
765 return HDF_FAILURE;
766 }
767 ret = libusb_set_interface_alt_setting(devHandle, interfaceId, altIndex);
768 if (ret == LIBUSB_ERROR_NO_DEVICE || ret == LIBUSB_ERROR_NOT_FOUND || ret == LIBUSB_ERROR_INVALID_PARAM) {
769 HDF_LOGE("%{public}s: SetInterface failed, busNum=%{public}u, devAddr=%{public}u, ret=%{public}d", __func__,
770 dev.busNum, dev.devAddr, ret);
771 return HDF_FAILURE;
772 }
773 if (!CheckDeviceAndConfiguration(devHandle)) {
774 HDF_LOGE("%{public}s: CheckDeviceAndConfiguration failed", __func__);
775 return HDF_FAILURE;
776 }
777 std::unique_lock<std::shared_mutex> lock(g_mapMutexDeviceSettingsMap);
778 g_deviceSettingsMap[devHandle].interfaceNumber = static_cast<int32_t>(interfaceId);
779 g_deviceSettingsMap[devHandle].alternateSetting = static_cast<int32_t>(altIndex);
780 HDF_LOGI("%{public}s leave", __func__);
781 return HDF_SUCCESS;
782 }
783
ClearHalt(const UsbDev & dev,const UsbPipe & pipe)784 int32_t LibusbAdapter::ClearHalt(const UsbDev &dev, const UsbPipe &pipe)
785 {
786 HDF_LOGI("%{public}s enter", __func__);
787 if (pipe.intfId >= LIBUSB_MAX_INTERFACEID) {
788 HDF_LOGE("interfaceId is invalid");
789 return HDF_ERR_INVALID_PARAM;
790 }
791 libusb_device_handle *devHandle = nullptr;
792 int32_t ret = FindHandleByDev(dev, &devHandle);
793 if (ret != HDF_SUCCESS || devHandle == nullptr) {
794 HDF_LOGE("%{public}s:FindHandleByDev failed, ret=%{public}d", __func__, ret);
795 return HDF_FAILURE;
796 }
797 ret = libusb_clear_halt(devHandle, pipe.endpointId);
798 if (ret < 0) {
799 HDF_LOGE("%{public}s: libusb_clear_halt error: %{public}d", __func__, ret);
800 return HDF_FAILURE;
801 }
802 HDF_LOGI("%{public}s leave", __func__);
803 return ret;
804 }
805
GetEndpointDesc(const UsbDev & dev,const UsbPipe & pipe,libusb_endpoint_descriptor ** endpoint_desc,libusb_device_handle ** deviceHandle)806 int32_t LibusbAdapter::GetEndpointDesc(const UsbDev &dev, const UsbPipe &pipe,
807 libusb_endpoint_descriptor **endpoint_desc, libusb_device_handle** deviceHandle)
808 {
809 HDF_LOGD("%{public}s enter", __func__);
810 libusb_device *device = nullptr;
811 int32_t ret = GetUsbDevice(dev, &device);
812 if (ret != HDF_SUCCESS || device == nullptr) {
813 HDF_LOGE("%{public}s: LibusbFindDevice is failed, ret=%{public}d", __func__, ret);
814 return HDF_DEV_ERR_NO_DEVICE;
815 }
816 libusb_device_handle *devHandle = nullptr;
817 ret = FindHandleByDev(dev, &devHandle);
818 if (ret != HDF_SUCCESS || devHandle == nullptr) {
819 HDF_LOGE("%{public}s: FindHandleByDev is failed, ret=%{public}d", __func__, ret);
820 return HDF_FAILURE;
821 }
822 *deviceHandle = devHandle;
823 libusb_config_descriptor *config_desc = nullptr;
824 ret = libusb_get_active_config_descriptor(libusb_get_device(devHandle), &config_desc);
825 if (ret < 0) {
826 HDF_LOGE("%{public}s: libusb_get_active_config_descriptor failed ret=%{public}d", __func__, ret);
827 return HDF_ERR_INVALID_PARAM;
828 }
829 if (pipe.intfId < 0 || pipe.intfId >= config_desc->bNumInterfaces) {
830 HDF_LOGE("%{public}s: pipe.intfId is failed", __func__);
831 return HDF_FAILURE;
832 }
833 bool findFlag = false;
834 const libusb_interface *intf = &config_desc->interface[pipe.intfId];
835 for (int j = 0; j < intf->num_altsetting; j++) {
836 const libusb_interface_descriptor *intf_desc = &intf->altsetting[j];
837 for (int k = 0; k < intf_desc->bNumEndpoints; k++) {
838 const libusb_endpoint_descriptor *endpoint_desc_tmp = &intf_desc->endpoint[k];
839 if (endpoint_desc_tmp->bEndpointAddress == pipe.endpointId) {
840 *endpoint_desc = (libusb_endpoint_descriptor *)endpoint_desc_tmp;
841 findFlag = true;
842 break;
843 }
844 }
845 if (findFlag) {
846 break;
847 }
848 }
849
850 if (findFlag) {
851 HDF_LOGD("%{public}s leave", __func__);
852 return HDF_SUCCESS;
853 } else {
854 HDF_LOGE("%{public}s: LibUSBGetEndpointDesc is failed", __func__);
855 return HDF_FAILURE;
856 }
857 }
858
InterruptTransferRead(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,std::vector<uint8_t> & data)859 int32_t LibusbAdapter::InterruptTransferRead(
860 const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, std::vector<uint8_t> &data)
861 {
862 HDF_LOGI("%{public}s enter", __func__);
863 libusb_device_handle* deviceHandle = nullptr;
864 libusb_endpoint_descriptor* endpointDes = nullptr;
865 StartTrace(HITRACE_TAG_USB, "GetEndpointDesc");
866 int32_t ret = GetEndpointDesc(dev, pipe, &endpointDes, &deviceHandle);
867 FinishTrace(HITRACE_TAG_USB);
868 if (ret != HDF_SUCCESS) {
869 HDF_LOGE("%{public}s: InterruptTransferRead_lhx LibUSBGetEndpointDesc failed ret:%{public}d", __func__, ret);
870 return ret;
871 }
872 if ((endpointDes->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) != LIBUSB_ENDPOINT_TRANSFER_TYPE_INTERRUPT ||
873 (endpointDes->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) != LIBUSB_ENDPOINT_IN) {
874 HDF_LOGE("%{public}s: InterruptTransferRead_lhx invalid param", __func__);
875 return HDF_ERR_INVALID_PARAM;
876 }
877
878 uint8_t tbuf[INTERRUPT_READ_BUF_SIZE] = {0};
879 uint32_t tsize = INTERRUPT_READ_BUF_SIZE;
880 uint32_t actlength = 0;
881 StartTrace(HITRACE_TAG_USB, "libusb_interrupt_transfer");
882 ret = libusb_interrupt_transfer(deviceHandle, pipe.endpointId, tbuf, tsize, (int *)&actlength, timeout);
883 FinishTrace(HITRACE_TAG_USB);
884 if (ret < 0) {
885 HDF_LOGE("%{public}s: failed", __func__);
886 return HDF_FAILURE;
887 }
888 data.assign(tbuf, tbuf + actlength);
889 HDF_LOGI("%{public}s leave", __func__);
890 return HDF_SUCCESS;
891 }
892
InterruptTransferWrite(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,const std::vector<uint8_t> & data)893 int32_t LibusbAdapter::InterruptTransferWrite(
894 const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, const std::vector<uint8_t> &data)
895 {
896 HDF_LOGI("%{public}s enter", __func__);
897 libusb_device_handle* deviceHandle = nullptr;
898 libusb_endpoint_descriptor* endpointDes = nullptr;
899 StartTrace(HITRACE_TAG_USB, "GetEndpointDesc");
900 int32_t ret = GetEndpointDesc(dev, pipe, &endpointDes, &deviceHandle);
901 FinishTrace(HITRACE_TAG_USB);
902 if (ret != HDF_SUCCESS) {
903 HDF_LOGE("%{public}s: InterruptTransferRead_lhx LibUSBGetEndpointDesc failed ret:%{public}d", __func__, ret);
904 return ret;
905 }
906 if ((endpointDes->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) != LIBUSB_ENDPOINT_TRANSFER_TYPE_INTERRUPT ||
907 (endpointDes->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) != LIBUSB_ENDPOINT_OUT) {
908 HDF_LOGE("%{public}s: InterruptTransferWrite invalid param", __func__);
909 return HDF_ERR_INVALID_PARAM;
910 }
911 int transferred = 0;
912 StartTrace(HITRACE_TAG_USB, "libusb_interrupt_transfer");
913 ret = libusb_interrupt_transfer(deviceHandle, pipe.endpointId, (unsigned char *)data.data(), data.size(),
914 &transferred, timeout);
915 FinishTrace(HITRACE_TAG_USB);
916 if (ret == 0 && transferred > 0) {
917 HDF_LOGI("%{public}s: InterruptTransferWrite_lhx libusb_interrupt_transfer ok transferred:%{public}d",
918 __func__, transferred);
919 } else {
920 HDF_LOGE("%{public}s: ret:%{public}d error", __func__, ret);
921 return HDF_FAILURE;
922 }
923 HDF_LOGI("%{public}s leave", __func__);
924 return HDF_SUCCESS;
925 }
926
GetStringDescriptor(const UsbDev & dev,uint8_t descId,std::vector<uint8_t> & descriptor)927 int32_t LibusbAdapter::GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor)
928 {
929 HDF_LOGI("%{public}s enter", __func__);
930 libusb_device_handle *devHandle = nullptr;
931 libusb_device *device = nullptr;
932 uint8_t data[USB_MAX_DESCRIPTOR_SIZE] = {0};
933 int32_t ret = GetUsbDevice(dev, &device);
934 if (ret != HDF_SUCCESS || device == nullptr) {
935 HDF_LOGE("%{public}s: GetUsbDevice is failed, ret=%{public}d", __func__, ret);
936 return HDF_DEV_ERR_NO_DEVICE;
937 }
938 ret = FindHandleByDev(dev, &devHandle);
939 if (ret != HDF_SUCCESS || devHandle == nullptr) {
940 HDF_LOGE("%{public}s: FindHandleByDev is failed, ret=%{public}d", __func__, ret);
941 return HDF_FAILURE;
942 }
943 int32_t length = sizeof(data);
944 uint16_t descLength = USB_MAX_DESCRIPTOR_SIZE;
945 ret = libusb_get_string_descriptor(devHandle, descId, ENGLISH_US_LANGUAGE_ID, data, length);
946 if (ret <= 0) {
947 if (descId == INVALID_NUM) {
948 return HDF_SUCCESS;
949 }
950 HDF_LOGE("%{public}s: libusb_get_string_descriptor is failed, ret = %{public}d", __func__, ret);
951 return HDF_FAILURE;
952 }
953 descriptor.resize(USB_MAX_DESCRIPTOR_SIZE);
954 std::copy(data, data + std::min(USB_MAX_DESCRIPTOR_SIZE, static_cast<int>(descLength)), descriptor.begin());
955 HDF_LOGI("%{public}s leave", __func__);
956 return HDF_SUCCESS;
957 }
958
ClaimInterface(const UsbDev & dev,uint8_t interfaceId,uint8_t force)959 int32_t LibusbAdapter::ClaimInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t force)
960 {
961 HDF_LOGI("%{public}s enter", __func__);
962 libusb_device_handle *devHandle = nullptr;
963 int32_t ret = FindHandleByDev(dev, &devHandle);
964 if (ret != HDF_SUCCESS || devHandle == nullptr) {
965 HDF_LOGE("%{public}s: FindHandleByDev failed, ret=%{public}d", __func__, ret);
966 return HDF_FAILURE;
967 }
968
969 if (force) {
970 if (libusb_kernel_driver_active(devHandle, interfaceId) != 1) {
971 HDF_LOGW("This interface is not occupied by the kernel driver,interfaceId : %{public}d", interfaceId);
972 } else {
973 ret = libusb_detach_kernel_driver(devHandle, interfaceId);
974 if (ret < HDF_SUCCESS) {
975 HDF_LOGE("libusb_detach_kernel_driver is error, ret: %{public}d", ret);
976 }
977 }
978 }
979
980 ret = libusb_claim_interface(devHandle, interfaceId);
981 HDF_LOGI("Interface claim ret : %{public}d, force : %{public}d", ret, force);
982 if (ret != LIBUSB_SUCCESS) {
983 HDF_LOGE("%{public}s: ClaimInterface failed, busNum=%{public}u, devAddr=%{public}u, ret=%{public}d",
984 __func__, dev.busNum, dev.devAddr, ret);
985 return HDF_FAILURE;
986 }
987 if (!CheckDeviceAndConfiguration(devHandle)) {
988 HDF_LOGE("CheckDeviceAndConfiguration failed");
989 return HDF_FAILURE;
990 }
991 {
992 std::unique_lock<std::shared_mutex> lock(g_mapMutexDeviceSettingsMap);
993 g_deviceSettingsMap[devHandle].interfaceNumber = static_cast<int32_t>(interfaceId);
994 g_deviceSettingsMap[devHandle].alternateSetting = 0;
995 }
996 {
997 std::unique_lock<std::shared_mutex> lock(g_mapMutexInterfaceIdMap);
998 uint32_t result = (static_cast<uint32_t>(dev.busNum) << DISPLACEMENT_NUMBER) |
999 static_cast<uint32_t>(dev.devAddr);
1000 int32_t currentConfig = -1;
1001 ret = GetCurrentConfiguration(devHandle, currentConfig);
1002 if (ret != HDF_SUCCESS) {
1003 HDF_LOGE("%{public}s: GetCurrentConfiguration failed", __func__);
1004 return HDF_FAILURE;
1005 }
1006 g_InterfaceIdMap[result][currentConfig].push_back(interfaceId);
1007 }
1008 HDF_LOGI("%{public}s leave", __func__);
1009 return HDF_SUCCESS;
1010 }
1011
ControlTransferRead(const UsbDev & dev,const UsbCtrlTransfer & ctrl,std::vector<uint8_t> & data)1012 int32_t LibusbAdapter::ControlTransferRead(const UsbDev &dev, const UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data)
1013 {
1014 HITRACE_METER_NAME(HITRACE_TAG_USB, "LibusbAdapter::ControlTransferRead");
1015 HDF_LOGI("%{public}s enter", __func__);
1016 if ((static_cast<uint32_t>(ctrl.requestType) & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) {
1017 HDF_LOGE("%{public}s: this function is read, not write", __func__);
1018 return HDF_FAILURE;
1019 }
1020 std::vector<uint8_t> buffer(MAX_CONTROL_BUFF_SIZE);
1021 int32_t ret = DoControlTransfer(dev, ctrl, buffer);
1022 if (ret < 0) {
1023 HDF_LOGE("%{public}s:libusb_control_transfer failed with error: %{public}d", __func__, ret);
1024 return ret;
1025 }
1026 data.assign(buffer.begin(), buffer.begin() + ret);
1027 HDF_LOGI("%{public}s leave", __func__);
1028 return HDF_SUCCESS;
1029 }
1030
ControlTransferWrite(const UsbDev & dev,const UsbCtrlTransfer & ctrl,const std::vector<uint8_t> & data)1031 int32_t LibusbAdapter::ControlTransferWrite(const UsbDev &dev, const UsbCtrlTransfer &ctrl,
1032 const std::vector<uint8_t> &data)
1033 {
1034 HITRACE_METER_NAME(HITRACE_TAG_USB, "LibusbAdapter::ControlTransferWrite");
1035 HDF_LOGI("%{public}s enter", __func__);
1036 if ((static_cast<uint32_t>(ctrl.requestType) & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_IN) {
1037 HDF_LOGE("%{public}s: this function is write, not read", __func__);
1038 return HDF_FAILURE;
1039 }
1040 std::vector<uint8_t> buffer(data);
1041 int32_t ret = DoControlTransfer(dev, ctrl, buffer);
1042 if (ret < 0) {
1043 HDF_LOGE("%{public}s:libusb_control_transfer failed with error: %{public}d", __func__, ret);
1044 return ret;
1045 }
1046 HDF_LOGI("%{public}s leave", __func__);
1047 return HDF_SUCCESS;
1048 }
1049
ControlTransferReadwithLength(const UsbDev & dev,const UsbCtrlTransferParams & ctrlParams,std::vector<uint8_t> & data)1050 int32_t LibusbAdapter::ControlTransferReadwithLength(
1051 const UsbDev &dev, const UsbCtrlTransferParams &ctrlParams, std::vector<uint8_t> &data)
1052 {
1053 HITRACE_METER_NAME(HITRACE_TAG_USB, "LibusbAdapter::ControlTransferReadwithLength");
1054 HDF_LOGI("%{public}s enter", __func__);
1055 if ((static_cast<uint32_t>(ctrlParams.requestType) & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) {
1056 HDF_LOGE("%{public}s: this function is read, not write", __func__);
1057 return HDF_FAILURE;
1058 }
1059 int32_t size = (ctrlParams.length <= 0 || ctrlParams.length > MAX_CONTROL_BUFF_SIZE)
1060 ? MAX_CONTROL_BUFF_SIZE : ctrlParams.length;
1061 std::vector<uint8_t> buffer(size);
1062
1063 const UsbCtrlTransfer ctrl = {
1064 .requestType = ctrlParams.requestType,
1065 .requestCmd = ctrlParams.requestCmd,
1066 .value = ctrlParams.value,
1067 .index = ctrlParams.index,
1068 .timeout = ctrlParams.timeout
1069 };
1070
1071 int32_t ret = DoControlTransfer(dev, ctrl, buffer);
1072 if (ret < 0) {
1073 HDF_LOGE("%{public}s: libusb_control_transfer failed, ret: %{public}d",
1074 __func__, ret);
1075 return ret;
1076 }
1077 data.assign(buffer.begin(), buffer.begin() + ret);
1078 HDF_LOGI("%{public}s leave", __func__);
1079 return HDF_SUCCESS;
1080 }
1081
DoControlTransfer(const UsbDev & dev,const UsbCtrlTransfer & ctrl,std::vector<uint8_t> & data)1082 int32_t LibusbAdapter::DoControlTransfer(const UsbDev &dev, const UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data)
1083 {
1084 HDF_LOGD("%{public}s enter", __func__);
1085 libusb_device_handle *devHandle = nullptr;
1086 StartTrace(HITRACE_TAG_USB, "FindHandleByDev");
1087 int32_t ret = FindHandleByDev(dev, &devHandle);
1088 FinishTrace(HITRACE_TAG_USB);
1089 if (ret != HDF_SUCCESS || devHandle == nullptr) {
1090 HDF_LOGE("%{public}s: Find UsbHandle failed, ret=%{public}d", __func__, ret);
1091 return HDF_FAILURE;
1092 }
1093
1094 uint8_t reqType = static_cast<uint8_t>(ctrl.requestType);
1095 uint8_t reqCmd = static_cast<uint8_t>(ctrl.requestCmd);
1096 uint16_t wValue = static_cast<uint16_t>(ctrl.value);
1097 uint16_t wIndex = static_cast<uint16_t>(ctrl.index);
1098 unsigned char *wData = (unsigned char *)data.data();
1099 uint16_t wLength = static_cast<uint16_t>(data.size());
1100 HDF_LOGD("%{public}s: wLength=%{public}d", __func__, wLength);
1101 if (ctrl.requestCmd == LIBUSB_REQUEST_SYNCH_FRAME) {
1102 wIndex = reqType | LIBUSB_RECIPIENT_ENDPOINT;
1103 }
1104
1105 if (reqType == LIBUSB_ENDPOINT_OUT) {
1106 reqType = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE;
1107 } else if ((reqType & LIBUSB_RECIPIENT_ENDPOINT) == LIBUSB_RECIPIENT_ENDPOINT) {
1108 wIndex = reqType;
1109 }
1110
1111 ret = libusb_control_transfer(devHandle, reqType, reqCmd, wValue, wIndex, wData, wLength, ctrl.timeout);
1112 if (ret < 0) {
1113 int32_t apiVersion = 0;
1114 GetApiVersion(apiVersion);
1115 HDF_LOGD("%{public}s: apiVersion %{public}d", __func__, apiVersion);
1116 if (apiVersion < API_VERSION_ID_18) {
1117 HDF_LOGD("%{public}s: The version number is smaller than 18 apiVersion %{public}d",
1118 __func__, apiVersion);
1119 ret = HDF_SUCCESS;
1120 }
1121 }
1122
1123 HDF_LOGD("%{public}s leave", __func__);
1124 return ret;
1125 }
1126
GetFileDescriptor(const UsbDev & dev,int32_t & fd)1127 int32_t LibusbAdapter::GetFileDescriptor(const UsbDev &dev, int32_t &fd)
1128 {
1129 HDF_LOGI("%{public}s enter", __func__);
1130 libusb_device *device = nullptr;
1131 int32_t ret = GetUsbDevice(dev, &device);
1132 if (ret != HDF_SUCCESS || device == nullptr) {
1133 HDF_LOGE("Search device does not exist, ret=%{public}d", ret);
1134 return HDF_FAILURE;
1135 }
1136 libusb_device_handle *devHandle = nullptr;
1137 ret = FindHandleByDev(dev, &devHandle);
1138 if (ret != HDF_SUCCESS || devHandle == nullptr) {
1139 HDF_LOGE("%{public}s: FindHandleByDev is failed, ret=%{public}d", __func__, ret);
1140 return HDF_FAILURE;
1141 }
1142 uint32_t result = (static_cast<uint32_t>(dev.busNum) << DISPLACEMENT_NUMBER) |
1143 static_cast<uint32_t>(dev.devAddr);
1144 {
1145 std::shared_lock<std::shared_mutex> lock(g_mapMutexUsbOpenFdMap);
1146 auto info = g_usbOpenFdMap.find(result);
1147 if (info != g_usbOpenFdMap.end()) {
1148 fd = info->second;
1149 HDF_LOGI("%{public}s open is already on, fd: %{public}d", __func__, info->second);
1150 return HDF_SUCCESS;
1151 }
1152 }
1153 char path[LIBUSB_PATH_LENGTH] = {'\0'};
1154 ret = sprintf_s(path, sizeof(path), "%s/%03u/%03u", USB_DEV_FS_PATH, dev.busNum, dev.devAddr);
1155 if (ret < 0) {
1156 HDF_LOGE("%{public}s:sprintf_s path failed, ret:%{public}d", __func__, ret);
1157 return ret;
1158 }
1159 int32_t fileFd = open(path, O_RDWR);
1160 if (fileFd < 0) {
1161 HDF_LOGE("%{public}s: open device failed errno = %{public}d %{public}s", __func__, errno, strerror(errno));
1162 return HDF_FAILURE;
1163 }
1164 fd = fileFd;
1165 {
1166 std::unique_lock<std::shared_mutex> lock(g_mapMutexUsbOpenFdMap);
1167 g_usbOpenFdMap[result] = fd;
1168 }
1169 HDF_LOGI("%{public}s leave", __func__);
1170 return HDF_SUCCESS;
1171 }
1172
GetDeviceSpeed(const UsbDev & dev,uint8_t & speed)1173 int32_t LibusbAdapter::GetDeviceSpeed(const UsbDev &dev, uint8_t &speed)
1174 {
1175 HDF_LOGI("%{public}s enter", __func__);
1176 libusb_device *device = nullptr;
1177 int32_t ret = GetUsbDevice(dev, &device);
1178 if (ret != HDF_SUCCESS || device == nullptr) {
1179 HDF_LOGE("%{public}s: GetUsbDevice failed, ret=%{public}d", __func__, ret);
1180 return HDF_DEV_ERR_NO_DEVICE;
1181 }
1182 int deviceSpeed = libusb_get_device_speed(device);
1183 if (deviceSpeed < 0) {
1184 HDF_LOGE("%{public}s: Failed to get device speed, error: %{public}d", __func__, deviceSpeed);
1185 return HDF_FAILURE;
1186 }
1187 speed = static_cast<uint8_t>(deviceSpeed);
1188 HDF_LOGI("%{public}s Device speed retrieved successfully leave", __func__);
1189 return HDF_SUCCESS;
1190 }
1191
GetInterfaceActiveStatus(const UsbDev & dev,uint8_t interfaceId,bool & unactivated)1192 int32_t LibusbAdapter::GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool &unactivated)
1193 {
1194 HDF_LOGI("%{public}s enter", __func__);
1195 libusb_device *device = nullptr;
1196 int32_t ret = GetUsbDevice(dev, &device);
1197 if (ret != HDF_SUCCESS || device == nullptr) {
1198 HDF_LOGE("GetUsbDevice failed, ret=%{public}d", ret);
1199 return HDF_DEV_ERR_NO_DEVICE;
1200 }
1201
1202 libusb_device_handle *devHandle = nullptr;
1203 ret = FindHandleByDev(dev, &devHandle);
1204 if (ret != HDF_SUCCESS || devHandle == nullptr) {
1205 HDF_LOGE("%{public}s: FindHandleByDev failed, ret=%{public}d", __func__, ret);
1206 return HDF_DEV_ERR_NO_DEVICE;
1207 }
1208
1209 ret = libusb_kernel_driver_active(devHandle, interfaceId);
1210 if (ret != HDF_SUCCESS) {
1211 unactivated = false;
1212 HDF_LOGE("%{public}s unactivated:%{public}d", __func__, unactivated);
1213 return ret;
1214 }
1215 unactivated = true;
1216 HDF_LOGI("%{public}s leave", __func__);
1217
1218 return ret;
1219 }
1220
GetCurrentInterfaceSetting(const UsbDev & dev,uint8_t & settingIndex)1221 int32_t LibusbAdapter::GetCurrentInterfaceSetting(const UsbDev &dev, uint8_t &settingIndex)
1222 {
1223 HDF_LOGI("%{public}s leave", __func__);
1224 libusb_device *device = nullptr;
1225 int32_t ret = GetUsbDevice(dev, &device);
1226 if (ret != HDF_SUCCESS || device == nullptr) {
1227 HDF_LOGE("GetUsbDevice failed, ret=%{public}d", ret);
1228 return HDF_DEV_ERR_NO_DEVICE;
1229 }
1230 libusb_device_handle *devHandle = nullptr;
1231 ret = FindHandleByDev(dev, &devHandle);
1232 if (ret != HDF_SUCCESS || devHandle == nullptr) {
1233 HDF_LOGE("%{public}s FindHandleByDev failed, ret=%{public}d", __func__, ret);
1234 return HDF_DEV_ERR_NO_DEVICE;
1235 }
1236 if (!CheckDeviceAndConfiguration(devHandle)) {
1237 HDF_LOGE("CheckDeviceAndConfiguration failed");
1238 return HDF_FAILURE;
1239 }
1240 std::shared_lock<std::shared_mutex> lock(g_mapMutexDeviceSettingsMap);
1241 if (g_deviceSettingsMap[devHandle].alternateSetting < 0) {
1242 HDF_LOGE("%{public}s: Current Interface Setting Invalid, settingIndex = :%{public}d",
1243 __func__, g_deviceSettingsMap[devHandle].alternateSetting);
1244 return HDF_FAILURE;
1245 }
1246 settingIndex = g_deviceSettingsMap[devHandle].alternateSetting;
1247 HDF_LOGI("%{public}s leave", __func__);
1248 return HDF_SUCCESS;
1249 }
1250
IsInterfaceIdByUsbDev(const UsbDev & dev,const uint8_t intfId)1251 bool LibusbAdapter::IsInterfaceIdByUsbDev(const UsbDev &dev, const uint8_t intfId)
1252 {
1253 HDF_LOGD("%{public}s enter", __func__);
1254 libusb_device_handle *devHandle = nullptr;
1255 int32_t ret = FindHandleByDev(dev, &devHandle);
1256 if (ret != HDF_SUCCESS || devHandle == nullptr) {
1257 HDF_LOGE("%{public}s: FindHandleByDev failed, ret=%{public}d", __func__, ret);
1258 return false;
1259 }
1260 std::shared_lock<std::shared_mutex> lock(g_mapMutexInterfaceIdMap);
1261 uint32_t result = (static_cast<uint32_t>(dev.busNum) << DISPLACEMENT_NUMBER) |
1262 static_cast<uint32_t>(dev.devAddr);
1263 auto deviceIt = g_InterfaceIdMap.find(result);
1264 if (deviceIt == g_InterfaceIdMap.end()) {
1265 HDF_LOGE("%{public}s device not found", __func__);
1266 return false;
1267 }
1268 int32_t currentConfig = -1;
1269 ret = GetCurrentConfiguration(devHandle, currentConfig);
1270 if (ret != HDF_SUCCESS) {
1271 HDF_LOGE("%{public}s: GetCurrentConfiguration failed", __func__);
1272 return false;
1273 }
1274 auto configIt = deviceIt->second.find(currentConfig);
1275 if (configIt == deviceIt->second.end()) {
1276 HDF_LOGE("%{public}s config not found", __func__);
1277 return false;
1278 }
1279 std::vector<uint8_t> interfaceIds = configIt->second;
1280 if (std::find(interfaceIds.begin(), interfaceIds.end(), intfId) == interfaceIds.end()) {
1281 HDF_LOGE("%{public}s: Interface %{public}u is not claimed", __func__, intfId);
1282 return false;
1283 }
1284
1285 HDF_LOGD("%{public}s leave", __func__);
1286 return true;
1287 }
1288
GetMmapBufferByFd(int32_t fd,size_t len)1289 unsigned char *LibusbAdapter::GetMmapBufferByFd(int32_t fd, size_t len)
1290 {
1291 HDF_LOGD("%{public}s enter", __func__);
1292 if (fd < 0 || len < 0) {
1293 HDF_LOGE("%{public}s Invalid parameter", __func__);
1294 return nullptr;
1295 }
1296
1297 void *memBuf = nullptr;
1298 ftruncate(fd, len);
1299 memBuf = mmap(nullptr, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
1300 if (memBuf == MAP_FAILED) {
1301 HDF_LOGE("%{public}s fd:%{public}d mmap failed, errno=%{public}d, len=%{public}zu",
1302 __func__, fd, errno, len);
1303 return nullptr;
1304 }
1305 HDF_LOGD("%{public}s leave", __func__);
1306 return static_cast<unsigned char *>(memBuf);
1307 }
1308
GetMmapFdAndBuffer(uint8_t busNumber,uint8_t busAddress,int32_t & fd,size_t len)1309 unsigned char *LibusbAdapter::GetMmapFdAndBuffer(uint8_t busNumber, uint8_t busAddress, int32_t &fd, size_t len)
1310 {
1311 HDF_LOGD("%{public}s enter", __func__);
1312 if (len < 0) {
1313 HDF_LOGE("%{public}s Invalid parameter", __func__);
1314 return nullptr;
1315 }
1316 uint32_t result = (static_cast<uint32_t>(busNumber) << DISPLACEMENT_NUMBER) |
1317 static_cast<uint32_t>(busAddress);
1318 {
1319 std::shared_lock<std::shared_mutex> lock(g_mapMutexUsbOpenFdMap);
1320 auto info = g_usbOpenFdMap.find(result);
1321 if (info == g_usbOpenFdMap.end()) {
1322 HDF_LOGE("%{public}s not open fd", __func__);
1323 return nullptr;
1324 }
1325 fd = info->second;
1326 HDF_LOGD("%{public}s open is already on, fd: %{public}d", __func__, info->second);
1327 }
1328 unsigned char *memBuf = GetMmapBufferByFd(fd, len);
1329 if (memBuf == nullptr) {
1330 HDF_LOGE("%{public}s: GetMmapBufferByFd failed", __func__);
1331 return nullptr;
1332 }
1333 HDF_LOGD("%{public}s Get mmap fd: %{public}d and memBuf: %{public}p success", __func__, fd, memBuf);
1334 return memBuf;
1335 }
1336
CloseMmapBuffer(void * mmapBuf,size_t length)1337 int32_t LibusbAdapter::CloseMmapBuffer(void *mmapBuf, size_t length)
1338 {
1339 HDF_LOGD("%{public}s enter", __func__);
1340 if (mmapBuf == nullptr) {
1341 HDF_LOGE("%{public}s mmapBuf is nullptr", __func__);
1342 return HDF_FAILURE;
1343 }
1344
1345 if (munmap(mmapBuf, length) != 0) {
1346 HDF_LOGE("%{public}s:%{public}d munmap failed, errno=%{public}d", __func__, __LINE__, errno);
1347 return HDF_ERR_IO;
1348 }
1349 HDF_LOGD("%{public}s leave", __func__);
1350 return HDF_SUCCESS;
1351 }
1352
SendPipeRequest(const UsbDev & dev,unsigned char endpointAddr,uint32_t size,uint32_t & transferedLength,unsigned int timeout)1353 int32_t LibusbAdapter::SendPipeRequest(const UsbDev &dev, unsigned char endpointAddr, uint32_t size,
1354 uint32_t &transferedLength, unsigned int timeout)
1355 {
1356 HDF_LOGI("%{public}s enter", __func__);
1357 int actlength = 0;
1358 libusb_device_handle *devHandle = nullptr;
1359 int32_t ret = FindHandleByDev(dev, &devHandle);
1360 if (ret != HDF_SUCCESS || devHandle == nullptr) {
1361 HDF_LOGE("%{public}s:FindHandleByDev failed, ret=%{public}d", __func__, ret);
1362 return HDF_FAILURE;
1363 }
1364 int32_t mmapFd = HDF_FAILURE;
1365 unsigned char *buffer = nullptr;
1366 buffer = GetMmapFdAndBuffer(dev.busNum, dev.devAddr, mmapFd, size);
1367 if (buffer == nullptr) {
1368 HDF_LOGE("%{public}s: GetMmapFdAndBuffer is error ", __func__);
1369 return HDF_FAILURE;
1370 }
1371 SyncTranfer syncTranfer = {size, &actlength, timeout};
1372 ret = DoSyncPipeTranfer(devHandle, endpointAddr, buffer, syncTranfer);
1373 if (ret < 0) {
1374 if (ret != LIBUSB_ERROR_OVERFLOW) {
1375 ret = HDF_FAILURE;
1376 } else {
1377 ret = HDF_ERR_INVALID_PARAM;
1378 }
1379 int32_t apiVersion = 0;
1380 GetApiVersion(apiVersion);
1381 HDF_LOGI("%{public}s: apiVersion %{public}d", __func__, apiVersion);
1382 if (apiVersion < API_VERSION_ID_20) {
1383 HDF_LOGI("%{public}s: The version number is smaller than 20 apiVersion %{public}d",
1384 __func__, apiVersion);
1385 ret = HDF_SUCCESS;
1386 }
1387 }
1388 transferedLength = static_cast<uint32_t>(actlength);
1389 CloseMmapBuffer(buffer, size);
1390 HDF_LOGI("%{public}s leave", __func__);
1391 return ret;
1392 }
1393
SendPipeRequestWithAshmem(const UsbDev & dev,unsigned char endpointAddr,SendRequestAshmemParameter sendRequestAshmemParameter,uint32_t & transferredLength,unsigned int timeout)1394 int32_t LibusbAdapter::SendPipeRequestWithAshmem(const UsbDev &dev, unsigned char endpointAddr,
1395 SendRequestAshmemParameter sendRequestAshmemParameter, uint32_t &transferredLength, unsigned int timeout)
1396 {
1397 HDF_LOGI("%{public}s enter", __func__);
1398 int actlength = 0;
1399 libusb_device_handle *devHandle = nullptr;
1400 int32_t ret = FindHandleByDev(dev, &devHandle);
1401 if (ret != HDF_SUCCESS || devHandle == nullptr) {
1402 HDF_LOGE("%{public}s:FindHandleByDev failed, ret=%{public}d", __func__, ret);
1403 return HDF_FAILURE;
1404 }
1405
1406 unsigned char *buffer = GetMmapBufferByFd(sendRequestAshmemParameter.ashmemFd,
1407 sendRequestAshmemParameter.ashmemSize);
1408 if (buffer == nullptr) {
1409 HDF_LOGE("%{public}s: GetMmapBufferByFd failed", __func__);
1410 return HDF_FAILURE;
1411 }
1412 SyncTranfer syncTranfer = {sendRequestAshmemParameter.ashmemSize, &actlength, timeout};
1413 ret = DoSyncPipeTranfer(devHandle, endpointAddr, buffer, syncTranfer);
1414 HDF_LOGI("SendPipeRequestWithAshmem DoSyncPipeTranfer ret :%{public}d", ret);
1415 if (ret < 0) {
1416 if (ret != LIBUSB_ERROR_OVERFLOW) {
1417 ret = HDF_FAILURE;
1418 } else {
1419 ret = HDF_ERR_INVALID_PARAM;
1420 }
1421 int32_t apiVersion = 0;
1422 GetApiVersion(apiVersion);
1423 HDF_LOGI("%{public}s: apiVersion %{public}d", __func__, apiVersion);
1424 if (apiVersion < API_VERSION_ID_20) {
1425 HDF_LOGI("%{public}s: The version number is smaller than 20 apiVersion %{public}d",
1426 __func__, apiVersion);
1427 ret = HDF_SUCCESS;
1428 }
1429 }
1430 transferredLength = static_cast<uint32_t>(actlength);
1431 CloseMmapBuffer(buffer, sendRequestAshmemParameter.ashmemSize);
1432 close(sendRequestAshmemParameter.ashmemFd);
1433 return ret;
1434 }
1435
GetRawDescriptor(const UsbDev & dev,std::vector<uint8_t> & descriptor)1436 int32_t LibusbAdapter::GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor)
1437 {
1438 HDF_LOGI("%{public}s enter", __func__);
1439 libusb_device *device = nullptr;
1440 int32_t ret = GetUsbDevice(dev, &device);
1441 if (ret != HDF_SUCCESS || device == nullptr) {
1442 HDF_LOGE("Search device does not exist, ret=%{public}d", ret);
1443 return HDF_FAILURE;
1444 }
1445 libusb_device_handle *devHandle = nullptr;
1446 ret = FindHandleByDev(dev, &devHandle);
1447 if (ret != HDF_SUCCESS || devHandle == nullptr) {
1448 HDF_LOGE("%{public}s: FindHandleByDev is failed, ret=%{public}d", __func__, ret);
1449 return HDF_FAILURE;
1450 }
1451 char pathBuf[LIBUSB_PATH_LENGTH] = {'\0'};
1452 ret = GetUsbDevicePath(dev, pathBuf, LIBUSB_PATH_LENGTH);
1453 if (ret != HDF_SUCCESS) {
1454 HDF_LOGE("%{public}s: get usb device path failed:%{public}d", __func__, ret);
1455 return HDF_FAILURE;
1456 }
1457 char resolvedPath[PATH_MAX] = {'\0'};
1458 char *ptrBuf = realpath(pathBuf, resolvedPath);
1459 if (ptrBuf == nullptr) {
1460 HDF_LOGE("%{public}s: path conversion failed, ptr: %{public}s", __func__, ptrBuf);
1461 return HDF_FAILURE;
1462 }
1463 int32_t fd = open(ptrBuf, O_RDWR | O_CLOEXEC);
1464 if (fd < 0) {
1465 HDF_LOGE("%{public}s: failed to open file: %{public}s, errno: %{public}d",
1466 __func__, ptrBuf, errno);
1467 return HDF_FAILURE;
1468 }
1469 void *descriptors = nullptr;
1470 size_t descriptorsLength = 0;
1471 if (ReadDescriptors(fd, &descriptors, descriptorsLength) != HDF_SUCCESS) {
1472 HDF_LOGE("%{public}s: ReadDescriptors failed", __func__);
1473 close(fd);
1474 return HDF_FAILURE;
1475 }
1476 uint8_t *ptr = static_cast<uint8_t *>(descriptors);
1477 uint32_t length = descriptorsLength;
1478 descriptor.resize(length);
1479 std::copy(ptr, ptr + length, descriptor.begin());
1480 FreeUsbDescriptorsMemory(descriptors);
1481 close(fd);
1482 HDF_LOGI("%{public}s leave", __func__);
1483 return HDF_SUCCESS;
1484 }
1485
ReadDescriptors(int32_t fd,void ** descriptors,size_t & descriptorsLength)1486 int32_t LibusbAdapter::ReadDescriptors(int32_t fd, void **descriptors, size_t &descriptorsLength)
1487 {
1488 HDF_LOGD("%{public}s enter", __func__);
1489 size_t allocLen = 0;
1490 do {
1491 size_t oldLen = allocLen;
1492 allocLen += USB_MAX_DESCRIPTOR_SIZE;
1493 *descriptors = AdapterRealloc(*descriptors, oldLen, allocLen);
1494 if (*descriptors == nullptr) {
1495 HDF_LOGE("%{public}s:%{public}d", __func__, __LINE__);
1496 return HDF_ERR_MALLOC_FAIL;
1497 }
1498
1499 uint8_t *ptr = (uint8_t *)*descriptors + oldLen;
1500 if (memset_s(ptr, USB_MAX_DESCRIPTOR_SIZE, 0, USB_MAX_DESCRIPTOR_SIZE) != EOK) {
1501 HDF_LOGE("%{public}s:%{public}d memset_s failed", __func__, __LINE__);
1502 FreeUsbDescriptorsMemory(*descriptors);
1503 return HDF_FAILURE;
1504 }
1505
1506 int32_t len = read(fd, ptr, USB_MAX_DESCRIPTOR_SIZE);
1507 if (len < 0) {
1508 HDF_LOGE("read descriptor failed, errno=%{public}d", errno);
1509 FreeUsbDescriptorsMemory(*descriptors);
1510 return HDF_ERR_IO;
1511 }
1512 descriptorsLength += static_cast<size_t>(len);
1513 } while (descriptorsLength == allocLen);
1514 HDF_LOGD("%{public}s leave", __func__);
1515 return HDF_SUCCESS;
1516 }
1517
GetUsbDevicePath(const UsbDev & dev,char * pathBuf,size_t length)1518 int32_t LibusbAdapter::GetUsbDevicePath(const UsbDev &dev, char *pathBuf, size_t length)
1519 {
1520 HDF_LOGD("%{public}s enter", __func__);
1521 char path[PATH_MAX] = {'\0'};
1522 int32_t ret = sprintf_s(path, sizeof(path), "%s/%03u/%03u", USB_DEV_FS_PATH, dev.busNum, dev.devAddr);
1523 if (ret < HDF_SUCCESS) {
1524 HDF_LOGE("%{public}s:%{public}d path error", __func__, __LINE__);
1525 return HDF_FAILURE;
1526 }
1527 char resolvedPath[PATH_MAX] = {'\0'};
1528 char *ptr = realpath(path, resolvedPath);
1529 if (ptr == nullptr) {
1530 HDF_LOGE("%{public}s: path conversion failed, resolvedPath: %{public}s", __func__, resolvedPath);
1531 return HDF_FAILURE;
1532 }
1533 uint32_t len = strlen(resolvedPath);
1534 if (len >= PATH_MAX) {
1535 HDF_LOGE("%{public}s: path too long, resolvedPath: %{public}s", __func__, resolvedPath);
1536 return HDF_FAILURE;
1537 }
1538 if (length < (len + 1)) {
1539 HDF_LOGE("%{public}s: invalid length", __func__);
1540 return HDF_FAILURE;
1541 }
1542 ret = memcpy_s(pathBuf, length, resolvedPath, len + 1);
1543 if (ret != EOK) {
1544 HDF_LOGE("%{public}s: memcpy_s failed", __func__);
1545 return HDF_FAILURE;
1546 }
1547 if (strncmp(USB_DEV_FS_PATH, pathBuf, strlen(USB_DEV_FS_PATH)) != 0) {
1548 HDF_LOGE("%{public}s: The file path is incorrect, path: %{public}s", __func__, path);
1549 return HDF_FAILURE;
1550 }
1551 HDF_LOGD("%{public}s leave", __func__);
1552
1553 return HDF_SUCCESS;
1554 }
1555
AdapterRealloc(void * ptr,size_t oldSize,size_t newSize)1556 void *LibusbAdapter::AdapterRealloc(void *ptr, size_t oldSize, size_t newSize)
1557 {
1558 HDF_LOGD("%{public}s enter", __func__);
1559 void *mem = AllocateUsbDescriptorsMemory(newSize);
1560 if (mem == nullptr) {
1561 HDF_LOGE("%{public}s:%{public}d RawUsbMemAlloc failed.", __func__, __LINE__);
1562 return nullptr;
1563 }
1564
1565 if (oldSize > 0) {
1566 if (memmove_s(mem, newSize, ptr, oldSize) != EOK) {
1567 HDF_LOGE("%{public}s:%{public}d", __func__, __LINE__);
1568 FreeUsbDescriptorsMemory(mem);
1569 mem = nullptr;
1570 return nullptr;
1571 }
1572 }
1573 FreeUsbDescriptorsMemory(ptr);
1574 ptr = nullptr;
1575 HDF_LOGD("%{public}s leave", __func__);
1576 return mem;
1577 }
1578
AllocateUsbDescriptorsMemory(size_t size)1579 void *LibusbAdapter::AllocateUsbDescriptorsMemory(size_t size)
1580 {
1581 HDF_LOGD("%{public}s enter", __func__);
1582 if (size == 0) {
1583 HDF_LOGE("%{public}s:%{public}d size is 0", __func__, __LINE__);
1584 return nullptr;
1585 }
1586 if (size > MAX_TOTAL_SIZE) {
1587 HDF_LOGE("%{public}s:%{public}d size is exceeded the maximum MAX_TOTAL_SIZE", __func__, __LINE__);
1588 return nullptr;
1589 }
1590 void* buf = calloc(size, 1);
1591 if (buf == nullptr) {
1592 HDF_LOGE("%{public}s: %{public}d, AllocateUsbDescriptorsMemory failed", __func__, __LINE__);
1593 return nullptr;
1594 }
1595 HDF_LOGD("%{public}s leave", __func__);
1596 return buf;
1597 }
1598
FreeUsbDescriptorsMemory(void * mem)1599 void LibusbAdapter::FreeUsbDescriptorsMemory(void *mem)
1600 {
1601 HDF_LOGD("%{public}s enter", __func__);
1602 if (mem == nullptr) {
1603 HDF_LOGW("%{public}s:%{public}d mem is null.", __func__, __LINE__);
1604 return;
1605 }
1606 free(mem);
1607 HDF_LOGD("%{public}s leave", __func__);
1608 mem = nullptr;
1609 }
1610
GetConfigDescriptor(libusb_device * dev,uint8_t descId,std::vector<uint8_t> & descriptor)1611 int32_t LibusbAdapter::GetConfigDescriptor(libusb_device *dev, uint8_t descId, std::vector<uint8_t> &descriptor)
1612 {
1613 HDF_LOGI("%{public}s enter", __func__);
1614 if (dev == nullptr) {
1615 HDF_LOGE("%{public}s: Dev is null", __func__);
1616 return HDF_FAILURE;
1617 }
1618 struct libusb_config_descriptor* config = FindConfigDescriptorById(dev, descId);
1619 if (config == nullptr) {
1620 HDF_LOGE("%{public}s: Config descriptor not found for descId: %{public}d", __func__, descId);
1621 return HDF_FAILURE;
1622 }
1623 size_t currentOffset = descriptor.size();
1624 descriptor.resize(descriptor.size() + config->bLength);
1625 int32_t ret = memcpy_s(descriptor.data() + currentOffset, descriptor.size(), config, config->bLength);
1626 if (ret != EOK) {
1627 HDF_LOGE("%{public}s: memcpy_s failed", __func__);
1628 libusb_free_config_descriptor(config);
1629 return HDF_FAILURE;
1630 }
1631 currentOffset += config->bLength;
1632 ProcessExtraData(descriptor, currentOffset, config->extra, config->extra_length);
1633 const libusb_interface *interfaces = config->interface;
1634 if (config->bNumInterfaces > 0 && interfaces != nullptr) {
1635 for (int j = 0; j < config->bNumInterfaces; ++j) {
1636 const libusb_interface &iface = interfaces[j];
1637 if (ProcessInterfaceDescriptors(&iface, descriptor, currentOffset) != HDF_SUCCESS) {
1638 HDF_LOGE("%{public}s: Interface descriptors find error", __func__);
1639 libusb_free_config_descriptor(config);
1640 return HDF_FAILURE;
1641 }
1642 }
1643 }
1644 libusb_free_config_descriptor(config);
1645 HDF_LOGI("%{public}s leave", __func__);
1646 return HDF_SUCCESS;
1647 }
1648
FindConfigDescriptorById(libusb_device * dev,uint8_t descId)1649 struct libusb_config_descriptor* LibusbAdapter::FindConfigDescriptorById(libusb_device *dev, uint8_t descId)
1650 {
1651 HDF_LOGD("%{public}s enter", __func__);
1652 if (dev == nullptr) {
1653 HDF_LOGE("%{public}s: dev is null.", __func__);
1654 return nullptr;
1655 }
1656 struct libusb_device_descriptor deviceDescriptor;
1657 int ret = libusb_get_device_descriptor(dev, &deviceDescriptor);
1658 if (ret != LIBUSB_SUCCESS) {
1659 HDF_LOGE("%{public}s:libusb_get_device_descriptor failed. ret:%{public}d", __func__, ret);
1660 return nullptr;
1661 }
1662 uint8_t numConfig = deviceDescriptor.bNumConfigurations;
1663 if ((deviceDescriptor.bNumConfigurations >= 1) && (descId == 0)) {
1664 struct libusb_config_descriptor* configDescriptor = nullptr;
1665 ret = libusb_get_config_descriptor(dev, 0, &configDescriptor);
1666 if (ret != LIBUSB_SUCCESS) {
1667 HDF_LOGE("%{public}s: libusb_get_config_descriptor failed. ret:%{public}d", __func__, ret);
1668 return nullptr;
1669 }
1670 return configDescriptor;
1671 }
1672 for (uint8_t i = 0; i < numConfig; ++i) {
1673 struct libusb_config_descriptor* config = nullptr;
1674 ret = libusb_get_config_descriptor(dev, i, &config);
1675 if (ret != LIBUSB_SUCCESS) {
1676 HDF_LOGE("%{public}s: libusb_get_config_descriptor failed for i:%{public}d. ret:%{public}d",
1677 __func__, i, ret);
1678 return nullptr;
1679 }
1680 if (config->bConfigurationValue == descId) {
1681 return config;
1682 }
1683 libusb_free_config_descriptor(config);
1684 }
1685 HDF_LOGD("%{public}s: leave, No matching configuration descriptor found for descId: %{public}d", __func__, descId);
1686 return nullptr;
1687 }
1688
ProcessInterfaceDescriptors(const libusb_interface * iface,std::vector<uint8_t> & descriptor,size_t & currentOffset)1689 int32_t LibusbAdapter::ProcessInterfaceDescriptors(const libusb_interface *iface, std::vector<uint8_t> &descriptor,
1690 size_t ¤tOffset)
1691 {
1692 HDF_LOGD("%{public}s enter", __func__);
1693 if (iface == nullptr) {
1694 HDF_LOGE("%{public}s: iface is nullptr", __func__);
1695 return HDF_ERR_INVALID_PARAM;
1696 }
1697
1698 for (int32_t i = 0; i < iface->num_altsetting; ++i) {
1699 const libusb_interface_descriptor &altSetting = iface->altsetting[i];
1700 descriptor.resize(descriptor.size() + altSetting.bLength);
1701 int32_t ret = memcpy_s(descriptor.data() + currentOffset, descriptor.size(), &altSetting, altSetting.bLength);
1702 if (ret != EOK) {
1703 HDF_LOGE("%{public}s: memcpy_s failed", __func__);
1704 return HDF_FAILURE;
1705 }
1706 currentOffset += altSetting.bLength;
1707 ProcessExtraData(descriptor, currentOffset, altSetting.extra, altSetting.extra_length);
1708 for (int32_t j = 0; j < altSetting.bNumEndpoints; ++j) {
1709 const libusb_endpoint_descriptor &endpoint = altSetting.endpoint[j];
1710 descriptor.resize(descriptor.size() + endpoint.bLength);
1711 ret = memcpy_s(descriptor.data() + currentOffset, descriptor.size(), &endpoint, endpoint.bLength);
1712 if (ret != EOK) {
1713 HDF_LOGE("%{public}s: memcpy_s failed", __func__);
1714 return HDF_FAILURE;
1715 }
1716 currentOffset += endpoint.bLength;
1717 ProcessExtraData(descriptor, currentOffset, endpoint.extra, endpoint.extra_length);
1718 }
1719 }
1720 HDF_LOGD("%{public}s leave", __func__);
1721 return HDF_SUCCESS;
1722 }
1723
ProcessExtraData(std::vector<uint8_t> & descriptor,size_t & currentOffset,const unsigned char * extra,int32_t extraLength)1724 void LibusbAdapter::ProcessExtraData(std::vector<uint8_t> &descriptor, size_t ¤tOffset,
1725 const unsigned char *extra, int32_t extraLength)
1726 {
1727 HDF_LOGD("%{public}s enter", __func__);
1728 if (extra != nullptr && extraLength > 0) {
1729 descriptor.resize(descriptor.size() + extraLength);
1730 int32_t ret = memcpy_s(descriptor.data() + currentOffset, descriptor.size(), extra, extraLength);
1731 if (ret != EOK) {
1732 HDF_LOGE("%{public}s: memcpy_s failed", __func__);
1733 return;
1734 }
1735 currentOffset += static_cast<size_t>(extraLength);
1736 }
1737 HDF_LOGD("%{public}s leave", __func__);
1738 }
1739
DoSyncPipeTranfer(libusb_device_handle * devHandle,unsigned char endpoint,unsigned char * buffer,SyncTranfer & syncTranfer)1740 int32_t LibusbAdapter::DoSyncPipeTranfer(libusb_device_handle *devHandle, unsigned char endpoint,
1741 unsigned char *buffer, SyncTranfer &syncTranfer)
1742 {
1743 HDF_LOGD("%{public}s enter", __func__);
1744 int32_t ret = HDF_FAILURE;
1745 uint32_t endpointAttributes = endpoint & LIBUSB_TRANSFER_TYPE_INTERRUPT;
1746 if (endpointAttributes == LIBUSB_TRANSFER_TYPE_INTERRUPT) {
1747 HDF_LOGD("%{public}s: DoSyncPipeTranfer call libusb_interrupt_transfer", __func__);
1748 ret = libusb_interrupt_transfer(devHandle, endpoint, buffer, syncTranfer.length,
1749 syncTranfer.transferred, syncTranfer.timeout);
1750 } else {
1751 HDF_LOGD("%{public}s: DoSyncPipeTranfer call libusb_bulk_transfer", __func__);
1752 ret = libusb_bulk_transfer(devHandle, endpoint, buffer,
1753 syncTranfer.length, syncTranfer.transferred, syncTranfer.timeout);
1754 }
1755
1756 if (ret < 0 && (*(syncTranfer.transferred)) <= 0) {
1757 HDF_LOGE("%{public}s: DoSyncPipeTranfer failed:%{public}d ret:%{public}d, error:%{public}s",
1758 __func__, *(syncTranfer.transferred), ret, libusb_strerror(ret));
1759 return HDF_FAILURE;
1760 }
1761 HDF_LOGD("%{public}s: leave DoSyncPipeTranfer success:%{public}d", __func__, *(syncTranfer.transferred));
1762 return ret;
1763 }
1764
GetDeviceMemMapFd(const UsbDev & dev,int & fd)1765 int32_t LibusbAdapter::GetDeviceMemMapFd(const UsbDev &dev, int &fd)
1766 {
1767 HDF_LOGD("%{public}s enter", __func__);
1768 uint32_t result = (static_cast<uint32_t>(dev.busNum) << DISPLACEMENT_NUMBER) |
1769 static_cast<uint32_t>(dev.devAddr);
1770 {
1771 std::shared_lock<std::shared_mutex> lock(g_mapMutexUsbOpenFdMap);
1772 auto info = g_usbOpenFdMap.find(result);
1773 if (info != g_usbOpenFdMap.end()) {
1774 fd = info->second;
1775 HDF_LOGI("%{public}s open is already on, fd: %{public}d", __func__, info->second);
1776 return HDF_SUCCESS;
1777 }
1778 }
1779 char path[LIBUSB_PATH_LENGTH] = {'\0'};
1780 int32_t ret = sprintf_s(path, LIBUSB_PATH_LENGTH, "%s%03u_%03u", LIBUSB_DEVICE_MMAP_PATH, dev.busNum, dev.devAddr);
1781 if (ret < HDF_SUCCESS) {
1782 HDF_LOGE("%{public}s:%{public}d path error ret=%{public}d", __func__, __LINE__, ret);
1783 return HDF_FAILURE;
1784 }
1785
1786 ret = open(path, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
1787 if (ret < 0) {
1788 HDF_LOGE("%{public}s: open error: ret=%{public}d", __func__, ret);
1789 return HDF_FAILURE;
1790 }
1791 fd = ret;
1792 {
1793 std::unique_lock<std::shared_mutex> lock(g_mapMutexUsbOpenFdMap);
1794 g_usbOpenFdMap[result] = fd;
1795 }
1796 HDF_LOGD("%{public}s leave :%{public}d fd:%{public}d", __func__, __LINE__, fd);
1797 return HDF_SUCCESS;
1798 }
1799
CheckDeviceAndConfiguration(libusb_device_handle * handle)1800 bool LibusbAdapter::CheckDeviceAndConfiguration(libusb_device_handle *handle)
1801 {
1802 HDF_LOGD("%{public}s: enter", __func__);
1803 if (handle == nullptr) {
1804 HDF_LOGE("Device handle is null");
1805 return false;
1806 }
1807 std::shared_lock<std::shared_mutex> lock(g_mapMutexDeviceSettingsMap);
1808 auto it = g_deviceSettingsMap.find(handle);
1809 if (it == g_deviceSettingsMap.end()) {
1810 HDF_LOGE("No device handle found");
1811 return false;
1812 }
1813
1814 int32_t currentConfig = -1;
1815 int32_t ret = GetCurrentConfiguration(handle, currentConfig);
1816 if (ret != HDF_SUCCESS) {
1817 HDF_LOGE("%{public}s: GetCurrentConfiguration failed", __func__);
1818 return false;
1819 }
1820 if ((currentConfig < 0) || (currentConfig != it->second.configurationIndex)) {
1821 HDF_LOGE("Current configuration does not match");
1822 return false;
1823 }
1824 HDF_LOGD("%{public}s: leave ", __func__);
1825
1826 return true;
1827 }
1828
GetCurrentConfiguration(libusb_device_handle * handle,int32_t & currentConfig)1829 int32_t LibusbAdapter::GetCurrentConfiguration(libusb_device_handle *handle, int32_t ¤tConfig)
1830 {
1831 HDF_LOGD("%{public}s: enter", __func__);
1832 if (handle == nullptr) {
1833 HDF_LOGE("Device handle is null");
1834 return HDF_FAILURE;
1835 }
1836 int32_t ret = libusb_get_configuration(handle, ¤tConfig);
1837 if (ret < 0) {
1838 HDF_LOGE("Failed to get current configuration, ret=%{public}d", ret);
1839 return HDF_FAILURE;
1840 }
1841 HDF_LOGD("%{public}s: leave ", __func__);
1842 return HDF_SUCCESS;
1843 }
1844
RemoveInterfaceFromMap(const UsbDev & dev,libusb_device_handle * devHandle,uint8_t interfaceId)1845 int32_t LibusbAdapter::RemoveInterfaceFromMap(const UsbDev &dev, libusb_device_handle *devHandle, uint8_t interfaceId)
1846 {
1847 HDF_LOGD("%{public}s enter", __func__);
1848 std::shared_lock<std::shared_mutex> lock(g_mapMutexInterfaceIdMap);
1849 uint32_t result = (static_cast<uint32_t>(dev.busNum) << DISPLACEMENT_NUMBER) |
1850 static_cast<uint32_t>(dev.devAddr);
1851 auto deviceIt = g_InterfaceIdMap.find(result);
1852 if (deviceIt != g_InterfaceIdMap.end()) {
1853 int32_t currentConfig = -1;
1854 int32_t ret = GetCurrentConfiguration(devHandle, currentConfig);
1855 if (ret != HDF_SUCCESS) {
1856 HDF_LOGE("%{public}s: GetCurrentConfiguration failed", __func__);
1857 return HDF_FAILURE;
1858 }
1859 auto configIt = deviceIt->second.find(currentConfig);
1860 if (configIt != deviceIt->second.end()) {
1861 auto& interfaceIds = configIt->second;
1862 interfaceIds.erase(std::remove(interfaceIds.begin(), interfaceIds.end(),
1863 interfaceId), interfaceIds.end());
1864 HDF_LOGD("%{public}s erase interfaceId=%{public}u from, configIndex=%{public}u", __func__,
1865 interfaceId, currentConfig);
1866 if (interfaceIds.empty()) {
1867 deviceIt->second.erase(configIt);
1868 }
1869 if (deviceIt->second.empty()) {
1870 g_InterfaceIdMap.erase(deviceIt);
1871 }
1872 }
1873 }
1874 HDF_LOGD("%{public}s leave", __func__);
1875 return HDF_SUCCESS;
1876 }
1877
1878 /* Async Transfer */
1879
AsyncSubmitTransfer(const UsbDev & dev,const V1_2::USBTransferInfo & info,const sptr<V1_2::IUsbdTransferCallback> & cb,const sptr<Ashmem> & ashmem)1880 int32_t LibusbAdapter::AsyncSubmitTransfer(const UsbDev &dev, const V1_2::USBTransferInfo &info,
1881 const sptr<V1_2::IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
1882 {
1883 HDF_LOGI("%{public}s: params endpoint: 0x%{public}x, type: %{public}d, length: %{public}d, timeout: %{public}d",
1884 __func__, info.endpoint, info.type, info.length, info.timeOut);
1885 // 1.get device handle
1886 libusb_device_handle *devHandle = nullptr;
1887 StartTrace(HITRACE_TAG_USB, "FindHandleByDev");
1888 int32_t ret = FindHandleByDev(dev, &devHandle);
1889 FinishTrace(HITRACE_TAG_USB);
1890 if (ret < 0 || devHandle == nullptr) {
1891 HDF_LOGE("%{public}s: find libusb device handle failed, ret = %{public}d", __func__, ret);
1892 return LIBUSB_ERROR_NO_DEVICE;
1893 }
1894 // 2.get buffer
1895 unsigned char *buffer = AllocAsyncBuffer(info, ashmem);
1896 if (buffer == nullptr) {
1897 HDF_LOGE("%{public}s: alloc async buffer failed", __func__);
1898 return LIBUSB_ERROR_NO_MEM;
1899 }
1900 // 3.create LibusbAsyncTransfer
1901 LibusbAsyncTransfer *asyncTransfer = CreateAsyncTransfer(dev, info, ashmem, cb);
1902 if (asyncTransfer == nullptr) {
1903 HDF_LOGE("%{public}s: create libusb async transfer failed", __func__);
1904 OsalMemFree(buffer);
1905 buffer = nullptr;
1906 return LIBUSB_ERROR_NO_MEM;
1907 }
1908 // 4.fill and submit libusb transfer
1909 StartTrace(HITRACE_TAG_USB, "FillAndSubmitTransfer");
1910 ret = FillAndSubmitTransfer(asyncTransfer, devHandle, buffer, info);
1911 FinishTrace(HITRACE_TAG_USB);
1912 if (ret < 0) {
1913 HDF_LOGE("%{public}s: libusb submit transfer failed, ret: %{public}d", __func__, ret);
1914 OsalMemFree(buffer);
1915 buffer = nullptr;
1916 delete asyncTransfer;
1917 asyncTransfer = nullptr;
1918 return ret;
1919 }
1920 // 5.save transfer
1921 AddTransferToList(asyncTransfer);
1922 HDF_LOGI("%{public}s: handle async transfer success", __func__);
1923 return LIBUSB_SUCCESS;
1924 }
1925
AsyncCancelTransfer(const UsbDev & dev,const int32_t endpoint)1926 int32_t LibusbAdapter::AsyncCancelTransfer(const UsbDev &dev, const int32_t endpoint)
1927 {
1928 HITRACE_METER_NAME(HITRACE_TAG_USB, "LibusbAdapter::AsyncCancelTransfer");
1929 HDF_LOGI("%{public}s: cancel transfer start", __func__);
1930 int ret = HDF_FAILURE;
1931 std::lock_guard<std::mutex> managerLock(g_asyncManager.transferVecLock);
1932 auto asyncWrapper = GetAsyncWrapper(dev);
1933 if (!asyncWrapper) {
1934 HDF_LOGE("%{public}s: get async wrapper failed", __func__);
1935 return LIBUSB_ERROR_NO_DEVICE;
1936 }
1937 std::lock_guard guard(asyncWrapper->transferLock);
1938 if (asyncWrapper->transferList.empty()) {
1939 HDF_LOGE("%{public}s: transfer list is empty", __func__);
1940 return LIBUSB_ERROR_NOT_FOUND;
1941 }
1942 for (auto it = asyncWrapper->transferList.begin(); it != asyncWrapper->transferList.end();) {
1943 auto asyncTransfer = *it;
1944 if (asyncTransfer->transferRef == nullptr || asyncTransfer->transferRef->endpoint != endpoint) {
1945 ++it;
1946 continue;
1947 }
1948 ret = libusb_cancel_transfer(asyncTransfer->transferRef);
1949 if (ret == LIBUSB_ERROR_NOT_FOUND) {
1950 HDF_LOGE("%{public}s: the transfer is already complete, or already cancelled", __func__);
1951 return ret;
1952 }
1953 if (ret != LIBUSB_SUCCESS) {
1954 HDF_LOGE("%{public}s: libusb cancel transfer failed, error: %{public}d", __func__, ret);
1955 return ret;
1956 }
1957 it = asyncWrapper->transferList.erase(it);
1958 break;
1959 }
1960 HDF_LOGI("%{public}s: cancel transfer end", __func__);
1961 return ret;
1962 }
1963
LibusbEventHandling()1964 void LibusbAdapter::LibusbEventHandling()
1965 {
1966 HDF_LOGI("%{public}s: libusb event handling thread started.", __func__);
1967 while (isRunning) {
1968 if (g_libusb_context != nullptr) {
1969 int rc = libusb_handle_events_completed(g_libusb_context, nullptr);
1970 if (rc != LIBUSB_SUCCESS) {
1971 HDF_LOGE("%{public}s: libusb handle events failed: %{public}d", __func__, rc);
1972 }
1973 }
1974 }
1975 }
1976
FillAndSubmitTransfer(LibusbAsyncTransfer * asyncTransfer,libusb_device_handle * devHandle,unsigned char * buffer,const V1_2::USBTransferInfo & info)1977 int32_t LibusbAdapter::FillAndSubmitTransfer(LibusbAsyncTransfer *asyncTransfer, libusb_device_handle *devHandle,
1978 unsigned char *buffer, const V1_2::USBTransferInfo &info)
1979 {
1980 HDF_LOGI("%{public}s: endpoint: 0x%{public}x, timeout: %{public}d, numIsoPackets: %{public}d",
1981 __func__, info.endpoint, info.timeOut, info.numIsoPackets);
1982 if (info.type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
1983 libusb_fill_iso_transfer(asyncTransfer->transferRef, devHandle, info.endpoint, buffer, info.length,
1984 info.numIsoPackets, HandleAsyncResult, asyncTransfer, info.timeOut);
1985 if (info.numIsoPackets > 0) {
1986 uint32_t packetLength = info.length / info.numIsoPackets;
1987 uint32_t maxIsoPacketLength =
1988 static_cast<uint32_t>(libusb_get_max_iso_packet_size(libusb_get_device(devHandle), info.endpoint));
1989 packetLength = packetLength >= maxIsoPacketLength ? maxIsoPacketLength : packetLength;
1990 HDF_LOGI("%{public}s: iso pkg len: %{public}d, max iso pkg len: %{public}d",
1991 __func__, packetLength, maxIsoPacketLength);
1992 libusb_set_iso_packet_lengths(asyncTransfer->transferRef, packetLength);
1993 }
1994 } else {
1995 libusb_fill_bulk_transfer(asyncTransfer->transferRef, devHandle, info.endpoint, buffer, info.length,
1996 HandleAsyncResult, asyncTransfer, info.timeOut);
1997 asyncTransfer->transferRef->type = info.type;
1998 }
1999 HDF_LOGI("%{public}s: libusb submit transfer", __func__);
2000 int ret = libusb_submit_transfer(asyncTransfer->transferRef);
2001 if (ret < 0) {
2002 HDF_LOGE("%{public}s: libusb submit transfer failed, ret: %{public}d", __func__, ret);
2003 return ret;
2004 }
2005 return LIBUSB_SUCCESS;
2006 }
2007
HandleAsyncResult(struct libusb_transfer * transfer)2008 void LIBUSB_CALL LibusbAdapter::HandleAsyncResult(struct libusb_transfer *transfer)
2009 {
2010 HDF_LOGI("%{public}s: start handle async transfer result", __func__);
2011 if (transfer == nullptr || transfer->user_data == nullptr) {
2012 HDF_LOGE("%{public}s: async transfer or user_data is null", __func__);
2013 return;
2014 }
2015 HDF_LOGI("%{public}s: transfer status: %{public}d, actual length: %{public}d", __func__,
2016 transfer->status, transfer->actual_length);
2017 LibusbAsyncTransfer *asyncTransfer = reinterpret_cast<LibusbAsyncTransfer *>(transfer->user_data);
2018 // handle failed transfer
2019 if (transfer->status == LIBUSB_TRANSFER_CANCELLED) {
2020 HDF_LOGE("%{public}s: async transfer has been canceled", __func__);
2021 HandleAsyncFailure(transfer);
2022 return;
2023 }
2024 if (transfer->status != LIBUSB_TRANSFER_COMPLETED && transfer->actual_length <= 0) {
2025 HDF_LOGE("%{public}s: libusb async transfer failed", __func__);
2026 FeedbackToBase(transfer);
2027 HandleAsyncFailure(transfer);
2028 return;
2029 }
2030 // write data to ashmem when direction is in
2031 if ((transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN) {
2032 HDF_LOGI("%{public}s: write data to ashmem", __func__);
2033 if (transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
2034 transfer->actual_length = transfer->length;
2035 }
2036 int32_t ret = WriteAshmem(asyncTransfer->ashmemRef, transfer->actual_length, transfer->buffer);
2037 if (ret != HDF_SUCCESS) {
2038 HandleAsyncFailure(transfer);
2039 return;
2040 }
2041 }
2042 // call V1_2::IUsbdTransferCallback
2043 FeedbackToBase(transfer);
2044 // close resource
2045 if (transfer->buffer != nullptr) {
2046 OsalMemFree(transfer->buffer);
2047 transfer->buffer = nullptr;
2048 }
2049 DeleteTransferFromList(asyncTransfer);
2050 HDF_LOGI("%{public}s: handle async transfer result success", __func__);
2051 }
2052
FeedbackToBase(struct libusb_transfer * transfer)2053 void LibusbAdapter::FeedbackToBase(struct libusb_transfer *transfer)
2054 {
2055 HDF_LOGI("%{public}s: call feedback callback, actual length: %{public}d", __func__, transfer->actual_length);
2056 LibusbAsyncTransfer *asyncTransfer = reinterpret_cast<LibusbAsyncTransfer *>(transfer->user_data);
2057 sptr<V1_2::IUsbdTransferCallback> callback = asyncTransfer->cbRef;
2058 std::vector<V1_2::UsbIsoPacketDescriptor> isoPkgDescVec;
2059
2060 if (transfer->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
2061 ParseIsoPacketDesc(transfer, isoPkgDescVec);
2062 }
2063
2064 int32_t ret = 0;
2065 if ((transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN) {
2066 ret = callback->OnTransferReadCallback(transfer->status, transfer->actual_length, isoPkgDescVec,
2067 asyncTransfer->userData);
2068 } else {
2069 ret = callback->OnTransferWriteCallback(transfer->status, transfer->actual_length, isoPkgDescVec,
2070 asyncTransfer->userData);
2071 }
2072 if (ret != HDF_SUCCESS) {
2073 HDF_LOGE("%{public}s: feedback callback failed", __func__);
2074 return;
2075 }
2076 HDF_LOGI("%{public}s: call feedback callback success", __func__);
2077 }
2078
ParseIsoPacketDesc(libusb_transfer * transfer,std::vector<V1_2::UsbIsoPacketDescriptor> & isoPkgDescs)2079 void LibusbAdapter::ParseIsoPacketDesc(libusb_transfer *transfer,
2080 std::vector<V1_2::UsbIsoPacketDescriptor> &isoPkgDescs)
2081 {
2082 HDF_LOGI("%{public}s: start parse iso package desc", __func__);
2083 for (int i = 0; i < transfer->num_iso_packets; ++i) {
2084 struct libusb_iso_packet_descriptor *pack = &transfer->iso_packet_desc[i];
2085 HDF_LOGI("%{public}s: iso pack %{public}d, status: %{public}d, length:%{public}u, actual length:%{public}u",
2086 __func__, i, pack->status, pack->length, pack->actual_length);
2087
2088 V1_2::UsbIsoPacketDescriptor desc;
2089 desc.isoLength = static_cast<int32_t>(pack->length);
2090 desc.isoActualLength = static_cast<int32_t>(pack->actual_length);
2091 desc.isoStatus = pack->status;
2092 isoPkgDescs.push_back(desc);
2093 }
2094 }
2095
CreateAsyncTransfer(const UsbDev & dev,const V1_2::USBTransferInfo & info,const sptr<Ashmem> & ashmem,const sptr<V1_2::IUsbdTransferCallback> & cb)2096 LibusbAsyncTransfer *LibusbAdapter::CreateAsyncTransfer(const UsbDev &dev, const V1_2::USBTransferInfo &info,
2097 const sptr<Ashmem> &ashmem, const sptr<V1_2::IUsbdTransferCallback> &cb)
2098 {
2099 uint32_t pkgNum = 0;
2100 if (info.type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
2101 pkgNum = info.numIsoPackets > 0 ? info.numIsoPackets : MIN_NUM_OF_ISO_PACKAGE;
2102 }
2103 LibusbAsyncTransfer *asyncTransfer = new(std::nothrow) LibusbAsyncTransfer(pkgNum);
2104 if (asyncTransfer == nullptr) {
2105 return nullptr;
2106 }
2107 asyncTransfer->ashmemRef = ashmem;
2108 asyncTransfer->cbRef = cb;
2109 asyncTransfer->busNum = dev.busNum;
2110 asyncTransfer->devAddr = dev.devAddr;
2111 asyncTransfer->userData = info.userData;
2112 return asyncTransfer;
2113 }
2114
HandleAsyncFailure(struct libusb_transfer * transfer)2115 void LibusbAdapter::HandleAsyncFailure(struct libusb_transfer *transfer)
2116 {
2117 if (transfer == nullptr) {
2118 return;
2119 }
2120 if (transfer->buffer != nullptr) {
2121 OsalMemFree(transfer->buffer);
2122 transfer->buffer = nullptr;
2123 }
2124 libusb_cancel_transfer(transfer);
2125 if (transfer->user_data != nullptr) {
2126 LibusbAsyncTransfer *asyncTransfer = reinterpret_cast<LibusbAsyncTransfer *>(transfer->user_data);
2127 DeleteTransferFromList(asyncTransfer);
2128 }
2129 }
2130
DeleteTransferFromList(LibusbAsyncTransfer * asyncTransfer)2131 void LibusbAdapter::DeleteTransferFromList(LibusbAsyncTransfer *asyncTransfer)
2132 {
2133 if (asyncTransfer == nullptr) {
2134 return;
2135 }
2136 HDF_LOGI("%{public}s: enter delete transfer from list, bus num: %{public}d, dev addr: %{public}d",
2137 __func__, asyncTransfer->busNum, asyncTransfer->devAddr);
2138
2139 std::lock_guard<std::mutex> managerLock(g_asyncManager.transferVecLock);
2140 LibusbAsyncWrapper *asyncWrapper = GetAsyncWrapper({asyncTransfer->busNum, asyncTransfer->devAddr});
2141 if (asyncWrapper == nullptr) {
2142 HDF_LOGE("%{public}s: get async wrapper failed", __func__);
2143 return;
2144 }
2145
2146 std::lock_guard<std::mutex> lock(asyncWrapper->transferLock);
2147 if (asyncWrapper->transferList.size() <= 0) {
2148 HDF_LOGI("%{public}s: transfer list is empty", __func__);
2149 return;
2150 }
2151 if (asyncTransfer != nullptr) {
2152 asyncWrapper->transferList.remove(asyncTransfer);
2153 delete asyncTransfer;
2154 asyncTransfer = nullptr;
2155 }
2156 HDF_LOGI("%{public}s: delete transfer from list end", __func__);
2157 }
2158
GetAsyncWrapper(const UsbDev & dev)2159 LibusbAsyncWrapper *LibusbAdapter::GetAsyncWrapper(const UsbDev &dev)
2160 {
2161 LibusbAsyncWrapper *asyncWrapper = nullptr;
2162
2163 for (size_t i = 0; i < g_asyncManager.transferVec.size(); ++i) {
2164 if (g_asyncManager.transferVec[i].first.busNum == dev.busNum
2165 && g_asyncManager.transferVec[i].first.devAddr == dev.devAddr) {
2166 asyncWrapper = g_asyncManager.transferVec[i].second;
2167 }
2168 }
2169
2170 return asyncWrapper;
2171 }
2172
AllocAsyncBuffer(const V1_2::USBTransferInfo & info,const sptr<Ashmem> & ashmem)2173 uint8_t *LibusbAdapter::AllocAsyncBuffer(const V1_2::USBTransferInfo &info, const sptr<Ashmem> &ashmem)
2174 {
2175 if (info.length <= 0) {
2176 HDF_LOGE("%{public}s: invalid buffer length", __func__);
2177 return nullptr;
2178 }
2179 HDF_LOGI("%{public}s: malloc buffer", __func__);
2180 uint8_t *buffer = static_cast<uint8_t *>(OsalMemCalloc(info.length));
2181 if (buffer == nullptr) {
2182 HDF_LOGE("%{public}s: malloc buffer failed", __func__);
2183 return nullptr;
2184 }
2185 uint32_t endpointId = static_cast<uint32_t>(info.endpoint) & LIBUSB_ENDPOINT_DIR_MASK;
2186 if (endpointId == LIBUSB_ENDPOINT_OUT) {
2187 HDF_LOGI("%{public}s: read from ashmem", __func__);
2188 int32_t ret = ReadAshmem(ashmem, info.length, buffer);
2189 if (ret != HDF_SUCCESS) {
2190 OsalMemFree(buffer);
2191 return nullptr;
2192 }
2193 }
2194 return buffer;
2195 }
2196
AddTransferToList(LibusbAsyncTransfer * asyncTransfer)2197 void LibusbAdapter::AddTransferToList(LibusbAsyncTransfer *asyncTransfer)
2198 {
2199 HDF_LOGI("%{public}s: start add transfer to list", __func__);
2200 if (asyncTransfer == nullptr || asyncTransfer->transferRef == nullptr) {
2201 HDF_LOGW("%{public}s: async transfer or libusb transfer is nullptr", __func__);
2202 return;
2203 }
2204 std::lock_guard<std::mutex> managerLock(g_asyncManager.transferVecLock);
2205 LibusbAsyncWrapper *asyncWrapper = GetAsyncWrapper({asyncTransfer->busNum, asyncTransfer->devAddr});
2206 if (asyncWrapper == nullptr) {
2207 HDF_LOGE("%{public}s: get async wrapper failed", __func__);
2208 return;
2209 }
2210
2211 HDF_LOGI("%{public}s: push async transfer", __func__);
2212 std::lock_guard<std::mutex> lock(asyncWrapper->transferLock);
2213 asyncWrapper->transferList.push_back(asyncTransfer);
2214 }
2215
TransferInit(const UsbDev & dev)2216 void LibusbAdapter::TransferInit(const UsbDev &dev)
2217 {
2218 // init LibusbAsyncManager
2219 HDF_LOGI("%{public}s: start init libusb async manager", __func__);
2220 LibusbAsyncWrapper *asyncWrapper = new(std::nothrow) LibusbAsyncWrapper();
2221 if (asyncWrapper == nullptr) {
2222 HDF_LOGE("%{public}s:create libusb async manager failed", __func__);
2223 return;
2224 }
2225 std::pair<UsbDev, LibusbAsyncWrapper*> asyncWrapperPair = std::make_pair(dev, asyncWrapper);
2226 std::lock_guard<std::mutex> lock(g_asyncManager.transferVecLock);
2227 g_asyncManager.transferVec.push_back(asyncWrapperPair);
2228 }
2229
TransferRelease(const UsbDev & dev)2230 void LibusbAdapter::TransferRelease(const UsbDev &dev)
2231 {
2232 // release LibusbAsyncManager
2233 std::lock_guard<std::mutex> lock(g_asyncManager.transferVecLock);
2234 DeleteAsyncDevRequest(dev);
2235 }
2236
DeleteAsyncDevRequest(const UsbDev & dev)2237 void LibusbAdapter::DeleteAsyncDevRequest(const UsbDev &dev)
2238 {
2239 int32_t deleteId = -1;
2240 int32_t number = static_cast<int32_t>(g_asyncManager.transferVec.size());
2241 for (int32_t i = 0; i < number; ++i) {
2242 if (g_asyncManager.transferVec[i].first.busNum == dev.busNum
2243 && g_asyncManager.transferVec[i].first.devAddr == dev.devAddr) {
2244 HDF_LOGI("%{public}s: delete async dev request device found", __func__);
2245 if (g_asyncManager.transferVec[i].second != nullptr) {
2246 ClearAsyncTranfer(g_asyncManager.transferVec[i].second);
2247 }
2248 deleteId = i;
2249 break;
2250 }
2251 }
2252 if (deleteId >= 0 && deleteId < static_cast<int32_t>(g_asyncManager.transferVec.size())) {
2253 g_asyncManager.transferVec.erase(g_asyncManager.transferVec.begin() + deleteId);
2254 }
2255 }
2256
ClearAsyncTranfer(LibusbAsyncWrapper * asyncWrapper)2257 void LibusbAdapter::ClearAsyncTranfer(LibusbAsyncWrapper *asyncWrapper)
2258 {
2259 HDF_LOGI("%{public}s: clear async tranfer enter", __func__);
2260 if (asyncWrapper == nullptr) {
2261 return;
2262 }
2263 if (asyncWrapper->transferList.size() <= 0) {
2264 HDF_LOGI("%{public}s: clear async tranfer transfer list is empty", __func__);
2265 return;
2266 }
2267
2268 for (auto &asyncTransfer : asyncWrapper->transferList) {
2269 if (asyncTransfer == nullptr) {
2270 continue;
2271 }
2272 if (asyncTransfer->transferRef != nullptr) {
2273 HDF_LOGI("%{public}s: clear async tranfer libusb free transfer", __func__);
2274 libusb_free_transfer(asyncTransfer->transferRef);
2275 asyncTransfer->transferRef = nullptr;
2276 }
2277 delete asyncTransfer;
2278 asyncTransfer = nullptr;
2279 }
2280 delete asyncWrapper;
2281 asyncWrapper = nullptr;
2282 }
2283
ReadAshmem(const sptr<Ashmem> & ashmem,int32_t length,uint8_t * buffer)2284 int32_t LibusbAdapter::ReadAshmem(const sptr<Ashmem> &ashmem, int32_t length, uint8_t *buffer)
2285 {
2286 if (!ashmem->MapReadAndWriteAshmem()) {
2287 HDF_LOGE("%{public}s: map read and write ashmem failed", __func__);
2288 return HDF_FAILURE;
2289 }
2290 const void *content = ashmem->ReadFromAshmem(length, 0);
2291 if (content == nullptr) {
2292 HDF_LOGE("%{public}s: read from ashmem failed", __func__);
2293 ashmem->UnmapAshmem();
2294 return HDF_FAILURE;
2295 }
2296 if (memcpy_s(buffer, length, content, length) != EOK) {
2297 HDF_LOGE("%{public}s: memcpy_s failed", __func__);
2298 ashmem->UnmapAshmem();
2299 return HDF_FAILURE;
2300 }
2301 ashmem->UnmapAshmem();
2302 return HDF_SUCCESS;
2303 }
2304
WriteAshmem(const sptr<Ashmem> & ashmem,int32_t length,uint8_t * buffer)2305 int32_t LibusbAdapter::WriteAshmem(const sptr<Ashmem> &ashmem, int32_t length, uint8_t *buffer)
2306 {
2307 if (!ashmem->MapReadAndWriteAshmem()) {
2308 HDF_LOGE("%{public}s: map read and write ashmem failed", __func__);
2309 return HDF_FAILURE;
2310 }
2311 HDF_LOGI("%{public}s: libusb async read actual_length: %{public}d", __func__, length);
2312 bool ret = ashmem->WriteToAshmem(buffer, length, 0);
2313 if (!ret) {
2314 HDF_LOGE("%{public}s: write to ashmem failed", __func__);
2315 ashmem->UnmapAshmem();
2316 return HDF_FAILURE;
2317 }
2318 ashmem->UnmapAshmem();
2319 return HDF_SUCCESS;
2320 }
2321
GetDevices(std::vector<struct DeviceInfo> & devices)2322 int32_t LibusbAdapter::GetDevices(std::vector<struct DeviceInfo> &devices)
2323 {
2324 HDF_LOGD("%{public}s: enter", __func__);
2325 if (g_libusb_context == nullptr) {
2326 HDF_LOGE("%{public}s: g_libusb_context is nullptr", __func__);
2327 return HDF_FAILURE;
2328 }
2329 libusb_device **devs = nullptr;
2330 ssize_t count = libusb_get_device_list(g_libusb_context, &devs);
2331 HDF_LOGI("%{public}s: libusb_get_device_list return count: %{public}zu", __func__, count);
2332 for (ssize_t i = 0; i < count; ++i) {
2333 libusb_device *device = devs[i];
2334 struct libusb_device_descriptor desc;
2335 if (libusb_get_device_descriptor(device, &desc) != HDF_SUCCESS) {
2336 HDF_LOGE("%{public}s: libusb_get_device_descriptor failed", __func__);
2337 continue;
2338 }
2339 uint64_t deviceId = ToDdkDeviceId(libusb_get_bus_number(device), libusb_get_device_address(device));
2340 devices.emplace_back(DeviceInfo{deviceId, desc.idVendor});
2341 }
2342 libusb_free_device_list(devs, 1);
2343 return HDF_SUCCESS;
2344 }
2345
AllocBulkBuffer(const UsbPipe & pipe,const int32_t & length,const sptr<Ashmem> & ashmem)2346 uint8_t *LibusbAdapter::AllocBulkBuffer(const UsbPipe &pipe, const int32_t &length, const sptr<Ashmem> &ashmem)
2347 {
2348 HDF_LOGI("%{public}s: enter", __func__);
2349 if (length <= 0) {
2350 HDF_LOGE("%{public}s: invalid buffer length", __func__);
2351 return nullptr;
2352 }
2353
2354 uint8_t *buffer = static_cast<uint8_t *>(OsalMemCalloc(length));
2355 if (buffer == nullptr) {
2356 HDF_LOGE("%{public}s: malloc buffer failed", __func__);
2357 return nullptr;
2358 }
2359 if ((pipe.endpointId & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_OUT) {
2360 HDF_LOGI("%{public}s: read from ashmem", __func__);
2361 int32_t ret = ReadAshmem(ashmem, length, buffer);
2362 if (ret != HDF_SUCCESS) {
2363 OsalMemFree(buffer);
2364 return nullptr;
2365 }
2366 }
2367 return buffer;
2368 }
2369
DeleteBulkTransferFromList(LibusbBulkTransfer * bulkTransfer)2370 void LibusbAdapter::DeleteBulkTransferFromList(LibusbBulkTransfer *bulkTransfer)
2371 {
2372 HDF_LOGI("%{public}s: enter", __func__);
2373 if (bulkTransfer == nullptr) {
2374 HDF_LOGE("%{public}s: bulkTransfer is nullptr", __func__);
2375 return;
2376 }
2377 HDF_LOGI("%{public}s: enter delete transfer, bus num: %{public}d, dev addr: %{public}d", __func__,
2378 bulkTransfer->busNum, bulkTransfer->devAddr);
2379
2380 LibusbBulkWrapper *bulkWrapper = GetBulkWrapper({bulkTransfer->busNum, bulkTransfer->devAddr});
2381 if (bulkWrapper == nullptr) {
2382 HDF_LOGE("%{public}s: bulkWrapper is nullptr", __func__);
2383 return;
2384 }
2385
2386 std::lock_guard<std::mutex> lock(bulkWrapper->bulkTransferLock);
2387 if (bulkWrapper->bulkTransferList.size() <= 0) {
2388 HDF_LOGE("%{public}s: transfer list is empty", __func__);
2389 return;
2390 }
2391 if (bulkTransfer != nullptr) {
2392 bulkWrapper->bulkTransferList.remove(bulkTransfer);
2393 }
2394 HDF_LOGI("%{public}s: delete transfer from list end", __func__);
2395 }
2396
GetBulkWrapper(const UsbDev & dev)2397 LibusbBulkWrapper *LibusbAdapter::GetBulkWrapper(const UsbDev &dev)
2398 {
2399 HDF_LOGI("%{public}s: enter", __func__);
2400 std::lock_guard<std::mutex> lock(g_bulkManager.bulkTransferVecLock);
2401 LibusbBulkWrapper *bulkWrapper = nullptr;
2402
2403 for (size_t i = 0; i < g_bulkManager.bulktransferVec.size(); ++i) {
2404 if (g_bulkManager.bulktransferVec[i].first.busNum == dev.busNum
2405 && g_bulkManager.bulktransferVec[i].first.devAddr == dev.devAddr) {
2406 bulkWrapper = g_bulkManager.bulktransferVec[i].second;
2407 }
2408 }
2409
2410 return bulkWrapper;
2411 }
2412
HandleBulkFail(struct libusb_transfer * transfer)2413 void LibusbAdapter::HandleBulkFail(struct libusb_transfer *transfer)
2414 {
2415 HDF_LOGI("%{public}s: enter", __func__);
2416 if (transfer == nullptr) {
2417 HDF_LOGE("%{public}s: transfer is nullptr", __func__);
2418 return;
2419 }
2420 if (transfer->buffer != nullptr) {
2421 OsalMemFree(transfer->buffer);
2422 transfer->buffer = nullptr;
2423 }
2424 libusb_cancel_transfer(transfer);
2425 if (transfer->user_data != nullptr) {
2426 LibusbBulkTransfer *bulkTransfer = reinterpret_cast<LibusbBulkTransfer *>(transfer->user_data);
2427 DeleteBulkTransferFromList(bulkTransfer);
2428 if (bulkTransfer != nullptr) {
2429 delete bulkTransfer;
2430 bulkTransfer = nullptr;
2431 }
2432 }
2433 }
2434
BulkFeedbackToBase(struct libusb_transfer * transfer)2435 void LibusbAdapter::BulkFeedbackToBase(struct libusb_transfer *transfer)
2436 {
2437 HDF_LOGI("%{public}s: enter, actual_length=%{public}d", __func__, transfer->actual_length);
2438 LibusbBulkTransfer *bulkTransfer = reinterpret_cast<LibusbBulkTransfer *>(transfer->user_data);
2439 sptr<V2_0::IUsbdBulkCallback> callback = bulkTransfer->bulkCbRef;
2440
2441 int32_t ret = 0;
2442 if ((transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN) {
2443 ret = callback->OnBulkReadCallback(transfer->status, transfer->actual_length);
2444 } else {
2445 ret = callback->OnBulkWriteCallback(transfer->status, transfer->actual_length);
2446 }
2447 if (ret != HDF_SUCCESS) {
2448 HDF_LOGE("%{public}s: feedback callback failed", __func__);
2449 return;
2450 }
2451 bulkTransfer->isTransferring = false;
2452 HDF_LOGI("%{public}s: call feedback callback success", __func__);
2453 }
2454
HandleBulkResult(struct libusb_transfer * transfer)2455 void LIBUSB_CALL LibusbAdapter::HandleBulkResult(struct libusb_transfer *transfer)
2456 {
2457 HDF_LOGI("%{public}s: enter", __func__);
2458 if (transfer == nullptr || transfer->user_data == nullptr) {
2459 HDF_LOGE("%{public}s: bulk transfer or user_data is null", __func__);
2460 return;
2461 }
2462 HDF_LOGI("%{public}s: transfer status: %{public}d, actual length: %{public}d", __func__,
2463 transfer->status, transfer->actual_length);
2464 LibusbBulkTransfer *bulkTransfer = reinterpret_cast<LibusbBulkTransfer *>(transfer->user_data);
2465
2466 if (transfer->status == LIBUSB_TRANSFER_CANCELLED) {
2467 HDF_LOGE("%{public}s: bulk transfer has been canceled", __func__);
2468 return;
2469 }
2470 if (transfer->status != LIBUSB_TRANSFER_COMPLETED && transfer->actual_length <= 0) {
2471 HDF_LOGE("%{public}s: libusb bulk transfer failed", __func__);
2472 BulkFeedbackToBase(transfer);
2473 HandleBulkFail(transfer);
2474 return;
2475 }
2476
2477 if ((transfer->endpoint & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN) {
2478 HDF_LOGI("%{public}s: write data to ashmem", __func__);
2479 int32_t ret = WriteAshmem(bulkTransfer->buikAshmemRef, transfer->actual_length, transfer->buffer);
2480 if (ret != HDF_SUCCESS) {
2481 HandleBulkFail(transfer);
2482 return;
2483 }
2484 }
2485
2486 BulkFeedbackToBase(transfer);
2487 HDF_LOGI("%{public}s: handle bulk transfer success", __func__);
2488 }
2489
BulkRead(const UsbDev & dev,const UsbPipe & pipe,const sptr<Ashmem> & ashmem)2490 int32_t LibusbAdapter::BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
2491 {
2492 HDF_LOGI("%{public}s: enter", __func__);
2493 if (pipe.endpointId < ENDPOINTID) {
2494 HDF_LOGE("%{public}s: endpointId is not expect", __func__);
2495 return HDF_FAILURE;
2496 }
2497
2498 libusb_device_handle *devHandle = nullptr;
2499 int32_t ret = FindHandleByDev(dev, &devHandle);
2500 if (devHandle == nullptr) {
2501 HDF_LOGE("%{public}s: find libusb device handle failed", __func__);
2502 return HDF_FAILURE;
2503 }
2504
2505 LibusbBulkTransfer *bulkTransfer = FindBulkTransfer(dev, pipe, ashmem);
2506 if (bulkTransfer == nullptr) {
2507 HDF_LOGE("%{public}s: create libusb bulk transfer failed", __func__);
2508 return HDF_FAILURE;
2509 }
2510 int32_t length = libusb_get_max_packet_size(libusb_get_device(devHandle), pipe.endpointId);
2511 unsigned char *buffer = AllocBulkBuffer(pipe, length, ashmem);
2512 if (buffer == nullptr) {
2513 HDF_LOGE("%{public}s: alloc bulk buffer failed", __func__);
2514 return HDF_FAILURE;
2515 }
2516
2517 libusb_fill_bulk_transfer(bulkTransfer->bulkTransferRef, devHandle, pipe.endpointId, buffer, length,
2518 HandleBulkResult, bulkTransfer, USB_CTRL_SET_TIMEOUT);
2519 HDF_LOGI("%{public}s: libusb submit transfer", __func__);
2520 ret = libusb_submit_transfer(bulkTransfer->bulkTransferRef);
2521 if (ret < 0) {
2522 HDF_LOGE("%{public}s: libusb submit transfer failed, ret: %{public}d", __func__, ret);
2523 return ret;
2524 }
2525 bulkTransfer->isTransferring = true;
2526 return HDF_SUCCESS;
2527 }
2528
BulkWrite(const UsbDev & dev,const UsbPipe & pipe,const sptr<Ashmem> & ashmem)2529 int32_t LibusbAdapter::BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
2530 {
2531 HDF_LOGI("%{public}s: enter", __func__);
2532 if (pipe.endpointId >= ENDPOINTID) {
2533 HDF_LOGE("%{public}s: endpointId is not expect", __func__);
2534 return HDF_FAILURE;
2535 }
2536 libusb_device_handle *devHandle = nullptr;
2537 int32_t ret = FindHandleByDev(dev, &devHandle);
2538 if (devHandle == nullptr) {
2539 HDF_LOGE("%{public}s: find handle failed", __func__);
2540 return HDF_FAILURE;
2541 }
2542
2543 LibusbBulkTransfer *bulkTransfer = FindBulkTransfer(dev, pipe, ashmem);
2544 if (bulkTransfer == nullptr) {
2545 HDF_LOGE("%{public}s: create libusb bulk transfer failed", __func__);
2546 return HDF_FAILURE;
2547 }
2548 int32_t length = libusb_get_max_packet_size(libusb_get_device(devHandle), pipe.endpointId);
2549 unsigned char *buffer = AllocBulkBuffer(pipe, length, ashmem);
2550 if (buffer == nullptr) {
2551 HDF_LOGE("%{public}s: alloc bulk buffer failed", __func__);
2552 return HDF_FAILURE;
2553 }
2554
2555 libusb_fill_bulk_transfer(bulkTransfer->bulkTransferRef, devHandle, pipe.endpointId, buffer, length,
2556 HandleBulkResult, bulkTransfer, USB_CTRL_SET_TIMEOUT);
2557 HDF_LOGI("%{public}s: libusb submit transfer", __func__);
2558 ret = libusb_submit_transfer(bulkTransfer->bulkTransferRef);
2559 if (ret < 0) {
2560 HDF_LOGE("%{public}s: libusb submit transfer failed, ret: %{public}d", __func__, ret);
2561 return ret;
2562 }
2563 bulkTransfer->isTransferring = true;
2564 return HDF_SUCCESS;
2565 }
2566
BulkCancel(const UsbDev & dev,const UsbPipe & pipe)2567 int32_t LibusbAdapter::BulkCancel(const UsbDev &dev, const UsbPipe &pipe)
2568 {
2569 HDF_LOGI("%{public}s: enter", __func__);
2570 std::lock_guard<std::mutex> lock(g_bulkManager.bulkTransferVecLock);
2571 auto it = std::find_if(
2572 g_bulkManager.bulktransferVec.begin(), g_bulkManager.bulktransferVec.end(),
2573 [&dev](const auto& pair) {
2574 return pair.first.busNum == dev.busNum && pair.first.devAddr == dev.devAddr;
2575 });
2576 if (it == g_bulkManager.bulktransferVec.end()) {
2577 HDF_LOGE("%{public}s: wrapper is nullptr, dev is not exist", __func__);
2578 return HDF_FAILURE;
2579 }
2580 LibusbBulkWrapper* wrapper = it->second;
2581 if (wrapper == nullptr) {
2582 HDF_LOGE("%{public}s: wrapper is nullptr", __func__);
2583 return HDF_FAILURE;
2584 }
2585 std::lock_guard<std::mutex> listLock(wrapper->bulkTransferLock);
2586 auto transferIt = std::find_if(
2587 wrapper->bulkTransferList.begin(), wrapper->bulkTransferList.end(),
2588 [&pipe](const auto& pair) {
2589 return pair->bulkTransferRef->endpoint == pipe.endpointId;
2590 });
2591 if (transferIt == wrapper->bulkTransferList.end()) {
2592 HDF_LOGE("%{public}s: transferCancle is nullptr", __func__);
2593 return HDF_FAILURE;
2594 }
2595 LibusbBulkTransfer* transferCancle = *transferIt;
2596 if (transferCancle == nullptr) {
2597 HDF_LOGE("%{public}s: transferCancle is nullptr", __func__);
2598 return HDF_FAILURE;
2599 }
2600 int32_t ret = libusb_cancel_transfer(transferCancle->bulkTransferRef);
2601 if (ret != LIBUSB_SUCCESS && ret != LIBUSB_ERROR_NOT_FOUND) {
2602 HDF_LOGE("%{public}s: libusb cancel transfer fail ret=%{public}d", __func__, ret);
2603 return HDF_FAILURE;
2604 }
2605 if (transferCancle->bulkTransferRef->buffer != nullptr) {
2606 OsalMemFree(transferCancle->bulkTransferRef->buffer);
2607 transferCancle->bulkTransferRef->buffer = nullptr;
2608 }
2609 wrapper->bulkTransferList.remove(transferCancle);
2610 delete transferCancle;
2611 transferCancle = nullptr;
2612 return HDF_SUCCESS;
2613 }
2614
BulkTransferInit(const UsbDev & dev)2615 void LibusbAdapter::BulkTransferInit(const UsbDev &dev)
2616 {
2617 HDF_LOGI("%{public}s: enter", __func__);
2618 LibusbBulkWrapper *bulkWrapper = new(std::nothrow) LibusbBulkWrapper();
2619 if (bulkWrapper == nullptr) {
2620 HDF_LOGE("%{public}s:bulkWrapper is nullptr", __func__);
2621 return;
2622 }
2623 std::pair<UsbDev, LibusbBulkWrapper*> bulkWrapperPair = std::make_pair(dev, bulkWrapper);
2624 std::lock_guard<std::mutex> lock(g_bulkManager.bulkTransferVecLock);
2625 g_bulkManager.bulktransferVec.push_back(bulkWrapperPair);
2626 }
2627
BulkTransferRelease(const UsbDev & dev)2628 void LibusbAdapter::BulkTransferRelease(const UsbDev &dev)
2629 {
2630 HDF_LOGI("%{public}s: enter", __func__);
2631 std::lock_guard<std::mutex> lock(g_bulkManager.bulkTransferVecLock);
2632 DeleteBulkDevRequest(dev);
2633 }
2634
DeleteBulkDevRequest(const UsbDev & dev)2635 void LibusbAdapter::DeleteBulkDevRequest(const UsbDev &dev)
2636 {
2637 HDF_LOGI("%{public}s: enter", __func__);
2638 int32_t deleteId = -1;
2639 int32_t number = static_cast<int32_t>(g_bulkManager.bulktransferVec.size());
2640 for (int32_t i = 0; i < number; ++i) {
2641 if (g_bulkManager.bulktransferVec[i].first.busNum == dev.busNum
2642 && g_bulkManager.bulktransferVec[i].first.devAddr == dev.devAddr) {
2643 HDF_LOGI("%{public}s: delete bulk dev request device found", __func__);
2644 if (g_bulkManager.bulktransferVec[i].second != nullptr) {
2645 ClearBulkTranfer(g_bulkManager.bulktransferVec[i].second);
2646 }
2647 deleteId = i;
2648 break;
2649 }
2650 }
2651 if (deleteId >= 0) {
2652 g_bulkManager.bulktransferVec.erase(g_bulkManager.bulktransferVec.begin() + deleteId);
2653 }
2654 }
2655
ClearBulkTranfer(LibusbBulkWrapper * bulkWrapper)2656 void LibusbAdapter::ClearBulkTranfer(LibusbBulkWrapper *bulkWrapper)
2657 {
2658 HDF_LOGI("%{public}s: enter", __func__);
2659 if (bulkWrapper == nullptr) {
2660 HDF_LOGE("%{public}s: bulkWrapper is nullptr", __func__);
2661 return;
2662 }
2663 if (bulkWrapper->bulkTransferList.size() <= 0) {
2664 HDF_LOGI("%{public}s: clear bulk tranfer transfer list is empty", __func__);
2665 return;
2666 }
2667
2668 for (auto &bulkTransfer : bulkWrapper->bulkTransferList) {
2669 if (bulkTransfer == nullptr) {
2670 continue;
2671 }
2672 if (bulkTransfer->bulkTransferRef != nullptr) {
2673 HDF_LOGI("%{public}s: clear bulk tranfer libusb free transfer", __func__);
2674 libusb_free_transfer(bulkTransfer->bulkTransferRef);
2675 bulkTransfer->bulkTransferRef = nullptr;
2676 }
2677 delete bulkTransfer;
2678 bulkTransfer = nullptr;
2679 }
2680 delete bulkWrapper;
2681 bulkWrapper = nullptr;
2682 }
2683
FindBulkTransfer(const UsbDev & dev,const UsbPipe & pipe,const sptr<Ashmem> & ashmem)2684 LibusbBulkTransfer *LibusbAdapter::FindBulkTransfer(const UsbDev &dev, const UsbPipe &pipe,
2685 const sptr<Ashmem> &ashmem)
2686 {
2687 HDF_LOGI("%{public}s: enter", __func__);
2688 std::lock_guard<std::mutex> lock(g_bulkManager.bulkTransferVecLock);
2689 auto it = std::find_if(
2690 g_bulkManager.bulktransferVec.begin(), g_bulkManager.bulktransferVec.end(),
2691 [&dev](const auto& pair) {
2692 return pair.first.busNum == dev.busNum && pair.first.devAddr == dev.devAddr;
2693 });
2694 if (it == g_bulkManager.bulktransferVec.end()) {
2695 HDF_LOGE("%{public}s: wrapper is nullptr", __func__);
2696 return nullptr;
2697 }
2698 LibusbBulkWrapper* wrapper = it->second;
2699 if (wrapper == nullptr) {
2700 HDF_LOGE("%{public}s: wrapper is nullptr", __func__);
2701 return nullptr;
2702 }
2703 std::lock_guard<std::mutex> listLock(wrapper->bulkTransferLock);
2704
2705 auto bulkPair = std::find_if(
2706 wrapper->bulkTransferList.begin(), wrapper->bulkTransferList.end(),
2707 [&pipe](const auto& pair) {
2708 return pair->bulkTransferRef->endpoint == pipe.endpointId;
2709 });
2710 if (bulkPair != wrapper->bulkTransferList.end()) {
2711 LibusbBulkTransfer* transferCancle = *bulkPair;
2712 transferCancle->buikAshmemRef = ashmem;
2713 return transferCancle;
2714 }
2715 HDF_LOGI("%{public}s:not find BulkTransfer", __func__);
2716 return nullptr;
2717 }
2718
RegBulkCallback(const UsbDev & dev,const UsbPipe & pipe,const sptr<V2_0::IUsbdBulkCallback> & cb)2719 int32_t LibusbAdapter::RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<V2_0::IUsbdBulkCallback> &cb)
2720 {
2721 HDF_LOGI("%{public}s: enter", __func__);
2722 if (cb == nullptr) {
2723 HDF_LOGE("%{public}s: cb is nullptr", __func__);
2724 return HDF_FAILURE;
2725 }
2726 LibusbBulkTransfer *bulkTransfer = new(std::nothrow) LibusbBulkTransfer();
2727 if (bulkTransfer == nullptr) {
2728 HDF_LOGE("%{public}s: bulkTransfer is nullptr", __func__);
2729 return HDF_FAILURE;
2730 }
2731 std::lock_guard<std::mutex> lock(g_bulkManager.bulkTransferVecLock);
2732 auto it = std::find_if(
2733 g_bulkManager.bulktransferVec.begin(), g_bulkManager.bulktransferVec.end(),
2734 [&dev](const auto& pair) {
2735 return pair.first.busNum == dev.busNum && pair.first.devAddr == dev.devAddr;
2736 });
2737 if (it == g_bulkManager.bulktransferVec.end()) {
2738 HDF_LOGE("%{public}s: Wrapper not found, device does not exist", __func__);
2739 return HDF_FAILURE;
2740 }
2741 LibusbBulkWrapper* wrapper = it->second;
2742 if (wrapper == nullptr) {
2743 HDF_LOGE("%{public}s: Wrapper is nullptr", __func__);
2744 return HDF_FAILURE;
2745 }
2746 bulkTransfer->busNum = dev.busNum;
2747 bulkTransfer->devAddr = dev.devAddr;
2748 bulkTransfer->bulkCbRef = cb;
2749 bulkTransfer->bulkTransferRef->endpoint = pipe.endpointId;
2750 std::lock_guard<std::mutex> listLock(wrapper->bulkTransferLock);
2751 wrapper->bulkTransferList.push_back(bulkTransfer);
2752 return HDF_SUCCESS;
2753 }
2754
UnRegBulkCallback(const UsbDev & dev,const UsbPipe & pipe)2755 int32_t LibusbAdapter::UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
2756 {
2757 HDF_LOGI("%{public}s: enter", __func__);
2758 std::lock_guard<std::mutex> lock(g_bulkManager.bulkTransferVecLock);
2759 auto it = std::find_if(
2760 g_bulkManager.bulktransferVec.begin(), g_bulkManager.bulktransferVec.end(),
2761 [&dev](const auto& pair) {
2762 return pair.first.busNum == dev.busNum && pair.first.devAddr == dev.devAddr;
2763 });
2764 if (it == g_bulkManager.bulktransferVec.end()) {
2765 HDF_LOGE("%{public}s: wrapper is nullptr, dev is not exist", __func__);
2766 return HDF_FAILURE;
2767 }
2768 LibusbBulkWrapper* wrapper = it->second;
2769 if (wrapper == nullptr) {
2770 HDF_LOGE("%{public}s: Wrapper is nullptr", __func__);
2771 return HDF_FAILURE;
2772 }
2773 std::lock_guard<std::mutex> listLock(wrapper->bulkTransferLock);
2774 auto transferIt = std::find_if(
2775 wrapper->bulkTransferList.begin(), wrapper->bulkTransferList.end(),
2776 [&pipe](const auto& pair) {
2777 return pair->bulkTransferRef->endpoint == pipe.endpointId;
2778 });
2779 if (transferIt == wrapper->bulkTransferList.end()) {
2780 HDF_LOGE("%{public}s: transferCancle is nullptr", __func__);
2781 return HDF_FAILURE;
2782 }
2783 LibusbBulkTransfer* transferCancle = *transferIt;
2784 if (transferCancle == nullptr) {
2785 HDF_LOGE("%{public}s:transferCancle is nullptr", __func__);
2786 return HDF_FAILURE;
2787 }
2788 if (transferCancle->isTransferring) {
2789 HDF_LOGE("%{public}s:Data is being transmitted and cancellation of regist is not allowed", __func__);
2790 return HDF_FAILURE;
2791 }
2792 transferCancle->bulkCbRef = nullptr;
2793 return HDF_SUCCESS;
2794 }
2795
RemoveSubscriber(sptr<V2_0::IUsbdSubscriber> subscriber)2796 int32_t LibusbAdapter::RemoveSubscriber(sptr<V2_0::IUsbdSubscriber> subscriber)
2797 {
2798 HDF_LOGI("%{public}s: enter RemoveSubscriber.", __func__);
2799 auto tempSize = subscribers_.size();
2800 subscribers_.remove(subscriber);
2801 if (tempSize == subscribers_.size()) {
2802 HDF_LOGE("%{public}s: subsciber not exist.", __func__);
2803 return HDF_FAILURE;
2804 }
2805 return HDF_SUCCESS;
2806 }
2807
GetCurrentDeviceList(libusb_context * ctx,sptr<V2_0::IUsbdSubscriber> subscriber)2808 void LibusbAdapter::GetCurrentDeviceList(libusb_context *ctx, sptr<V2_0::IUsbdSubscriber> subscriber)
2809 {
2810 int r;
2811 ssize_t cnt = 0;
2812 libusb_device **devs;
2813 cnt = libusb_get_device_list(ctx, &devs);
2814 if (cnt < 0) {
2815 HDF_LOGW("%{public}s ctx not init", __func__);
2816 return;
2817 }
2818 int busNum = 0;
2819 int devAddr = 0;
2820 for (ssize_t i = 0; i < cnt; i++) {
2821 libusb_device *dev = devs[i];
2822 struct libusb_device_descriptor desc;
2823 r = libusb_get_device_descriptor(dev, &desc);
2824 if (r < 0) {
2825 continue;
2826 }
2827 busNum = libusb_get_bus_number(dev);
2828 devAddr = libusb_get_device_address(dev);
2829 if (busNum == 0 || devAddr == 0) {
2830 HDF_LOGW("%{public}s Invalid parameter", __func__);
2831 continue;
2832 }
2833 if (desc.bDeviceClass == LIBUSB_CLASS_HUB) {
2834 continue;
2835 }
2836 HDF_LOGI("%{public}s:busNum: %{public}d, devAddr: %{public}d", __func__, busNum, devAddr);
2837 V2_0::USBDeviceInfo info = {ACT_DEVUP, busNum, devAddr};
2838 subscriber->DeviceEvent(info);
2839 }
2840 libusb_free_device_list(devs, 1);
2841 }
2842
SetSubscriber(sptr<V2_0::IUsbdSubscriber> subscriber)2843 int32_t LibusbAdapter::SetSubscriber(sptr<V2_0::IUsbdSubscriber> subscriber)
2844 {
2845 HDF_LOGI("%{public}s: enter", __func__);
2846 if (subscriber == nullptr || g_libusb_context == nullptr) {
2847 HDF_LOGE("%{public}s subsriber or g_libusb_context is nullptr", __func__);
2848 return HDF_FAILURE;
2849 }
2850 if (subscribers_.size() == 0) {
2851 HDF_LOGI("%{public}s: rigister callback.", __func__);
2852 int rc = libusb_hotplug_register_callback(g_libusb_context,
2853 static_cast<libusb_hotplug_event>(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT),
2854 LIBUSB_HOTPLUG_NO_FLAGS,
2855 LIBUSB_HOTPLUG_MATCH_ANY,
2856 LIBUSB_HOTPLUG_MATCH_ANY,
2857 LIBUSB_HOTPLUG_MATCH_ANY,
2858 HotplugCallback,
2859 this,
2860 &hotplug_handle_);
2861 if (rc != LIBUSB_SUCCESS) {
2862 HDF_LOGE("%{public}s: Failed to register hotplug callback: %{public}d", __func__, rc);
2863 libusb_exit(g_libusb_context);
2864 g_libusb_context = nullptr;
2865 return HDF_FAILURE;
2866 }
2867 }
2868 GetCurrentDeviceList(g_libusb_context, subscriber);
2869 subscribers_.push_back(subscriber);
2870 HDF_LOGI("%{public}s: hotpluginit success", __func__);
2871 return HDF_SUCCESS;
2872 }
2873
NotifyAllSubscriber(std::list<sptr<V2_0::IUsbdSubscriber>> subscribers,V2_0::USBDeviceInfo info)2874 void NotifyAllSubscriber(std::list<sptr<V2_0::IUsbdSubscriber>> subscribers, V2_0::USBDeviceInfo info)
2875 {
2876 HDF_LOGI("%{public}s: enter", __func__);
2877 for (auto subscriber: subscribers) {
2878 subscriber->DeviceEvent(info);
2879 }
2880 }
2881
RunHotplugTask(std::list<sptr<V2_0::IUsbdSubscriber>> subscribers,V2_0::USBDeviceInfo info)2882 void RunHotplugTask(std::list<sptr<V2_0::IUsbdSubscriber>> subscribers, V2_0::USBDeviceInfo info)
2883 {
2884 HDF_LOGI("%{public}s: enter.", __func__);
2885 std::thread hotplugThread([subscribers, info]() {
2886 NotifyAllSubscriber(subscribers, info);
2887 });
2888 hotplugThread.detach();
2889 }
2890
HotplugCallback(libusb_context * ctx,libusb_device * device,libusb_hotplug_event event,void * user_data)2891 int32_t LibusbAdapter::HotplugCallback(libusb_context* ctx, libusb_device* device,
2892 libusb_hotplug_event event, void* user_data)
2893 {
2894 HDF_LOGI("%{public}s: enter.", __func__);
2895 struct libusb_device_descriptor devDesc;
2896 libusb_get_device_descriptor(device, &devDesc);
2897 if (devDesc.bDeviceClass == LIBUSB_CLASS_HUB) {
2898 HDF_LOGW("%{public}s: do not handle hub class device", __func__);
2899 return HDF_SUCCESS;
2900 }
2901 if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED) {
2902 HDF_LOGD("%{public}s: event=%{public}d arrival device", __func__, event);
2903 V2_0::USBDeviceInfo info = {ACT_DEVUP, libusb_get_bus_number(device),
2904 libusb_get_device_address(device)};
2905 RunHotplugTask(LibusbAdapter::subscribers_, info);
2906 } else if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT) {
2907 HDF_LOGD("%{public}s: event=%{public}d remove device", __func__, event);
2908 V2_0::USBDeviceInfo info = {ACT_DEVDOWN, libusb_get_bus_number(device),
2909 libusb_get_device_address(device)};
2910 RunHotplugTask(LibusbAdapter::subscribers_, info);
2911 }
2912 return HDF_SUCCESS;
2913 }
2914
SetLoadUsbSaSubscriber(sptr<V1_2::LibUsbSaSubscriber> libUsbSaSubscriber)2915 int32_t LibusbAdapter::SetLoadUsbSaSubscriber(sptr<V1_2::LibUsbSaSubscriber> libUsbSaSubscriber)
2916 {
2917 HDF_LOGI("%{public}s: enter", __func__);
2918 if (libUsbSaSubscriber == nullptr || g_libusb_context == nullptr) {
2919 HDF_LOGE("%{public}s subsriber or g_libusb_context is nullptr", __func__);
2920 return HDF_FAILURE;
2921 }
2922 int rc = libusb_hotplug_register_callback(g_libusb_context,
2923 static_cast<libusb_hotplug_event>(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED | LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT),
2924 LIBUSB_HOTPLUG_NO_FLAGS,
2925 LIBUSB_HOTPLUG_MATCH_ANY,
2926 LIBUSB_HOTPLUG_MATCH_ANY,
2927 LIBUSB_HOTPLUG_MATCH_ANY,
2928 LoadUsbSaCallback,
2929 this,
2930 &hotplug_handle_);
2931 if (rc != LIBUSB_SUCCESS) {
2932 HDF_LOGE("%{public}s: Failed to register hotplug callback: %{public}d", __func__, rc);
2933 libusb_exit(g_libusb_context);
2934 g_libusb_context = nullptr;
2935 return HDF_FAILURE;
2936 }
2937
2938 GetCurrentDevList(g_libusb_context, libUsbSaSubscriber);
2939 libUsbSaSubscriber_ = libUsbSaSubscriber;
2940 return HDF_SUCCESS;
2941 }
2942
LoadUsbSaCallback(libusb_context * ctx,libusb_device * device,libusb_hotplug_event event,void * user_data)2943 int32_t LibusbAdapter::LoadUsbSaCallback(libusb_context* ctx, libusb_device* device,
2944 libusb_hotplug_event event, void* user_data)
2945 {
2946 HDF_LOGI("%{public}s: enter.", __func__);
2947 if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED) {
2948 if (libUsbSaSubscriber_ == nullptr) {
2949 HDF_LOGE("%{public}s: libUsbSaSubscriber is nullptr", __func__);
2950 return HDF_FAILURE;
2951 }
2952 libUsbSaSubscriber_->LoadUsbSa(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED);
2953 }
2954 return HDF_SUCCESS;
2955 }
2956
GetCurrentDevList(libusb_context * ctx,sptr<V1_2::LibUsbSaSubscriber> libUsbSaSubscriber)2957 void LibusbAdapter::GetCurrentDevList(libusb_context *ctx, sptr<V1_2::LibUsbSaSubscriber> libUsbSaSubscriber)
2958 {
2959 HDF_LOGI("%{public}s: enter.", __func__);
2960 ssize_t cnt = 0;
2961 libusb_device **devs;
2962 cnt = libusb_get_device_list(ctx, &devs);
2963 if (cnt < 0) {
2964 HDF_LOGW("%{public}s ctx not init", __func__);
2965 return;
2966 }
2967 int busNum = 0;
2968 int devAddr = 0;
2969 for (ssize_t i = 0; i < cnt; i++) {
2970 libusb_device *dev = devs[i];
2971 struct libusb_device_descriptor desc;
2972 int ret = libusb_get_device_descriptor(dev, &desc);
2973 if (ret < 0) {
2974 continue;
2975 }
2976 busNum = libusb_get_bus_number(dev);
2977 devAddr = libusb_get_device_address(dev);
2978 if (busNum == 0 || devAddr == 0) {
2979 HDF_LOGW("%{public}s Invalid parameter", __func__);
2980 continue;
2981 }
2982 if (desc.bDeviceClass == LIBUSB_CLASS_HUB) {
2983 continue;
2984 }
2985 HDF_LOGI("%{public}s:busNum: %{public}d, devAddr: %{public}d", __func__, busNum, devAddr);
2986 libUsbSaSubscriber->LoadUsbSa(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED);
2987 }
2988 libusb_free_device_list(devs, 1);
2989 }
2990 } // namespace V1_2
2991 } // namespace Usb
2992 } // namespace HDI
2993 } // namespace OHOS
2994