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" 42using namespace OHOS::HiviewDFX; 43constexpr double USB_RECOGNITION_FAIL_RATE_BASE = 100.00; 44constexpr uint16_t ENGLISH_US_LANGUAGE_ID = 0x409; 45constexpr uint32_t FUNCTION_VALUE_MAX_LEN = 32; 46constexpr uint8_t USB_PARAM_REQTYPE = 128; 47constexpr uint8_t USB_PARAM_STAND_REQTYPE = 0; 48int32_t g_usbOpenCount = 0; 49namespace OHOS { 50namespace HDI { 51namespace Usb { 52namespace V1_1 { 53HdfDevEventlistener UsbImpl::listenerForLoadService_ = {nullptr}; 54UsbdLoadService UsbImpl::loadUsbService_ = {USB_SYSTEM_ABILITY_ID}; 55UsbdLoadService UsbImpl::loadHdfEdm_ = {HDF_EXTERNAL_DEVICE_MANAGER_SA_ID}; 56UsbdSubscriber UsbImpl::subscribers_[MAX_SUBSCRIBER] = {{0}}; 57bool UsbImpl::isGadgetConnected_ = false; 58uint32_t UsbImpl::attachCount_ = 0; 59uint32_t UsbImpl::attachFailedCount_ = 0; 60static 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 71extern "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 81UsbImpl::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 90UsbImpl::~UsbImpl() 91{ 92 UsbdReleaseDevices(); 93} 94 95HostDevice *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 120void 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 138void 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 156int32_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 214void 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 232int32_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 267UsbInterfaceHandle *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 282int32_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 308int32_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 334int32_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 351int32_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 404int32_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 461int32_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 503int32_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 541UsbdRequestASync *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 593int32_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 635int32_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 660int32_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 691int32_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 714UsbdBulkASyncList *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 731UsbdBulkASyncList *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 744int32_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 773int32_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 802int32_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 831void 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 856int32_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 884void 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 908int32_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 960int32_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 998int32_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 1017void 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 1036int32_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 1048int32_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 1059int32_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 1073int32_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 if (g_usbOpenCount >= INT_MAX) { 1081 HDF_LOGE("%{public}s: OpenDevice too many times ", __func__); 1082 return HDF_FAILURE; 1083 } 1084 g_usbOpenCount++; 1085 port->initFlag = true; 1086 if (port->ctrDevHandle == nullptr && port->ctrIface != nullptr) { 1087 HDF_LOGD("%{public}s:start openInterface, busNum: %{public}d, devAddr: %{public}d ", 1088 __func__, dev.busNum, dev.devAddr); 1089 port->ctrDevHandle = UsbOpenInterface(port->ctrIface); 1090 if (port->ctrDevHandle == nullptr) { 1091 HDF_LOGE("%{public}s:ctrDevHandle UsbOpenInterface nullptr", __func__); 1092 return HDF_FAILURE; 1093 } 1094 } 1095 return HDF_SUCCESS; 1096} 1097 1098int32_t UsbImpl::CloseDevice(const UsbDev &dev) 1099{ 1100 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1101 if (port == nullptr) { 1102 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1103 return HDF_DEV_ERR_NO_DEVICE; 1104 } 1105 if (!port->initFlag) { 1106 HDF_LOGE("%{public}s: openPort failed", __func__); 1107 return HDF_DEV_ERR_DEV_INIT_FAIL; 1108 } 1109 g_usbOpenCount--; 1110 int32_t ret = 0; 1111 if (port->ctrDevHandle != nullptr && g_usbOpenCount == 0) { 1112 RawUsbCloseCtlProcess(port->ctrDevHandle); 1113 ret = UsbCloseInterface(port->ctrDevHandle, true); 1114 if (ret != HDF_SUCCESS) { 1115 HDF_LOGE("%{public}s:usbCloseInterface ctrDevHandle failed.", __func__); 1116 return HDF_FAILURE; 1117 } 1118 port->ctrDevHandle = nullptr; 1119 port->initFlag = false; 1120 } 1121 return HDF_SUCCESS; 1122} 1123 1124int32_t UsbImpl::ResetDevice(const UsbDev &dev) 1125{ 1126 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1127 if (port == nullptr) { 1128 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1129 return HDF_DEV_ERR_NO_DEVICE; 1130 } 1131 if (port->ctrDevHandle == nullptr && port->ctrIface != nullptr) { 1132 HDF_LOGD("%{public}s:start resetDevice, busNum: %{public}d, devAddr: %{public}d ", 1133 __func__, dev.busNum, dev.devAddr); 1134 port->ctrDevHandle = UsbResetDevice(port->ctrIface); 1135 if (port->ctrDevHandle == nullptr) { 1136 HDF_LOGE("%{public}s:UsbResetDevice failed", __func__); 1137 return HDF_FAILURE; 1138 } 1139 } 1140 return HDF_SUCCESS; 1141} 1142 1143int32_t UsbImpl::GetDeviceDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor) 1144{ 1145 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1146 if (port == nullptr) { 1147 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1148 return HDF_DEV_ERR_NO_DEVICE; 1149 } 1150 1151 uint16_t length = USB_MAX_DESCRIPTOR_SIZE; 1152 uint8_t buffer[USB_MAX_DESCRIPTOR_SIZE] = {0}; 1153 UsbControlParams controlParams = {0}; 1154 MakeUsbControlParams(&controlParams, buffer, length, static_cast<int32_t>(USB_DDK_DT_DEVICE) << TYPE_OFFSET_8, 0); 1155 int32_t ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT); 1156 if (ret != HDF_SUCCESS) { 1157 HDF_LOGE("%{public}s:UsbControlTransferEx failed, ret:%{public}d", __func__, ret); 1158 return ret; 1159 } 1160 descriptor.resize(USB_MAX_DESCRIPTOR_SIZE); 1161 std::copy(buffer, buffer + USB_MAX_DESCRIPTOR_SIZE, descriptor.begin()); 1162 return HDF_SUCCESS; 1163} 1164 1165int32_t UsbImpl::GetStringDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor) 1166{ 1167 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1168 if (port == nullptr) { 1169 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1170 return HDF_DEV_ERR_NO_DEVICE; 1171 } 1172 1173 uint16_t length = USB_MAX_DESCRIPTOR_SIZE; 1174 uint8_t buffer[USB_MAX_DESCRIPTOR_SIZE] = {0}; 1175 UsbControlParams controlParams = {0}; 1176 MakeUsbControlParams( 1177 &controlParams, buffer, length, 1178 (static_cast<int32_t>(USB_DDK_DT_STRING) << TYPE_OFFSET_8) + descId, ENGLISH_US_LANGUAGE_ID); 1179 int32_t ret = UsbControlTransferEx(port, &controlParams, GET_STRING_SET_TIMEOUT); 1180 if (ret != HDF_SUCCESS) { 1181 HDF_LOGE("%{public}s:UsbControlTransferEx failed ret=%{public}d", __func__, ret); 1182 return ret; 1183 } 1184 1185 descriptor.resize(USB_MAX_DESCRIPTOR_SIZE); 1186 std::copy(buffer, buffer + USB_MAX_DESCRIPTOR_SIZE, descriptor.begin()); 1187 return HDF_SUCCESS; 1188} 1189 1190int32_t UsbImpl::GetConfigDescriptor(const UsbDev &dev, uint8_t descId, std::vector<uint8_t> &descriptor) 1191{ 1192 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1193 if (port == nullptr) { 1194 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1195 return HDF_DEV_ERR_NO_DEVICE; 1196 } 1197 1198 uint16_t length = USB_MAX_DESCRIPTOR_SIZE; 1199 uint8_t buffer[USB_MAX_DESCRIPTOR_SIZE] = {0}; 1200 UsbControlParams controlParams = {0}; 1201 MakeUsbControlParams( 1202 &controlParams, buffer, length, (static_cast<int32_t>(USB_DDK_DT_CONFIG) << TYPE_OFFSET_8) + descId, 0); 1203 int32_t ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT); 1204 if (ret != HDF_SUCCESS) { 1205 HDF_LOGE("%{public}s:UsbControlTransferEx failed ret=%{public}d", __func__, ret); 1206 return ret; 1207 } 1208 1209 descriptor.resize(USB_MAX_DESCRIPTOR_SIZE); 1210 std::copy(buffer, buffer + USB_MAX_DESCRIPTOR_SIZE, descriptor.begin()); 1211 return HDF_SUCCESS; 1212} 1213 1214int32_t UsbImpl::GetRawDescriptor(const UsbDev &dev, std::vector<uint8_t> &descriptor) 1215{ 1216 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1217 if (port == nullptr || port->ctrDevHandle == nullptr) { 1218 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1219 return HDF_DEV_ERR_NO_DEVICE; 1220 } 1221 1222 UsbInterfaceHandleEntity *handle = reinterpret_cast<UsbInterfaceHandleEntity *>(port->ctrDevHandle); 1223 OsalMutexLock(&handle->devHandle->lock); 1224 uint8_t *ptr = static_cast<uint8_t *>(handle->devHandle->dev->descriptors); 1225 uint32_t length = handle->devHandle->dev->descriptorsLength; 1226 descriptor.resize(length); 1227 std::copy(ptr, ptr + length, descriptor.begin()); 1228 OsalMutexUnlock(&handle->devHandle->lock); 1229 return HDF_SUCCESS; 1230} 1231 1232int32_t UsbImpl::GetFileDescriptor(const UsbDev &dev, int32_t &fd) 1233{ 1234 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1235 if (port == nullptr || port->ctrDevHandle == nullptr) { 1236 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1237 return HDF_DEV_ERR_NO_DEVICE; 1238 } 1239 1240 UsbInterfaceHandleEntity *handle = reinterpret_cast<UsbInterfaceHandleEntity *>(port->ctrDevHandle); 1241 OsalMutexLock(&handle->devHandle->lock); 1242 fd = handle->devHandle->fd; 1243 OsalMutexUnlock(&handle->devHandle->lock); 1244 return HDF_SUCCESS; 1245} 1246 1247int32_t UsbImpl::GetDeviceFileDescriptor(const UsbDev &dev, int32_t &fd) 1248{ 1249 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1250 if (port == nullptr || port->ctrDevHandle == nullptr) { 1251 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1252 return HDF_DEV_ERR_NO_DEVICE; 1253 } 1254 1255 UsbInterfaceHandleEntity *handle = reinterpret_cast<UsbInterfaceHandleEntity *>(port->ctrDevHandle); 1256 OsalMutexLock(&handle->devHandle->lock); 1257 fd = handle->devHandle->fd; 1258 OsalMutexUnlock(&handle->devHandle->lock); 1259 return HDF_SUCCESS; 1260} 1261 1262int32_t UsbImpl::SetConfig(const UsbDev &dev, uint8_t configIndex) 1263{ 1264 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1265 if (port == nullptr) { 1266 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1267 return HDF_DEV_ERR_NO_DEVICE; 1268 } 1269 if (!port->initFlag) { 1270 HDF_LOGE("%{public}s: openPort failed", __func__); 1271 return HDF_DEV_ERR_DEV_INIT_FAIL; 1272 } 1273 1274 uint8_t configIdOld = 0; 1275 uint8_t configIdNew = 0; 1276 uint16_t length = 1; 1277 UsbControlParams controlParams; 1278 MakeGetActiveUsbControlParams(&controlParams, &configIdOld, length, 0, 0); 1279 int32_t ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT); 1280 if (ret != HDF_SUCCESS) { 1281 HDF_LOGE("%{public}s:setConfiguration failed ret:%{public}d", __func__, ret); 1282 return HDF_ERR_INVALID_PARAM; 1283 } 1284 if (configIndex == configIdOld) { 1285 HDF_LOGE("%{public}s:setConfiguration success, configIndex:%{public}d configIdOld:%{public}d", __func__, 1286 configIndex, configIdOld); 1287 return HDF_SUCCESS; 1288 } 1289 1290 length = 0; 1291 MakeSetActiveUsbControlParams(&controlParams, &configIndex, length, static_cast<int32_t>(configIndex), 0); 1292 ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT); 1293 if (ret != HDF_SUCCESS) { 1294 HDF_LOGE("%{public}s:setConfiguration failed ret:%{public}d", __func__, ret); 1295 return HDF_ERR_IO; 1296 } 1297 1298 length = 1; 1299 MakeGetActiveUsbControlParams(&controlParams, &configIdNew, length, 0, 0); 1300 ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT); 1301 if (ret != HDF_SUCCESS || configIndex != configIdNew) { 1302 HDF_LOGE("%{public}s:getConfiguration failed ret:%{public}d", __func__, ret); 1303 HDF_LOGE("%{public}s:setConfiguration failed, IdSet:%{public}d,IdOld:%{public}d,IdNew:%{public}d", 1304 __func__, configIndex, configIdOld, configIdNew); 1305 return HDF_ERR_IO; 1306 } 1307 if (configIndex != 0) { 1308 ret = ReOpenDevice(port); 1309 if (ret != HDF_SUCCESS) { 1310 HDF_LOGE("%{public}s:ReOpenDevice failed ret:%{public}d", __func__, ret); 1311 return ret; 1312 } 1313 } 1314 return ret; 1315} 1316 1317int32_t UsbImpl::GetConfig(const UsbDev &dev, uint8_t &configIndex) 1318{ 1319 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1320 if (port == nullptr) { 1321 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1322 return HDF_DEV_ERR_NO_DEVICE; 1323 } 1324 1325 uint16_t length = 1; 1326 UsbControlParams controlParams; 1327 MakeGetActiveUsbControlParams(&controlParams, &configIndex, length, 0, 0); 1328 int32_t ret = UsbControlTransferEx(port, &controlParams, USB_CTRL_SET_TIMEOUT); 1329 if (ret != HDF_SUCCESS) { 1330 HDF_LOGE("%{public}s:UsbControlTransferEx failed", __func__); 1331 return HDF_ERR_IO; 1332 } 1333 return HDF_SUCCESS; 1334} 1335 1336int32_t UsbImpl::ClaimInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t force) 1337{ 1338 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1339 if (port == nullptr) { 1340 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1341 return HDF_DEV_ERR_NO_DEVICE; 1342 } 1343 if (!port->initFlag) { 1344 HDF_LOGE("%{public}s: openPort failed", __func__); 1345 return HDF_DEV_ERR_DEV_INIT_FAIL; 1346 } 1347 if (interfaceId >= USB_MAX_INTERFACES) { 1348 HDF_LOGE("%{public}s:interfaceId larger than max num", __func__); 1349 return HDF_ERR_INVALID_PARAM; 1350 } 1351 1352 if (port->iface[interfaceId] == nullptr) { 1353 if (force) { 1354 port->iface[interfaceId] = 1355 UsbClaimInterface(port->service->session_, port->busNum, port->devAddr, interfaceId); 1356 } else { 1357 port->iface[interfaceId] = 1358 UsbClaimInterfaceUnforce(port->service->session_, port->busNum, port->devAddr, interfaceId); 1359 } 1360 if (port->iface[interfaceId] == nullptr) { 1361 HDF_LOGE("%{public}s:UsbClaimInterface failed, busNum=%{public}u, devAddr=%{public}u", __func__, 1362 port->busNum, port->devAddr); 1363 return HDF_FAILURE; 1364 } 1365 } 1366 if (port->devHandle[interfaceId] == nullptr) { 1367 port->devHandle[interfaceId] = UsbOpenInterface(port->iface[interfaceId]); 1368 if (port->devHandle[interfaceId] == nullptr) { 1369 HDF_LOGE("%{public}s:UsbOpenInterface failed.", __func__); 1370 return HDF_FAILURE; 1371 } 1372 } 1373 return HDF_SUCCESS; 1374} 1375 1376int32_t UsbImpl::ManageInterface(const UsbDev &dev, uint8_t interfaceId, bool disable) 1377{ 1378 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1379 if (port == nullptr) { 1380 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1381 return HDF_DEV_ERR_NO_DEVICE; 1382 } 1383 if (interfaceId >= USB_MAX_INTERFACES) { 1384 HDF_LOGE("%{public}s:interfaceId larger then max num", __func__); 1385 return HDF_ERR_INVALID_PARAM; 1386 } 1387 1388 port->iface[interfaceId] = 1389 UsbManageInterface(port->service->session_, port->busNum, port->devAddr, interfaceId, disable); 1390 if (port->iface[interfaceId] == nullptr) { 1391 HDF_LOGE("%{public}s: ManageInterface failed, busNum=%{public}u, devAddr=%{public}u", __func__, 1392 port->busNum, port->devAddr); 1393 return HDF_FAILURE; 1394 } 1395 return HDF_SUCCESS; 1396} 1397 1398int32_t UsbImpl::ReleaseInterface(const UsbDev &dev, uint8_t interfaceId) 1399{ 1400 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1401 if (port == nullptr) { 1402 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1403 return HDF_DEV_ERR_NO_DEVICE; 1404 } 1405 if (!port->initFlag) { 1406 HDF_LOGE("%{public}s: openPort failed", __func__); 1407 return HDF_DEV_ERR_DEV_INIT_FAIL; 1408 } 1409 1410 if (interfaceId < USB_MAX_INTERFACES) { 1411 if (port->devHandle[interfaceId] == nullptr || port->iface[interfaceId] == nullptr) { 1412 HDF_LOGE("%{public}s: UsbOpenInterface or UsbClaimInterface failed", __func__); 1413 return HDF_DEV_ERR_OP; 1414 } 1415 if (HdfSListCount(&port->reqSyncList) > 0) { 1416 UsbdRequestSyncReleaseList(port); 1417 HDF_LOGD("%{public}s:release sync list", __func__); 1418 } 1419 if (HdfSListCount(&port->reqASyncList) > 0) { 1420 UsbdRequestASyncReleaseList(port); 1421 HDF_LOGD("%{public}s:release async list", __func__); 1422 } 1423 int32_t ret = UsbdBulkASyncListReleasePort(port); 1424 if (ret != HDF_SUCCESS) { 1425 HDF_LOGW("%{public}s:release bulk async list failed", __func__); 1426 } 1427 UsbCloseInterface(port->devHandle[interfaceId], false); 1428 port->devHandle[interfaceId] = nullptr; 1429 UsbReleaseInterface(port->iface[interfaceId]); 1430 port->iface[interfaceId] = nullptr; 1431 return HDF_SUCCESS; 1432 } else { 1433 HDF_LOGE("%{public}s:interfaceId failed busNum:%{public}u devAddr:%{public}u interfaceId:%{public}u", __func__, 1434 port->busNum, port->devAddr, interfaceId); 1435 return HDF_FAILURE; 1436 } 1437 1438 return HDF_SUCCESS; 1439} 1440 1441int32_t UsbImpl::SetInterface(const UsbDev &dev, uint8_t interfaceId, uint8_t altIndex) 1442{ 1443 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1444 if (port == nullptr) { 1445 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1446 return HDF_DEV_ERR_NO_DEVICE; 1447 } 1448 if (!port->initFlag) { 1449 HDF_LOGE("%{public}s: openPort failed", __func__); 1450 return HDF_DEV_ERR_DEV_INIT_FAIL; 1451 } 1452 1453 UsbInterfaceHandle *interfaceHandle = InterfaceIdToHandle(port, interfaceId); 1454 if (interfaceHandle == nullptr || interfaceId >= USB_MAX_INTERFACES) { 1455 HDF_LOGE("%{public}s:interfaceId failed busNum:%{public}u devAddr:%{public}u interfaceId:%{public}u", __func__, 1456 port->busNum, port->devAddr, interfaceId); 1457 return HDF_FAILURE; 1458 } 1459 1460 int32_t ret = UsbSelectInterfaceSetting(interfaceHandle, altIndex, &port->iface[interfaceId]); 1461 if (ret == HDF_SUCCESS) { 1462 UsbdRequestSyncReleaseList(port); 1463 UsbdRequestASyncReleaseList(port); 1464 UsbdBulkASyncListReleasePort(port); 1465 } 1466 return ret; 1467} 1468 1469int32_t UsbImpl::BulkTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, std::vector<uint8_t> &data) 1470{ 1471 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1472 if (port == nullptr) { 1473 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1474 return HDF_DEV_ERR_NO_DEVICE; 1475 } 1476 1477 uint8_t tbuf[READ_BUF_SIZE] = {0}; 1478 uint32_t tsize = READ_BUF_SIZE; 1479 uint32_t actlength = 0; 1480 UsbdRequestSync *requestSync = nullptr; 1481 int32_t ret = UsbdFindRequestSyncAndCreat(port, pipe.intfId, pipe.endpointId, &requestSync); 1482 if (ret != HDF_SUCCESS || requestSync == nullptr) { 1483 HDF_LOGE("%{public}s:UsbdFindRequestSyncAndCreat failed.", __func__); 1484 return ret; 1485 } 1486 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN || 1487 (requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK && requestSync->pipe.pipeType != USB_PIPE_TYPE_INTERRUPT)) { 1488 HDF_LOGE("%{public}s:invalid param", __func__); 1489 return HDF_ERR_INVALID_PARAM; 1490 } 1491 ret = UsbdBulkReadSyncBase(timeout, tbuf, tsize, &actlength, requestSync); 1492 if (ret != HDF_SUCCESS) { 1493 HDF_LOGW("%{public}s:UsbdBulkReadSyncBase ret:%{public}d, actlength:%{public}u", __func__, ret, actlength); 1494 } 1495 1496 if (actlength > 0) { 1497 data.assign(tbuf, tbuf + actlength); 1498 ret = HDF_SUCCESS; 1499 } 1500 return ret; 1501} 1502 1503int32_t UsbImpl::BulkTransferReadwithLength(const UsbDev &dev, 1504 const UsbPipe &pipe, int32_t timeout, int32_t length, std::vector<uint8_t> &data) 1505{ 1506 if (length<= 0) { 1507 HDF_LOGE("%{public}s:invalid length param, length: %{public}d.", __func__, length); 1508 return HDF_ERR_INVALID_PARAM; 1509 } 1510 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1511 if (port == nullptr) { 1512 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1513 return HDF_DEV_ERR_NO_DEVICE; 1514 } 1515 1516 uint8_t* tbuf = (uint8_t *)malloc(length); 1517 if (tbuf == nullptr) { 1518 HDF_LOGE("%{public}s:malloc failed", __func__); 1519 return HDF_FAILURE; 1520 } 1521 memset_s(tbuf, length, 0, length); 1522 uint32_t tsize = static_cast<uint32_t>(length); 1523 uint32_t actlength = 0; 1524 UsbdRequestSync *requestSync = nullptr; 1525 int32_t ret = UsbdFindRequestSyncAndCreatwithLength(port, pipe.intfId, pipe.endpointId, length, &requestSync); 1526 if (ret != HDF_SUCCESS || requestSync == nullptr) { 1527 HDF_LOGE("%{public}s:UsbdFindRequestSyncAndCreat failed.", __func__); 1528 free(tbuf); 1529 tbuf = nullptr; 1530 return ret; 1531 } 1532 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN || 1533 (requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK && requestSync->pipe.pipeType != USB_PIPE_TYPE_INTERRUPT)) { 1534 HDF_LOGE("%{public}s:invalid param", __func__); 1535 free(tbuf); 1536 tbuf = nullptr; 1537 return HDF_ERR_INVALID_PARAM; 1538 } 1539 ret = UsbdBulkReadSyncBase(timeout, tbuf, tsize, &actlength, requestSync); 1540 if (ret != HDF_SUCCESS) { 1541 HDF_LOGW("%{public}s:UsbdBulkReadSyncBase ret:%{public}d, actlength:%{public}u", __func__, ret, actlength); 1542 } 1543 1544 if (actlength > 0) { 1545 data.assign(tbuf, tbuf + actlength); 1546 ret = HDF_SUCCESS; 1547 } 1548 free(tbuf); 1549 tbuf = nullptr; 1550 return ret; 1551} 1552 1553int32_t UsbImpl::BulkTransferWrite( 1554 const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, const std::vector<uint8_t> &data) 1555{ 1556 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1557 if (port == nullptr) { 1558 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1559 return HDF_DEV_ERR_NO_DEVICE; 1560 } 1561 1562 UsbdRequestSync *requestSync = nullptr; 1563 int32_t ret = UsbdFindRequestSyncAndCreat(port, pipe.intfId, pipe.endpointId, &requestSync); 1564 if (ret != HDF_SUCCESS || requestSync == nullptr) { 1565 HDF_LOGE("%{public}s:read timeout error", __func__); 1566 return ret; 1567 } 1568 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_OUT || 1569 (requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK && requestSync->pipe.pipeType != USB_PIPE_TYPE_INTERRUPT)) { 1570 HDF_LOGE("%{public}s:invalid param", __func__); 1571 return HDF_ERR_INVALID_PARAM; 1572 } 1573 ret = UsbdBulkWriteSyncBase(port, requestSync, data.data(), data.size(), timeout); 1574 return ret; 1575} 1576 1577int32_t UsbImpl::ControlTransferRead(const UsbDev &dev, const UsbCtrlTransfer &ctrl, std::vector<uint8_t> &data) 1578{ 1579 if ((static_cast<uint32_t>(ctrl.requestType) & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) { 1580 HDF_LOGE("%{public}s: this function is read, not write", __func__); 1581 return HDF_FAILURE; 1582 } 1583 1584 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1585 if (port == nullptr || port->ctrDevHandle == nullptr) { 1586 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1587 return HDF_DEV_ERR_NO_DEVICE; 1588 } 1589 1590 UsbControlParams controlParams; 1591 if (memset_s(&controlParams, sizeof(controlParams), 0, sizeof(controlParams)) != EOK) { 1592 HDF_LOGE("%{public}s:memset_s failed ", __func__); 1593 return HDF_FAILURE; 1594 } 1595 controlParams.request = static_cast<uint8_t>(ctrl.requestCmd); 1596 controlParams.value = ctrl.value; 1597 controlParams.index = ctrl.index; 1598 controlParams.target = (UsbRequestTargetType)(static_cast<uint32_t>(ctrl.requestType) & USB_RECIP_MASK); 1599 controlParams.directon = (UsbRequestDirection)(((static_cast<uint32_t>(ctrl.requestType)) >> DIRECTION_OFFSET_7) & 1600 ENDPOINT_DIRECTION_MASK); 1601 controlParams.reqType = static_cast<uint32_t>(ctrl.requestType); 1602 controlParams.size = MAX_CONTROL_BUFF_SIZE; 1603 controlParams.data = static_cast<void *>(OsalMemCalloc(controlParams.size)); 1604 if (controlParams.data == nullptr) { 1605 HDF_LOGE("%{public}s:OsalMemCalloc failed", __func__); 1606 return HDF_ERR_MALLOC_FAIL; 1607 } 1608 int32_t ret = UsbControlTransferEx(port, &controlParams, ctrl.timeout); 1609 if (ret != HDF_SUCCESS) { 1610 HDF_LOGE("%{public}s:%{public}d UsbControlTransfer failed ret:%{public}d", __func__, __LINE__, ret); 1611 } 1612 1613 uint8_t *dataValue = static_cast<uint8_t *>(controlParams.data); 1614 data.assign(dataValue, dataValue + controlParams.size); 1615 OsalMemFree(controlParams.data); 1616 return ret; 1617} 1618 1619int32_t UsbImpl::ControlTransferWrite(const UsbDev &dev, const UsbCtrlTransfer &ctrl, const std::vector<uint8_t> &data) 1620{ 1621 if ((static_cast<uint32_t>(ctrl.requestType) & USB_ENDPOINT_DIR_MASK) != USB_ENDPOINT_DIR_OUT) { 1622 HDF_LOGE("%{public}s: this function is write, not read", __func__); 1623 return HDF_FAILURE; 1624 } 1625 1626 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1627 if (port == nullptr || port->ctrDevHandle == nullptr) { 1628 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1629 return HDF_DEV_ERR_NO_DEVICE; 1630 } 1631 1632 UsbControlParams controlParams; 1633 if (memset_s(&controlParams, sizeof(controlParams), 0, sizeof(controlParams)) != EOK) { 1634 HDF_LOGE("%{public}s:memset_s failed ", __func__); 1635 return HDF_FAILURE; 1636 } 1637 controlParams.request = static_cast<uint8_t>(ctrl.requestCmd); 1638 controlParams.value = ctrl.value; 1639 controlParams.index = ctrl.index; 1640 controlParams.target = (UsbRequestTargetType)(static_cast<uint32_t>(ctrl.requestType) & USB_RECIP_MASK); 1641 controlParams.directon = (UsbRequestDirection)(((static_cast<uint32_t>(ctrl.requestType)) >> DIRECTION_OFFSET_7) & 1642 ENDPOINT_DIRECTION_MASK); 1643 controlParams.reqType = static_cast<uint32_t>(ctrl.requestType); 1644 controlParams.size = data.size(); 1645 controlParams.data = static_cast<void *>(const_cast<uint8_t *>(data.data())); 1646 int32_t ret = UsbControlTransferEx(port, &controlParams, ctrl.timeout); 1647 if (ret != HDF_SUCCESS) { 1648 HDF_LOGE("%{public}s:%{public}d UsbControlTransfer failed ret:%{public}d", __func__, __LINE__, ret); 1649 } 1650 return ret; 1651} 1652 1653int32_t UsbImpl::ControlTransferReadwithLength( 1654 const UsbDev &dev, const UsbCtrlTransferParams &ctrlParams, std::vector<uint8_t> &data) 1655{ 1656 if ((static_cast<uint32_t>(ctrlParams.requestType) & USB_ENDPOINT_DIR_MASK) == USB_ENDPOINT_DIR_OUT) { 1657 HDF_LOGE("%{public}s: this function is read, not write", __func__); 1658 return HDF_FAILURE; 1659 } 1660 1661 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1662 if (port == nullptr || port->ctrDevHandle == nullptr) { 1663 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1664 return HDF_DEV_ERR_NO_DEVICE; 1665 } 1666 1667 UsbControlParams controlParams; 1668 if (memset_s(&controlParams, sizeof(controlParams), 0, sizeof(controlParams)) != EOK) { 1669 HDF_LOGE("%{public}s:memset_s failed ", __func__); 1670 return HDF_FAILURE; 1671 } 1672 controlParams.request = static_cast<uint8_t>(ctrlParams.requestCmd); 1673 controlParams.value = ctrlParams.value; 1674 controlParams.index = ctrlParams.index; 1675 controlParams.target = (UsbRequestTargetType)(static_cast<uint32_t>(ctrlParams.requestType) & USB_RECIP_MASK); 1676 controlParams.directon = (UsbRequestDirection)(((static_cast<uint32_t>(ctrlParams.requestType)) 1677 >> DIRECTION_OFFSET_7) & ENDPOINT_DIRECTION_MASK); 1678 controlParams.reqType = static_cast<uint32_t>(ctrlParams.requestType); 1679 controlParams.size = (ctrlParams.length <= 0 || ctrlParams.length > MAX_CONTROL_BUFF_SIZE) 1680 ? MAX_CONTROL_BUFF_SIZE : ctrlParams.length; 1681 controlParams.data = static_cast<void *>(OsalMemCalloc(controlParams.size)); 1682 if (controlParams.data == nullptr) { 1683 HDF_LOGE("%{public}s:OsalMemCalloc failed", __func__); 1684 return HDF_ERR_MALLOC_FAIL; 1685 } 1686 int32_t ret = UsbControlTransferEx(port, &controlParams, ctrlParams.timeout); 1687 if (ret != HDF_SUCCESS) { 1688 HDF_LOGE("%{public}s:%{public}d UsbControlTransfer failed ret:%{public}d", __func__, __LINE__, ret); 1689 } 1690 1691 uint8_t *dataValue = static_cast<uint8_t *>(controlParams.data); 1692 data.assign(dataValue, dataValue + controlParams.size); 1693 OsalMemFree(controlParams.data); 1694 return ret; 1695} 1696 1697int32_t UsbImpl::InterruptTransferRead( 1698 const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, std::vector<uint8_t> &data) 1699{ 1700 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1701 if (port == nullptr) { 1702 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1703 return HDF_DEV_ERR_NO_DEVICE; 1704 } 1705 1706 uint8_t tbuf[READ_BUF_SIZE] = {0}; 1707 uint32_t tsize = READ_BUF_SIZE; 1708 uint32_t actlength = 0; 1709 UsbdRequestSync *requestSync = nullptr; 1710 int32_t ret = UsbdFindRequestSyncAndCreat(port, pipe.intfId, pipe.endpointId, &requestSync); 1711 if (ret != HDF_SUCCESS || requestSync == nullptr) { 1712 HDF_LOGE("%{public}s:read timeout error", __func__); 1713 return ret; 1714 } 1715 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN || requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK) { 1716 HDF_LOGE("%{public}s:invalid param", __func__); 1717 return HDF_ERR_INVALID_PARAM; 1718 } 1719 ret = UsbdBulkReadSyncBase(timeout, tbuf, tsize, &actlength, requestSync); 1720 if (ret != HDF_SUCCESS) { 1721 HDF_LOGW("%{public}s:UsbdBulkReadSyncBase ret:%{public}d, actlength:%{public}u", __func__, ret, actlength); 1722 } 1723 1724 if (actlength > 0) { 1725 data.assign(tbuf, tbuf + actlength); 1726 ret = HDF_SUCCESS; 1727 } 1728 return ret; 1729} 1730 1731int32_t UsbImpl::InterruptTransferWrite( 1732 const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, const std::vector<uint8_t> &data) 1733{ 1734 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1735 if (port == nullptr) { 1736 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1737 return HDF_DEV_ERR_NO_DEVICE; 1738 } 1739 1740 UsbdRequestSync *requestSync = nullptr; 1741 int32_t ret = UsbdFindRequestSyncAndCreat(port, pipe.intfId, pipe.endpointId, &requestSync); 1742 if (ret != HDF_SUCCESS || requestSync == nullptr) { 1743 HDF_LOGE("%{public}s:read timeout error", __func__); 1744 return ret; 1745 } 1746 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_OUT || requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK) { 1747 HDF_LOGE("%{public}s:invalid param", __func__); 1748 return HDF_ERR_INVALID_PARAM; 1749 } 1750 ret = UsbdBulkWriteSyncBase(port, requestSync, data.data(), data.size(), timeout); 1751 return ret; 1752} 1753 1754int32_t UsbImpl::IsoTransferRead(const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, std::vector<uint8_t> &data) 1755{ 1756 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1757 if (port == nullptr) { 1758 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1759 return HDF_DEV_ERR_NO_DEVICE; 1760 } 1761 1762 uint8_t tbuf[READ_BUF_SIZE] = {0}; 1763 uint32_t tsize = READ_BUF_SIZE; 1764 uint32_t actlength = 0; 1765 UsbdRequestSync *requestSync = nullptr; 1766 int32_t ret = UsbdFindRequestSyncAndCreat(port, pipe.intfId, pipe.endpointId, &requestSync); 1767 if (ret != HDF_SUCCESS || requestSync == nullptr) { 1768 HDF_LOGE("%{public}s:UsbdFindRequestSyncAndCreat failed of requestSync is nullptr", __func__); 1769 return ret; 1770 } 1771 1772 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_IN || requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK) { 1773 HDF_LOGE("%{public}s:invalid param", __func__); 1774 return HDF_ERR_INVALID_PARAM; 1775 } 1776 1777 ret = UsbdBulkReadSyncBase(timeout, tbuf, tsize, &actlength, requestSync); 1778 if (ret != HDF_SUCCESS) { 1779 HDF_LOGW("%{public}s:UsbdBulkReadSyncBase failed, ret:%{public}d, len:%{public}u", __func__, ret, actlength); 1780 } 1781 1782 if (actlength > 0) { 1783 data.assign(tbuf, tbuf + actlength); 1784 ret = HDF_SUCCESS; 1785 } 1786 return ret; 1787} 1788 1789int32_t UsbImpl::IsoTransferWrite( 1790 const UsbDev &dev, const UsbPipe &pipe, int32_t timeout, const std::vector<uint8_t> &data) 1791{ 1792 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1793 if (port == nullptr) { 1794 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1795 return HDF_DEV_ERR_NO_DEVICE; 1796 } 1797 1798 UsbdRequestSync *requestSync = nullptr; 1799 int32_t ret = UsbdFindRequestSyncAndCreat(port, pipe.intfId, pipe.endpointId, &requestSync); 1800 if (ret != HDF_SUCCESS || requestSync == nullptr) { 1801 HDF_LOGE("%{public}s:read timeout error", __func__); 1802 return ret; 1803 } 1804 1805 if (requestSync->pipe.pipeDirection != USB_PIPE_DIRECTION_OUT || requestSync->pipe.pipeType != USB_PIPE_TYPE_BULK) { 1806 HDF_LOGE("%{public}s:invalid param", __func__); 1807 return HDF_ERR_INVALID_PARAM; 1808 } 1809 1810 ret = UsbdBulkWriteSyncBase(port, requestSync, data.data(), data.size(), timeout); 1811 return ret; 1812} 1813 1814int32_t UsbImpl::RequestQueue( 1815 const UsbDev &dev, const UsbPipe &pipe, const std::vector<uint8_t> &clientData, const std::vector<uint8_t> &buffer) 1816{ 1817 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1818 if (port == nullptr) { 1819 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1820 return HDF_DEV_ERR_NO_DEVICE; 1821 } 1822 1823 UsbdRequestASync *reqAsync = UsbdFindRequestASync(port, pipe.intfId, pipe.endpointId); 1824 if (reqAsync == nullptr) { 1825 HDF_LOGE("%{public}s:UsbdFindRequestASync failed", __func__); 1826 return HDF_ERR_DEVICE_BUSY; 1827 } 1828 1829 uint8_t *clientDataAddr = nullptr; 1830 int32_t ret = UsbdDispatcher::UsbdMallocAndFill(clientDataAddr, clientData); 1831 if (ret != HDF_SUCCESS) { 1832 HDF_LOGE("%{public}s:clientDataAddr UsbdMallocAndFill failed", __func__); 1833 return HDF_FAILURE; 1834 } 1835 1836 uint8_t *bufferAddr = nullptr; 1837 ret = UsbdDispatcher::UsbdMallocAndFill(bufferAddr, buffer); 1838 if (ret != HDF_SUCCESS) { 1839 OsalMemFree(clientDataAddr); 1840 clientDataAddr = nullptr; 1841 HDF_LOGE("%{public}s:bufferAddr UsbdMallocAndFill failed", __func__); 1842 return HDF_FAILURE; 1843 } 1844 1845 reqAsync->reqMsg.clientData = static_cast<void *>(clientDataAddr); 1846 reqAsync->reqMsg.clientLength = sizeof(uint8_t) * clientData.size(); 1847 ret = FunRequestQueueFillAndSubmit(port, reqAsync, bufferAddr, sizeof(uint8_t) * buffer.size()); 1848 if (ret != HDF_SUCCESS) { 1849 HDF_LOGE("%{public}s:FunRequestQueueFillAndSubmit failed:%{public}d", __func__, ret); 1850 OsalMemFree(clientDataAddr); 1851 clientDataAddr = nullptr; 1852 } 1853 1854 OsalMemFree(bufferAddr); 1855 bufferAddr = nullptr; 1856 return ret; 1857} 1858 1859int32_t UsbImpl::RequestWait( 1860 const UsbDev &dev, std::vector<uint8_t> &clientData, std::vector<uint8_t> &buffer, int32_t timeout) 1861{ 1862 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1863 if (port == nullptr) { 1864 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1865 return HDF_DEV_ERR_NO_DEVICE; 1866 } 1867 1868 UsbdRequestASync *reqMsg = nullptr; 1869 int32_t ret = GetRequestMsgFromQueue(port, &reqMsg); 1870 if (ret != HDF_SUCCESS || reqMsg == nullptr || reqMsg->reqMsg.request == nullptr) { 1871 HDF_LOGE("%{public}s:GetRequestMsgFromQueue error:%{public}d", __func__, ret); 1872 return ret; 1873 } 1874 1875 UsbIfRequest *reqValue = reinterpret_cast<UsbIfRequest *>(reqMsg->reqMsg.request); 1876 if (static_cast<int32_t>(reqMsg->reqMsg.request->compInfo.status) == -1) { 1877 ret = OsalSemWait(&reqValue->hostRequest->sem, timeout); 1878 if (ret != HDF_SUCCESS) { 1879 HDF_LOGE("%{public}s:OsalSemWait failed, ret=%{public}d", __func__, ret); 1880 OsalMutexLock(&port->requestLock); 1881 HdfSListAdd(&port->requestQueue, &reqMsg->qNode); 1882 OsalMutexUnlock(&port->requestLock); 1883 return ret; 1884 } 1885 } 1886 1887 uint32_t length = 0; 1888 uint8_t *buf = nullptr; 1889 ret = GetRequestMsgData(port, reqMsg, timeout, &buf, &length); 1890 if (ret != HDF_SUCCESS) { 1891 HDF_LOGE("%{public}s:GetRequestMsgData failed:%{public}d", __func__, ret); 1892 return ret; 1893 } 1894 1895 uint8_t *clientDataAddr = static_cast<uint8_t *>(reqMsg->reqMsg.clientData); 1896 uint8_t *bufferAddr = static_cast<uint8_t *>(reqMsg->reqMsg.request->compInfo.buffer); 1897 clientData.assign(clientDataAddr, clientDataAddr + reqMsg->reqMsg.clientLength); 1898 buffer.assign(bufferAddr, bufferAddr + reqMsg->reqMsg.request->compInfo.length); 1899 UsbdRequestASyncReleaseData(reqMsg); 1900 return ret; 1901} 1902 1903int32_t UsbImpl::RequestCancel(const UsbDev &dev, const UsbPipe &pipe) 1904{ 1905 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 1906 if (port == nullptr) { 1907 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 1908 return HDF_DEV_ERR_NO_DEVICE; 1909 } 1910 1911 UsbdRequestASync *reqMsg = nullptr; 1912 while (GetRequestMsgFromQueue(port, &reqMsg) == HDF_SUCCESS) { 1913 if (reqMsg) { 1914 int32_t ret = UsbCancelRequest(reqMsg->reqMsg.request); 1915 if (ret != HDF_SUCCESS) { 1916 HDF_LOGW("%{public}s:request cancel failed = %{public}d", __func__, ret); 1917 } 1918 OsalMutexLock(&reqMsg->lock); 1919 UsbdRequestASyncReleaseData(reqMsg); 1920 reqMsg->status = 0; 1921 OsalMutexUnlock(&reqMsg->lock); 1922 } 1923 } 1924 return HDF_SUCCESS; 1925} 1926 1927int32_t UsbImpl::GetCurrentFunctions(int32_t &funcs) 1928{ 1929 funcs = UsbdFunction::UsbdGetFunction(); 1930 return HDF_SUCCESS; 1931} 1932 1933int32_t UsbImpl::SetCurrentFunctions(int32_t funcs) 1934{ 1935 OsalMutexLock(&lock_); 1936 int32_t ret = UsbdFunction::UsbdSetFunction(funcs); 1937 if (ret != HDF_SUCCESS) { 1938 HDF_LOGE("%{public}s:UsbdSetFunction failed, ret:%{public}d", __func__, ret); 1939 OsalMutexUnlock(&lock_); 1940 return ret; 1941 } 1942 OsalMutexUnlock(&lock_); 1943 return HDF_SUCCESS; 1944} 1945 1946void UsbImpl::parsePortPath() 1947{ 1948 const char *path_ = nullptr; 1949 const char *pathDef_ = nullptr; 1950 struct DeviceResourceIface *iface = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); 1951 if (iface == nullptr) { 1952 HDF_LOGE("%{public}s: DeviceResourceGetIfaceInstance failed", __func__); 1953 return; 1954 } 1955 1956 if (device_ == nullptr) { 1957 HDF_LOGE("%{public}s: device_ is empty", __func__); 1958 return; 1959 } 1960 if (iface->GetString(device_->property, "port_file_path", &path_, pathDef_) != HDF_SUCCESS) { 1961 HDF_LOGE("%{public}s: read port_file_path failed", __func__); 1962 return; 1963 } 1964 UsbdPort::GetInstance().setPortPath(path_); 1965 return; 1966} 1967 1968int32_t UsbImpl::SetPortRole(int32_t portId, int32_t powerRole, int32_t dataRole) 1969{ 1970 int32_t ret = UsbdPort::GetInstance().SetPort(portId, powerRole, dataRole, subscribers_, MAX_SUBSCRIBER); 1971 if (ret != HDF_SUCCESS) { 1972 HDF_LOGE("%{public}s:FunSetRole failed, ret:%{public}d", __func__, ret); 1973 return ret; 1974 } 1975 1976 return HDF_SUCCESS; 1977} 1978 1979int32_t UsbImpl::QueryPort(int32_t &portId, int32_t &powerRole, int32_t &dataRole, int32_t &mode) 1980{ 1981 int32_t ret = UsbdPort::GetInstance().QueryPort(portId, powerRole, dataRole, mode); 1982 if (ret != HDF_SUCCESS) { 1983 HDF_LOGE("%{public}s:QueryPort failed, ret:%{public}d", __func__, ret); 1984 return ret; 1985 } 1986 1987 return HDF_SUCCESS; 1988} 1989 1990int32_t UsbImpl::BindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber) 1991{ 1992 int32_t i; 1993 if (subscriber == nullptr) { 1994 HDF_LOGE("%{public}s:subscriber is null", __func__); 1995 return HDF_ERR_INVALID_PARAM; 1996 } 1997 const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<IUsbdSubscriber>(subscriber); 1998 for (i = 0; i < MAX_SUBSCRIBER; i++) { 1999 if (subscribers_[i].remote == remote) { 2000 break; 2001 } 2002 } 2003 if (i < MAX_SUBSCRIBER) { 2004 HDF_LOGI("%{public}s: current subscriber was bind", __func__); 2005 return HDF_SUCCESS; 2006 } 2007 for (i = 0; i < MAX_SUBSCRIBER; i++) { 2008 if (subscribers_[i].subscriber == nullptr) { 2009 subscribers_[i].subscriber = subscriber; 2010 subscribers_[i].impl = this; 2011 subscribers_[i].usbPnpListener.callBack = UsbdPnpLoaderEventReceived; 2012 subscribers_[i].usbPnpListener.priv = &subscribers_[i]; 2013 subscribers_[i].remote = remote; 2014 subscribers_[i].deathRecipient = new UsbImpl::UsbDeathRecipient(subscriber); 2015 if (subscribers_[i].deathRecipient == nullptr) { 2016 HDF_LOGE("%{public}s: new deathRecipient failed", __func__); 2017 return HDF_FAILURE; 2018 } 2019 bool result = subscribers_[i].remote->AddDeathRecipient( 2020 static_cast<UsbDeathRecipient *>(subscribers_[i].deathRecipient)); 2021 if (!result) { 2022 HDF_LOGE("%{public}s:AddUsbDeathRecipient failed", __func__); 2023 return HDF_FAILURE; 2024 } 2025 2026 HDF_LOGI("%{public}s: index = %{public}d", __func__, i); 2027 break; 2028 } 2029 } 2030 if (i == MAX_SUBSCRIBER) { 2031 HDF_LOGE("%{public}s: too many listeners", __func__); 2032 return HDF_ERR_OUT_OF_RANGE; 2033 } 2034 2035 if (DdkListenerMgrAdd(&subscribers_[i].usbPnpListener) != HDF_SUCCESS) { 2036 HDF_LOGE("%{public}s: register listerer failed", __func__); 2037 return HDF_FAILURE; 2038 } 2039 return HDF_SUCCESS; 2040} 2041 2042int32_t UsbImpl::UnbindUsbdSubscriber(const sptr<IUsbdSubscriber> &subscriber) 2043{ 2044 if (subscriber == nullptr) { 2045 HDF_LOGE("%{public}s:subscriber is null", __func__); 2046 return HDF_ERR_INVALID_PARAM; 2047 } 2048 int32_t i; 2049 const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<IUsbdSubscriber>(subscriber); 2050 for (i = 0; i < MAX_SUBSCRIBER; i++) { 2051 if (subscribers_[i].remote == remote) { 2052 break; 2053 } 2054 } 2055 if (i == MAX_SUBSCRIBER) { 2056 HDF_LOGE("%{public}s: current subscriber not bind", __func__); 2057 return HDF_DEV_ERR_NO_DEVICE; 2058 } 2059 bool result = remote->RemoveDeathRecipient(static_cast<UsbDeathRecipient *>(subscribers_[i].deathRecipient)); 2060 if (!result) { 2061 HDF_LOGE("%{public}s:RemoveUsbDeathRecipient failed", __func__); 2062 return HDF_FAILURE; 2063 } 2064 2065 subscribers_[i].subscriber = nullptr; 2066 subscribers_[i].remote = nullptr; 2067 subscribers_[i].deathRecipient = nullptr; 2068 if (DdkListenerMgrRemove(&subscribers_[i].usbPnpListener) != HDF_SUCCESS) { 2069 HDF_LOGE("%{public}s: remove listerer failed", __func__); 2070 return HDF_FAILURE; 2071 } 2072 return HDF_SUCCESS; 2073} 2074 2075void UsbImpl::UsbDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &object) 2076{ 2077 int32_t i; 2078 for (i = 0; i < MAX_SUBSCRIBER; i++) { 2079 if (UsbImpl::subscribers_[i].subscriber == deathSubscriber_) { 2080 break; 2081 } 2082 } 2083 if (i == MAX_SUBSCRIBER) { 2084 HDF_LOGE("%{public}s: current subscriber not bind", __func__); 2085 return; 2086 } 2087 UsbImpl::subscribers_[i].subscriber = nullptr; 2088 subscribers_[i].remote = nullptr; 2089 subscribers_[i].deathRecipient = nullptr; 2090 if (DdkListenerMgrRemove(&UsbImpl::subscribers_[i].usbPnpListener) != HDF_SUCCESS) { 2091 HDF_LOGE("%{public}s: remove listerer failed", __func__); 2092 } 2093} 2094 2095int32_t UsbImpl::RegBulkCallback(const UsbDev &dev, const UsbPipe &pipe, const sptr<IUsbdBulkCallback> &cb) 2096{ 2097 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 2098 if (port == nullptr) { 2099 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 2100 return HDF_DEV_ERR_NO_DEVICE; 2101 } 2102 2103 UsbdBulkASyncList *list = UsbdBulkASyncListInit(port, pipe.intfId, pipe.endpointId); 2104 if (list == nullptr) { 2105 HDF_LOGE("%{public}s:UsbdBulkASyncListFind failed", __func__); 2106 return HDF_ERR_MALLOC_FAIL; 2107 } 2108 list->cb = cb; 2109 if (list->cb == nullptr) { 2110 HDF_LOGE("%{public}s:get callback error", __func__); 2111 return HDF_ERR_IO; 2112 } 2113 2114 return HDF_SUCCESS; 2115} 2116 2117int32_t UsbImpl::UnRegBulkCallback(const UsbDev &dev, const UsbPipe &pipe) 2118{ 2119 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 2120 if (port == nullptr) { 2121 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 2122 return HDF_DEV_ERR_NO_DEVICE; 2123 } 2124 2125 UsbdBulkASyncList *list = UsbdBulkASyncListFind(port, pipe.intfId, pipe.endpointId); 2126 if (list == nullptr) { 2127 HDF_LOGE("%{public}s:UsbdBulkASyncListFind failed", __func__); 2128 return HDF_FAILURE; 2129 } 2130 list->cb = nullptr; 2131 return HDF_SUCCESS; 2132} 2133 2134int32_t UsbImpl::BulkRead(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem) 2135{ 2136 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 2137 if (port == nullptr) { 2138 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 2139 return HDF_DEV_ERR_NO_DEVICE; 2140 } 2141 2142 UsbdBulkASyncList *list = UsbdBulkASyncListInit(port, pipe.intfId, pipe.endpointId); 2143 if (list == nullptr) { 2144 HDF_LOGE("%{public}s:UsbdBulkASyncListInit failed.", __func__); 2145 return HDF_ERR_MALLOC_FAIL; 2146 } 2147 2148 int32_t ret = InitAsmBufferHandle(&list->asmHandle, ashmem->GetAshmemFd(), ashmem->GetAshmemSize()); 2149 if (ret != HDF_SUCCESS) { 2150 HDF_LOGE("%{public}s:InitAsmBufferHandle failed ret:%{public}d ashmem fd:%{public}d size:%{public}d", __func__, 2151 ret, ashmem->GetAshmemFd(), ashmem->GetAshmemSize()); 2152 return ret; 2153 } 2154 2155 ret = UsbdBulkReadASyncSubmitStart(list); 2156 if (ret == HDF_DEV_ERR_NODATA || ret == HDF_DEV_ERR_NO_MEMORY || ret == HDF_ERR_DEVICE_BUSY) { 2157 ret = HDF_SUCCESS; 2158 } 2159 if (ret != HDF_SUCCESS) { 2160 HDF_LOGE("%{public}s:UsbdBulkReadASyncSubmitStart error ret:%{public}d", __func__, ret); 2161 return ret; 2162 } 2163 2164 return ret; 2165} 2166 2167int32_t UsbImpl::BulkWrite(const UsbDev &dev, const UsbPipe &pipe, const sptr<Ashmem> &ashmem) 2168{ 2169 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 2170 if (port == nullptr) { 2171 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 2172 return HDF_DEV_ERR_NO_DEVICE; 2173 } 2174 2175 UsbdBulkASyncList *list = UsbdBulkASyncListInit(port, pipe.intfId, pipe.endpointId); 2176 if (list == nullptr) { 2177 HDF_LOGE("%{public}s:UsbdBulkASyncListInit failed.", __func__); 2178 return HDF_ERR_MALLOC_FAIL; 2179 } 2180 2181 int32_t ret = InitAsmBufferHandle(&list->asmHandle, ashmem->GetAshmemFd(), ashmem->GetAshmemSize()); 2182 if (ret != HDF_SUCCESS) { 2183 HDF_LOGE("%{public}s:InitAsmBufferHandle failed ret:%{public}d ashmem fd:%{public}d size:%{public}d", __func__, 2184 ret, ashmem->GetAshmemFd(), ashmem->GetAshmemSize()); 2185 return ret; 2186 } 2187 2188 ret = UsbdBulkASyncWriteSubmitStart(list); 2189 if (ret == HDF_DEV_ERR_NODATA || ret == HDF_DEV_ERR_NO_MEMORY || ret == HDF_ERR_DEVICE_BUSY) { 2190 ret = HDF_SUCCESS; 2191 } 2192 if (ret != HDF_SUCCESS) { 2193 HDF_LOGE("%{public}s:UsbdBulkASyncWriteSubmitStart error ret:%{public}d", __func__, ret); 2194 return ret; 2195 } 2196 2197 return ret; 2198} 2199 2200int32_t UsbImpl::BulkCancel(const UsbDev &dev, const UsbPipe &pipe) 2201{ 2202 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 2203 if (port == nullptr) { 2204 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 2205 return HDF_DEV_ERR_NO_DEVICE; 2206 } 2207 2208 UsbdBulkASyncList *list = UsbdBulkASyncListFind(port, pipe.intfId, pipe.endpointId); 2209 if (list == nullptr) { 2210 HDF_LOGW("%{public}s:UsbdBulkASyncListFind failed interfaceId:%{public}u endpointId:%{public}u", __func__, 2211 pipe.intfId, pipe.endpointId); 2212 return HDF_FAILURE; 2213 } 2214 sptr<IUsbdBulkCallback> tcb = list->cb; 2215 list->cb = nullptr; 2216 ReleaseAsmBufferHandle(&list->asmHandle); 2217 BulkRequestCancel(list); 2218 list->cb = tcb; 2219 return HDF_SUCCESS; 2220} 2221 2222int32_t UsbImpl::ClearHalt(const UsbDev &dev, const UsbPipe &pipe) 2223{ 2224 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 2225 if (port == nullptr) { 2226 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 2227 return HDF_DEV_ERR_NO_DEVICE; 2228 } 2229 if (pipe.intfId >= USB_MAX_INTERFACES) { 2230 HDF_LOGE("%{public}s:interfaceId larger then max num", __func__); 2231 return HDF_ERR_INVALID_PARAM; 2232 } 2233 int32_t ret = UsbClearInterfaceHalt(port->devHandle[pipe.intfId], pipe.endpointId); 2234 if (ret != HDF_SUCCESS) { 2235 HDF_LOGE("%{public}s:ClearHalt error ret:%{public}d", __func__, ret); 2236 } 2237 return ret; 2238} 2239 2240int32_t UsbImpl::GetInterfaceActiveStatus(const UsbDev &dev, uint8_t interfaceId, bool &unactivated) 2241{ 2242 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 2243 if (port == nullptr) { 2244 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 2245 return HDF_DEV_ERR_NO_DEVICE; 2246 } 2247 if (interfaceId >= USB_MAX_INTERFACES) { 2248 HDF_LOGE("%{public}s:interfaceId larger then max num", __func__); 2249 return HDF_ERR_INVALID_PARAM; 2250 } 2251 2252 unactivated = UsbGetInterfaceActiveStatus(port->service->session_, port->busNum, port->devAddr, interfaceId); 2253 return HDF_SUCCESS; 2254} 2255 2256int32_t UsbImpl::GetDeviceSpeed(const UsbDev &dev, uint8_t &speed) 2257{ 2258 HostDevice *port = FindDevFromService(dev.busNum, dev.devAddr); 2259 if (port == nullptr) { 2260 HDF_LOGE("%{public}s:FindDevFromService failed", __func__); 2261 return HDF_DEV_ERR_NO_DEVICE; 2262 } 2263 UsbInterfaceHandleEntity *handle = reinterpret_cast<UsbInterfaceHandleEntity *>(port->ctrDevHandle); 2264 int32_t ret = RawUsbGetUsbSpeed(handle->devHandle); 2265 speed = (uint8_t)ret; 2266 HDF_LOGE("%{public}s:GetDeviceSpeed, speed=%{public}u", __func__, speed); 2267 return HDF_SUCCESS; 2268} 2269 2270 2271} // namespace V1_1 2272} // namespace Usb 2273} // namespace HDI 2274} // namespace OHOS 2275