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