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