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