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