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