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