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 "usbd_function.h"
17 
18 #include <dlfcn.h>
19 #include <unistd.h>
20 #include <cerrno>
21 
22 #include "devmgr_hdi.h"
23 #include "hdf_log.h"
24 #include "hdf_remote_service.h"
25 #include "hdf_sbuf.h"
26 #include "idevmgr_hdi.h"
27 #include "iservmgr_hdi.h"
28 #include "message_option.h"
29 #include "message_parcel.h"
30 #include "osal_time.h"
31 #include "parameter.h"
32 #include "securec.h"
33 #include "string_ex.h"
34 #include "usbd_type.h"
35 #include "usbfn_mtp_impl.h"
36 #include "usbd_wrapper.h"
37 
38 namespace OHOS {
39 namespace HDI {
40 namespace Usb {
41 namespace V1_1 {
42 uint32_t UsbdFunction::currentFuncs_ = USB_FUNCTION_HDC;
43 
44 using OHOS::HDI::DeviceManager::V1_0::IDeviceManager;
45 using OHOS::HDI::ServiceManager::V1_0::IServiceManager;
46 using OHOS::HDI::Usb::Gadget::Mtp::V1_0::IUsbfnMtpInterface;
47 using GetMtpImplFunc = void*(*)();
48 
49 constexpr uint32_t UDC_NAME_MAX_LEN = 32;
50 constexpr int32_t WAIT_UDC_MAX_LOOP = 30;
51 constexpr uint32_t WAIT_UDC_TIME = 100000;
52 constexpr int32_t WRITE_UDC_MAX_RETRY = 5;
53 /* mtp and ptp use same driver and same service */
54 static std::string MTP_PTP_SERVICE_NAME {"usbfn_mtp_interface_service"};
55 #define UDC_PATH "/config/usb_gadget/g1/UDC"
56 
57 static void *g_libHandle = nullptr;
58 static GetMtpImplFunc g_getMtpImpl = nullptr;
59 
InitGetMtpImpl()60 static void InitGetMtpImpl()
61 {
62     if (g_getMtpImpl != nullptr) {
63         return;
64     }
65 
66     g_libHandle = dlopen("libusbfn_mtp_interface_service_1.0.z.so", RTLD_LAZY);
67     if (g_libHandle == nullptr) {
68         HDF_LOGE("%{public}s dlopen failed: %{public}s", __func__, dlerror());
69         return;
70     }
71 
72     void *funcPtr = dlsym(g_libHandle, "UsbfnMtpInterfaceImplGetInstance");
73     if (funcPtr == nullptr) {
74         HDF_LOGE("%{public}s dlsym failed: %{public}s", __func__, dlerror());
75         dlclose(g_libHandle);
76         g_libHandle = nullptr;
77         return;
78     }
79 
80     g_getMtpImpl = reinterpret_cast<GetMtpImplFunc>(funcPtr);
81 }
82 
ReleaseGetMtpImpl()83 static void ReleaseGetMtpImpl()
84 {
85     g_getMtpImpl = nullptr;
86     if (g_libHandle != nullptr) {
87         dlclose(g_libHandle);
88         g_libHandle = nullptr;
89     }
90 }
91 
GetUsbfnMtpImpl()92 static IUsbfnMtpInterface *GetUsbfnMtpImpl()
93 {
94     InitGetMtpImpl();
95     if (g_getMtpImpl == nullptr) {
96         return nullptr;
97     }
98 
99     void *instance = g_getMtpImpl();
100     if (instance != nullptr) {
101         return reinterpret_cast<IUsbfnMtpInterface *>(instance);
102     }
103     return nullptr;
104 }
105 
SendCmdToService(const char * name,int32_t cmd,unsigned char funcMask)106 int32_t UsbdFunction::SendCmdToService(const char *name, int32_t cmd, unsigned char funcMask)
107 {
108     auto servMgr = IServiceManager::Get();
109     if (servMgr == nullptr) {
110         HDF_LOGE("%{public}s: get IServiceManager failed", __func__);
111         return HDF_FAILURE;
112     }
113 
114     sptr<IRemoteObject> remote = servMgr->GetService(name);
115     if (remote == nullptr) {
116         HDF_LOGE("%{public}s: get remote object failed: %{public}s", __func__, name);
117         return HDF_FAILURE;
118     }
119 
120     OHOS::MessageParcel data;
121     OHOS::MessageParcel reply;
122     OHOS::MessageOption option;
123 
124     if (!data.WriteInterfaceToken(Str8ToStr16(HDF_USB_USBFN_DESC))) {
125         HDF_LOGE("%{public}s: WriteInterfaceToken failed", __func__);
126         return HDF_FAILURE;
127     }
128 
129     if (!data.WriteUint8(funcMask)) {
130         HDF_LOGE("%{public}s: WriteInt8 failed: %{public}d", __func__, funcMask);
131         return HDF_FAILURE;
132     }
133 
134     int32_t ret = remote->SendRequest(cmd, data, reply, option);
135     if (ret != HDF_SUCCESS) {
136         HDF_LOGE("%{public}s: send request to %{public}s failed, ret=%{public}d", __func__, name, ret);
137         return ret;
138     }
139     return HDF_SUCCESS;
140 }
141 
InitMtp()142 int32_t UsbdFunction::InitMtp()
143 {
144     int32_t ret = UsbdRegisterDevice(MTP_PTP_SERVICE_NAME);
145     if (ret != HDF_SUCCESS) {
146         HDF_LOGE("%{public}s: register mtp device failed: %{public}d", __func__, ret);
147         return ret;
148     }
149     auto serviceImpl = GetUsbfnMtpImpl();
150     if (serviceImpl == nullptr) {
151         HDF_LOGE("%{public}s: failed to get of implement service", __func__);
152         return HDF_FAILURE;
153     }
154     ret = serviceImpl->Init();
155     if (ret != HDF_SUCCESS) {
156         UsbdUnregisterDevice(MTP_PTP_SERVICE_NAME);
157         HDF_LOGE("%{public}s: init mtp device failed: %{public}d", __func__, ret);
158     }
159     HDF_LOGI("%{public}s: start Init done", __func__);
160     return ret;
161 }
162 
ReleaseMtp()163 int32_t UsbdFunction::ReleaseMtp()
164 {
165     auto serviceImpl = GetUsbfnMtpImpl();
166     if (serviceImpl == nullptr) {
167         HDF_LOGE("%{public}s: failed to get of implement service", __func__);
168         return HDF_FAILURE;
169     }
170     int32_t ret = serviceImpl->Release();
171     if (ret != HDF_SUCCESS) {
172         HDF_LOGE("%{public}s: release mtp device failed: %{public}d", __func__, ret);
173     }
174     ReleaseGetMtpImpl();
175 
176     UsbdUnregisterDevice(MTP_PTP_SERVICE_NAME);
177     HDF_LOGI("%{public}s: release Mtp done", __func__);
178     return ret;
179 }
180 
RemoveHdc()181 int32_t UsbdFunction::RemoveHdc()
182 {
183     int32_t status = SetParameter(SYS_USB_CONFIG, HDC_CONFIG_OFF);
184     if (status != 0) {
185         HDF_LOGE("%{public}s:remove hdc config error = %{public}d", __func__, status);
186         return HDF_FAILURE;
187     }
188     return HDF_SUCCESS;
189 }
190 
AddHdc()191 int32_t UsbdFunction::AddHdc()
192 {
193     int32_t status = SetParameter(SYS_USB_CONFIG, HDC_CONFIG_ON);
194     if (status != 0) {
195         HDF_LOGE("%{public}s:add hdc config error = %{public}d", __func__, status);
196         return HDF_FAILURE;
197     }
198 
199     status = SetParameter(PERSIST_SYS_USB_CONFIG, HDC_CONFIG_ON);
200     if (status != 0) {
201         HDF_LOGE("%{public}s:add hdc persist config error = %{public}d", __func__, status);
202         return HDF_FAILURE;
203     }
204     return HDF_SUCCESS;
205 }
206 
SetFunctionToRndis()207 int32_t UsbdFunction::SetFunctionToRndis()
208 {
209     int32_t status = SetParameter(SYS_USB_CONFIG, HDC_CONFIG_RNDIS);
210     if (status != 0) {
211         HDF_LOGE("%{public}s:add rndis config error = %{public}d", __func__, status);
212         return HDF_FAILURE;
213     }
214     return HDF_SUCCESS;
215 }
216 
SetFunctionToStorage()217 int32_t UsbdFunction::SetFunctionToStorage()
218 {
219     int32_t status = SetParameter(SYS_USB_CONFIG, HDC_CONFIG_STORAGE);
220     if (status != 0) {
221         HDF_LOGE("%{public}s:add storage config error = %{public}d", __func__, status);
222         return HDF_FAILURE;
223     }
224 
225     status = SetParameter(PERSIST_SYS_USB_CONFIG, HDC_CONFIG_STORAGE);
226     if (status != 0) {
227         HDF_LOGE("%{public}s:add storage persist config error = %{public}d", __func__, status);
228         return HDF_FAILURE;
229     }
230     return HDF_SUCCESS;
231 }
232 
SetFunctionToRndisHdc()233 int32_t UsbdFunction::SetFunctionToRndisHdc()
234 {
235     int32_t status = SetParameter(SYS_USB_CONFIG, HDC_CONFIG_RNDIS_HDC);
236     if (status != 0) {
237         HDF_LOGE("%{public}s:add rndis hdc config error = %{public}d", __func__, status);
238         return HDF_FAILURE;
239     }
240     return HDF_SUCCESS;
241 }
242 
SetFunctionToManufactureHdc()243 int32_t UsbdFunction::SetFunctionToManufactureHdc()
244 {
245     int32_t status = SetParameter(SYS_USB_CONFIG, HDC_CONFIG_MANUFACTURE_HDC);
246     if (status != 0) {
247         HDF_LOGE("%{public}s:add manufacture hdc config error = %{public}d", __func__, status);
248         return HDF_FAILURE;
249     }
250     return HDF_SUCCESS;
251 }
252 
SetFunctionToStorageHdc()253 int32_t UsbdFunction::SetFunctionToStorageHdc()
254 {
255     int32_t status = SetParameter(SYS_USB_CONFIG, HDC_CONFIG_STORAGE_HDC);
256     if (status != 0) {
257         HDF_LOGE("%{public}s:add storage hdc config error = %{public}d", __func__, status);
258         return HDF_FAILURE;
259     }
260     return HDF_SUCCESS;
261 }
262 
SetFunctionToUsbAccessory()263 int32_t UsbdFunction::SetFunctionToUsbAccessory()
264 {
265     HDF_LOGD("%{public}s enter", __func__);
266     int32_t status = SetParameter(SYS_USB_CONFIG, HDC_CONFIG_AOA);
267     if (status != 0) {
268         HDF_LOGE("%{public}s:add aoa config error = %{public}d", __func__, status);
269         return HDF_FAILURE;
270     }
271     return HDF_SUCCESS;
272 }
273 
SetFunctionToNone()274 int32_t UsbdFunction::SetFunctionToNone()
275 {
276     uint32_t ddkFuns = currentFuncs_ & USB_DDK_FUNCTION_SUPPORT;
277     if (ddkFuns > 0) {
278         if ((ddkFuns & USB_FUNCTION_ACM) != 0) {
279             UsbdFunction::SendCmdToService(ACM_SERVICE_NAME, ACM_RELEASE, USB_FUNCTION_ACM);
280             UsbdUnregisterDevice(std::string(ACM_SERVICE_NAME));
281         }
282         if ((ddkFuns & USB_FUNCTION_ECM) != 0) {
283             UsbdFunction::SendCmdToService(ECM_SERVICE_NAME, ECM_RELEASE, USB_FUNCTION_ECM);
284             UsbdUnregisterDevice(std::string(ECM_SERVICE_NAME));
285         }
286         if ((ddkFuns & USB_FUNCTION_MTP) != 0 || (ddkFuns & USB_FUNCTION_PTP) != 0) {
287             if (ReleaseMtp() != HDF_SUCCESS) {
288                 HDF_LOGE("%{public}s: release mtp failed", __func__);
289             }
290         }
291     }
292     UsbdFunction::SendCmdToService(DEV_SERVICE_NAME, FUNCTION_DEL, USB_DDK_FUNCTION_SUPPORT);
293     UsbdUnregisterDevice(std::string(DEV_SERVICE_NAME));
294     int32_t ret = RemoveHdc();
295     if (ret != HDF_SUCCESS) {
296         HDF_LOGE("%{public}s: RemoveHdc error, ret = %{public}d", __func__, ret);
297         return ret;
298     }
299 
300     ret = UsbdWaitToNone();
301     if (ret != HDF_SUCCESS) {
302         HDF_LOGE("%{public}s: UsbdWaitToNone error, ret = %{public}d", __func__, ret);
303         return ret;
304     }
305     currentFuncs_ = USB_FUNCTION_NONE;
306     return ret;
307 }
308 
SetDDKFunction(uint32_t funcs)309 int32_t UsbdFunction::SetDDKFunction(uint32_t funcs)
310 {
311     HDF_LOGD("%{public}s: SetDDKFunction funcs=%{public}d", __func__, funcs);
312     uint32_t ddkFuns = static_cast<uint32_t>(funcs) & USB_DDK_FUNCTION_SUPPORT;
313     if (ddkFuns == 0) {
314         HDF_LOGE("%{public}s: not use ddkfunction", __func__);
315         return HDF_SUCCESS;
316     }
317     int32_t ret = UsbdRegisterDevice(std::string(DEV_SERVICE_NAME));
318     if (ret != HDF_SUCCESS) {
319         HDF_LOGE("%{public}s: failed to register device", __func__);
320         return ret;
321     }
322     if (UsbdFunction::SendCmdToService(DEV_SERVICE_NAME, FUNCTION_ADD, ddkFuns)) {
323         HDF_LOGE("%{public}s: create dev error: %{public}d", __func__, ddkFuns);
324         return HDF_FAILURE;
325     }
326     return HDF_SUCCESS;
327 }
328 
UsbdWriteUdc(char * udcName,size_t len)329 int32_t UsbdFunction::UsbdWriteUdc(char* udcName, size_t len)
330 {
331     FILE *fpWrite = fopen(UDC_PATH, "w");
332     if (fpWrite == NULL) {
333         HDF_LOGE("%{public}s: fopen failed", __func__);
334         return HDF_ERR_BAD_FD;
335     }
336 
337     size_t count = fwrite(udcName, len, 1, fpWrite);
338     if (count != 1) {
339         HDF_LOGE("%{public}s: fwrite failed, errno: %{public}d", __func__, errno);
340         (void)fclose(fpWrite);
341         return HDF_FAILURE;
342     }
343 
344     if (ferror(fpWrite)) {
345         HDF_LOGW("%{public}s: fwrite failed, errno: %{public}d", __func__, errno);
346     }
347     if (fclose(fpWrite) == EOF) {
348         HDF_LOGE("%{public}s: flcose failed, errno: %{public}d", __func__, errno);
349         return HDF_FAILURE;
350     }
351     return HDF_SUCCESS;
352 }
UsbdReadUdc(char * udcName,size_t len)353 int32_t UsbdFunction::UsbdReadUdc(char* udcName, size_t len)
354 {
355     FILE *fpRead = fopen(UDC_PATH, "r");
356     if (fpRead == NULL) {
357         HDF_LOGE("%{public}s: fopen failed", __func__);
358         return HDF_ERR_BAD_FD;
359     }
360 
361     size_t count = fread(udcName, len, 1, fpRead);
362     if (count != 1) {
363         if (feof(fpRead)) {
364             HDF_LOGI("%{public}s: fread end of file reached.", __func__);
365         } else if (ferror(fpRead)) {
366             HDF_LOGE("%{public}s: fread failed, errno: %{public}d", __func__, errno);
367         } else {
368             HDF_LOGW("%{public}s: fread len than expected", __func__);
369         }
370         (void)fclose(fpRead);
371         return HDF_FAILURE;
372     }
373 
374     if (fclose(fpRead) == EOF) {
375         HDF_LOGW("%{public}s: flcose failed, errno: %{public}d", __func__, errno);
376     }
377     return HDF_SUCCESS;
378 }
379 
UsbdEnableDevice(int32_t funcs)380 int32_t UsbdFunction::UsbdEnableDevice(int32_t funcs)
381 {
382     // get udc name
383     char udcName[UDC_NAME_MAX_LEN] = {0};
384     int32_t ret = GetParameter("sys.usb.controller", "invalid", udcName, UDC_NAME_MAX_LEN);
385     if (ret <= 0) {
386         HDF_LOGE("%{public}s: GetParameter failed", __func__);
387         return HDF_FAILURE;
388     }
389 
390     char tmpName[UDC_NAME_MAX_LEN] = {0};
391     for (int32_t i = 0; i < WRITE_UDC_MAX_RETRY; i++) {
392         if (i != 0 && ret != HDF_SUCCESS) {
393             ret = SetDDKFunction(funcs);
394             if (ret != HDF_SUCCESS) {
395                 UsbdFunction::SendCmdToService(DEV_SERVICE_NAME, FUNCTION_DEL, USB_DDK_FUNCTION_SUPPORT);
396                 UsbdUnregisterDevice(std::string(DEV_SERVICE_NAME));
397                 usleep(WAIT_UDC_TIME);
398                 continue;
399             }
400         }
401         ret = UsbdWriteUdc(udcName, strlen(udcName));
402         if (ret != HDF_SUCCESS) {
403             UsbdFunction::SendCmdToService(DEV_SERVICE_NAME, FUNCTION_DEL, USB_DDK_FUNCTION_SUPPORT);
404             UsbdUnregisterDevice(std::string(DEV_SERVICE_NAME));
405             usleep(WAIT_UDC_TIME);
406             continue;
407         }
408 
409         (void)memset_s(tmpName, UDC_NAME_MAX_LEN, 0, UDC_NAME_MAX_LEN);
410         ret = UsbdReadUdc(tmpName, strlen(udcName));
411         if (ret != HDF_SUCCESS) {
412             UsbdFunction::SendCmdToService(DEV_SERVICE_NAME, FUNCTION_DEL, USB_DDK_FUNCTION_SUPPORT);
413             UsbdUnregisterDevice(std::string(DEV_SERVICE_NAME));
414             usleep(WAIT_UDC_TIME);
415             continue;
416         }
417 
418         if (strcmp(udcName, tmpName) == 0) {
419             return HDF_SUCCESS;
420         }
421         HDF_LOGI("%{public}s:  tmpName: %{public}s", __func__, tmpName);
422         usleep(WAIT_UDC_TIME);
423     }
424 
425     if (strcmp(udcName, tmpName) != 0) {
426         HDF_LOGE("%{public}s: strcmp failed", __func__);
427         return HDF_FAILURE;
428     }
429     return HDF_SUCCESS;
430 }
431 
UsbdWaitUdc()432 int32_t UsbdFunction::UsbdWaitUdc()
433 {
434     // get udc name
435     char udcName[UDC_NAME_MAX_LEN] = {0};
436     int32_t ret = GetParameter("sys.usb.controller", "invalid", udcName, UDC_NAME_MAX_LEN - 1);
437     if (ret <= 0) {
438         HDF_LOGE("%{public}s: GetParameter failed", __func__);
439         return HDF_FAILURE;
440     }
441 
442     char tmpName[UDC_NAME_MAX_LEN] = {0};
443     for (int32_t i = 0; i < WAIT_UDC_MAX_LOOP; i++) {
444         (void)memset_s(tmpName, UDC_NAME_MAX_LEN, 0, UDC_NAME_MAX_LEN);
445         ret = UsbdReadUdc(tmpName, strlen(udcName));
446         if (ret != HDF_SUCCESS) {
447             usleep(WAIT_UDC_TIME);
448             continue;
449         }
450 
451         if (strcmp(udcName, tmpName) == 0) {
452             return HDF_SUCCESS;
453         }
454         HDF_LOGE("%{public}s: read UDC_PATH: %{public}s", __func__, tmpName);
455         usleep(WAIT_UDC_TIME);
456     }
457 
458     if (strcmp(udcName, tmpName) != 0) {
459         HDF_LOGE("%{public}s: strcmp failed", __func__);
460         return HDF_FAILURE;
461     }
462 
463     return HDF_SUCCESS;
464 }
465 
UsbdWaitToNone()466 int32_t UsbdFunction::UsbdWaitToNone()
467 {
468     char stateName[UDC_NAME_MAX_LEN] = {0};
469     for (int32_t i = 0; i < WAIT_UDC_MAX_LOOP; i++) {
470         (void)memset_s(stateName, UDC_NAME_MAX_LEN, 0, UDC_NAME_MAX_LEN);
471         int32_t ret = GetParameter(SYS_USB_STATE, "invalid", stateName, UDC_NAME_MAX_LEN - 1);
472         if (ret <= 0) {
473             HDF_LOGE("%{public}s: GetParameter failed", __func__);
474             return HDF_FAILURE;
475         }
476         if (strcmp(stateName, HDC_CONFIG_OFF) == 0) {
477             return HDF_SUCCESS;
478         }
479         usleep(WAIT_UDC_TIME);
480     }
481 
482     if (strcmp(stateName, HDC_CONFIG_OFF) != 0) {
483         HDF_LOGE("%{public}s: strcmp failed", __func__);
484         return HDF_FAILURE;
485     }
486 
487     return HDF_SUCCESS;
488 }
489 
UsbdInitDDKFunction(uint32_t funcs)490 int32_t UsbdFunction::UsbdInitDDKFunction(uint32_t funcs)
491 {
492     int32_t ret;
493     if ((funcs & USB_FUNCTION_ACM) != 0) {
494         ret = UsbdRegisterDevice(std::string(ACM_SERVICE_NAME));
495         if (ret != HDF_SUCCESS) {
496             HDF_LOGE("%{public}s: failed to register device", __func__);
497             return HDF_FAILURE;
498         }
499         if (SendCmdToService(ACM_SERVICE_NAME, ACM_INIT, USB_FUNCTION_ACM) != 0) {
500             UsbdUnregisterDevice(std::string(ACM_SERVICE_NAME));
501             HDF_LOGE("%{public}s: acm init error", __func__);
502             return HDF_FAILURE;
503         }
504         currentFuncs_ |= USB_FUNCTION_ACM;
505     }
506     if ((funcs & USB_FUNCTION_ECM) != 0) {
507         ret = UsbdRegisterDevice(std::string(ECM_SERVICE_NAME));
508         if (ret != HDF_SUCCESS) {
509             HDF_LOGE("%{public}s: failed to register device", __func__);
510             return HDF_FAILURE;
511         }
512         if (SendCmdToService(ECM_SERVICE_NAME, ECM_INIT, USB_FUNCTION_ECM) != 0) {
513             UsbdUnregisterDevice(std::string(ECM_SERVICE_NAME));
514             HDF_LOGE("%{public}s: ecm init error", __func__);
515             return HDF_FAILURE;
516         }
517         currentFuncs_ |= USB_FUNCTION_ACM;
518     }
519     if ((funcs & USB_FUNCTION_MTP) != 0 || (funcs & USB_FUNCTION_PTP) != 0) {
520         ret = InitMtp();
521         if (ret != HDF_SUCCESS) {
522             HDF_LOGE("%{public}s: failed to init mtp", __func__);
523             return HDF_FAILURE;
524         }
525     }
526     return HDF_SUCCESS;
527 }
528 
UsbdSetKernelFunction(int32_t kfuns,int32_t funcs)529 int32_t UsbdFunction::UsbdSetKernelFunction(int32_t kfuns, int32_t funcs)
530 {
531     switch (kfuns) {
532         case USB_FUNCTION_HDC:
533             HDF_LOGI("%{public}s: set hdc", __func__);
534             return UsbdFunction::AddHdc();
535         case USB_FUNCTION_RNDIS:
536             HDF_LOGI("%{public}s: set rndis", __func__);
537             return UsbdFunction::SetFunctionToRndis();
538         case USB_FUNCTION_STORAGE:
539             HDF_LOGI("%{public}s: set mass_storage", __func__);
540             return UsbdFunction::SetFunctionToStorage();
541         case USB_FUNCTION_RNDIS | USB_FUNCTION_HDC:
542             HDF_LOGI("%{public}s: set rndis hdc", __func__);
543             return UsbdFunction::SetFunctionToRndisHdc();
544         case USB_FUNCTION_STORAGE | USB_FUNCTION_HDC:
545             HDF_LOGI("%{public}s: set storage hdc", __func__);
546             return UsbdFunction::SetFunctionToStorageHdc();
547         case USB_FUNCTION_MANUFACTURE | USB_FUNCTION_HDC:
548             HDF_LOGI("%{public}s: set manufacture hdc", __func__);
549             return UsbdFunction::SetFunctionToManufactureHdc();
550         case USB_FUNCTION_ACCESSORY:
551             HDF_LOGI("%{public}s: set usb accessory", __func__);
552             return UsbdFunction::SetFunctionToUsbAccessory();
553         default:
554             HDF_LOGI("%{public}s: enable device", __func__);
555             return UsbdEnableDevice(funcs);
556     }
557 }
558 
UsbdSetFunction(uint32_t funcs)559 int32_t UsbdFunction::UsbdSetFunction(uint32_t funcs)
560 {
561     HDF_LOGI("%{public}s: UsbdSetFunction funcs=%{public}d", __func__, funcs);
562     if ((funcs | USB_FUNCTION_SUPPORT) != USB_FUNCTION_SUPPORT) {
563         HDF_LOGE("%{public}s: funcs invalid", __func__);
564         return HDF_ERR_NOT_SUPPORT;
565     }
566 
567     uint32_t kfuns = static_cast<uint32_t>(funcs) & (~USB_DDK_FUNCTION_SUPPORT);
568     if (UsbdFunction::SetFunctionToNone()) {
569         HDF_LOGW("%{public}s: setFunctionToNone error", __func__);
570     }
571 
572     if (funcs == USB_FUNCTION_NONE) {
573         HDF_LOGW("%{public}s: setFunctionToNone", __func__);
574         return HDF_SUCCESS;
575     }
576 
577     if (UsbdFunction::SetDDKFunction(funcs)) {
578         HDF_LOGE("%{public}s:SetDDKFunction error", __func__);
579         return HDF_FAILURE;
580     }
581 
582     int32_t ret = UsbdSetKernelFunction(kfuns, funcs);
583     if (ret != HDF_SUCCESS) {
584         HDF_LOGE("%{public}s, set kernel func failed", __func__);
585         return HDF_FAILURE;
586     }
587     currentFuncs_ |= kfuns;
588     if (funcs == USB_FUNCTION_NONE) {
589         HDF_LOGI("%{public}s, none function", __func__);
590         return HDF_SUCCESS;
591     }
592 
593     if (UsbdWaitUdc() != HDF_SUCCESS) {
594         HDF_LOGE("%{public}s, wait udc failed", __func__);
595         return HDF_FAILURE;
596     }
597     if (UsbdInitDDKFunction(funcs) != HDF_SUCCESS) {
598         HDF_LOGE("%{public}s, init ddk func failed", __func__);
599         UsbdFunction::SendCmdToService(DEV_SERVICE_NAME, FUNCTION_DEL, USB_DDK_FUNCTION_SUPPORT);
600         UsbdUnregisterDevice(std::string(DEV_SERVICE_NAME));
601         return HDF_FAILURE;
602     }
603     currentFuncs_ = funcs;
604     return HDF_SUCCESS;
605 }
606 
UsbdGetFunction(void)607 int32_t UsbdFunction::UsbdGetFunction(void)
608 {
609     return currentFuncs_;
610 }
611 
UsbdUpdateFunction(uint32_t funcs)612 int32_t UsbdFunction::UsbdUpdateFunction(uint32_t funcs)
613 {
614     if ((funcs | USB_FUNCTION_SUPPORT) != USB_FUNCTION_SUPPORT && funcs != (USB_FUNCTION_HDC + USB_FUNCTION_RNDIS) &&
615         funcs != (USB_FUNCTION_HDC + USB_FUNCTION_STORAGE)) {
616         HDF_LOGE("%{public}s: funcs invalid funcs is: %{public}d", __func__, funcs);
617         return HDF_FAILURE;
618     }
619     currentFuncs_ = funcs;
620     return HDF_SUCCESS;
621 }
622 
UsbdRegisterDevice(const std::string & serviceName)623 int32_t UsbdFunction::UsbdRegisterDevice(const std::string &serviceName)
624 {
625     int32_t ret;
626     OHOS::sptr<IDeviceManager> devMgr = IDeviceManager::Get();
627     if (devMgr == nullptr) {
628         HDF_LOGE("%{public}s: get IDeviceManager failed", __func__);
629         return HDF_FAILURE;
630     }
631     ret = devMgr->LoadDevice(serviceName);
632     if (ret != HDF_SUCCESS) {
633         HDF_LOGE("%{public}s, load %{public}s failed", __func__, serviceName.c_str());
634         return ret;
635     }
636     return ret;
637 }
638 
UsbdUnregisterDevice(const std::string & serviceName)639 void UsbdFunction::UsbdUnregisterDevice(const std::string &serviceName)
640 {
641     int32_t ret;
642     OHOS::sptr<IDeviceManager> devMgr = IDeviceManager::Get();
643     if (devMgr == nullptr) {
644         HDF_LOGE("%{public}s: get devMgr object failed", __func__);
645         return;
646     }
647     ret = devMgr->UnloadDevice(serviceName);
648     if (ret != HDF_SUCCESS) {
649         HDF_LOGW("%{public}s, %{public}s unload  failed", __func__, serviceName.c_str());
650     }
651 }
652 } // namespace V1_0
653 } // namespace Usb
654 } // namespace HDI
655 } // namespace OHOS