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