1 /*
2  * Copyright (c) 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 "v1_0/usb_ddk_service.h"
17 
18 #include <hdf_base.h>
19 #include <iproxy_broker.h>
20 
21 #include "ddk_pnp_listener_mgr.h"
22 #include "usb_ddk_hash.h"
23 #include "usb_ddk_interface.h"
24 #include "usb_ddk_permission.h"
25 #include "usb_raw_api.h"
26 #include "usbd_wrapper.h"
27 #define HDF_LOG_TAG usb_ddk_service
28 
29 namespace OHOS {
30 namespace HDI {
31 namespace Usb {
32 namespace Ddk {
33 namespace V1_0 {
34 // 32 means size of uint32_t
35 #define GET_BUS_NUM(devHandle)          ((uint8_t)((devHandle) >> 32))
36 #define GET_DEV_NUM(devHandle)          ((uint8_t)((devHandle)&0xFFFFFFFF))
37 #define USB_RECIP_MASK                  0x1F
38 #define GET_CTRL_REQ_RECIP(requestType) ((requestType)&USB_RECIP_MASK)
39 #define TRANS_DIRECTION_OFFSET          7
40 #define GET_CTRL_REQ_DIR(requestType)   ((requestType) >> TRANS_DIRECTION_OFFSET)
41 #define REQ_TYPE_OFFERT                 5
42 #define REQ_TYPE_MASK                   0x3
43 #define GET_CTRL_REQ_TYPE(requestType)  (((requestType) >> REQ_TYPE_OFFERT) & REQ_TYPE_MASK)
44 
45 #define MAX_BUFF_SIZE         16384
46 #define MAX_CONTROL_BUFF_SIZE 1024
47 
48 static const std::string PERMISSION_NAME = "ohos.permission.ACCESS_DDK_USB";
49 static std::mutex g_infMutex;
UsbDdkImplGetInstance(void)50 extern "C" IUsbDdk *UsbDdkImplGetInstance(void)
51 {
52     return new (std::nothrow) UsbDdkService();
53 }
54 
ReleaseUsbInterface(uint64_t interfaceHandle)55 int32_t ReleaseUsbInterface(uint64_t interfaceHandle)
56 {
57     std::lock_guard<std::mutex> lock(g_infMutex);
58     uint64_t handle = 0;
59     int32_t ret = UsbDdkUnHash(interfaceHandle, handle);
60     if (ret != HDF_SUCCESS) {
61         HDF_LOGE("%{public}s unhash failed %{public}d", __func__, ret);
62         return ret;
63     }
64     UsbDdkDelHashRecord(interfaceHandle);
65 
66     struct UsbInterface *interface = nullptr;
67     const UsbInterfaceHandle *handleConvert = reinterpret_cast<const UsbInterfaceHandle *>(handle);
68     ret = GetInterfaceByHandle(handleConvert, &interface);
69     if (ret != HDF_SUCCESS) {
70         HDF_LOGE("%{public}s get interface failed %{public}d", __func__, ret);
71         return ret;
72     }
73 
74     ret = UsbCloseInterface(handleConvert, false);
75     if (ret != HDF_SUCCESS) {
76         HDF_LOGE("%{public}s close interface failed %{public}d", __func__, ret);
77         return ret;
78     }
79 
80     return UsbReleaseInterface(interface);
81 }
82 
UsbdPnpEventHandler(void * priv,uint32_t id,HdfSBuf * data)83 static int32_t UsbdPnpEventHandler(void *priv, uint32_t id, HdfSBuf *data)
84 {
85     if (id == USB_PNP_NOTIFY_REMOVE_DEVICE) {
86         uint32_t infoSize;
87         struct UsbPnpNotifyMatchInfoTable *infoTable = NULL;
88         auto flag = HdfSbufReadBuffer(data, (const void **)(&infoTable), &infoSize);
89         if ((!flag) || (infoTable == NULL)) {
90             HDF_LOGE("%{public}s: fail to read infoTable in event data, flag = %{public}d", __func__, flag);
91             return HDF_ERR_INVALID_PARAM;
92         }
93 
94         uint64_t interfaceHandle = 0;
95         if (UsbDdkGetRecordByVal({0, infoTable->busNum, infoTable->devNum}, interfaceHandle)) {
96             HDF_LOGD("%{public}s: need release interface", __func__);
97             ReleaseUsbInterface(interfaceHandle);
98         }
99     }
100     return HDF_SUCCESS;
101 }
102 
103 static HdfDevEventlistener *g_pnpListener = nullptr;
104 
Init()105 int32_t UsbDdkService::Init()
106 {
107     HDF_LOGI("usb ddk init");
108     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
109         HDF_LOGE("%{public}s: no permission", __func__);
110         return HDF_ERR_NOPERM;
111     }
112     if (g_pnpListener == nullptr) {
113         g_pnpListener = new HdfDevEventlistener();
114         if (g_pnpListener == nullptr) {
115             HDF_LOGE("%{public}s: create listener failed", __func__);
116             return HDF_ERR_MALLOC_FAIL;
117         }
118         g_pnpListener->callBack = UsbdPnpEventHandler;
119         if (DdkListenerMgrAdd(g_pnpListener) != HDF_SUCCESS) {
120             HDF_LOGE("%{public}s: add listener failed", __func__);
121             delete g_pnpListener;
122             g_pnpListener = nullptr;
123             return HDF_FAILURE;
124         }
125     }
126 
127     return UsbInitHostSdk(nullptr);
128 }
129 
Release()130 int32_t UsbDdkService::Release()
131 {
132     HDF_LOGI("usb ddk exit");
133     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
134         HDF_LOGE("%{public}s: no permission", __func__);
135         return HDF_ERR_NOPERM;
136     }
137 
138     DdkPermissionManager::Reset();
139     return UsbExitHostSdk(nullptr);
140 }
141 
GetDeviceDescriptor(uint64_t deviceId,UsbDeviceDescriptor & desc)142 int32_t UsbDdkService::GetDeviceDescriptor(uint64_t deviceId, UsbDeviceDescriptor &desc)
143 {
144     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
145         HDF_LOGE("%{public}s: no permission", __func__);
146         return HDF_ERR_NOPERM;
147     }
148 
149     UsbRawHandle *rawHandle = UsbRawOpenDevice(nullptr, GET_BUS_NUM(deviceId), GET_DEV_NUM(deviceId));
150     if (rawHandle == nullptr) {
151         HDF_LOGE("%{public}s open device failed", __func__);
152         return HDF_FAILURE;
153     }
154 
155     UsbRawDevice *rawDevice = UsbRawGetDevice(rawHandle);
156     if (rawDevice == nullptr) {
157         HDF_LOGE("%{public}s get device failed", __func__);
158         (void)UsbRawCloseDevice(rawHandle);
159         return HDF_FAILURE;
160     }
161 
162     int32_t ret = UsbRawGetDeviceDescriptor(rawDevice, reinterpret_cast<::UsbDeviceDescriptor *>(&desc));
163     if (ret != HDF_SUCCESS) {
164         HDF_LOGW("%{public}s get desc failed %{public}d", __func__, ret);
165     }
166     (void)UsbRawCloseDevice(rawHandle);
167     return ret;
168 }
169 
GetConfigDescriptor(uint64_t deviceId,uint8_t configIndex,std::vector<uint8_t> & configDesc)170 int32_t UsbDdkService::GetConfigDescriptor(uint64_t deviceId, uint8_t configIndex, std::vector<uint8_t> &configDesc)
171 {
172     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
173         HDF_LOGE("%{public}s: no permission", __func__);
174         return HDF_ERR_NOPERM;
175     }
176 
177     UsbRawHandle *rawHandle = UsbRawOpenDevice(nullptr, GET_BUS_NUM(deviceId), GET_DEV_NUM(deviceId));
178     if (rawHandle == nullptr) {
179         HDF_LOGE("%{public}s open device failed", __func__);
180         return HDF_FAILURE;
181     }
182 
183     struct UsbConfigDescriptor tmpDesc {};
184     int32_t ret = GetRawConfigDescriptor(
185         rawHandle, configIndex, reinterpret_cast<uint8_t *>(&tmpDesc), sizeof(struct UsbConfigDescriptor));
186     if (ret <= 0) {
187         HDF_LOGW("%{public}s get config desc failed %{public}d", __func__, ret);
188         (void)UsbRawCloseDevice(rawHandle);
189         return ret;
190     }
191 
192     std::vector<uint8_t> tmpBuffer(tmpDesc.wTotalLength);
193     ret = GetRawConfigDescriptor(rawHandle, configIndex, tmpBuffer.data(), tmpDesc.wTotalLength);
194     if (ret <= 0) {
195         HDF_LOGW("%{public}s get config desc failed %{public}d", __func__, ret);
196         (void)UsbRawCloseDevice(rawHandle);
197         return ret;
198     }
199 
200     if (static_cast<size_t>(ret) != tmpBuffer.size()) {
201         HDF_LOGE("%{public}s config desc invalid length : %{public}d, bufferSize:%{public}zu", __func__, ret,
202             tmpBuffer.size());
203         return HDF_FAILURE;
204     }
205 
206     configDesc = tmpBuffer;
207 
208     (void)UsbRawCloseDevice(rawHandle);
209     return HDF_SUCCESS;
210 }
211 
ClaimInterface(uint64_t deviceId,uint8_t interfaceIndex,uint64_t & interfaceHandle)212 int32_t UsbDdkService::ClaimInterface(uint64_t deviceId, uint8_t interfaceIndex, uint64_t &interfaceHandle)
213 {
214     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
215         HDF_LOGE("%{public}s: no permission", __func__);
216         return HDF_ERR_NOPERM;
217     }
218 
219     struct UsbInterface *interface =
220         UsbClaimInterface(nullptr, GET_BUS_NUM(deviceId), GET_DEV_NUM(deviceId), interfaceIndex);
221     if (interface == nullptr) {
222         HDF_LOGE("%{public}s claim failed", __func__);
223         return HDF_FAILURE;
224     }
225 
226     UsbInterfaceHandle *handle = UsbOpenInterface(interface);
227     if (handle == nullptr) {
228         HDF_LOGE("%{public}s open failed", __func__);
229         return HDF_FAILURE;
230     }
231 
232     int32_t ret = UsbDdkHash({(uint64_t)handle, GET_BUS_NUM(deviceId), GET_DEV_NUM(deviceId)}, interfaceHandle);
233     if (ret != HDF_SUCCESS) {
234         HDF_LOGE("%{public}s hash failed %{public}d", __func__, ret);
235     }
236     return ret;
237 }
238 
ReleaseInterface(uint64_t interfaceHandle)239 int32_t UsbDdkService::ReleaseInterface(uint64_t interfaceHandle)
240 {
241     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
242         HDF_LOGE("%{public}s: no permission", __func__);
243         return HDF_ERR_NOPERM;
244     }
245 
246     return ReleaseUsbInterface(interfaceHandle);
247 }
248 
SelectInterfaceSetting(uint64_t interfaceHandle,uint8_t settingIndex)249 int32_t UsbDdkService::SelectInterfaceSetting(uint64_t interfaceHandle, uint8_t settingIndex)
250 {
251     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
252         HDF_LOGE("%{public}s: no permission", __func__);
253         return HDF_ERR_NOPERM;
254     }
255 
256     uint64_t handle = 0;
257     int32_t ret = UsbDdkUnHash(interfaceHandle, handle);
258     if (ret != HDF_SUCCESS) {
259         HDF_LOGE("%{public}s unhash failed %{public}d", __func__, ret);
260         return ret;
261     }
262 
263     struct UsbInterface *interface = nullptr;
264     const UsbInterfaceHandle *handleConvert = reinterpret_cast<const UsbInterfaceHandle *>(handle);
265     return UsbSelectInterfaceSetting(handleConvert, settingIndex, &interface);
266 }
267 
GetCurrentInterfaceSetting(uint64_t interfaceHandle,uint8_t & settingIndex)268 int32_t UsbDdkService::GetCurrentInterfaceSetting(uint64_t interfaceHandle, uint8_t &settingIndex)
269 {
270     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
271         HDF_LOGE("%{public}s: no permission", __func__);
272         return HDF_ERR_NOPERM;
273     }
274 
275     uint64_t handle = 0;
276     int32_t ret = UsbDdkUnHash(interfaceHandle, handle);
277     if (ret != HDF_SUCCESS) {
278         HDF_LOGE("%{public}s unhash failed %{public}d", __func__, ret);
279         return ret;
280     }
281 
282     const UsbInterfaceHandle *handleConvert = reinterpret_cast<const UsbInterfaceHandle *>(handle);
283     return UsbGetInterfaceSetting(handleConvert, &settingIndex);
284 }
285 
SendControlReadRequest(uint64_t interfaceHandle,const UsbControlRequestSetup & setup,uint32_t timeout,std::vector<uint8_t> & data)286 int32_t UsbDdkService::SendControlReadRequest(
287     uint64_t interfaceHandle, const UsbControlRequestSetup &setup, uint32_t timeout, std::vector<uint8_t> &data)
288 {
289     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
290         HDF_LOGE("%{public}s: no permission", __func__);
291         return HDF_ERR_NOPERM;
292     }
293 
294     uint64_t handle = 0;
295     int32_t ret = UsbDdkUnHash(interfaceHandle, handle);
296     if (ret != HDF_SUCCESS) {
297         HDF_LOGE("%{public}s unhash failed %{public}d", __func__, ret);
298         return ret;
299     }
300 
301     const UsbInterfaceHandle *handleConvert = reinterpret_cast<const UsbInterfaceHandle *>(handle);
302     uint32_t length = setup.length > MAX_CONTROL_BUFF_SIZE ? MAX_CONTROL_BUFF_SIZE : setup.length;
303     struct UsbRequest *request = UsbAllocRequest(handleConvert, 0, static_cast<int32_t>(length));
304     if (request == nullptr) {
305         HDF_LOGE("%{public}s alloc request failed", __func__);
306         return HDF_DEV_ERR_NO_MEMORY;
307     }
308 
309     struct UsbRequestParams params;
310     (void)memset_s(&params, sizeof(struct UsbRequestParams), 0, sizeof(struct UsbRequestParams));
311     params.interfaceId = USB_CTRL_INTERFACE_ID;
312     params.requestType = USB_REQUEST_PARAMS_CTRL_TYPE;
313     params.timeout = timeout;
314     params.ctrlReq.target = static_cast<UsbRequestTargetType>(GET_CTRL_REQ_RECIP(setup.requestType));
315     params.ctrlReq.reqType = setup.requestType;
316     params.ctrlReq.directon = static_cast<UsbRequestDirection>(GET_CTRL_REQ_DIR(setup.requestType));
317     params.ctrlReq.request = setup.requestCmd;
318     params.ctrlReq.value = setup.value;
319     params.ctrlReq.index = setup.index;
320     params.ctrlReq.length = length;
321 
322     ret = UsbFillRequest(request, handleConvert, &params);
323     if (ret != HDF_SUCCESS) {
324         HDF_LOGE("%{public}s fill request failed %{public}d", __func__, ret);
325         goto FINISHED;
326     }
327 
328     ret = UsbSubmitRequestSync(request);
329     if (ret != HDF_SUCCESS) {
330         HDF_LOGE("%{public}s submit request failed %{public}d", __func__, ret);
331         goto FINISHED;
332     }
333 
334     data.assign(request->compInfo.buffer, request->compInfo.buffer + request->compInfo.actualLength);
335 FINISHED:
336     (void)UsbFreeRequest(request);
337     return ret;
338 }
339 
SendControlWriteRequest(uint64_t interfaceHandle,const UsbControlRequestSetup & setup,uint32_t timeout,const std::vector<uint8_t> & data)340 int32_t UsbDdkService::SendControlWriteRequest(
341     uint64_t interfaceHandle, const UsbControlRequestSetup &setup, uint32_t timeout, const std::vector<uint8_t> &data)
342 {
343     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
344         HDF_LOGE("%{public}s: no permission", __func__);
345         return HDF_ERR_NOPERM;
346     }
347 
348     uint64_t handle = 0;
349     int32_t ret = UsbDdkUnHash(interfaceHandle, handle);
350     if (ret != HDF_SUCCESS) {
351         HDF_LOGE("%{public}s unhash failed %{public}d", __func__, ret);
352         return ret;
353     }
354 
355     const UsbInterfaceHandle *handleConvert = reinterpret_cast<const UsbInterfaceHandle *>(handle);
356     struct UsbRequest *request = UsbAllocRequest(handleConvert, 0, MAX_CONTROL_BUFF_SIZE);
357     if (request == nullptr) {
358         HDF_LOGE("%{public}s alloc request failed", __func__);
359         return HDF_DEV_ERR_NO_MEMORY;
360     }
361 
362     struct UsbRequestParams params;
363     (void)memset_s(&params, sizeof(struct UsbRequestParams), 0, sizeof(struct UsbRequestParams));
364     params.interfaceId = USB_CTRL_INTERFACE_ID;
365     params.pipeAddress = 0;
366     params.pipeId = 0;
367     params.requestType = USB_REQUEST_PARAMS_CTRL_TYPE;
368     params.timeout = timeout;
369     params.ctrlReq.target = static_cast<UsbRequestTargetType>(GET_CTRL_REQ_RECIP(setup.requestType));
370     params.ctrlReq.reqType = setup.requestType;
371     params.ctrlReq.directon = static_cast<UsbRequestDirection>(GET_CTRL_REQ_DIR(setup.requestType));
372     params.ctrlReq.request = setup.requestCmd;
373     params.ctrlReq.value = setup.value;
374     params.ctrlReq.index = setup.index;
375     params.ctrlReq.buffer = (void *)data.data();
376     params.ctrlReq.length = data.size();
377 
378     ret = UsbFillRequest(request, handleConvert, &params);
379     if (ret != HDF_SUCCESS) {
380         HDF_LOGE("%{public}s fill request failed %{public}d", __func__, ret);
381         goto FINISHED;
382     }
383 
384     ret = UsbSubmitRequestSync(request);
385     if (ret != HDF_SUCCESS) {
386         HDF_LOGE("%{public}s submit request failed %{public}d", __func__, ret);
387         goto FINISHED;
388     }
389 
390 FINISHED:
391     (void)UsbFreeRequest(request);
392     return ret;
393 }
394 
SendPipeRequest(const UsbRequestPipe & pipe,uint32_t size,uint32_t offset,uint32_t length,uint32_t & transferedLength)395 int32_t UsbDdkService::SendPipeRequest(
396     const UsbRequestPipe &pipe, uint32_t size, uint32_t offset, uint32_t length, uint32_t &transferedLength)
397 {
398     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
399         HDF_LOGE("%{public}s: no permission", __func__);
400         return HDF_ERR_NOPERM;
401     }
402 
403     std::lock_guard<std::mutex> lock(g_infMutex);
404     uint64_t handle = 0;
405     int32_t ret = UsbDdkUnHash(pipe.interfaceHandle, handle);
406     if (ret != HDF_SUCCESS) {
407         HDF_LOGE("%{public}s unhash failed %{public}d", __func__, ret);
408         return ret;
409     }
410 
411     const UsbInterfaceHandle *handleConvert = reinterpret_cast<const UsbInterfaceHandle *>(handle);
412     struct UsbRequest *request = UsbAllocRequestByMmap(handleConvert, 0, size);
413     if (request == nullptr) {
414         HDF_LOGE("%{public}s alloc request failed", __func__);
415         return HDF_DEV_ERR_NO_MEMORY;
416     }
417 
418     struct UsbRequestParams params;
419     (void)memset_s(&params, sizeof(struct UsbRequestParams), 0, sizeof(struct UsbRequestParams));
420     params.pipeId = pipe.endpoint;
421     params.pipeAddress = pipe.endpoint;
422     params.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
423     params.timeout = pipe.timeout;
424     params.dataReq.length = length;
425 
426     ret = UsbFillRequestByMmap(request, handleConvert, &params);
427     if (ret != HDF_SUCCESS) {
428         HDF_LOGE("%{public}s fill request failed %{public}d", __func__, ret);
429         goto FINISHED;
430     }
431 
432     ret = UsbSubmitRequestSync(request);
433     if (ret != HDF_SUCCESS) {
434         HDF_LOGE("%{public}s submit request failed %{public}d", __func__, ret);
435         goto FINISHED;
436     }
437 
438     transferedLength = request->compInfo.actualLength;
439 FINISHED:
440     (void)UsbFreeRequestByMmap(request);
441     return ret;
442 }
443 
SendPipeRequestWithAshmem(const UsbRequestPipe & pipe,const UsbAshmem & ashmem,uint32_t & transferredLength)444 int32_t UsbDdkService::SendPipeRequestWithAshmem(
445     const UsbRequestPipe &pipe, const UsbAshmem &ashmem, uint32_t &transferredLength)
446 {
447     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
448         HDF_LOGE("%{public}s: no permission", __func__);
449         return HDF_ERR_NOPERM;
450     }
451 
452     std::lock_guard<std::mutex> lock(g_infMutex);
453     uint64_t handle = 0;
454     int32_t ret = UsbDdkUnHash(pipe.interfaceHandle, handle);
455     if (ret != HDF_SUCCESS) {
456         HDF_LOGE("%{public}s unhash failed %{public}d", __func__, ret);
457         return ret;
458     }
459 
460     const UsbInterfaceHandle *handleConvert = reinterpret_cast<const UsbInterfaceHandle *>(handle);
461     struct UsbRequest *request = UsbAllocRequestByAshmem(handleConvert, 0, ashmem.size, ashmem.ashmemFd);
462     if (request == nullptr) {
463         HDF_LOGE("%{public}s alloc request failed", __func__);
464         return HDF_DEV_ERR_NO_MEMORY;
465     }
466 
467     struct UsbRequestParams params;
468     (void)memset_s(&params, sizeof(struct UsbRequestParams), 0, sizeof(struct UsbRequestParams));
469     params.pipeId = pipe.endpoint;
470     params.pipeAddress = pipe.endpoint;
471     params.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
472     params.timeout = pipe.timeout;
473     params.dataReq.length = ashmem.bufferLength;
474 
475     ret = UsbFillRequestByMmap(request, handleConvert, &params);
476     if (ret != HDF_SUCCESS) {
477         HDF_LOGE("%{public}s fill request failed %{public}d", __func__, ret);
478         goto FINISHED;
479     }
480 
481     ret = UsbSubmitRequestSync(request);
482     if (ret != HDF_SUCCESS) {
483         HDF_LOGE("%{public}s submit request failed %{public}d", __func__, ret);
484         goto FINISHED;
485     }
486 
487     transferredLength = request->compInfo.actualLength;
488 FINISHED:
489     (void)UsbFreeRequestByMmap(request);
490     return ret;
491 }
492 
GetDeviceMemMapFd(uint64_t deviceId,int & fd)493 int32_t UsbDdkService::GetDeviceMemMapFd(uint64_t deviceId, int &fd)
494 {
495     if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
496         HDF_LOGE("%{public}s: no permission", __func__);
497         return HDF_ERR_NOPERM;
498     }
499 
500     int32_t ret = UsbGetDeviceMemMapFd(nullptr, GET_BUS_NUM(deviceId), GET_DEV_NUM(deviceId));
501     if (ret < 0) {
502         HDF_LOGE("%{public}s UsbGetDeviceMemMapFd failed %{public}d", __func__, ret);
503         return ret;
504     }
505     fd = ret;
506     HDF_LOGI("%{public}s:%{public}d fd:%{public}d", __func__, __LINE__, fd);
507     return HDF_SUCCESS;
508 }
509 } // namespace V1_0
510 } // namespace Ddk
511 } // namespace Usb
512 } // namespace HDI
513 } // namespace OHOS
514