1 /*
2 * Copyright (c) 2022-2023 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 "usb_impl.h"
17
18 #include <cerrno>
19 #include <hdf_base.h>
20 #include <hdf_log.h>
21 #include <sys/mman.h>
22 #include <sys/types.h>
23 #include <unistd.h>
24 #include <climits>
25
26 #include "parameter.h"
27 #include "parameters.h"
28 #include "ddk_pnp_listener_mgr.h"
29 #include "ddk_device_manager.h"
30 #include "device_resource_if.h"
31 #include "hdf_slist.h"
32 #include "hisysevent.h"
33 #include "hitrace_meter.h"
34 #include "libusb_adapter.h"
35 #include "osal_mutex.h"
36 #include "usb_ddk_interface.h"
37 #include "usb_ddk_pnp_loader.h"
38 #include "usb_interface_pool.h"
39 #include "usbd_dispatcher.h"
40 #include "usbd_function.h"
41 #include "usbd_accessory.h"
42 #include "usbd_port.h"
43 #include "usbd_wrapper.h"
44 using namespace OHOS::HiviewDFX;
45 constexpr double USB_RECOGNITION_FAIL_RATE_BASE = 100.00;
46 #ifndef LIBUSB_ENABLE
47 constexpr uint16_t ENGLISH_US_LANGUAGE_ID = 0x409;
48 #endif
49 constexpr uint32_t FUNCTION_VALUE_MAX_LEN = 32;
50 constexpr uint8_t USB_PARAM_REQTYPE = 128;
51 constexpr uint8_t USB_PARAM_STAND_REQTYPE = 0;
52 int32_t g_usbOpenCount = 0;
53 #ifdef LIBUSB_ENABLE
54 constexpr uint8_t MAX_DEVICE_ADDRESS = 255;
55 constexpr uint8_t MAX_DEVICE_BUSNUM = 255;
56 constexpr uint8_t MAX_ENDPOINT_ID = 158;
57 constexpr uint8_t MAX_CANCEL_ENDPOINT_ID = 255;
58 constexpr uint8_t MAX_INTERFACE_ID = 255;
59 constexpr uint8_t LIBUSB_INTERFACE_ID = 0x80;
60 constexpr uint8_t LIBUSB_ENDPOINT_MASK = 0x80;
61 #endif
62 namespace OHOS {
63 namespace HDI {
64 namespace Usb {
65 namespace V1_2 {
66 HdfDevEventlistener UsbImpl::listenerForLoadService_ = {nullptr};
67 UsbdLoadService UsbImpl::loadUsbService_ = {USB_SYSTEM_ABILITY_ID};
68 UsbdLoadService UsbImpl::loadHdfEdm_ = {HDF_EXTERNAL_DEVICE_MANAGER_SA_ID};
69 UsbdSubscriber UsbImpl::subscribers_[MAX_SUBSCRIBER] = {{0}};
70 bool UsbImpl::isGadgetConnected_ = false;
71 uint32_t UsbImpl::attachCount_ = 0;
72 uint32_t UsbImpl::attachFailedCount_ = 0;
73 static const std::map<std::string, uint32_t> configMap = {
74 {HDC_CONFIG_OFF, USB_FUNCTION_NONE},
75 {HDC_CONFIG_HDC, USB_FUNCTION_HDC},
76 {HDC_CONFIG_ON, USB_FUNCTION_HDC},
77 {HDC_CONFIG_RNDIS, USB_FUNCTION_RNDIS},
78 {HDC_CONFIG_STORAGE, USB_FUNCTION_STORAGE},
79 {HDC_CONFIG_RNDIS_HDC, USB_FUNCTION_HDC + USB_FUNCTION_RNDIS},
80 {HDC_CONFIG_STORAGE_HDC, USB_FUNCTION_HDC + USB_FUNCTION_STORAGE},
81 {HDC_CONFIG_MANUFACTURE_HDC, USB_FUNCTION_MANUFACTURE},
82 {HDC_CONFIG_NCM, USB_FUNCTION_NCM},
83 {HDC_CONFIG_NCM_HDC, USB_FUNCTION_HDC + USB_FUNCTION_NCM}
84 };
85
UsbInterfaceImplGetInstance(void)86 extern "C" IUsbInterface *UsbInterfaceImplGetInstance(void)
87 {
88 using OHOS::HDI::Usb::V1_2::UsbImpl;
89 UsbImpl *service = new (std::nothrow) UsbImpl();
90 if (service == nullptr) {
91 return nullptr;
92 }
93 return service;
94 }
95
UsbImpl()96 UsbImpl::UsbImpl() : session_(nullptr), device_(nullptr)
97 {
98 HdfSListInit(&devList_);
99 OsalMutexInit(&lock_);
100 if (OHOS::system::GetBoolParameter("const.security.developermode.state", true)) {
101 loadUsbService_.LoadService();
102 }
103 }
104
~UsbImpl()105 UsbImpl::~UsbImpl()
106 {
107 UsbdReleaseDevices();
108 }
109
FindDevFromService(uint8_t busNum,uint8_t devAddr)110 HostDevice *UsbImpl::FindDevFromService(uint8_t busNum, uint8_t devAddr)
111 {
112 HdfSListIterator it;
113 HostDevice *port = nullptr;
114 bool flag = false;
115
116 OsalMutexLock(&lock_);
117 HdfSListIteratorInit(&it, &devList_);
118 while (HdfSListIteratorHasNext(&it)) {
119 port = reinterpret_cast<HostDevice *>(HdfSListIteratorNext(&it));
120 if (port == nullptr) {
121 continue;
122 }
123 if (port->busNum == busNum && port->devAddr == devAddr) {
124 flag = true;
125 break;
126 }
127 }
128 OsalMutexUnlock(&lock_);
129 if (!flag) {
130 return nullptr;
131 }
132 return port;
133 }
134
MakeUsbControlParams(UsbControlParams * controlParams,uint8_t * buffer,uint16_t length,uint16_t value,uint16_t index)135 void UsbImpl::MakeUsbControlParams(
136 UsbControlParams *controlParams, uint8_t *buffer, uint16_t length, uint16_t value, uint16_t index)
137 {
138 if (controlParams == nullptr || buffer == nullptr) {
139 HDF_LOGE("%{public}s: %{public}d controlParams or buffer is nullptr", __func__, __LINE__);
140 return;
141 }
142
143 controlParams->request = USB_DDK_REQ_GET_DESCRIPTOR;
144 controlParams->target = USB_REQUEST_TARGET_DEVICE;
145 controlParams->reqType = USB_PARAM_REQTYPE;
146 controlParams->directon = USB_REQUEST_DIR_FROM_DEVICE;
147 controlParams->value = value;
148 controlParams->index = index;
149 controlParams->data = buffer;
150 controlParams->size = length;
151 }
152
MakeGetActiveUsbControlParams(UsbControlParams * controlParams,uint8_t * buffer,uint16_t length,uint16_t value,uint16_t index)153 void UsbImpl::MakeGetActiveUsbControlParams(
154 UsbControlParams *controlParams, uint8_t *buffer, uint16_t length, uint16_t value, uint16_t index)
155 {
156 if (controlParams == nullptr || buffer == nullptr) {
157 HDF_LOGE("%{public}s: %{public}d controlParams or buffer is nullptr", __func__, __LINE__);
158 return;
159 }
160
161 controlParams->request = USB_DDK_REQ_GET_CONFIGURATION;
162 controlParams->target = USB_REQUEST_TARGET_DEVICE;
163 controlParams->reqType = USB_PARAM_REQTYPE;
164 controlParams->directon = USB_REQUEST_DIR_FROM_DEVICE;
165 controlParams->value = value;
166 controlParams->index = index;
167 controlParams->data = buffer;
168 controlParams->size = length;
169 }
170
UsbControlTransferEx(HostDevice * dev,UsbControlParams * ctrParams,int32_t timeout)171 int32_t UsbImpl::UsbControlTransferEx(HostDevice *dev, UsbControlParams *ctrParams, int32_t timeout)
172 {
173 UsbRequestParams params;
174 if (memset_s(¶ms, sizeof(params), 0, sizeof(params)) != EOK) {
175 HDF_LOGE("%{public}s:memset_s params failed", __func__);
176 return HDF_FAILURE;
177 }
178
179 if (dev == nullptr || dev->ctrDevHandle == nullptr || ctrParams == nullptr) {
180 HDF_LOGE("%{public}s:invalid params", __func__);
181 return HDF_ERR_INVALID_PARAM;
182 }
183
184 UsbRequest *request = nullptr;
185 if (dev->ctrlReq == nullptr) {
186 request = UsbAllocRequest(dev->ctrDevHandle, 0, MAX_CONTROL_BUFF_SIZE);
187 if (request == nullptr) {
188 return HDF_ERR_MALLOC_FAIL;
189 }
190 dev->ctrlReq = request;
191 } else {
192 request = dev->ctrlReq;
193 }
194
195 UsbdDispatcher::UsbRequestParamsInit(¶ms, timeout);
196 int32_t ret = UsbdDispatcher::UsbControlSetUp(ctrParams, ¶ms.ctrlReq);
197 if (ret != HDF_SUCCESS) {
198 return ret;
199 }
200 OsalMutexLock(&dev->lock);
201 do {
202 ret = UsbFillRequest(request, dev->ctrDevHandle, ¶ms);
203 if (ret != HDF_SUCCESS) {
204 HDF_LOGE("%{public}s:UsbFillRequest failed, ret = %{public}d", __func__, ret);
205 break;
206 }
207
208 ret = UsbSubmitRequestSync(request);
209 if (ret != HDF_SUCCESS) {
210 HDF_LOGE("%{public}s:UsbSubmitRequestSync failed, ret=%{public}d", __func__, ret);
211 break;
212 }
213
214 if (ctrParams->directon == USB_REQUEST_DIR_FROM_DEVICE) {
215 ret = memcpy_s(ctrParams->data, ctrParams->size, request->compInfo.buffer, request->compInfo.actualLength);
216 if (ret != EOK) {
217 HDF_LOGE("%{public}s: memcpy_s failed, ret = %{public}d", __func__, ret);
218 break;
219 }
220 ctrParams->size =
221 ctrParams->size < request->compInfo.actualLength ? ctrParams->size : request->compInfo.actualLength;
222 }
223 } while (0);
224
225 OsalMutexUnlock(&dev->lock);
226 return ret;
227 }
228
MakeSetActiveUsbControlParams(UsbControlParams * controlParams,uint8_t * buffer,uint16_t length,uint16_t value,uint16_t index)229 void UsbImpl::MakeSetActiveUsbControlParams(
230 UsbControlParams *controlParams, uint8_t *buffer, uint16_t length, uint16_t value, uint16_t index)
231 {
232 if (controlParams == nullptr || buffer == nullptr) {
233 HDF_LOGE("%{public}s: %{public}d controlParams or buffer is nullptr", __func__, __LINE__);
234 return;
235 }
236
237 controlParams->request = USB_DDK_REQ_SET_CONFIGURATION;
238 controlParams->target = USB_REQUEST_TARGET_DEVICE;
239 controlParams->reqType = USB_PARAM_STAND_REQTYPE;
240 controlParams->directon = USB_REQUEST_DIR_TO_DEVICE;
241 controlParams->value = value;
242 controlParams->index = index;
243 controlParams->data = buffer;
244 controlParams->size = length;
245 }
246
ReOpenDevice(HostDevice * port)247 int32_t UsbImpl::ReOpenDevice(HostDevice *port)
248 {
249 if (port == nullptr) {
250 HDF_LOGE("%{public}s:invalid param port", __func__);
251 return HDF_FAILURE;
252 }
253
254 uint8_t busNum = port->busNum;
255 uint8_t devAddr = port->devAddr;
256 UsbdDispatcher::UsbdRelease(port);
257 port->busNum = busNum;
258 port->devAddr = devAddr;
259 OsalMutexInit(&port->writeLock);
260 OsalMutexInit(&port->readLock);
261 OsalMutexInit(&port->lock);
262 OsalMutexInit(&port->requestLock);
263 OsalMutexInit(&port->reqSyncLock);
264 OsalMutexInit(&port->reqASyncLock);
265 HdfSListInit(&port->requestQueue);
266 HdfSListInit(&port->reqSyncList);
267 HdfSListInit(&port->reqASyncList);
268 int32_t ret = UsbdDispatcher::UsbdInit(port);
269 if (ret != HDF_SUCCESS) {
270 HDF_LOGE("%{public}s:UsbInit failed ret:%{public}d", __func__, ret);
271 UsbdDispatcher::UsbdRelease(port);
272 UsbdDispatcher::RemoveDevFromService(port->service, port);
273 OsalMemFree(port);
274 return ret;
275 }
276
277 DataFifoReset(&port->readFifo);
278 port->initFlag = true;
279 return HDF_SUCCESS;
280 }
281
InterfaceIdToHandle(const HostDevice * dev,uint8_t id)282 UsbInterfaceHandle *UsbImpl::InterfaceIdToHandle(const HostDevice *dev, uint8_t id)
283 {
284 if (dev == nullptr) {
285 HDF_LOGE("%{public}s: invalid param dev is nullptr", __func__);
286 return nullptr;
287 }
288
289 if (id == MAX_INTERFACEID) {
290 return dev->ctrDevHandle;
291 } else if (id < USB_MAX_INTERFACES) {
292 return dev->devHandle[id];
293 }
294 return nullptr;
295 }
296
UsbdRequestSyncReleaseList(HostDevice * port)297 int32_t UsbImpl::UsbdRequestSyncReleaseList(HostDevice *port)
298 {
299 if (port == nullptr) {
300 HDF_LOGE("%{public}s:invalid param port is nullptr", __func__);
301 return HDF_ERR_INVALID_PARAM;
302 }
303
304 HdfSListIterator it;
305 OsalMutexLock(&port->reqSyncLock);
306 HdfSListIteratorInit(&it, &port->reqSyncList);
307 while (HdfSListIteratorHasNext(&it)) {
308 UsbdRequestSync *req = reinterpret_cast<UsbdRequestSync *>(HdfSListIteratorNext(&it));
309 if (req == nullptr) {
310 continue;
311 }
312 HdfSListIteratorRemove(&it);
313 int32_t ret = UsbdDispatcher::UsbdRequestSyncRelease(req);
314 if (ret != HDF_SUCCESS) {
315 HDF_LOGE("%{public}s:UsbdRequestSyncRelease failed", __func__);
316 }
317 }
318 OsalMutexUnlock(&port->reqSyncLock);
319
320 return HDF_SUCCESS;
321 }
322
UsbdRequestASyncReleaseList(HostDevice * port)323 int32_t UsbImpl::UsbdRequestASyncReleaseList(HostDevice *port)
324 {
325 if (port == nullptr) {
326 HDF_LOGE("%{public}s:invalid param port", __func__);
327 return HDF_ERR_INVALID_PARAM;
328 }
329
330 HdfSListIterator it;
331 OsalMutexLock(&port->reqASyncLock);
332 HdfSListIteratorInit(&it, &port->reqASyncList);
333 while (HdfSListIteratorHasNext(&it)) {
334 UsbdRequestASync *req = reinterpret_cast<UsbdRequestASync *>(HdfSListIteratorNext(&it));
335 if (req == nullptr) {
336 continue;
337 }
338 HdfSListIteratorRemove(&it);
339 int32_t ret = UsbdDispatcher::UsbdRequestASyncRelease(req);
340 if (ret != HDF_SUCCESS) {
341 HDF_LOGW("%{public}s:UsbdRequestASyncRelease failed", __func__);
342 }
343 }
344 OsalMutexUnlock(&port->reqASyncLock);
345
346 return HDF_SUCCESS;
347 }
348
UsbdBulkASyncListReleasePort(HostDevice * port)349 int32_t UsbImpl::UsbdBulkASyncListReleasePort(HostDevice *port)
350 {
351 if (port == nullptr || port->bulkASyncList == nullptr) {
352 HDF_LOGE("%{public}s: port or port->bulkASyncList is nullptr", __func__);
353 return HDF_SUCCESS;
354 }
355
356 UsbdBulkASyncList *list = nullptr;
357 while (port->bulkASyncList) {
358 list = port->bulkASyncList;
359 port->bulkASyncList = list->next;
360 UsbdDispatcher::UsbdBulkASyncListRelease(list);
361 list = nullptr;
362 }
363 return HDF_SUCCESS;
364 }
365
UsbdFindRequestSyncAndCreat(HostDevice * port,uint8_t interfaceId,uint8_t pipeAddr,UsbdRequestSync ** request)366 int32_t UsbImpl::UsbdFindRequestSyncAndCreat(
367 HostDevice *port, uint8_t interfaceId, uint8_t pipeAddr, UsbdRequestSync **request)
368 {
369 if (port == nullptr || request == nullptr) {
370 HDF_LOGE("%{public}s:ifId:%{public}u, epId:%{public}u", __func__, interfaceId, pipeAddr);
371 return HDF_ERR_INVALID_PARAM;
372 }
373
374 *request = nullptr;
375 UsbdRequestSync *requestSync = UsbdDispatcher::UsbdFindRequestSync(port, interfaceId, pipeAddr);
376 if (requestSync != nullptr) {
377 *request = requestSync;
378 return HDF_SUCCESS;
379 }
380
381 UsbPipeInfo pipe;
382 if (memset_s(&pipe, sizeof(UsbPipeInfo), 0, sizeof(UsbPipeInfo)) != EOK) {
383 HDF_LOGE("%{public}s:memset_s pipe failed ", __func__);
384 return HDF_FAILURE;
385 }
386
387 int32_t ret = UsbdDispatcher::GetPipe(port, interfaceId, pipeAddr, &pipe);
388 if (ret != HDF_SUCCESS) {
389 HDF_LOGE("%{public}s: get pipe failed ifId:%{public}u, epId:%{public}u", __func__, interfaceId, pipeAddr);
390 return HDF_FAILURE;
391 }
392
393 UsbInterfaceHandle *ifHandle = InterfaceIdToHandle(port, interfaceId);
394 if (ifHandle == nullptr) {
395 HDF_LOGE("%{public}s:get interface handle failed", __func__);
396 return HDF_ERR_INVALID_PARAM;
397 }
398
399 requestSync = UsbdDispatcher::UsbdRequestSyncAlloc();
400 if (requestSync == nullptr) {
401 HDF_LOGE("%{public}s:fail ifId:%{public}u pipeId:%{public}u", __func__, interfaceId, pipeAddr);
402 return HDF_ERR_MALLOC_FAIL;
403 }
404
405 ret = UsbdDispatcher::UsbdRequestSyncInit(port, ifHandle, &pipe, requestSync);
406 if (ret != HDF_SUCCESS) {
407 HDF_LOGE("%{public}s:UsbdRequestSyncInit failed ret:%{public}d", __func__, ret);
408 int32_t tRet = UsbdDispatcher::UsbdRequestSyncRelease(requestSync);
409 requestSync = nullptr;
410 if (tRet != HDF_SUCCESS) {
411 HDF_LOGE("%{public}s:Release failed ifId:%{public}u pipeId:%{public}u", __func__, interfaceId, pipeAddr);
412 }
413 return ret;
414 }
415 *request = requestSync;
416 return ret;
417 }
418
UsbdFindRequestSyncAndCreatwithLength(HostDevice * port,uint8_t interfaceId,uint8_t pipeAddr,int32_t length,UsbdRequestSync ** request)419 int32_t UsbImpl::UsbdFindRequestSyncAndCreatwithLength(HostDevice *port, uint8_t interfaceId,
420 uint8_t pipeAddr, int32_t length, UsbdRequestSync **request)
421 {
422 if (port == nullptr || request == nullptr) {
423 HDF_LOGE("%{public}s:ifId:%{public}u, epId:%{public}u", __func__, interfaceId, pipeAddr);
424 return HDF_ERR_INVALID_PARAM;
425 }
426
427 *request = nullptr;
428 UsbdRequestSync *requestSync = UsbdDispatcher::UsbdFindRequestSync(port, interfaceId, pipeAddr);
429 if (requestSync != nullptr) {
430 struct UsbIfRequest *requestObj = (struct UsbIfRequest *)requestSync->request;
431 if (requestObj->hostRequest->bufLen >= length) {
432 *request = requestSync;
433 return HDF_SUCCESS;
434 } else {
435 UsbdRequestSyncReleaseList(port);
436 HDF_LOGD("%{public}s:ifId:%{public}u, epId:%{public}u,realloc reqeustsync.",
437 __func__, interfaceId, pipeAddr);
438 }
439 }
440
441 UsbPipeInfo pipe;
442 if (memset_s(&pipe, sizeof(UsbPipeInfo), 0, sizeof(UsbPipeInfo)) != EOK) {
443 HDF_LOGE("%{public}s:memset_s pipe failed ", __func__);
444 return HDF_FAILURE;
445 }
446
447 int32_t ret = UsbdDispatcher::GetPipe(port, interfaceId, pipeAddr, &pipe);
448 if (ret != HDF_SUCCESS) {
449 HDF_LOGE("%{public}s: get pipe failed ifId:%{public}u, epId:%{public}u", __func__, interfaceId, pipeAddr);
450 return HDF_FAILURE;
451 }
452
453 UsbInterfaceHandle *ifHandle = InterfaceIdToHandle(port, interfaceId);
454 if (ifHandle == nullptr) {
455 HDF_LOGE("%{public}s:get interface handle failed", __func__);
456 return HDF_ERR_INVALID_PARAM;
457 }
458
459 requestSync = UsbdDispatcher::UsbdRequestSyncAlloc();
460 if (requestSync == nullptr) {
461 HDF_LOGE("%{public}s:fail ifId:%{public}u pipeId:%{public}u", __func__, interfaceId, pipeAddr);
462 return HDF_ERR_MALLOC_FAIL;
463 }
464
465 ret = UsbdDispatcher::UsbdRequestSyncInitwithLength(port, ifHandle, &pipe, length, requestSync);
466 if (ret != HDF_SUCCESS) {
467 HDF_LOGE("%{public}s:UsbdRequestSyncInit failed ret:%{public}d", __func__, ret);
468 UsbdDispatcher::UsbdRequestSyncRelease(requestSync);
469 requestSync = nullptr;
470 return ret;
471 }
472 *request = requestSync;
473 return ret;
474 }
475
UsbdBulkReadSyncBase(int32_t timeout,uint8_t * buffer,uint32_t size,uint32_t * actlength,UsbdRequestSync * requestSync)476 int32_t UsbImpl::UsbdBulkReadSyncBase(
477 int32_t timeout, uint8_t *buffer, uint32_t size, uint32_t *actlength, UsbdRequestSync *requestSync)
478 {
479 if (requestSync == nullptr || requestSync->request == nullptr || buffer == nullptr || actlength == nullptr ||
480 size < 1) {
481 HDF_LOGE("%{public}s:invalid params", __func__);
482 return HDF_ERR_INVALID_PARAM;
483 }
484
485 HITRACE_METER_NAME(HITRACE_TAG_HDF, "UsbdBulkReadSyncBase");
486 int32_t ret = HDF_FAILURE;
487 uint32_t tcur = 0;
488 OsalMutexLock(&requestSync->lock);
489 requestSync->params.timeout = static_cast<uint32_t>(timeout);
490 ret = UsbFillRequest(requestSync->request, requestSync->ifHandle, &requestSync->params);
491 if (ret != HDF_SUCCESS) {
492 HDF_LOGE("%{public}s: UsbFillRequest failed, ret=%{public}d ", __func__, ret);
493 OsalMutexUnlock(&requestSync->lock);
494 return HDF_FAILURE;
495 }
496
497 struct UsbIfRequest* requestObj = (struct UsbIfRequest *)requestSync->request;
498 struct UsbHostRequest* hostRequest = requestObj->hostRequest;
499 hostRequest->length = size;
500
501 ret = UsbSubmitRequestSync(requestSync->request);
502 if (ret == HDF_SUCCESS) {
503 ret = memcpy_s(buffer + tcur, size - tcur, requestSync->request->compInfo.buffer,
504 requestSync->request->compInfo.actualLength);
505 if (ret != HDF_SUCCESS) {
506 HDF_LOGE("%{public}s: memcpy_s failed, ret = %{public}d", __func__, ret);
507 OsalMutexUnlock(&requestSync->lock);
508 return HDF_FAILURE;
509 }
510 tcur += requestSync->request->compInfo.actualLength;
511 }
512 OsalMutexUnlock(&requestSync->lock);
513
514 *actlength = tcur;
515 return ret;
516 }
517
UsbdBulkWriteSyncBase(HostDevice * port,UsbdRequestSync * requestSync,const uint8_t * buffer,uint32_t length,int32_t timeout)518 int32_t UsbImpl::UsbdBulkWriteSyncBase(
519 HostDevice *port, UsbdRequestSync *requestSync, const uint8_t *buffer, uint32_t length, int32_t timeout)
520 {
521 if (port == nullptr || requestSync == nullptr || buffer == nullptr || length < 1) {
522 HDF_LOGE("%{public}s:invalid param", __func__);
523 return HDF_ERR_INVALID_PARAM;
524 }
525
526 HITRACE_METER_NAME(HITRACE_TAG_HDF, "UsbdBulkWriteSyncBase");
527 int32_t ret = HDF_FAILURE;
528 OsalMutexLock(&requestSync->lock);
529 uint32_t initTimeout = timeout < 0 ? 0 : static_cast<uint32_t>(timeout);
530 requestSync->params.timeout = initTimeout;
531 requestSync->params.userData = port;
532 uint32_t tcur = 0;
533 uint32_t msize = static_cast<uint32_t>(requestSync->pipe.maxPacketSize);
534 while (tcur < length) {
535 uint32_t tsize = (length - tcur) < msize ? (length - tcur) : msize;
536 requestSync->params.dataReq.buffer = static_cast<unsigned char *>(const_cast<uint8_t *>(buffer) + tcur);
537 requestSync->params.dataReq.length = tsize;
538 tcur += tsize;
539 ret = UsbFillRequest(requestSync->request, requestSync->ifHandle, &requestSync->params);
540 if (ret != HDF_SUCCESS) {
541 HDF_LOGE("%{public}s:UsbFillRequest failed, ret:%{public}d, tcur:%{public}u, length:%{public}u", __func__,
542 ret, tcur, length);
543 break;
544 }
545 ret = UsbSubmitRequestSync(requestSync->request);
546 if (ret != HDF_SUCCESS) {
547 HDF_LOGE("%{public}s:UsbSubmitRequestSync failed, ret:%{public}d tcur:%{public}u length:%{public}u",
548 __func__, ret, tcur, length);
549 break;
550 }
551 }
552 OsalMutexUnlock(&requestSync->lock);
553 return ret;
554 }
555
UsbdFindRequestASync(HostDevice * port,uint8_t interfaceId,uint8_t pipeAddr)556 UsbdRequestASync *UsbImpl::UsbdFindRequestASync(HostDevice *port, uint8_t interfaceId, uint8_t pipeAddr)
557 {
558 if (port == nullptr) {
559 HDF_LOGE("%{public}s:invalid param port", __func__);
560 return nullptr;
561 }
562
563 UsbdRequestASync *req = nullptr;
564 HdfSListIterator it;
565 uint8_t reqnum = 0;
566 uint8_t usenum = 0;
567 bool flag = false;
568 OsalMutexLock(&port->reqASyncLock);
569 HdfSListIteratorInit(&it, &port->reqASyncList);
570 while (HdfSListIteratorHasNext(&it)) {
571 req = reinterpret_cast<UsbdRequestASync *>(HdfSListIteratorNext(&it));
572 if (req == nullptr) {
573 continue;
574 }
575 if (req->pipe.interfaceId == interfaceId && ((req->pipe.pipeAddress | req->pipe.pipeDirection) == pipeAddr)) {
576 reqnum++;
577 if (req->status) {
578 usenum++;
579 } else {
580 flag = true;
581 break;
582 }
583 }
584 }
585 OsalMutexUnlock(&port->reqASyncLock);
586
587 if (flag) {
588 if (req) {
589 OsalMutexLock(&req->lock);
590 req->status = 1;
591 OsalMutexUnlock(&req->lock);
592 }
593 return req;
594 } else {
595 if (reqnum < MAX_REQUESTASYNC_NUM) {
596 req = UsbdDispatcher::UsbdRequestASyncCreatAndInsert(port, interfaceId, pipeAddr);
597 if (req) {
598 OsalMutexLock(&req->lock);
599 req->status = 1;
600 OsalMutexUnlock(&req->lock);
601 }
602 return req;
603 }
604 }
605 return nullptr;
606 }
607
FunRequestQueueFillAndSubmit(HostDevice * port,UsbdRequestASync * reqAsync,const uint8_t * buffer,uint32_t length)608 int32_t UsbImpl::FunRequestQueueFillAndSubmit(
609 HostDevice *port, UsbdRequestASync *reqAsync, const uint8_t *buffer, uint32_t length)
610 {
611 if (port == nullptr || reqAsync == nullptr) {
612 HDF_LOGE("%{public}s:invalid param port or reqAsync", __func__);
613 return HDF_ERR_INVALID_PARAM;
614 }
615
616 UsbdDispatcher::FillReqAyncParams(reqAsync, &reqAsync->pipe, &reqAsync->params, buffer, length);
617 int32_t ret = UsbFillRequest(reqAsync->reqMsg.request, reqAsync->ifHandle, &reqAsync->params);
618 if (ret != HDF_SUCCESS) {
619 HDF_LOGE("%{public}s:UsbFillRequest failed, ret:%{public}d", __func__, ret);
620 OsalMutexLock(&reqAsync->lock);
621 reqAsync->reqMsg.clientData = nullptr;
622 reqAsync->reqMsg.clientLength = 0;
623 reqAsync->params.dataReq.buffer = nullptr;
624 reqAsync->params.dataReq.length = 0;
625 reqAsync->status = 0;
626 OsalMutexUnlock(&reqAsync->lock);
627 return ret;
628 }
629
630 UsbIfRequest *requestConvertVal = reinterpret_cast<UsbIfRequest *>(reqAsync->reqMsg.request);
631 OsalSemInit(&requestConvertVal->hostRequest->sem, 0);
632 ret = UsbSubmitRequestAsync(reqAsync->reqMsg.request);
633 if (ret == HDF_SUCCESS) {
634 OsalMutexLock(&port->requestLock);
635 HdfSListAddTail(&port->requestQueue, &reqAsync->qNode);
636 OsalMutexUnlock(&port->requestLock);
637 } else {
638 HDF_LOGE("%{public}s:UsbSubmitRequestAsync failed, ret:%{public}d", __func__, ret);
639 OsalMutexLock(&reqAsync->lock);
640 reqAsync->status = 0;
641 reqAsync->reqMsg.clientData = nullptr;
642 reqAsync->reqMsg.clientLength = 0;
643 reqAsync->params.dataReq.buffer = nullptr;
644 reqAsync->params.dataReq.length = 0;
645 OsalMutexUnlock(&reqAsync->lock);
646 }
647 return ret;
648 }
649
GetRequestMsgFromQueue(HostDevice * port,UsbdRequestASync ** reqMsg)650 int32_t UsbImpl::GetRequestMsgFromQueue(HostDevice *port, UsbdRequestASync **reqMsg)
651 {
652 if (port == nullptr || reqMsg == nullptr) {
653 HDF_LOGE("%{public}s: port or reqMsg is nullptr", __func__);
654 return HDF_ERR_INVALID_PARAM;
655 }
656
657 HdfSListNode *requestNode = nullptr;
658 OsalMutexLock(&port->requestLock);
659 if (!HdfSListIsEmpty(&port->requestQueue)) {
660 requestNode = HdfSListPop(&port->requestQueue);
661 }
662 OsalMutexUnlock(&port->requestLock);
663 if (requestNode == nullptr) {
664 HDF_LOGE("%{public}s:requestNode is nullptr", __func__);
665 return HDF_FAILURE;
666 }
667 *reqMsg = HDF_SLIST_CONTAINER_OF(HdfSListNode, requestNode, UsbdRequestASync, qNode);
668 if (*reqMsg == nullptr) {
669 HDF_LOGE("%{public}s:request msg is nullptr", __func__);
670 return HDF_FAILURE;
671 }
672 return HDF_SUCCESS;
673 }
674
GetRequestMsgData(HostDevice * port,UsbdRequestASync * reqMsg,int32_t timeout,uint8_t ** buffer,uint32_t * length)675 int32_t UsbImpl::GetRequestMsgData(
676 HostDevice *port, UsbdRequestASync *reqMsg, int32_t timeout, uint8_t **buffer, uint32_t *length)
677 {
678 if (port == nullptr || reqMsg == nullptr || reqMsg->reqMsg.request == nullptr) {
679 HDF_LOGE("%{public}s: invalid param", __func__);
680 return HDF_ERR_INVALID_PARAM;
681 }
682
683 int32_t ret = HDF_SUCCESS;
684 UsbIfRequest *reqValue = reinterpret_cast<UsbIfRequest *>(reqMsg->reqMsg.request);
685 if (static_cast<int32_t>(reqMsg->reqMsg.request->compInfo.status) == -1) {
686 ret = OsalSemWait(&reqValue->hostRequest->sem, timeout);
687 if (ret != HDF_SUCCESS) {
688 HDF_LOGE("%{public}s:OsalSemWait failed, ret:%{public}d", __func__, ret);
689 OsalMutexLock(&port->requestLock);
690 HdfSListAdd(&port->requestQueue, &reqMsg->qNode);
691 OsalMutexUnlock(&port->requestLock);
692 return ret;
693 }
694 }
695
696 OsalMutexLock(&reqMsg->lock);
697 *length = reqMsg->reqMsg.length;
698 *buffer = static_cast<uint8_t *>(reqMsg->reqMsg.buffer);
699 reqMsg->reqMsg.buffer = nullptr;
700 reqMsg->reqMsg.length = 0;
701 reqMsg->status = 0;
702 OsalMutexUnlock(&reqMsg->lock);
703 return ret;
704 }
705
UsbdRequestASyncReleaseData(UsbdRequestASync * request)706 int32_t UsbImpl::UsbdRequestASyncReleaseData(UsbdRequestASync *request)
707 {
708 if (request == nullptr) {
709 HDF_LOGE("%{public}s: invalid param request is nullptr", __func__);
710 return HDF_ERR_INVALID_PARAM;
711 }
712
713 if (request->reqMsg.buffer != nullptr) {
714 HDF_LOGI("%{public}s:free buffer", __func__);
715 OsalMemFree(request->reqMsg.buffer);
716 request->reqMsg.buffer = nullptr;
717 }
718 request->reqMsg.length = 0;
719 if (request->reqMsg.clientData) {
720 HDF_LOGI("%{public}s:free clientData", __func__);
721 OsalMemFree(request->reqMsg.clientData);
722 request->reqMsg.clientData = nullptr;
723 }
724 request->reqMsg.clientLength = 0;
725 request->status = 0;
726 return HDF_SUCCESS;
727 }
728
UsbdBulkASyncListFind(HostDevice * port,uint8_t ifId,uint8_t epId)729 UsbdBulkASyncList *UsbImpl::UsbdBulkASyncListFind(HostDevice *port, uint8_t ifId, uint8_t epId)
730 {
731 if (port == nullptr) {
732 HDF_LOGE("%{public}s:invalid param port", __func__);
733 return nullptr;
734 }
735
736 UsbdBulkASyncList *list = port->bulkASyncList;
737 while (list) {
738 if (list->epId == epId && list->ifId == ifId) {
739 return list;
740 }
741 list = list->next;
742 }
743 return nullptr;
744 }
745
UsbdBulkASyncListInit(HostDevice * port,uint8_t ifId,uint8_t epId)746 UsbdBulkASyncList *UsbImpl::UsbdBulkASyncListInit(HostDevice *port, uint8_t ifId, uint8_t epId)
747 {
748 UsbdBulkASyncList *list = UsbdBulkASyncListFind(port, ifId, epId);
749 if (list == nullptr) {
750 list = UsbdDispatcher::UsbdBulkASyncListAlloc(port, ifId, epId);
751 if (list != nullptr) {
752 list->next = port->bulkASyncList;
753 port->bulkASyncList = list;
754 }
755 }
756 return list;
757 }
758
InitAsmBufferHandle(UsbdBufferHandle * handle,int32_t fd,int32_t size)759 int32_t UsbImpl::InitAsmBufferHandle(UsbdBufferHandle *handle, int32_t fd, int32_t size)
760 {
761 if (handle == nullptr) {
762 HDF_LOGE("%{public}s:invalid param handle", __func__);
763 return HDF_ERR_INVALID_PARAM;
764 }
765 ReleaseAsmBufferHandle(handle);
766
767 if (fd < 0 || size < 0) {
768 HDF_LOGE("%{public}s:invalid param fd or size", __func__);
769 return HDF_ERR_INVALID_PARAM;
770 }
771 handle->fd = fd;
772 handle->size = static_cast<uint32_t>(size);
773 handle->cur = 0;
774 handle->rcur = 0;
775 handle->cbflg = 0;
776 lseek(fd, 0, SEEK_SET);
777 handle->starAddr = static_cast<uint8_t *>(mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
778 close(fd);
779 if (handle->starAddr == nullptr) {
780 handle->fd = -1;
781 handle->size = 0;
782 HDF_LOGE("%{public}s:mmap error:%{public}s", __func__, strerror(errno));
783 return HDF_ERR_MALLOC_FAIL;
784 }
785 return HDF_SUCCESS;
786 }
787
UsbdBulkReadASyncSubmitStart(UsbdBulkASyncList * list)788 int32_t UsbImpl::UsbdBulkReadASyncSubmitStart(UsbdBulkASyncList *list)
789 {
790 if (list == nullptr) {
791 HDF_LOGE("%{public}s:invalid param list", __func__);
792 return HDF_ERR_INVALID_PARAM;
793 }
794
795 uint32_t i = 0;
796 int32_t ret = HDF_SUCCESS;
797 do {
798 UsbdBulkASyncReqNode *req = UsbdDispatcher::UsbdBulkASyncReqGetENode(&list->rList);
799 if (req == nullptr) {
800 HDF_LOGE("%{public}s:UsbdBulkASyncReqGetENode failed", __func__);
801 ret = HDF_ERR_DEVICE_BUSY;
802 break;
803 } else {
804 ret = UsbdDispatcher::UsbdBulkASyncReqReadSubmit(req);
805 if (ret != HDF_SUCCESS) {
806 HDF_LOGE("%{public}s:UsbdBulkASyncReqReadSubmit failed", __func__);
807 break;
808 }
809 }
810 if (++i > USBD_BULKASYNCREQ_NUM_MAX) {
811 break;
812 }
813 } while (!DListIsEmpty(&list->rList.eList));
814 return ret;
815 }
816
UsbdBulkASyncWriteSubmitStart(UsbdBulkASyncList * list)817 int32_t UsbImpl::UsbdBulkASyncWriteSubmitStart(UsbdBulkASyncList *list)
818 {
819 if (list == nullptr) {
820 HDF_LOGE("%{public}s:invalid param list", __func__);
821 return HDF_ERR_INVALID_PARAM;
822 }
823
824 uint32_t i = 0;
825 int32_t ret = HDF_SUCCESS;
826 do {
827 UsbdBulkASyncReqNode *req = UsbdDispatcher::UsbdBulkASyncReqGetENode(&list->rList);
828 if (req == nullptr) {
829 HDF_LOGE("%{public}s:UsbdBulkASyncReqGetENode failed", __func__);
830 ret = HDF_ERR_DEVICE_BUSY;
831 break;
832 } else {
833 ret = UsbdDispatcher::UsbdBulkASyncReqWriteSubmit(req);
834 if (ret != HDF_SUCCESS) {
835 HDF_LOGE("%{public}s:UsbdBulkASyncReqWriteSubmit failed", __func__);
836 break;
837 }
838 }
839 if (++i > USBD_BULKASYNCREQ_NUM_MAX) {
840 break;
841 }
842 } while (!DListIsEmpty(&list->rList.eList));
843 return ret;
844 }
845
ReleaseAsmBufferHandle(UsbdBufferHandle * handle)846 void UsbImpl::ReleaseAsmBufferHandle(UsbdBufferHandle *handle)
847 {
848 if (handle == nullptr) {
849 HDF_LOGE("%{public}s:invalid param handle", __func__);
850 return;
851 }
852
853 if (handle->size > 0) {
854 OsalMutexLock(&handle->lock);
855 handle->cur = 0;
856 handle->rcur = 0;
857 handle->fd = -1;
858 handle->cbflg = 0;
859 munmap(handle->starAddr, handle->size);
860 OsalMutexUnlock(&handle->lock);
861 }
862
863 handle->fd = -1;
864 handle->cur = 0;
865 handle->rcur = 0;
866 handle->size = 0;
867 handle->cbflg = 0;
868 handle->starAddr = nullptr;
869 }
870
BulkRequestCancel(UsbdBulkASyncList * list)871 int32_t UsbImpl::BulkRequestCancel(UsbdBulkASyncList *list)
872 {
873 if (list == nullptr) {
874 HDF_LOGE("%{public}s:invalid param list", __func__);
875 return HDF_ERR_INVALID_PARAM;
876 }
877
878 for (int32_t i = 0; i < USBD_BULKASYNCREQ_NUM_MAX; ++i) {
879 if (list->rList.node[i].use == USBD_REQNODE_USE || list->rList.node[i].use == USBD_REQNODE_OTHER) {
880 int32_t ret = UsbCancelRequest(list->rList.node[i].request);
881 if (ret != HDF_SUCCESS) {
882 HDF_LOGE("%{public}s: UsbCancelRequest failed, ret=%{public}d ", __func__, ret);
883 return ret;
884 }
885 }
886 }
887 OsalMSleep(USB_BULK_CANCEL_SLEEP_TIME);
888
889 for (int32_t i = 0; i < USBD_BULKASYNCREQ_NUM_MAX; ++i) {
890 list->rList.node[i].request->compInfo.status = UsbRequestStatus::USB_REQUEST_COMPLETED;
891 if (list->rList.node[i].use == USBD_REQNODE_USE || list->rList.node[i].use == USBD_REQNODE_OTHER) {
892 list->rList.node[i].request->compInfo.status = UsbRequestStatus::USB_REQUEST_COMPLETED;
893 UsbdDispatcher::UsbdBulkASyncReqNodeSetNoUse(&list->rList.node[i]);
894 }
895 }
896 return HDF_SUCCESS;
897 }
898
ReportUsbdSysEvent(int32_t code,UsbPnpNotifyMatchInfoTable * infoTable)899 void UsbImpl::ReportUsbdSysEvent(int32_t code, UsbPnpNotifyMatchInfoTable *infoTable)
900 {
901 if (code == HDF_SUCCESS) {
902 HDF_LOGI("%{public}s: UsbdDeviceCreateAndAttach successed", __func__);
903 attachCount_++;
904 } else if (code != HDF_ERR_DEVICE_BUSY) {
905 attachFailedCount_++;
906 attachCount_++;
907 HDF_LOGI("%{public}s: UsbdDeviceCreateAndAttach failed", __func__);
908 HiSysEventWrite(HiSysEvent::Domain::HDF_USB, "RECOGNITION_FAIL", HiSysEvent::EventType::FAULT, "DEVICE_NAME",
909 std::to_string(infoTable->busNum) + "-" + std::to_string(infoTable->devNum), "DEVICE_PROTOCOL",
910 infoTable->deviceInfo.deviceProtocol, "DEVICE_CLASS", infoTable->deviceInfo.deviceClass, "VENDOR_ID",
911 infoTable->deviceInfo.vendorId, "PRODUCT_ID", infoTable->deviceInfo.productId, "VERSION", "1.0.0",
912 "FAIL_REASON", 0, "FAIL_INFO", "USB device recognition failed");
913 HiSysEventWrite(HiSysEvent::Domain::HDF_USB, "RECOGNITION_FAIL_STATISTICS", HiSysEvent::EventType::FAULT,
914 "EXCEPTION_CNT", attachFailedCount_, "TOTAL_CNT", attachCount_, "FAIL_RATE",
915 (static_cast<double>(attachFailedCount_)) /
916 (static_cast<double>(attachCount_) * USB_RECOGNITION_FAIL_RATE_BASE),
917 "QUALITY_STATISTICAL", "Failure rate statistics");
918 } else {
919 HDF_LOGI("%{public}s:device already add", __func__);
920 }
921 }
922
UsbdCloseFd(UsbImpl * super,UsbPnpNotifyMatchInfoTable * infoTable)923 void UsbImpl::UsbdCloseFd(UsbImpl *super, UsbPnpNotifyMatchInfoTable *infoTable)
924 {
925 std::lock_guard<std::mutex> lock(super->openedFdsMutex_);
926 auto iter = super->openedFds_.find({infoTable->busNum, infoTable->devNum});
927 if (iter != super->openedFds_.end()) {
928 int32_t fd = iter->second;
929 int res = close(fd);
930 super->openedFds_.erase(iter);
931 HDF_LOGI("%{public}s:%{public}d close %{public}d ret = %{public}d",
932 __func__, __LINE__, iter->second, res);
933 } else {
934 HDF_LOGI("%{public}s:%{public}d not opened", __func__, __LINE__);
935 }
936 }
937
UsbdPnpNotifyAddAndRemoveDevice(HdfSBuf * data,UsbdSubscriber * usbdSubscriber,uint32_t id)938 int32_t UsbImpl::UsbdPnpNotifyAddAndRemoveDevice(HdfSBuf *data, UsbdSubscriber *usbdSubscriber, uint32_t id)
939 {
940 if (data == nullptr) {
941 HDF_LOGE("%{public}s: data is nullptr", __func__);
942 return HDF_ERR_INVALID_PARAM;
943 }
944 sptr<UsbImpl> super = static_cast<UsbImpl *>(usbdSubscriber->impl);
945 if (super == nullptr) {
946 HDF_LOGE("%{public}s super is nullptr", __func__);
947 return HDF_ERR_INVALID_PARAM;
948 }
949 const sptr<IUsbdSubscriber> subscriber = usbdSubscriber->subscriber;
950
951 uint32_t infoSize;
952 UsbPnpNotifyMatchInfoTable *infoTable = nullptr;
953 bool flag = HdfSbufReadBuffer(data, (const void **)(&infoTable), &infoSize);
954 if (!flag || infoTable == nullptr) {
955 HDF_LOGE("%{public}s: HdfSbufReadBuffer failed, flag=%{public}d", __func__, flag);
956 return HDF_ERR_INVALID_PARAM;
957 }
958
959 if (infoTable->deviceInfo.deviceClass == BASE_CLASS_HUB) {
960 HDF_LOGI("%{public}s:hub device", __func__);
961 if (id == USB_PNP_NOTIFY_REMOVE_DEVICE) {
962 HDF_LOGI("%{public}s:UsbdRemoveBusDev busNum:%{public}d", __func__, infoTable->busNum);
963 UsbdDispatcher::UsbdRemoveBusDev(super, infoTable->busNum, subscriber);
964 }
965 return HDF_SUCCESS;
966 }
967
968 int32_t ret = HDF_SUCCESS;
969 if (id == USB_PNP_NOTIFY_ADD_DEVICE) {
970 ret = UsbdDispatcher::UsbdDeviceCreateAndAttach(super, infoTable->busNum, infoTable->devNum);
971 ReportUsbdSysEvent(ret, infoTable);
972 USBDeviceInfo info = {ACT_DEVUP, infoTable->busNum, infoTable->devNum};
973 if (subscriber == nullptr) {
974 HDF_LOGE("%{public}s: subscriber is nullptr, %{public}d", __func__, __LINE__);
975 return HDF_FAILURE;
976 }
977 ret = subscriber->DeviceEvent(info);
978 } else if (id == USB_PNP_NOTIFY_REMOVE_DEVICE) {
979 UsbImpl::UsbdCloseFd(super, infoTable);
980 UsbdDispatcher::UsbdDeviceDettach(super, infoTable->busNum, infoTable->devNum);
981 USBDeviceInfo info = {ACT_DEVDOWN, infoTable->busNum, infoTable->devNum};
982 if (subscriber == nullptr) {
983 HDF_LOGE("%{public}s: subscriber is nullptr, %{public}d", __func__, __LINE__);
984 return HDF_FAILURE;
985 }
986 ret = subscriber->DeviceEvent(info);
987 }
988 return ret;
989 }
990
UsbdPnpLoaderEventReceived(void * priv,uint32_t id,HdfSBuf * data)991 int32_t UsbImpl::UsbdPnpLoaderEventReceived(void *priv, uint32_t id, HdfSBuf *data)
992 {
993 UsbdSubscriber *usbdSubscriber = static_cast<UsbdSubscriber *>(priv);
994 const sptr<IUsbdSubscriber> subscriber = usbdSubscriber->subscriber;
995
996 if (id == USB_PNP_DRIVER_GADGET_ADD) {
997 HITRACE_METER_NAME(HITRACE_TAG_HDF, "USB_PNP_DRIVER_GADGET_ADD");
998 isGadgetConnected_ = true;
999 USBDeviceInfo info = {ACT_UPDEVICE, 0, 0};
1000 if (subscriber == nullptr) {
1001 HDF_LOGE("%{public}s: subscriber is nullptr, %{public}d", __func__, __LINE__);
1002 return HDF_FAILURE;
1003 }
1004 return subscriber->DeviceEvent(info);
1005 } else if (id == USB_PNP_DRIVER_GADGET_REMOVE) {
1006 HITRACE_METER_NAME(HITRACE_TAG_HDF, "USB_PNP_DRIVER_GADGET_REMOVE");
1007 isGadgetConnected_ = false;
1008 USBDeviceInfo info = {ACT_DOWNDEVICE, 0, 0};
1009 if (subscriber == nullptr) {
1010 HDF_LOGE("%{public}s: subscriber is nullptr, %{public}d", __func__, __LINE__);
1011 return HDF_FAILURE;
1012 }
1013 UsbdAccessory::GetInstance().HandleEvent(ACT_DOWNDEVICE);
1014 return subscriber->DeviceEvent(info);
1015 } else if (id == USB_PNP_DRIVER_PORT_HOST) {
1016 HITRACE_METER_NAME(HITRACE_TAG_HDF, "USB_PNP_DRIVER_PORT_HOST");
1017 return UsbdPort::GetInstance().UpdatePort(PORT_MODE_HOST, subscriber);
1018 } else if (id == USB_PNP_DRIVER_PORT_DEVICE) {
1019 HITRACE_METER_NAME(HITRACE_TAG_HDF, "USB_PNP_DRIVER_PORT_DEVICE");
1020 return UsbdPort::GetInstance().UpdatePort(PORT_MODE_DEVICE, subscriber);
1021 } else if (id == USB_ACCESSORY_START) {
1022 if (subscriber == nullptr) {
1023 HDF_LOGE("%{public}s: subscriber is nullptr, %{public}d", __func__, __LINE__);
1024 return HDF_FAILURE;
1025 }
1026 HITRACE_METER_NAME(HITRACE_TAG_HDF, "USB_ACCESSORY_START");
1027 USBDeviceInfo info = {ACT_ACCESSORYUP, 0, 0};
1028 return subscriber->DeviceEvent(info);
1029 } else if (id == USB_ACCESSORY_SEND) {
1030 if (subscriber == nullptr) {
1031 HDF_LOGE("%{public}s: subsciber is nullptr, %{public}d", __func__, __LINE__);
1032 return HDF_FAILURE;
1033 }
1034 HITRACE_METER_NAME(HITRACE_TAG_HDF, "USB_ACCESSORY_SEND");
1035 USBDeviceInfo info = {ACT_ACCESSORYSEND, 0, 0};
1036 return subscriber->DeviceEvent(info);
1037 }
1038 HITRACE_METER_NAME(HITRACE_TAG_HDF, "USB_PNP_NOTIFY_ADD_OR_REMOVE_DEVICE");
1039 return UsbdPnpNotifyAddAndRemoveDevice(data, usbdSubscriber, id);
1040 }
1041
UsbdLoadServiceCallback(void * priv,uint32_t id,HdfSBuf * data)1042 int32_t UsbImpl::UsbdLoadServiceCallback(void *priv, uint32_t id, HdfSBuf *data)
1043 {
1044 (void)priv;
1045 (void)data;
1046 if (id == USB_PNP_DRIVER_GADGET_ADD || id == USB_PNP_NOTIFY_ADD_DEVICE) {
1047 if (loadUsbService_.LoadService() != 0) {
1048 HDF_LOGE("loadUsbService_ LoadService error");
1049 return HDF_FAILURE;
1050 }
1051 if (id == USB_PNP_NOTIFY_ADD_DEVICE) {
1052 if (loadHdfEdm_.LoadService() != 0) {
1053 HDF_LOGE("loadHdfEdm_ LoadService error");
1054 return HDF_FAILURE;
1055 }
1056 }
1057 }
1058 return HDF_SUCCESS;
1059 }
1060
UpdateFunctionStatus()1061 void UsbImpl::UpdateFunctionStatus()
1062 {
1063 char cFunctionValue[FUNCTION_VALUE_MAX_LEN] = {0};
1064 int32_t ret = GetParameter(PERSIST_SYS_USB_CONFIG, "invalid", cFunctionValue, FUNCTION_VALUE_MAX_LEN);
1065 if (ret <= 0) {
1066 HDF_LOGE("%{public}s: GetParameter failed", __func__);
1067 }
1068
1069 std::string functionValue(cFunctionValue);
1070 auto it = configMap.find(functionValue);
1071 if (it != configMap.end()) {
1072 HDF_LOGI("Function is %{public}s", functionValue.c_str());
1073 ret = UsbdFunction::UsbdUpdateFunction(it->second);
1074 if (ret != HDF_SUCCESS) {
1075 HDF_LOGE("%{public}s: UsbdUpdateFunction failed", __func__);
1076 }
1077 }
1078 }
1079
UsbdEventHandle(const sptr<UsbImpl> & inst)1080 int32_t UsbImpl::UsbdEventHandle(const sptr<UsbImpl> &inst)
1081 {
1082 UsbImpl::UpdateFunctionStatus();
1083 inst->parsePortPath();
1084 listenerForLoadService_.callBack = UsbdLoadServiceCallback;
1085 if (DdkListenerMgrAdd(&listenerForLoadService_) != HDF_SUCCESS) {
1086 HDF_LOGE("%{public}s: register listerer failed", __func__);
1087 return HDF_FAILURE;
1088 }
1089 return HDF_SUCCESS;
1090 }
1091
UsbdEventHandleRelease(void)1092 int32_t UsbImpl::UsbdEventHandleRelease(void)
1093 {
1094 int32_t ret = DdkListenerMgrRemove(&listenerForLoadService_);
1095 if (ret != HDF_SUCCESS) {
1096 HDF_LOGE("%{public}s: DdkListenerMgrRemove failed", __func__);
1097 }
1098 listenerForLoadService_.callBack = nullptr;
1099 listenerForLoadService_.priv = nullptr;
1100 return ret;
1101 }
1102
UsbdReleaseDevices()1103 int32_t UsbImpl::UsbdReleaseDevices()
1104 {
1105 OsalMutexLock(&lock_);
1106 while (!HdfSListIsEmpty(&devList_)) {
1107 HostDevice *port = reinterpret_cast<HostDevice *>(HdfSListPop(&devList_));
1108 if (port != nullptr) {
1109 UsbdDispatcher::UsbdRelease(port);
1110 OsalMemFree(port);
1111 }
1112 }
1113 OsalMutexUnlock(&lock_);
1114 return HDF_SUCCESS;
1115 }
1116
OpenDevice(const UsbDev & dev)1117 int32_t UsbImpl::OpenDevice(const UsbDev &dev)
1118 {
1119 #ifndef LIBUSB_ENABLE
1120 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1121 if (port == nullptr) {
1122 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1123 return HDF_DEV_ERR_NO_DEVICE;
1124 }
1125 if (g_usbOpenCount >= INT_MAX) {
1126 HDF_LOGE("%{public}s: OpenDevice too many times ", __func__);
1127 return HDF_FAILURE;
1128 }
1129 OsalMutexLock(&lock_);
1130 g_usbOpenCount++;
1131 port->initFlag = true;
1132 if (port->ctrDevHandle == nullptr && port->ctrIface != nullptr) {
1133 HDF_LOGD("%{public}s:start openInterface, busNum: %{public}d, devAddr: %{public}d ",
1134 __func__, dev.busNum, dev.devAddr);
1135 port->ctrDevHandle = UsbOpenInterface(port->ctrIface);
1136 if (port->ctrDevHandle == nullptr) {
1137 OsalMutexUnlock(&lock_);
1138 HDF_LOGE("%{public}s:ctrDevHandle UsbOpenInterface nullptr", __func__);
1139 return HDF_FAILURE;
1140 }
1141 }
1142 OsalMutexUnlock(&lock_);
1143 return HDF_SUCCESS;
1144 #else
1145 return LibusbAdapter::GetInstance()->OpenDevice(dev);
1146 #endif // LIBUSB_ENABLE
1147 }
1148
CloseDevice(const UsbDev & dev)1149 int32_t UsbImpl::CloseDevice(const UsbDev &dev)
1150 {
1151 #ifndef LIBUSB_ENABLE
1152 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1153 if (port == nullptr) {
1154 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1155 return HDF_DEV_ERR_NO_DEVICE;
1156 }
1157 if (!port->initFlag) {
1158 HDF_LOGE("%{public}s: openPort failed", __func__);
1159 return HDF_DEV_ERR_DEV_INIT_FAIL;
1160 }
1161 OsalMutexLock(&lock_);
1162 g_usbOpenCount--;
1163 int32_t ret = 0;
1164 if (port->ctrDevHandle != nullptr && g_usbOpenCount == 0) {
1165 for (uint8_t interfaceId = 0; interfaceId < USB_MAX_INTERFACES; ++interfaceId) {
1166 if (port->iface[interfaceId] != nullptr) {
1167 ReleaseInterfaceByPort(port, interfaceId);
1168 }
1169 port->iface[interfaceId] = nullptr;
1170 }
1171 RawUsbCloseCtlProcess(port->ctrDevHandle);
1172 ret = UsbCloseInterface(port->ctrDevHandle, true);
1173 if (ret != HDF_SUCCESS) {
1174 OsalMutexUnlock(&lock_);
1175 HDF_LOGE("%{public}s:usbCloseInterface ctrDevHandle failed.", __func__);
1176 return HDF_FAILURE;
1177 }
1178 port->ctrDevHandle = nullptr;
1179 port->initFlag = false;
1180 }
1181 OsalMutexUnlock(&lock_);
1182 return HDF_SUCCESS;
1183 #else
1184 return LibusbAdapter::GetInstance()->CloseDevice(dev);
1185 #endif // LIBUSB_ENABLE
1186 }
1187
ResetDevice(const UsbDev & dev)1188 int32_t UsbImpl::ResetDevice(const UsbDev &dev)
1189 {
1190 #ifndef LIBUSB_ENABLE
1191 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1192 if (port == nullptr) {
1193 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1194 return HDF_DEV_ERR_NO_DEVICE;
1195 }
1196 if (port->ctrDevHandle == nullptr && port->ctrIface != nullptr) {
1197 HDF_LOGD("%{public}s:start resetDevice, busNum: %{public}d, devAddr: %{public}d ",
1198 __func__, dev.busNum, dev.devAddr);
1199 port->ctrDevHandle = UsbResetDevice(port->ctrIface);
1200 if (port->ctrDevHandle == nullptr) {
1201 HDF_LOGE("%{public}s:UsbResetDevice failed", __func__);
1202 return HDF_FAILURE;
1203 }
1204 }
1205 return HDF_SUCCESS;
1206 #else
1207 return LibusbAdapter::GetInstance()->ResetDevice(dev);
1208 #endif // LIBUSB_ENABLE
1209 }
1210
GetDeviceDescriptor(const UsbDev & dev,std::vector<uint8_t> & descriptor)1211 int32_t UsbImpl::GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor)
1212 {
1213 #ifndef LIBUSB_ENABLE
1214 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1215 if (port == nullptr) {
1216 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1217 return HDF_DEV_ERR_NO_DEVICE;
1218 }
1219
1220 uint16_t length = USB_MAX_DESCRIPTOR_SIZE;
1221 uint8_t buffer[USB_MAX_DESCRIPTOR_SIZE] = {0};
1222 UsbControlParams controlParams = {0};
1223 MakeUsbControlParams(&controlParams, buffer, length, static_cast<int32_t>(USB_DDK_DT_DEVICE) << TYPE_OFFSET_8, 0);
1224 int32_t ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT);
1225 if (ret != HDF_SUCCESS) {
1226 HDF_LOGE("%{public}s:UsbControlTransferEx failed, ret:%{public}d", __func__, ret);
1227 return ret;
1228 }
1229 descriptor.resize(USB_MAX_DESCRIPTOR_SIZE);
1230 std::copy(buffer, buffer + std::min(USB_MAX_DESCRIPTOR_SIZE, static_cast<int>(length)), descriptor.begin());
1231 return HDF_SUCCESS;
1232 #else
1233 return LibusbAdapter::GetInstance()->GetDeviceDescriptor(dev, descriptor);
1234 #endif // LIBUSB_ENABLE
1235 }
1236
GetStringDescriptor(const UsbDev & dev,uint8_t descId,std::vector<uint8_t> & descriptor)1237 int32_t UsbImpl::GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor)
1238 {
1239 #ifndef LIBUSB_ENABLE
1240 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1241 if (port == nullptr) {
1242 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1243 return HDF_DEV_ERR_NO_DEVICE;
1244 }
1245
1246 uint16_t length = USB_MAX_DESCRIPTOR_SIZE;
1247 uint8_t buffer[USB_MAX_DESCRIPTOR_SIZE] = {0};
1248 UsbControlParams controlParams = {0};
1249 MakeUsbControlParams(
1250 &controlParams, buffer, length,
1251 (static_cast<int32_t>(USB_DDK_DT_STRING) << TYPE_OFFSET_8) + descId, ENGLISH_US_LANGUAGE_ID);
1252 int32_t ret = UsbControlTransferEx(port, &controlParams, GET_STRING_SET_TIMEOUT);
1253 if (ret != HDF_SUCCESS) {
1254 HDF_LOGE("%{public}s:UsbControlTransferEx failed ret=%{public}d", __func__, ret);
1255 return ret;
1256 }
1257
1258 descriptor.resize(USB_MAX_DESCRIPTOR_SIZE);
1259 std::copy(buffer, buffer + std::min(USB_MAX_DESCRIPTOR_SIZE, static_cast<int>(length)), descriptor.begin());
1260 return HDF_SUCCESS;
1261 #else
1262 return LibusbAdapter::GetInstance()->GetStringDescriptor(dev, descId, descriptor);
1263 #endif // LIBUSB_ENABLE
1264 }
1265
GetConfigDescriptor(const UsbDev & dev,uint8_t descId,std::vector<uint8_t> & descriptor)1266 int32_t UsbImpl::GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor)
1267 {
1268 #ifndef LIBUSB_ENABLE
1269 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1270 if (port == nullptr) {
1271 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1272 return HDF_DEV_ERR_NO_DEVICE;
1273 }
1274
1275 uint16_t length = USB_MAX_DESCRIPTOR_SIZE;
1276 uint8_t buffer[USB_MAX_DESCRIPTOR_SIZE] = {0};
1277 UsbControlParams controlParams = {0};
1278 MakeUsbControlParams(
1279 &controlParams, buffer, length, (static_cast<int32_t>(USB_DDK_DT_CONFIG) << TYPE_OFFSET_8) + descId, 0);
1280 int32_t ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT);
1281 if (ret != HDF_SUCCESS) {
1282 HDF_LOGE("%{public}s:UsbControlTransferEx failed ret=%{public}d", __func__, ret);
1283 return ret;
1284 }
1285
1286 descriptor.resize(USB_MAX_DESCRIPTOR_SIZE);
1287 std::copy(buffer, buffer + std::min(USB_MAX_DESCRIPTOR_SIZE, static_cast<int>(length)), descriptor.begin());
1288 return HDF_SUCCESS;
1289 #else
1290 return LibusbAdapter::GetInstance()->GetConfigDescriptor(dev, descId, descriptor);
1291 #endif // LIBUSB_ENABLE
1292 }
1293
GetRawDescriptor(const UsbDev & dev,std::vector<uint8_t> & descriptor)1294 int32_t UsbImpl::GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor)
1295 {
1296 #ifndef LIBUSB_ENABLE
1297 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1298 if (port == nullptr || port->ctrDevHandle == nullptr) {
1299 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1300 return HDF_DEV_ERR_NO_DEVICE;
1301 }
1302
1303 UsbInterfaceHandleEntity *handle = reinterpret_cast<UsbInterfaceHandleEntity *>(port->ctrDevHandle);
1304 OsalMutexLock(&handle->devHandle->lock);
1305 uint8_t *ptr = static_cast<uint8_t *>(handle->devHandle->dev->descriptors);
1306 uint32_t length = handle->devHandle->dev->descriptorsLength;
1307 descriptor.resize(length);
1308 std::copy(ptr, ptr + length, descriptor.begin());
1309 OsalMutexUnlock(&handle->devHandle->lock);
1310 return HDF_SUCCESS;
1311 #else
1312 return LibusbAdapter::GetInstance()->GetRawDescriptor(dev, descriptor);
1313 #endif // LIBUSB_ENABLE
1314 }
1315
GetFileDescriptor(const UsbDev & dev,int32_t & fd)1316 int32_t UsbImpl::GetFileDescriptor(const UsbDev &dev, int32_t &fd)
1317 {
1318 #ifndef LIBUSB_ENABLE
1319 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1320 if (port == nullptr || port->ctrDevHandle == nullptr) {
1321 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1322 return HDF_DEV_ERR_NO_DEVICE;
1323 }
1324
1325 UsbInterfaceHandleEntity *handle = reinterpret_cast<UsbInterfaceHandleEntity *>(port->ctrDevHandle);
1326 OsalMutexLock(&handle->devHandle->lock);
1327 fd = handle->devHandle->fd;
1328 OsalMutexUnlock(&handle->devHandle->lock);
1329 return HDF_SUCCESS;
1330 #else
1331 return LibusbAdapter::GetInstance()->GetFileDescriptor(dev, fd);
1332 #endif // LIBUSB_ENABLE
1333 }
1334
GetDeviceFileDescriptor(const UsbDev & dev,int32_t & fd)1335 int32_t UsbImpl::GetDeviceFileDescriptor(const UsbDev &dev, int32_t &fd)
1336 {
1337 #ifndef LIBUSB_ENABLE
1338 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1339 if (port == nullptr || port->ctrDevHandle == nullptr) {
1340 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1341 return HDF_DEV_ERR_NO_DEVICE;
1342 }
1343
1344 UsbInterfaceHandleEntity *handle = reinterpret_cast<UsbInterfaceHandleEntity *>(port->ctrDevHandle);
1345 OsalMutexLock(&handle->devHandle->lock);
1346 fd = GetDeviceFd(handle->devHandle->dev, O_RDWR);
1347 if (fd <= 0) {
1348 fd = handle->devHandle->fd;
1349 HDF_LOGW("%{public}s:open fd failed, fall back to default", __func__);
1350 } else {
1351 std::lock_guard<std::mutex> lock(openedFdsMutex_);
1352 auto iter = openedFds_.find({dev.busNum, dev.devAddr});
1353 if (iter != openedFds_.end()) {
1354 int32_t oldFd = iter->second;
1355 int res = close(oldFd);
1356 HDF_LOGI("%{public}s:%{public}d close old %{public}d ret = %{public}d",
1357 __func__, __LINE__, iter->second, res);
1358 } else {
1359 HDF_LOGI("%{public}s:%{public}d first time get fd", __func__, __LINE__);
1360 }
1361 openedFds_[{dev.busNum, dev.devAddr}] = fd;
1362 HDF_LOGI("%{public}s:%{public}d opened %{public}d", __func__, __LINE__, fd);
1363 }
1364 OsalMutexUnlock(&handle->devHandle->lock);
1365 return HDF_SUCCESS;
1366 #else
1367 return LibusbAdapter::GetInstance()->GetDeviceFileDescriptor(dev, fd);
1368 #endif // LIBUSB_ENABLE
1369 }
1370
IfConfigIndex(const uint8_t configIndex,HostDevice * port,int32_t & ret)1371 int32_t UsbImpl::IfConfigIndex(const uint8_t configIndex, HostDevice *port, int32_t &ret)
1372 {
1373 if (configIndex != 0) {
1374 ret = ReOpenDevice(port);
1375 if (ret != HDF_SUCCESS) {
1376 HDF_LOGE("%{public}s:ReOpenDevice failed ret:%{public}d", __func__, ret);
1377 return ret;
1378 }
1379 }
1380 return ret;
1381 }
1382
SetConfig(const UsbDev & dev,uint8_t configIndex)1383 int32_t UsbImpl::SetConfig(const UsbDev &dev, uint8_t configIndex)
1384 {
1385 #ifndef LIBUSB_ENABLE
1386 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1387 if (port == nullptr) {
1388 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1389 return HDF_DEV_ERR_NO_DEVICE;
1390 }
1391 if (!port->initFlag) {
1392 HDF_LOGE("%{public}s: openPort failed", __func__);
1393 return HDF_DEV_ERR_DEV_INIT_FAIL;
1394 }
1395
1396 uint8_t configIdOld = 0;
1397 uint8_t configIdNew = 0;
1398 uint16_t length = 1;
1399 UsbControlParams controlParams;
1400 MakeGetActiveUsbControlParams(&controlParams, &configIdOld, length, 0, 0);
1401 int32_t ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT);
1402 if (ret != HDF_SUCCESS) {
1403 HDF_LOGE("%{public}s:setConfiguration failed ret:%{public}d", __func__, ret);
1404 return HDF_ERR_INVALID_PARAM;
1405 }
1406 if (configIndex == configIdOld) {
1407 HDF_LOGE("%{public}s:setConfiguration success, configIndex:%{public}d configIdOld:%{public}d", __func__,
1408 configIndex, configIdOld);
1409 return HDF_SUCCESS;
1410 }
1411
1412 length = 0;
1413 MakeSetActiveUsbControlParams(&controlParams, &configIndex, length, static_cast<int32_t>(configIndex), 0);
1414 ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT);
1415 if (ret != HDF_SUCCESS) {
1416 HDF_LOGE("%{public}s:setConfiguration failed ret:%{public}d", __func__, ret);
1417 return HDF_ERR_IO;
1418 }
1419
1420 length = 1;
1421 MakeGetActiveUsbControlParams(&controlParams, &configIdNew, length, 0, 0);
1422 ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT);
1423 if (ret != HDF_SUCCESS || configIndex != configIdNew) {
1424 HDF_LOGE("%{public}s:getConfiguration failed ret:%{public}d", __func__, ret);
1425 HDF_LOGE("%{public}s:setConfiguration failed, IdSet:%{public}d,IdOld:%{public}d,IdNew:%{public}d",
1426 __func__, configIndex, configIdOld, configIdNew);
1427 return HDF_ERR_IO;
1428 }
1429 return IfConfigIndex(configIndex, port, ret);
1430 #else
1431 return LibusbAdapter::GetInstance()->SetConfig(dev, configIndex);
1432 #endif // LIBUSB_ENABLE
1433 }
1434
GetConfig(const UsbDev & dev,uint8_t & configIndex)1435 int32_t UsbImpl::GetConfig(const UsbDev &dev, uint8_t &configIndex)
1436 {
1437 #ifndef LIBUSB_ENABLE
1438 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1439 if (port == nullptr) {
1440 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1441 return HDF_DEV_ERR_NO_DEVICE;
1442 }
1443
1444 uint16_t length = 1;
1445 UsbControlParams controlParams;
1446 MakeGetActiveUsbControlParams(&controlParams, &configIndex, length, 0, 0);
1447 int32_t ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT);
1448 if (ret != HDF_SUCCESS) {
1449 HDF_LOGE("%{public}s:UsbControlTransferEx failed", __func__);
1450 return HDF_ERR_IO;
1451 }
1452 return HDF_SUCCESS;
1453 #else
1454 return LibusbAdapter::GetInstance()->GetConfig(dev, configIndex);
1455 #endif // LIBUSB_ENABLE
1456 }
1457
ClaimInterface(const UsbDev & dev,uint8_t interfaceId,uint8_t force)1458 int32_t UsbImpl::ClaimInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t force)
1459 {
1460 #ifndef LIBUSB_ENABLE
1461 HDF_LOGI("%{public}s:%{public}d start", __func__, __LINE__);
1462 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1463 if (port == nullptr) {
1464 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1465 return HDF_DEV_ERR_NO_DEVICE;
1466 }
1467 if (!port->initFlag) {
1468 HDF_LOGE("%{public}s: openPort failed", __func__);
1469 return HDF_DEV_ERR_DEV_INIT_FAIL;
1470 }
1471 if (interfaceId >= USB_MAX_INTERFACES) {
1472 HDF_LOGE("%{public}s:interfaceId larger than max num", __func__);
1473 return HDF_ERR_INVALID_PARAM;
1474 }
1475
1476 if (port->iface[interfaceId] == nullptr) {
1477 if (force) {
1478 port->iface[interfaceId] =
1479 UsbClaimInterface(port->service->session_, port->busNum, port->devAddr, interfaceId);
1480 } else {
1481 port->iface[interfaceId] =
1482 UsbClaimInterfaceUnforce(port->service->session_, port->busNum, port->devAddr, interfaceId);
1483 }
1484 if (port->iface[interfaceId] == nullptr) {
1485 HDF_LOGE("%{public}s:UsbClaimInterface failed, busNum=%{public}u, devAddr=%{public}u", __func__,
1486 port->busNum, port->devAddr);
1487 return HDF_FAILURE;
1488 }
1489 }
1490 if (port->devHandle[interfaceId] == nullptr) {
1491 port->devHandle[interfaceId] = UsbOpenInterface(port->iface[interfaceId]);
1492 if (port->devHandle[interfaceId] == nullptr) {
1493 HDF_LOGE("%{public}s:UsbOpenInterface failed.", __func__);
1494 return HDF_FAILURE;
1495 }
1496 } else {
1497 HDF_LOGW("%{public}s:the interface has been claimed.", __func__);
1498 }
1499 HDF_LOGI("%{public}s:%{public}d end", __func__, __LINE__);
1500 return HDF_SUCCESS;
1501 #else
1502 return LibusbAdapter::GetInstance()->ClaimInterface(dev, interfaceId, force);
1503 #endif // LIBUSB_ENABLE
1504 }
1505
ManageInterface(const UsbDev & dev,uint8_t interfaceId,bool disable)1506 int32_t UsbImpl::ManageInterface(const UsbDev &dev, uint8_t interfaceId, bool disable)
1507 {
1508 #ifndef LIBUSB_ENABLE
1509 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1510 if (port == nullptr) {
1511 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1512 return HDF_DEV_ERR_NO_DEVICE;
1513 }
1514 if (interfaceId >= USB_MAX_INTERFACES) {
1515 HDF_LOGE("%{public}s:interfaceId larger then max num", __func__);
1516 return HDF_ERR_INVALID_PARAM;
1517 }
1518
1519 port->iface[interfaceId] =
1520 UsbManageInterface(port->service->session_, port->busNum, port->devAddr, interfaceId, disable);
1521 if (port->iface[interfaceId] == nullptr) {
1522 HDF_LOGE("%{public}s: ManageInterface failed, busNum=%{public}u, devAddr=%{public}u", __func__,
1523 port->busNum, port->devAddr);
1524 return HDF_FAILURE;
1525 }
1526 return HDF_SUCCESS;
1527 #else
1528 return LibusbAdapter::GetInstance()->ManageInterface(dev, interfaceId, disable);
1529 #endif // LIBUSB_ENABLE
1530 }
1531
ReleaseInterface(const UsbDev & dev,uint8_t interfaceId)1532 int32_t UsbImpl::ReleaseInterface(const UsbDev &dev, uint8_t interfaceId)
1533 {
1534 #ifndef LIBUSB_ENABLE
1535 HDF_LOGI("%{public}s:%{public}d start", __func__, __LINE__);
1536 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1537 if (port == nullptr) {
1538 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1539 return HDF_DEV_ERR_NO_DEVICE;
1540 }
1541 if (!port->initFlag) {
1542 HDF_LOGE("%{public}s: openPort failed", __func__);
1543 return HDF_DEV_ERR_DEV_INIT_FAIL;
1544 }
1545
1546 if (interfaceId < USB_MAX_INTERFACES) {
1547 if (port->devHandle[interfaceId] == nullptr || port->iface[interfaceId] == nullptr) {
1548 HDF_LOGE("%{public}s: UsbOpenInterface or UsbClaimInterface failed", __func__);
1549 return HDF_DEV_ERR_OP;
1550 }
1551 if (HdfSListCount(&port->reqSyncList) > 0) {
1552 UsbdRequestSyncReleaseList(port);
1553 HDF_LOGD("%{public}s:release sync list", __func__);
1554 }
1555 if (HdfSListCount(&port->reqASyncList) > 0) {
1556 UsbdRequestASyncReleaseList(port);
1557 HDF_LOGD("%{public}s:release async list", __func__);
1558 }
1559 int32_t ret = UsbdBulkASyncListReleasePort(port);
1560 if (ret != HDF_SUCCESS) {
1561 HDF_LOGW("%{public}s:release bulk async list failed", __func__);
1562 }
1563 UsbCloseInterface(port->devHandle[interfaceId], false);
1564 port->devHandle[interfaceId] = nullptr;
1565 UsbReleaseInterface(port->iface[interfaceId]);
1566 port->iface[interfaceId] = nullptr;
1567 HDF_LOGI("%{public}s:%{public}d end", __func__, __LINE__);
1568 return HDF_SUCCESS;
1569 } else {
1570 HDF_LOGE("%{public}s:interfaceId failed busNum:%{public}u devAddr:%{public}u interfaceId:%{public}u", __func__,
1571 port->busNum, port->devAddr, interfaceId);
1572 return HDF_FAILURE;
1573 }
1574
1575 return HDF_SUCCESS;
1576 #else
1577 return LibusbAdapter::GetInstance()->ReleaseInterface(dev, interfaceId);
1578 #endif // LIBUSB_ENABLE
1579 }
1580
ReleaseInterfaceByPort(HostDevice * port,uint8_t interfaceId)1581 int32_t UsbImpl::ReleaseInterfaceByPort(HostDevice *port, uint8_t interfaceId)
1582 {
1583 if (port == nullptr) {
1584 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1585 return HDF_DEV_ERR_NO_DEVICE;
1586 }
1587 if (!port->initFlag) {
1588 HDF_LOGE("%{public}s: openPort failed", __func__);
1589 return HDF_DEV_ERR_DEV_INIT_FAIL;
1590 }
1591
1592 if (interfaceId < USB_MAX_INTERFACES) {
1593 if (port->devHandle[interfaceId] == nullptr || port->iface[interfaceId] == nullptr) {
1594 HDF_LOGE("%{public}s: UsbOpenInterface or UsbClaimInterface failed", __func__);
1595 return HDF_DEV_ERR_OP;
1596 }
1597 if (HdfSListCount(&port->reqSyncList) > 0) {
1598 UsbdRequestSyncReleaseList(port);
1599 HDF_LOGD("%{public}s:release sync list", __func__);
1600 }
1601 if (HdfSListCount(&port->reqASyncList) > 0) {
1602 UsbdRequestASyncReleaseList(port);
1603 HDF_LOGD("%{public}s:release async list", __func__);
1604 }
1605 int32_t ret = UsbdBulkASyncListReleasePort(port);
1606 if (ret != HDF_SUCCESS) {
1607 HDF_LOGW("%{public}s:release bulk async list failed", __func__);
1608 }
1609 UsbCloseInterface(port->devHandle[interfaceId], false);
1610 port->devHandle[interfaceId] = nullptr;
1611 UsbReleaseInterface(port->iface[interfaceId]);
1612 port->iface[interfaceId] = nullptr;
1613 return HDF_SUCCESS;
1614 } else {
1615 HDF_LOGE("%{public}s:interfaceId failed busNum:%{public}u devAddr:%{public}u interfaceId:%{public}u", __func__,
1616 port->busNum, port->devAddr, interfaceId);
1617 return HDF_FAILURE;
1618 }
1619
1620 return HDF_SUCCESS;
1621 }
1622
SetInterface(const UsbDev & dev,uint8_t interfaceId,uint8_t altIndex)1623 int32_t UsbImpl::SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex)
1624 {
1625 #ifndef LIBUSB_ENABLE
1626 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1627 if (port == nullptr) {
1628 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1629 return HDF_DEV_ERR_NO_DEVICE;
1630 }
1631 if (!port->initFlag) {
1632 HDF_LOGE("%{public}s: openPort failed", __func__);
1633 return HDF_DEV_ERR_DEV_INIT_FAIL;
1634 }
1635
1636 UsbInterfaceHandle *interfaceHandle = InterfaceIdToHandle(port, interfaceId);
1637 if (interfaceHandle == nullptr || interfaceId >= USB_MAX_INTERFACES) {
1638 HDF_LOGE("%{public}s:interfaceId failed busNum:%{public}u devAddr:%{public}u interfaceId:%{public}u", __func__,
1639 port->busNum, port->devAddr, interfaceId);
1640 return HDF_FAILURE;
1641 }
1642
1643 int32_t ret = UsbSelectInterfaceSetting(interfaceHandle, altIndex, &port->iface[interfaceId]);
1644 if (ret == HDF_SUCCESS) {
1645 UsbdRequestSyncReleaseList(port);
1646 UsbdRequestASyncReleaseList(port);
1647 UsbdBulkASyncListReleasePort(port);
1648 }
1649 return ret;
1650 #else
1651 return LibusbAdapter::GetInstance()->SetInterface(dev, interfaceId, altIndex);
1652 #endif // LIBUSB_ENABLE
1653 }
1654
BulkTransferRead(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,std::vector<uint8_t> & data)1655 int32_t UsbImpl::BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, std::vector<uint8_t> &data)
1656 {
1657 #ifndef LIBUSB_ENABLE
1658 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1659 if (port == nullptr) {
1660 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1661 return HDF_DEV_ERR_NO_DEVICE;
1662 }
1663
1664 uint8_t tbuf[READ_BUF_SIZE] = {0};
1665 uint32_t tsize = READ_BUF_SIZE;
1666 uint32_t actlength = 0;
1667 UsbdRequestSync *requestSync = nullptr;
1668 int32_t ret = UsbdFindRequestSyncAndCreat(port, pipe.intfId, pipe.endpointId, &requestSync);
1669 if (ret != HDF_SUCCESS || requestSync == nullptr) {
1670 HDF_LOGE("%{public}s:UsbdFindRequestSyncAndCreat failed.", __func__);
1671 return ret;
1672 }
1673 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN ||
1674 (requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK && requestSync->pipe.pipeType != USB_PIPE_TYPE_INTERRUPT)) {
1675 HDF_LOGE("%{public}s:invalid param", __func__);
1676 return HDF_ERR_INVALID_PARAM;
1677 }
1678 ret = UsbdBulkReadSyncBase(timeout, tbuf, tsize, &actlength, requestSync);
1679 if (ret != HDF_SUCCESS) {
1680 HDF_LOGW("%{public}s:UsbdBulkReadSyncBase ret:%{public}d, actlength:%{public}u", __func__, ret, actlength);
1681 }
1682
1683 if (actlength > 0) {
1684 data.assign(tbuf, tbuf + actlength);
1685 ret = HDF_SUCCESS;
1686 }
1687 return ret;
1688 #else
1689 return LibusbAdapter::GetInstance()->BulkTransferRead(dev, pipe, timeout, data);
1690 #endif // LIBUSB_ENABLE
1691 }
1692
BulkTransferReadwithLength(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,int32_t length,std::vector<uint8_t> & data)1693 int32_t UsbImpl::BulkTransferReadwithLength(const UsbDev &dev,
1694 const UsbPipe &pipe, int32_t timeout, int32_t length, std::vector<uint8_t> &data)
1695 {
1696 #ifndef LIBUSB_ENABLE
1697 if (length<= 0) {
1698 HDF_LOGE("%{public}s:invalid length param, length: %{public}d.", __func__, length);
1699 return HDF_ERR_INVALID_PARAM;
1700 }
1701 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1702 if (port == nullptr) {
1703 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1704 return HDF_DEV_ERR_NO_DEVICE;
1705 }
1706
1707 uint8_t* tbuf = (uint8_t *)malloc(length);
1708 if (tbuf == nullptr) {
1709 HDF_LOGE("%{public}s:malloc failed", __func__);
1710 return HDF_FAILURE;
1711 }
1712 memset_s(tbuf, length, 0, length);
1713 uint32_t tsize = static_cast<uint32_t>(length);
1714 uint32_t actlength = 0;
1715 UsbdRequestSync *requestSync = nullptr;
1716 int32_t ret = UsbdFindRequestSyncAndCreatwithLength(port, pipe.intfId, pipe.endpointId, length, &requestSync);
1717 if (ret != HDF_SUCCESS || requestSync == nullptr) {
1718 HDF_LOGE("%{public}s:UsbdFindRequestSyncAndCreat failed.", __func__);
1719 free(tbuf);
1720 tbuf = nullptr;
1721 return ret;
1722 }
1723 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN ||
1724 (requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK && requestSync->pipe.pipeType != USB_PIPE_TYPE_INTERRUPT)) {
1725 HDF_LOGE("%{public}s:invalid param", __func__);
1726 free(tbuf);
1727 tbuf = nullptr;
1728 return HDF_ERR_INVALID_PARAM;
1729 }
1730 ret = UsbdBulkReadSyncBase(timeout, tbuf, tsize, &actlength, requestSync);
1731 if (ret != HDF_SUCCESS) {
1732 HDF_LOGW("%{public}s:UsbdBulkReadSyncBase ret:%{public}d, actlength:%{public}u", __func__, ret, actlength);
1733 }
1734
1735 if (actlength > 0) {
1736 data.assign(tbuf, tbuf + actlength);
1737 ret = HDF_SUCCESS;
1738 }
1739 free(tbuf);
1740 tbuf = nullptr;
1741 return ret;
1742 #else
1743 return LibusbAdapter::GetInstance()->BulkTransferReadwithLength(dev, pipe, timeout, length, data);
1744 #endif // LIBUSB_ENABLE
1745 }
1746
BulkTransferWrite(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,const std::vector<uint8_t> & data)1747 int32_t UsbImpl::BulkTransferWrite(
1748 const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, const std::vector<uint8_t> &data)
1749 {
1750 #ifndef LIBUSB_ENABLE
1751 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1752 if (port == nullptr) {
1753 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1754 return HDF_DEV_ERR_NO_DEVICE;
1755 }
1756
1757 UsbdRequestSync *requestSync = nullptr;
1758 int32_t ret = UsbdFindRequestSyncAndCreat(port, pipe.intfId, pipe.endpointId, &requestSync);
1759 if (ret != HDF_SUCCESS || requestSync == nullptr) {
1760 HDF_LOGE("%{public}s:read timeout error", __func__);
1761 return ret;
1762 }
1763 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_OUT ||
1764 (requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK && requestSync->pipe.pipeType != USB_PIPE_TYPE_INTERRUPT)) {
1765 HDF_LOGE("%{public}s:invalid param", __func__);
1766 return HDF_ERR_INVALID_PARAM;
1767 }
1768 ret = UsbdBulkWriteSyncBase(port, requestSync, data.data(), data.size(), timeout);
1769 return ret;
1770 #else
1771 return LibusbAdapter::GetInstance()->BulkTransferWrite(dev, pipe, timeout, data);
1772 #endif // LIBUSB_ENABLE
1773 }
1774
ControlTransferRead(const UsbDev & dev,const UsbCtrlTransfer & ctrl,std::vector<uint8_t> & data)1775 int32_t UsbImpl::ControlTransferRead(const UsbDev &dev, const UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data)
1776 {
1777 #ifndef LIBUSB_ENABLE
1778 if ((static_cast<uint32_t>(ctrl.requestType) & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) {
1779 HDF_LOGE("%{public}s: this function is read, not write", __func__);
1780 return HDF_FAILURE;
1781 }
1782
1783 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1784 if (port == nullptr || port->ctrDevHandle == nullptr) {
1785 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1786 return HDF_DEV_ERR_NO_DEVICE;
1787 }
1788
1789 UsbControlParams controlParams;
1790 if (memset_s(&controlParams, sizeof(controlParams), 0, sizeof(controlParams)) != EOK) {
1791 HDF_LOGE("%{public}s:memset_s failed ", __func__);
1792 return HDF_FAILURE;
1793 }
1794 controlParams.request = static_cast<uint8_t>(ctrl.requestCmd);
1795 controlParams.value = ctrl.value;
1796 controlParams.index = ctrl.index;
1797 controlParams.target = (UsbRequestTargetType)(static_cast<uint32_t>(ctrl.requestType) & USB_RECIP_MASK);
1798 controlParams.directon = (UsbRequestDirection)(((static_cast<uint32_t>(ctrl.requestType)) >> DIRECTION_OFFSET_7) &
1799 ENDPOINT_DIRECTION_MASK);
1800 controlParams.reqType = static_cast<uint32_t>(ctrl.requestType);
1801 controlParams.size = MAX_CONTROL_BUFF_SIZE;
1802 controlParams.data = static_cast<void *>(OsalMemCalloc(controlParams.size));
1803 if (controlParams.data == nullptr) {
1804 HDF_LOGE("%{public}s:OsalMemCalloc failed", __func__);
1805 return HDF_ERR_MALLOC_FAIL;
1806 }
1807 int32_t ret = UsbControlTransferEx(port, &controlParams, ctrl.timeout);
1808 if (ret != HDF_SUCCESS) {
1809 HDF_LOGE("%{public}s:%{public}d UsbControlTransfer failed ret:%{public}d", __func__, __LINE__, ret);
1810 }
1811
1812 uint8_t *dataValue = static_cast<uint8_t *>(controlParams.data);
1813 data.assign(dataValue, dataValue + controlParams.size);
1814 OsalMemFree(controlParams.data);
1815 return ret;
1816 #else
1817 return LibusbAdapter::GetInstance()->ControlTransferRead(dev, ctrl, data);
1818 #endif // LIBUSB_ENABLE
1819 }
1820
ControlTransferWrite(const UsbDev & dev,const UsbCtrlTransfer & ctrl,const std::vector<uint8_t> & data)1821 int32_t UsbImpl::ControlTransferWrite(const UsbDev &dev, const UsbCtrlTransfer &ctrl, const std::vector<uint8_t> &data)
1822 {
1823 #ifndef LIBUSB_ENABLE
1824 if ((static_cast<uint32_t>(ctrl.requestType) & USB_ENDPOINT_DIR_MASK) != USB_ENDPOINT_DIR_OUT) {
1825 HDF_LOGE("%{public}s: this function is write, not read", __func__);
1826 return HDF_FAILURE;
1827 }
1828
1829 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1830 if (port == nullptr || port->ctrDevHandle == nullptr) {
1831 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1832 return HDF_DEV_ERR_NO_DEVICE;
1833 }
1834
1835 UsbControlParams controlParams;
1836 if (memset_s(&controlParams, sizeof(controlParams), 0, sizeof(controlParams)) != EOK) {
1837 HDF_LOGE("%{public}s:memset_s failed ", __func__);
1838 return HDF_FAILURE;
1839 }
1840 controlParams.request = static_cast<uint8_t>(ctrl.requestCmd);
1841 controlParams.value = ctrl.value;
1842 controlParams.index = ctrl.index;
1843 controlParams.target = (UsbRequestTargetType)(static_cast<uint32_t>(ctrl.requestType) & USB_RECIP_MASK);
1844 controlParams.directon = (UsbRequestDirection)(((static_cast<uint32_t>(ctrl.requestType)) >> DIRECTION_OFFSET_7) &
1845 ENDPOINT_DIRECTION_MASK);
1846 controlParams.reqType = static_cast<uint32_t>(ctrl.requestType);
1847 controlParams.size = data.size();
1848 controlParams.data = static_cast<void *>(const_cast<uint8_t *>(data.data()));
1849 int32_t ret = UsbControlTransferEx(port, &controlParams, ctrl.timeout);
1850 if (ret != HDF_SUCCESS) {
1851 HDF_LOGE("%{public}s:%{public}d UsbControlTransfer failed ret:%{public}d", __func__, __LINE__, ret);
1852 }
1853 return ret;
1854 #else
1855 return LibusbAdapter::GetInstance()->ControlTransferWrite(dev, ctrl, data);
1856 #endif // LIBUSB_ENABLE
1857 }
1858
ControlTransferReadwithLength(const UsbDev & dev,const UsbCtrlTransferParams & ctrlParams,std::vector<uint8_t> & data)1859 int32_t UsbImpl::ControlTransferReadwithLength(
1860 const UsbDev &dev, const UsbCtrlTransferParams &ctrlParams, std::vector<uint8_t> &data)
1861 {
1862 #ifndef LIBUSB_ENABLE
1863 if ((static_cast<uint32_t>(ctrlParams.requestType) & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) {
1864 HDF_LOGE("%{public}s: this function is read, not write", __func__);
1865 return HDF_FAILURE;
1866 }
1867
1868 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1869 if (port == nullptr || port->ctrDevHandle == nullptr) {
1870 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1871 return HDF_DEV_ERR_NO_DEVICE;
1872 }
1873
1874 UsbControlParams controlParams;
1875 if (memset_s(&controlParams, sizeof(controlParams), 0, sizeof(controlParams)) != EOK) {
1876 HDF_LOGE("%{public}s:memset_s failed ", __func__);
1877 return HDF_FAILURE;
1878 }
1879 controlParams.request = static_cast<uint8_t>(ctrlParams.requestCmd);
1880 controlParams.value = ctrlParams.value;
1881 controlParams.index = ctrlParams.index;
1882 controlParams.target = (UsbRequestTargetType)(static_cast<uint32_t>(ctrlParams.requestType) & USB_RECIP_MASK);
1883 controlParams.directon = (UsbRequestDirection)(((static_cast<uint32_t>(ctrlParams.requestType))
1884 >> DIRECTION_OFFSET_7) & ENDPOINT_DIRECTION_MASK);
1885 controlParams.reqType = static_cast<uint32_t>(ctrlParams.requestType);
1886 controlParams.size = (ctrlParams.length <= 0 || ctrlParams.length > MAX_CONTROL_BUFF_SIZE)
1887 ? MAX_CONTROL_BUFF_SIZE : ctrlParams.length;
1888 controlParams.data = static_cast<void *>(OsalMemCalloc(controlParams.size));
1889 if (controlParams.data == nullptr) {
1890 HDF_LOGE("%{public}s:OsalMemCalloc failed", __func__);
1891 return HDF_ERR_MALLOC_FAIL;
1892 }
1893 int32_t ret = UsbControlTransferEx(port, &controlParams, ctrlParams.timeout);
1894 if (ret != HDF_SUCCESS) {
1895 HDF_LOGE("%{public}s:%{public}d UsbControlTransfer failed ret:%{public}d", __func__, __LINE__, ret);
1896 }
1897
1898 uint8_t *dataValue = static_cast<uint8_t *>(controlParams.data);
1899 data.assign(dataValue, dataValue + controlParams.size);
1900 OsalMemFree(controlParams.data);
1901 return ret;
1902 #else
1903 return LibusbAdapter::GetInstance()->ControlTransferReadwithLength(dev, ctrlParams, data);
1904 #endif // LIBUSB_ENABLE
1905 }
1906
InterruptTransferRead(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,std::vector<uint8_t> & data)1907 int32_t UsbImpl::InterruptTransferRead(
1908 const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, std::vector<uint8_t> &data)
1909 {
1910 #ifndef LIBUSB_ENABLE
1911 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1912 if (port == nullptr) {
1913 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1914 return HDF_DEV_ERR_NO_DEVICE;
1915 }
1916
1917 uint8_t tbuf[READ_BUF_SIZE] = {0};
1918 uint32_t tsize = READ_BUF_SIZE;
1919 uint32_t actlength = 0;
1920 UsbdRequestSync *requestSync = nullptr;
1921 int32_t ret = UsbdFindRequestSyncAndCreat(port, pipe.intfId, pipe.endpointId, &requestSync);
1922 if (ret != HDF_SUCCESS || requestSync == nullptr) {
1923 HDF_LOGE("%{public}s:read timeout error", __func__);
1924 return ret;
1925 }
1926 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN || requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK) {
1927 HDF_LOGE("%{public}s:invalid param", __func__);
1928 return HDF_ERR_INVALID_PARAM;
1929 }
1930 ret = UsbdBulkReadSyncBase(timeout, tbuf, tsize, &actlength, requestSync);
1931 if (ret != HDF_SUCCESS) {
1932 HDF_LOGW("%{public}s:UsbdBulkReadSyncBase ret:%{public}d, actlength:%{public}u", __func__, ret, actlength);
1933 }
1934
1935 if (actlength > 0) {
1936 data.assign(tbuf, tbuf + actlength);
1937 ret = HDF_SUCCESS;
1938 }
1939 return ret;
1940 #else
1941 return LibusbAdapter::GetInstance()->InterruptTransferRead(dev, pipe, timeout, data);
1942 #endif // LIBUSB_ENABLE
1943 }
1944
InterruptTransferWrite(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,const std::vector<uint8_t> & data)1945 int32_t UsbImpl::InterruptTransferWrite(
1946 const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, const std::vector<uint8_t> &data)
1947 {
1948 #ifndef LIBUSB_ENABLE
1949 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1950 if (port == nullptr) {
1951 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1952 return HDF_DEV_ERR_NO_DEVICE;
1953 }
1954
1955 UsbdRequestSync *requestSync = nullptr;
1956 int32_t ret = UsbdFindRequestSyncAndCreat(port, pipe.intfId, pipe.endpointId, &requestSync);
1957 if (ret != HDF_SUCCESS || requestSync == nullptr) {
1958 HDF_LOGE("%{public}s:read timeout error", __func__);
1959 return ret;
1960 }
1961 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_OUT || requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK) {
1962 HDF_LOGE("%{public}s:invalid param", __func__);
1963 return HDF_ERR_INVALID_PARAM;
1964 }
1965 ret = UsbdBulkWriteSyncBase(port, requestSync, data.data(), data.size(), timeout);
1966 return ret;
1967 #else
1968 return LibusbAdapter::GetInstance()->InterruptTransferWrite(dev, pipe, timeout, data);
1969 #endif // LIBUSB_ENABLE
1970 }
1971
IsoTransferRead(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,std::vector<uint8_t> & data)1972 int32_t UsbImpl::IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, std::vector<uint8_t> &data)
1973 {
1974 #ifndef LIBUSB_ENABLE
1975 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
1976 if (port == nullptr) {
1977 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
1978 return HDF_DEV_ERR_NO_DEVICE;
1979 }
1980
1981 uint8_t tbuf[READ_BUF_SIZE] = {0};
1982 uint32_t tsize = READ_BUF_SIZE;
1983 uint32_t actlength = 0;
1984 UsbdRequestSync *requestSync = nullptr;
1985 int32_t ret = UsbdFindRequestSyncAndCreat(port, pipe.intfId, pipe.endpointId, &requestSync);
1986 if (ret != HDF_SUCCESS || requestSync == nullptr) {
1987 HDF_LOGE("%{public}s:UsbdFindRequestSyncAndCreat failed of requestSync is nullptr", __func__);
1988 return ret;
1989 }
1990
1991 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN || requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK) {
1992 HDF_LOGE("%{public}s:invalid param", __func__);
1993 return HDF_ERR_INVALID_PARAM;
1994 }
1995
1996 ret = UsbdBulkReadSyncBase(timeout, tbuf, tsize, &actlength, requestSync);
1997 if (ret != HDF_SUCCESS) {
1998 HDF_LOGW("%{public}s:UsbdBulkReadSyncBase failed, ret:%{public}d, len:%{public}u", __func__, ret, actlength);
1999 }
2000
2001 if (actlength > 0) {
2002 data.assign(tbuf, tbuf + actlength);
2003 ret = HDF_SUCCESS;
2004 }
2005 return ret;
2006 #else
2007 return LibusbAdapter::GetInstance()->IsoTransferRead(dev, pipe, timeout, data);
2008 #endif // LIBUSB_ENABLE
2009 }
2010
IsoTransferWrite(const UsbDev & dev,const UsbPipe & pipe,int32_t timeout,const std::vector<uint8_t> & data)2011 int32_t UsbImpl::IsoTransferWrite(
2012 const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, const std::vector<uint8_t> &data)
2013 {
2014 #ifndef LIBUSB_ENABLE
2015 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
2016 if (port == nullptr) {
2017 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
2018 return HDF_DEV_ERR_NO_DEVICE;
2019 }
2020
2021 UsbdRequestSync *requestSync = nullptr;
2022 int32_t ret = UsbdFindRequestSyncAndCreat(port, pipe.intfId, pipe.endpointId, &requestSync);
2023 if (ret != HDF_SUCCESS || requestSync == nullptr) {
2024 HDF_LOGE("%{public}s:read timeout error", __func__);
2025 return ret;
2026 }
2027
2028 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_OUT || requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK) {
2029 HDF_LOGE("%{public}s:invalid param", __func__);
2030 return HDF_ERR_INVALID_PARAM;
2031 }
2032
2033 ret = UsbdBulkWriteSyncBase(port, requestSync, data.data(), data.size(), timeout);
2034 return ret;
2035 #else
2036 return LibusbAdapter::GetInstance()->IsoTransferWrite(dev, pipe, timeout, data);
2037 #endif // LIBUSB_ENABLE
2038 }
2039
RequestQueue(const UsbDev & dev,const UsbPipe & pipe,const std::vector<uint8_t> & clientData,const std::vector<uint8_t> & buffer)2040 int32_t UsbImpl::RequestQueue(
2041 const UsbDev &dev, const UsbPipe &pipe, const std::vector<uint8_t> &clientData, const std::vector<uint8_t> &buffer)
2042 {
2043 #ifndef LIBUSB_ENABLE
2044 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
2045 if (port == nullptr) {
2046 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
2047 return HDF_DEV_ERR_NO_DEVICE;
2048 }
2049
2050 UsbdRequestASync *reqAsync = UsbdFindRequestASync(port, pipe.intfId, pipe.endpointId);
2051 if (reqAsync == nullptr) {
2052 HDF_LOGE("%{public}s:UsbdFindRequestASync failed", __func__);
2053 return HDF_ERR_DEVICE_BUSY;
2054 }
2055
2056 uint8_t *clientDataAddr = nullptr;
2057 int32_t ret = UsbdDispatcher::UsbdMallocAndFill(clientDataAddr, clientData);
2058 if (ret != HDF_SUCCESS) {
2059 HDF_LOGE("%{public}s:clientDataAddr UsbdMallocAndFill failed", __func__);
2060 return HDF_FAILURE;
2061 }
2062
2063 uint8_t *bufferAddr = nullptr;
2064 ret = UsbdDispatcher::UsbdMallocAndFill(bufferAddr, buffer);
2065 if (ret != HDF_SUCCESS) {
2066 OsalMemFree(clientDataAddr);
2067 clientDataAddr = nullptr;
2068 HDF_LOGE("%{public}s:bufferAddr UsbdMallocAndFill failed", __func__);
2069 return HDF_FAILURE;
2070 }
2071
2072 reqAsync->reqMsg.clientData = static_cast<void *>(clientDataAddr);
2073 reqAsync->reqMsg.clientLength = sizeof(uint8_t) * clientData.size();
2074 ret = FunRequestQueueFillAndSubmit(port, reqAsync, bufferAddr, sizeof(uint8_t) * buffer.size());
2075 if (ret != HDF_SUCCESS) {
2076 HDF_LOGE("%{public}s:FunRequestQueueFillAndSubmit failed:%{public}d", __func__, ret);
2077 OsalMemFree(clientDataAddr);
2078 clientDataAddr = nullptr;
2079 }
2080
2081 OsalMemFree(bufferAddr);
2082 bufferAddr = nullptr;
2083 return ret;
2084 #else
2085 if ((dev.devAddr >= MAX_DEVICE_ADDRESS) || (dev.busNum >= MAX_DEVICE_BUSNUM) ||
2086 (pipe.endpointId >= MAX_ENDPOINT_ID) || (pipe.intfId >= LIBUSB_INTERFACE_ID)) {
2087 HDF_LOGE("%{public}s:Invalid parameter", __func__);
2088 return HDF_ERR_INVALID_PARAM;
2089 }
2090 return HDF_SUCCESS;
2091 #endif // LIBUSB_ENABLE
2092 }
2093
RequestWait(const UsbDev & dev,std::vector<uint8_t> & clientData,std::vector<uint8_t> & buffer,int32_t timeout)2094 int32_t UsbImpl::RequestWait(
2095 const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer, int32_t timeout)
2096 {
2097 #ifndef LIBUSB_ENABLE
2098 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
2099 if (port == nullptr) {
2100 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
2101 return HDF_DEV_ERR_NO_DEVICE;
2102 }
2103
2104 UsbdRequestASync *reqMsg = nullptr;
2105 int32_t ret = GetRequestMsgFromQueue(port, &reqMsg);
2106 if (ret != HDF_SUCCESS || reqMsg == nullptr || reqMsg->reqMsg.request == nullptr) {
2107 HDF_LOGE("%{public}s:GetRequestMsgFromQueue error:%{public}d", __func__, ret);
2108 return ret;
2109 }
2110
2111 UsbIfRequest *reqValue = reinterpret_cast<UsbIfRequest *>(reqMsg->reqMsg.request);
2112 if (static_cast<int32_t>(reqMsg->reqMsg.request->compInfo.status) == -1) {
2113 ret = OsalSemWait(&reqValue->hostRequest->sem, timeout);
2114 if (ret != HDF_SUCCESS) {
2115 HDF_LOGE("%{public}s:OsalSemWait failed, ret=%{public}d", __func__, ret);
2116 OsalMutexLock(&port->requestLock);
2117 HdfSListAdd(&port->requestQueue, &reqMsg->qNode);
2118 OsalMutexUnlock(&port->requestLock);
2119 return ret;
2120 }
2121 }
2122
2123 uint32_t length = 0;
2124 uint8_t *buf = nullptr;
2125 ret = GetRequestMsgData(port, reqMsg, timeout, &buf, &length);
2126 if (ret != HDF_SUCCESS) {
2127 HDF_LOGE("%{public}s:GetRequestMsgData failed:%{public}d", __func__, ret);
2128 return ret;
2129 }
2130
2131 uint8_t *clientDataAddr = static_cast<uint8_t *>(reqMsg->reqMsg.clientData);
2132 uint8_t *bufferAddr = static_cast<uint8_t *>(reqMsg->reqMsg.request->compInfo.buffer);
2133 clientData.assign(clientDataAddr, clientDataAddr + reqMsg->reqMsg.clientLength);
2134 buffer.assign(bufferAddr, bufferAddr + reqMsg->reqMsg.request->compInfo.length);
2135 UsbdRequestASyncReleaseData(reqMsg);
2136 return ret;
2137 #else
2138 if ((dev.devAddr >= MAX_DEVICE_ADDRESS) || (dev.busNum >= MAX_DEVICE_BUSNUM)) {
2139 HDF_LOGE("%{public}s:Invalid parameter", __func__);
2140 return HDF_ERR_INVALID_PARAM;
2141 }
2142 return HDF_SUCCESS;
2143 #endif // LIBUSB_ENABLE
2144 }
2145
RequestCancel(const UsbDev & dev,const UsbPipe & pipe)2146 int32_t UsbImpl::RequestCancel(const UsbDev &dev, const UsbPipe &pipe)
2147 {
2148 #ifndef LIBUSB_ENABLE
2149 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
2150 if (port == nullptr) {
2151 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
2152 return HDF_DEV_ERR_NO_DEVICE;
2153 }
2154
2155 UsbdRequestASync *reqMsg = nullptr;
2156 while (GetRequestMsgFromQueue(port, &reqMsg) == HDF_SUCCESS) {
2157 if (reqMsg) {
2158 int32_t ret = UsbCancelRequest(reqMsg->reqMsg.request);
2159 if (ret != HDF_SUCCESS) {
2160 HDF_LOGW("%{public}s:request cancel failed = %{public}d", __func__, ret);
2161 }
2162 OsalMutexLock(&reqMsg->lock);
2163 UsbdRequestASyncReleaseData(reqMsg);
2164 reqMsg->status = 0;
2165 OsalMutexUnlock(&reqMsg->lock);
2166 }
2167 }
2168 return HDF_SUCCESS;
2169 #else
2170 if ((dev.devAddr == MAX_DEVICE_ADDRESS) && (dev.busNum == MAX_DEVICE_BUSNUM) &&
2171 (pipe.endpointId == MAX_CANCEL_ENDPOINT_ID) && (pipe.intfId == MAX_INTERFACE_ID)) {
2172 HDF_LOGE("%{public}s:Invalid parameter", __func__);
2173 return HDF_ERR_INVALID_PARAM;
2174 }
2175 if (pipe.intfId == MAX_INTERFACE_ID && pipe.endpointId == MAX_ENDPOINT_ID) {
2176 HDF_LOGW("%{public}s: intfId = %{public}d, endpointId = %{public}d", __func__,
2177 pipe.intfId, pipe.endpointId);
2178 return HDF_SUCCESS;
2179 }
2180 if ((dev.devAddr >= MAX_DEVICE_ADDRESS) || (dev.busNum >= MAX_DEVICE_BUSNUM) ||
2181 (pipe.endpointId > MAX_CANCEL_ENDPOINT_ID) || (pipe.intfId > LIBUSB_INTERFACE_ID)) {
2182 HDF_LOGE("%{public}s:Invalid parameter", __func__);
2183 return HDF_ERR_INVALID_PARAM;
2184 }
2185 return HDF_SUCCESS;
2186 #endif // LIBUSB_ENABLE
2187 }
2188
GetCurrentFunctions(int32_t & funcs)2189 int32_t UsbImpl::GetCurrentFunctions(int32_t &funcs)
2190 {
2191 funcs = UsbdFunction::UsbdGetFunction();
2192 return HDF_SUCCESS;
2193 }
2194
SetCurrentFunctions(int32_t funcs)2195 int32_t UsbImpl::SetCurrentFunctions(int32_t funcs)
2196 {
2197 OsalMutexLock(&lock_);
2198 int32_t ret = UsbdFunction::UsbdSetFunction(funcs);
2199 if (ret != HDF_SUCCESS) {
2200 HDF_LOGE("%{public}s:UsbdSetFunction failed, ret:%{public}d", __func__, ret);
2201 OsalMutexUnlock(&lock_);
2202 return ret;
2203 }
2204 OsalMutexUnlock(&lock_);
2205 return HDF_SUCCESS;
2206 }
2207
parsePortPath()2208 void UsbImpl::parsePortPath()
2209 {
2210 const char *path_ = nullptr;
2211 const char *pathDef_ = nullptr;
2212 struct DeviceResourceIface *iface = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
2213 if (iface == nullptr) {
2214 HDF_LOGE("%{public}s: DeviceResourceGetIfaceInstance failed", __func__);
2215 return;
2216 }
2217
2218 if (device_ == nullptr) {
2219 HDF_LOGE("%{public}s: device_ is empty", __func__);
2220 return;
2221 }
2222 if (iface->GetString(device_->property, "port_file_path", &path_, pathDef_) != HDF_SUCCESS) {
2223 HDF_LOGE("%{public}s: read port_file_path failed", __func__);
2224 return;
2225 }
2226 UsbdPort::GetInstance().setPortPath(path_);
2227 return;
2228 }
2229
SetPortRole(int32_t portId,int32_t powerRole,int32_t dataRole)2230 int32_t UsbImpl::SetPortRole(int32_t portId, int32_t powerRole, int32_t dataRole)
2231 {
2232 int32_t ret = UsbdPort::GetInstance().SetPort(portId, powerRole, dataRole, subscribers_, MAX_SUBSCRIBER);
2233 if (ret != HDF_SUCCESS) {
2234 HDF_LOGE("%{public}s:FunSetRole failed, ret:%{public}d", __func__, ret);
2235 return ret;
2236 }
2237
2238 return HDF_SUCCESS;
2239 }
2240
QueryPort(int32_t & portId,int32_t & powerRole,int32_t & dataRole,int32_t & mode)2241 int32_t UsbImpl::QueryPort(int32_t &portId, int32_t &powerRole, int32_t &dataRole, int32_t &mode)
2242 {
2243 int32_t ret = UsbdPort::GetInstance().QueryPort(portId, powerRole, dataRole, mode);
2244 if (ret != HDF_SUCCESS) {
2245 HDF_LOGE("%{public}s:QueryPort failed, ret:%{public}d", __func__, ret);
2246 return ret;
2247 }
2248
2249 return HDF_SUCCESS;
2250 }
2251
BindUsbdSubscriber(const sptr<IUsbdSubscriber> & subscriber)2252 int32_t UsbImpl::BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
2253 {
2254 int32_t i;
2255 if (subscriber == nullptr) {
2256 HDF_LOGE("%{public}s:subscriber is null", __func__);
2257 return HDF_ERR_INVALID_PARAM;
2258 }
2259 const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<IUsbdSubscriber>(subscriber);
2260 for (i = 0; i < MAX_SUBSCRIBER; i++) {
2261 if (subscribers_[i].remote == remote) {
2262 break;
2263 }
2264 }
2265 if (i < MAX_SUBSCRIBER) {
2266 HDF_LOGI("%{public}s: current subscriber was bind", __func__);
2267 return HDF_SUCCESS;
2268 }
2269 for (i = 0; i < MAX_SUBSCRIBER; i++) {
2270 if (subscribers_[i].subscriber == nullptr) {
2271 subscribers_[i].subscriber = subscriber;
2272 subscribers_[i].impl = this;
2273 subscribers_[i].usbPnpListener.callBack = UsbdPnpLoaderEventReceived;
2274 subscribers_[i].usbPnpListener.priv = &subscribers_[i];
2275 subscribers_[i].remote = remote;
2276 subscribers_[i].deathRecipient = new UsbImpl::UsbDeathRecipient(subscriber);
2277 if (subscribers_[i].deathRecipient == nullptr) {
2278 HDF_LOGE("%{public}s: new deathRecipient failed", __func__);
2279 return HDF_FAILURE;
2280 }
2281 bool result = subscribers_[i].remote->AddDeathRecipient(
2282 static_cast<UsbDeathRecipient *>(subscribers_[i].deathRecipient));
2283 if (!result) {
2284 HDF_LOGE("%{public}s:AddUsbDeathRecipient failed", __func__);
2285 return HDF_FAILURE;
2286 }
2287
2288 HDF_LOGI("%{public}s: index = %{public}d", __func__, i);
2289 break;
2290 }
2291 }
2292 if (i == MAX_SUBSCRIBER) {
2293 HDF_LOGE("%{public}s: too many listeners", __func__);
2294 return HDF_ERR_OUT_OF_RANGE;
2295 }
2296
2297 if (DdkListenerMgrAdd(&subscribers_[i].usbPnpListener) != HDF_SUCCESS) {
2298 HDF_LOGE("%{public}s: register listerer failed", __func__);
2299 return HDF_FAILURE;
2300 }
2301 return HDF_SUCCESS;
2302 }
2303
UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> & subscriber)2304 int32_t UsbImpl::UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber)
2305 {
2306 if (subscriber == nullptr) {
2307 HDF_LOGE("%{public}s:subscriber is null", __func__);
2308 return HDF_ERR_INVALID_PARAM;
2309 }
2310 int32_t i;
2311 const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<IUsbdSubscriber>(subscriber);
2312 for (i = 0; i < MAX_SUBSCRIBER; i++) {
2313 if (subscribers_[i].remote == remote) {
2314 break;
2315 }
2316 }
2317 if (i == MAX_SUBSCRIBER) {
2318 HDF_LOGE("%{public}s: current subscriber not bind", __func__);
2319 return HDF_DEV_ERR_NO_DEVICE;
2320 }
2321 bool result = remote->RemoveDeathRecipient(static_cast<UsbDeathRecipient *>(subscribers_[i].deathRecipient));
2322 if (!result) {
2323 HDF_LOGE("%{public}s:RemoveUsbDeathRecipient failed", __func__);
2324 return HDF_FAILURE;
2325 }
2326
2327 subscribers_[i].subscriber = nullptr;
2328 subscribers_[i].remote = nullptr;
2329 subscribers_[i].deathRecipient = nullptr;
2330 if (DdkListenerMgrRemove(&subscribers_[i].usbPnpListener) != HDF_SUCCESS) {
2331 HDF_LOGE("%{public}s: remove listerer failed", __func__);
2332 return HDF_FAILURE;
2333 }
2334 return HDF_SUCCESS;
2335 }
2336
OnRemoteDied(const wptr<IRemoteObject> & object)2337 void UsbImpl::UsbDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &object)
2338 {
2339 int32_t i;
2340 for (i = 0; i < MAX_SUBSCRIBER; i++) {
2341 if (UsbImpl::subscribers_[i].subscriber == deathSubscriber_) {
2342 break;
2343 }
2344 }
2345 if (i == MAX_SUBSCRIBER) {
2346 HDF_LOGE("%{public}s: current subscriber not bind", __func__);
2347 return;
2348 }
2349 UsbImpl::subscribers_[i].subscriber = nullptr;
2350 subscribers_[i].remote = nullptr;
2351 subscribers_[i].deathRecipient = nullptr;
2352 if (DdkListenerMgrRemove(&UsbImpl::subscribers_[i].usbPnpListener) != HDF_SUCCESS) {
2353 HDF_LOGE("%{public}s: remove listerer failed", __func__);
2354 }
2355 }
2356
RegBulkCallback(const UsbDev & dev,const UsbPipe & pipe,const sptr<IUsbdBulkCallback> & cb)2357 int32_t UsbImpl::RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb)
2358 {
2359 #ifndef LIBUSB_ENABLE
2360 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
2361 if (port == nullptr) {
2362 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
2363 return HDF_DEV_ERR_NO_DEVICE;
2364 }
2365
2366 UsbdBulkASyncList *list = UsbdBulkASyncListInit(port, pipe.intfId, pipe.endpointId);
2367 if (list == nullptr) {
2368 HDF_LOGE("%{public}s:UsbdBulkASyncListFind failed", __func__);
2369 return HDF_ERR_MALLOC_FAIL;
2370 }
2371 list->cb = cb;
2372 if (list->cb == nullptr) {
2373 HDF_LOGE("%{public}s:get callback error", __func__);
2374 return HDF_ERR_IO;
2375 }
2376
2377 return HDF_SUCCESS;
2378 #else
2379 if ((dev.devAddr >= MAX_DEVICE_ADDRESS) || (dev.busNum >= MAX_DEVICE_BUSNUM) ||
2380 (pipe.endpointId >= MAX_ENDPOINT_ID) || (pipe.intfId >= LIBUSB_INTERFACE_ID) || (cb == nullptr)) {
2381 HDF_LOGE("%{public}s:Invalid parameter", __func__);
2382 return HDF_ERR_INVALID_PARAM;
2383 }
2384 return HDF_SUCCESS;
2385 #endif // LIBUSB_ENABLE
2386 }
2387
UnRegBulkCallback(const UsbDev & dev,const UsbPipe & pipe)2388 int32_t UsbImpl::UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe)
2389 {
2390 #ifndef LIBUSB_ENABLE
2391 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
2392 if (port == nullptr) {
2393 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
2394 return HDF_DEV_ERR_NO_DEVICE;
2395 }
2396
2397 UsbdBulkASyncList *list = UsbdBulkASyncListFind(port, pipe.intfId, pipe.endpointId);
2398 if (list == nullptr) {
2399 HDF_LOGE("%{public}s:UsbdBulkASyncListFind failed", __func__);
2400 return HDF_FAILURE;
2401 }
2402 list->cb = nullptr;
2403 return HDF_SUCCESS;
2404 #else
2405 if ((dev.devAddr >= MAX_DEVICE_ADDRESS) || (dev.busNum >= MAX_DEVICE_BUSNUM) ||
2406 (pipe.endpointId >= MAX_ENDPOINT_ID) || (pipe.intfId >= LIBUSB_INTERFACE_ID)) {
2407 HDF_LOGE("%{public}s:Invalid parameter", __func__);
2408 return HDF_ERR_INVALID_PARAM;
2409 }
2410 return HDF_SUCCESS;
2411 #endif // LIBUSB_ENABLE
2412 }
2413
BulkRead(const UsbDev & dev,const UsbPipe & pipe,const sptr<Ashmem> & ashmem)2414 int32_t UsbImpl::BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
2415 {
2416 #ifndef LIBUSB_ENABLE
2417 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
2418 if (port == nullptr) {
2419 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
2420 return HDF_DEV_ERR_NO_DEVICE;
2421 }
2422
2423 UsbdBulkASyncList *list = UsbdBulkASyncListInit(port, pipe.intfId, pipe.endpointId);
2424 if (list == nullptr) {
2425 HDF_LOGE("%{public}s:UsbdBulkASyncListInit failed.", __func__);
2426 return HDF_ERR_MALLOC_FAIL;
2427 }
2428
2429 int32_t ret = InitAsmBufferHandle(&list->asmHandle, ashmem->GetAshmemFd(), ashmem->GetAshmemSize());
2430 if (ret != HDF_SUCCESS) {
2431 HDF_LOGE("%{public}s:InitAsmBufferHandle failed ret:%{public}d ashmem fd:%{public}d size:%{public}d", __func__,
2432 ret, ashmem->GetAshmemFd(), ashmem->GetAshmemSize());
2433 return ret;
2434 }
2435
2436 ret = UsbdBulkReadASyncSubmitStart(list);
2437 if (ret == HDF_DEV_ERR_NODATA || ret == HDF_DEV_ERR_NO_MEMORY || ret == HDF_ERR_DEVICE_BUSY) {
2438 ret = HDF_SUCCESS;
2439 }
2440 if (ret != HDF_SUCCESS) {
2441 HDF_LOGE("%{public}s:UsbdBulkReadASyncSubmitStart error ret:%{public}d", __func__, ret);
2442 return ret;
2443 }
2444
2445 return ret;
2446 #else
2447 if ((pipe.endpointId & LIBUSB_ENDPOINT_MASK) != LIBUSB_ENDPOINT_MASK) {
2448 HDF_LOGE("%{public}s:EndpointId is invalid", __func__);
2449 return HDF_ERR_INVALID_PARAM;
2450 }
2451
2452 if ((dev.devAddr >= MAX_DEVICE_ADDRESS) || (dev.busNum >= MAX_DEVICE_BUSNUM) ||
2453 (pipe.endpointId >= MAX_ENDPOINT_ID) || (pipe.intfId >= LIBUSB_INTERFACE_ID)) {
2454 HDF_LOGE("%{public}s:Invalid parameter", __func__);
2455 return HDF_ERR_INVALID_PARAM;
2456 }
2457 return HDF_SUCCESS;
2458 #endif // LIBUSB_ENABLE
2459 }
2460
BulkWrite(const UsbDev & dev,const UsbPipe & pipe,const sptr<Ashmem> & ashmem)2461 int32_t UsbImpl::BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem)
2462 {
2463 #ifndef LIBUSB_ENABLE
2464 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
2465 if (port == nullptr) {
2466 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
2467 return HDF_DEV_ERR_NO_DEVICE;
2468 }
2469
2470 UsbdBulkASyncList *list = UsbdBulkASyncListInit(port, pipe.intfId, pipe.endpointId);
2471 if (list == nullptr) {
2472 HDF_LOGE("%{public}s:UsbdBulkASyncListInit failed.", __func__);
2473 return HDF_ERR_MALLOC_FAIL;
2474 }
2475
2476 int32_t ret = InitAsmBufferHandle(&list->asmHandle, ashmem->GetAshmemFd(), ashmem->GetAshmemSize());
2477 if (ret != HDF_SUCCESS) {
2478 HDF_LOGE("%{public}s:InitAsmBufferHandle failed ret:%{public}d ashmem fd:%{public}d size:%{public}d", __func__,
2479 ret, ashmem->GetAshmemFd(), ashmem->GetAshmemSize());
2480 return ret;
2481 }
2482
2483 ret = UsbdBulkASyncWriteSubmitStart(list);
2484 if (ret == HDF_DEV_ERR_NODATA || ret == HDF_DEV_ERR_NO_MEMORY || ret == HDF_ERR_DEVICE_BUSY) {
2485 ret = HDF_SUCCESS;
2486 }
2487 if (ret != HDF_SUCCESS) {
2488 HDF_LOGE("%{public}s:UsbdBulkASyncWriteSubmitStart error ret:%{public}d", __func__, ret);
2489 return ret;
2490 }
2491
2492 return ret;
2493 #else
2494 if ((dev.devAddr >= MAX_DEVICE_ADDRESS) || (dev.busNum >= MAX_DEVICE_BUSNUM) ||
2495 (pipe.endpointId >= MAX_ENDPOINT_ID) || (pipe.intfId >= LIBUSB_INTERFACE_ID)) {
2496 HDF_LOGE("%{public}s:Invalid parameter", __func__);
2497 return HDF_ERR_INVALID_PARAM;
2498 }
2499 return HDF_SUCCESS;
2500 #endif // LIBUSB_ENABLE
2501 }
2502
BulkCancel(const UsbDev & dev,const UsbPipe & pipe)2503 int32_t UsbImpl::BulkCancel(const UsbDev &dev, const UsbPipe &pipe)
2504 {
2505 #ifndef LIBUSB_ENABLE
2506 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
2507 if (port == nullptr) {
2508 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
2509 return HDF_DEV_ERR_NO_DEVICE;
2510 }
2511
2512 UsbdBulkASyncList *list = UsbdBulkASyncListFind(port, pipe.intfId, pipe.endpointId);
2513 if (list == nullptr) {
2514 HDF_LOGW("%{public}s:UsbdBulkASyncListFind failed interfaceId:%{public}u endpointId:%{public}u", __func__,
2515 pipe.intfId, pipe.endpointId);
2516 return HDF_FAILURE;
2517 }
2518 sptr<IUsbdBulkCallback> tcb = list->cb;
2519 list->cb = nullptr;
2520 ReleaseAsmBufferHandle(&list->asmHandle);
2521 BulkRequestCancel(list);
2522 list->cb = tcb;
2523 return HDF_SUCCESS;
2524 #else
2525 if ((dev.devAddr >= MAX_DEVICE_ADDRESS) || (dev.busNum >= MAX_DEVICE_BUSNUM) ||
2526 (pipe.endpointId >= MAX_ENDPOINT_ID) || (pipe.intfId >= LIBUSB_INTERFACE_ID)) {
2527 HDF_LOGE("%{public}s:Invalid parameter", __func__);
2528 return HDF_ERR_INVALID_PARAM;
2529 }
2530 return HDF_SUCCESS;
2531 #endif // LIBUSB_ENABLE
2532 }
2533
ClearHalt(const UsbDev & dev,const UsbPipe & pipe)2534 int32_t UsbImpl::ClearHalt(const UsbDev &dev, const UsbPipe &pipe)
2535 {
2536 #ifndef LIBUSB_ENABLE
2537 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
2538 if (port == nullptr) {
2539 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
2540 return HDF_DEV_ERR_NO_DEVICE;
2541 }
2542 if (pipe.intfId >= USB_MAX_INTERFACES) {
2543 HDF_LOGE("%{public}s:interfaceId larger then max num", __func__);
2544 return HDF_ERR_INVALID_PARAM;
2545 }
2546 int32_t ret = UsbClearInterfaceHalt(port->devHandle[pipe.intfId], pipe.endpointId);
2547 if (ret != HDF_SUCCESS) {
2548 HDF_LOGE("%{public}s:ClearHalt error ret:%{public}d", __func__, ret);
2549 }
2550 return ret;
2551 #else
2552 return LibusbAdapter::GetInstance()->ClearHalt(dev, pipe);
2553 #endif // LIBUSB_ENABLE
2554 }
2555
GetInterfaceActiveStatus(const UsbDev & dev,uint8_t interfaceId,bool & unactivated)2556 int32_t UsbImpl::GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool &unactivated)
2557 {
2558 #ifndef LIBUSB_ENABLE
2559 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
2560 if (port == nullptr) {
2561 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
2562 return HDF_DEV_ERR_NO_DEVICE;
2563 }
2564 if (interfaceId >= USB_MAX_INTERFACES) {
2565 HDF_LOGE("%{public}s:interfaceId larger then max num", __func__);
2566 return HDF_ERR_INVALID_PARAM;
2567 }
2568
2569 unactivated = UsbGetInterfaceActiveStatus(port->service->session_, port->busNum, port->devAddr, interfaceId);
2570 return HDF_SUCCESS;
2571 #else
2572 return LibusbAdapter::GetInstance()->GetInterfaceActiveStatus(dev, interfaceId, unactivated);
2573 #endif // LIBUSB_ENABLE
2574 }
2575
GetDeviceSpeed(const UsbDev & dev,uint8_t & speed)2576 int32_t UsbImpl::GetDeviceSpeed(const UsbDev &dev, uint8_t &speed)
2577 {
2578 #ifndef LIBUSB_ENABLE
2579 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr);
2580 if (port == nullptr) {
2581 HDF_LOGE("%{public}s:FindDevFromService failed", __func__);
2582 return HDF_DEV_ERR_NO_DEVICE;
2583 }
2584 UsbInterfaceHandleEntity *handle = reinterpret_cast<UsbInterfaceHandleEntity *>(port->ctrDevHandle);
2585 int32_t ret = RawUsbGetUsbSpeed(handle->devHandle);
2586 speed = (uint8_t)ret;
2587 HDF_LOGE("%{public}s:GetDeviceSpeed, speed=%{public}u", __func__, speed);
2588 return HDF_SUCCESS;
2589 #else
2590 return LibusbAdapter::GetInstance()->GetDeviceSpeed(dev, speed);
2591 #endif // LIBUSB_ENABLE
2592 }
2593
GetAccessoryInfo(std::vector<std::string> & accessoryInfo)2594 int32_t UsbImpl::GetAccessoryInfo(std::vector<std::string> &accessoryInfo)
2595 {
2596 return UsbdAccessory::GetInstance().GetAccessoryInfo(accessoryInfo);
2597 }
2598
OpenAccessory(int32_t & fd)2599 int32_t UsbImpl::OpenAccessory(int32_t &fd)
2600 {
2601 return UsbdAccessory::GetInstance().OpenAccessory(fd);
2602 }
2603
CloseAccessory(int32_t fd)2604 int32_t UsbImpl::CloseAccessory(int32_t fd)
2605 {
2606 return UsbdAccessory::GetInstance().CloseAccessory(fd);
2607 }
2608
OnRemoteDied(const wptr<IRemoteObject> & object)2609 void UsbImpl::UsbAsyncTransferDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &object)
2610 {
2611 HDF_LOGI("%{public}s: UsbImpl UsbAsyncTransferDeathRecipient enter", __func__);
2612 int32_t ret = usbImpl_->UsbCancelTransfer(dev_, endpoint_);
2613 if (ret == HDF_SUCCESS) {
2614 HDF_LOGI("%{public}s: UsbImpl OnRemoteDied close", __func__);
2615 usbImpl_->CloseDevice(dev_);
2616 }
2617 }
2618
UsbSubmitTransfer(const UsbDev & dev,const OHOS::HDI::Usb::V1_2::USBTransferInfo & info,const sptr<OHOS::HDI::Usb::V1_2::IUsbdTransferCallback> & cb,const sptr<Ashmem> & ashmem)2619 int32_t UsbImpl::UsbSubmitTransfer(const UsbDev &dev, const OHOS::HDI::Usb::V1_2::USBTransferInfo &info,
2620 const sptr<OHOS::HDI::Usb::V1_2::IUsbdTransferCallback> &cb, const sptr<Ashmem> &ashmem)
2621 {
2622 #ifndef LIBUSB_ENABLE
2623 HDF_LOGE("%{public}s: libusb is not enabled, please define macro LIBUSB_ENABLE.", __func__);
2624 return LIBUSB_ERROR_NOT_SUPPORTED;
2625 #else
2626 HDF_LOGI("%{public}s: UsbImpl UsbSubmitTransfer", __func__);
2627 sptr<IRemoteObject> remote = OHOS::HDI::hdi_objcast<OHOS::HDI::Usb::V1_2::IUsbdTransferCallback>(cb);
2628 sptr<UsbImpl::UsbAsyncTransferDeathRecipient> asyncRecipient =
2629 new UsbAsyncTransferDeathRecipient(dev, info.endpoint, this, remote);
2630 if (!remote->AddDeathRecipient(asyncRecipient)) {
2631 HDF_LOGE("%{public}s: add DeathRecipient failed", __func__);
2632 return HDF_ERR_INVALID_PARAM;
2633 }
2634 int32_t ret = LibusbAdapter::GetInstance()->AsyncSubmitTransfer(dev, info, cb, ashmem);
2635 if (ret < 0) {
2636 remote->RemoveDeathRecipient(asyncRecipient);
2637 asyncRecipient.clear();
2638 }
2639 return ret;
2640 #endif // LIBUSB_ENABLE
2641 }
2642
UsbCancelTransfer(const UsbDev & dev,const int32_t endpoint)2643 int32_t UsbImpl::UsbCancelTransfer(const UsbDev &dev, const int32_t endpoint)
2644 {
2645 #ifndef LIBUSB_ENABLE
2646 HDF_LOGE("%{public}s: libusb is not enabled, please define macro LIBUSB_ENABLE.", __func__);
2647 return LIBUSB_ERROR_NOT_SUPPORTED;
2648 #else
2649 HDF_LOGI("%{public}s: UsbImpl UsbCancelTransfer", __func__);
2650 return LibusbAdapter::GetInstance()->AsyncCancelTransfer(dev, endpoint);
2651 #endif // LIBUSB_ENABLE
2652 }
2653
2654 } // namespace V1_2
2655 } // namespace Usb
2656 } // namespace HDI
2657 } // namespace OHOS
2658