1 /*
2 * Copyright (c) 2025 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 <hdf_base.h>
17 #include <hdf_core_log.h>
18 #include <hdf_device_desc.h>
19 #include <hdf_sbuf_ipc.h>
20 #include "usb_device_impl.h"
21 #include "v2_0/usb_device_interface_stub.h"
22
23 #define HDF_LOG_TAG usb_device_interface_driver
24
25 using namespace OHOS::HDI::Usb::V2_0;
26
27 struct HdfUsbDeviceInterfaceHost {
28 struct IDeviceIoService ioService;
29 OHOS::sptr<OHOS::IRemoteObject> stub;
30 };
31
UsbDeviceInterfaceDriverDispatch(struct HdfDeviceIoClient * client,int cmdId,struct HdfSBuf * data,struct HdfSBuf * reply)32 static int32_t UsbDeviceInterfaceDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data,
33 struct HdfSBuf *reply)
34 {
35 if (client == nullptr || client->device == nullptr || client->device->service == nullptr) {
36 HDF_LOGE("%{public}s:invalid param", __func__);
37 return HDF_ERR_INVALID_PARAM;
38 }
39 OHOS::MessageParcel *dataParcel = nullptr;
40 OHOS::MessageParcel *replyParcel = nullptr;
41 OHOS::MessageOption option;
42
43 if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) {
44 HDF_LOGE("%{public}s: invalid data sbuf object to dispatch", __func__);
45 return HDF_ERR_INVALID_PARAM;
46 }
47 if (SbufToParcel(reply, &replyParcel) != HDF_SUCCESS) {
48 HDF_LOGE("%{public}s: invalid reply sbuf object to dispatch", __func__);
49 return HDF_ERR_INVALID_PARAM;
50 }
51 auto *hdfUsbDevInterfaceHost = CONTAINER_OF(client->device->service, struct HdfUsbDeviceInterfaceHost, ioService);
52 if (hdfUsbDevInterfaceHost == nullptr || hdfUsbDevInterfaceHost->stub == nullptr) {
53 HDF_LOGE("%{public}s:host or stub are nullptr", __func__);
54 return HDF_ERR_INVALID_PARAM;
55 }
56 return hdfUsbDevInterfaceHost->stub->SendRequest(cmdId, *dataParcel, *replyParcel, option);
57 }
58
HdfUsbDeviceInterfaceDriverInit(struct HdfDeviceObject * deviceObject)59 static int HdfUsbDeviceInterfaceDriverInit(struct HdfDeviceObject *deviceObject)
60 {
61 HDF_LOGI("%{public}s: driver init start", __func__);
62 if (deviceObject == nullptr) {
63 HDF_LOGE("%{public}s:deviceObject is nullptr", __func__);
64 return HDF_ERR_INVALID_OBJECT;
65 }
66 return HDF_SUCCESS;
67 }
68
HdfUsbDeviceInterfaceDriverBind(struct HdfDeviceObject * deviceObject)69 static int HdfUsbDeviceInterfaceDriverBind(struct HdfDeviceObject *deviceObject)
70 {
71 HDF_LOGI("%{public}s: driver bind start", __func__);
72 if (deviceObject == nullptr) {
73 HDF_LOGE("%{public}s:deviceObject is nullptr", __func__);
74 return HDF_ERR_INVALID_OBJECT;
75 }
76 auto *hdfUsbDeviceInterfaceHost = new (std::nothrow) HdfUsbDeviceInterfaceHost;
77 if (hdfUsbDeviceInterfaceHost == nullptr) {
78 HDF_LOGE("%{public}s: failed to create create HdfUsbDeviceInterfaceHost object", __func__);
79 return HDF_FAILURE;
80 }
81
82 hdfUsbDeviceInterfaceHost->ioService.Dispatch = UsbDeviceInterfaceDriverDispatch;
83 hdfUsbDeviceInterfaceHost->ioService.Open = nullptr;
84 hdfUsbDeviceInterfaceHost->ioService.Release = nullptr;
85
86 auto serviceImpl = OHOS::HDI::Usb::V2_0::IUsbDeviceInterface::Get(true);
87 if (serviceImpl == nullptr) {
88 HDF_LOGE("%{public}s: failed to get of implement service", __func__);
89 delete hdfUsbDeviceInterfaceHost;
90 hdfUsbDeviceInterfaceHost =nullptr;
91 return HDF_FAILURE;
92 }
93
94 hdfUsbDeviceInterfaceHost->stub = OHOS::HDI::ObjectCollector::GetInstance().GetOrNewObject(serviceImpl,
95 OHOS::HDI::Usb::V2_0::IUsbDeviceInterface::GetDescriptor());
96 if (hdfUsbDeviceInterfaceHost->stub == nullptr) {
97 HDF_LOGE("%{public}s: failed to get stub object", __func__);
98 delete hdfUsbDeviceInterfaceHost;
99 hdfUsbDeviceInterfaceHost = nullptr;
100 return HDF_FAILURE;
101 }
102
103 int32_t ret = UsbDeviceImpl::UsbdEventHandle();
104 if (ret != HDF_SUCCESS) {
105 HDF_LOGE("%{public}s: UsbdEventHandle failed", __func__);
106 hdfUsbDeviceInterfaceHost->stub = nullptr;
107 delete hdfUsbDeviceInterfaceHost;
108 hdfUsbDeviceInterfaceHost = nullptr;
109 return HDF_FAILURE;
110 }
111
112 deviceObject->service = &hdfUsbDeviceInterfaceHost->ioService;
113 return HDF_SUCCESS;
114 }
115
HdfUsbDeviceInterfaceDriverRelease(struct HdfDeviceObject * deviceObject)116 static void HdfUsbDeviceInterfaceDriverRelease(struct HdfDeviceObject *deviceObject)
117 {
118 HDF_LOGI("%{public}s: driver release start", __func__);
119 int32_t ret = UsbDeviceImpl::UsbdEventHandleRelease();
120 if (ret != HDF_SUCCESS) {
121 HDF_LOGW("%{public}s:UsbdEventHandleRelease ret=%{public}d", __func__, ret);
122 }
123 if (deviceObject == nullptr || deviceObject->service == nullptr) {
124 HDF_LOGE("HdfUsbInterfaceDriverRelease not initted");
125 return;
126 }
127
128 auto *hdfUsbDeviceInterfaceHost = CONTAINER_OF(deviceObject->service, struct HdfUsbDeviceInterfaceHost, ioService);
129 if (hdfUsbDeviceInterfaceHost == nullptr) {
130 HDF_LOGE("%{public}s:invalid param", __func__);
131 return;
132 }
133 delete hdfUsbDeviceInterfaceHost;
134 hdfUsbDeviceInterfaceHost = nullptr;
135 deviceObject->service = nullptr;
136 return;
137 }
138
139 static struct HdfDriverEntry g_usbdeviceinterfaceDriverEntry = {
140 .moduleVersion = 1,
141 .moduleName = "",
142 .Bind = HdfUsbDeviceInterfaceDriverBind,
143 .Init = HdfUsbDeviceInterfaceDriverInit,
144 .Release = HdfUsbDeviceInterfaceDriverRelease,
145 };
146
147 #ifdef __cplusplus
148 extern "C" {
149 #endif /* __cplusplus */
150 HDF_INIT(g_usbdeviceinterfaceDriverEntry);
151 #ifdef __cplusplus
152 }
153 #endif /* __cplusplus */
154