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 "usb_device_impl.h"
17
18 #include <cerrno>
19 #include <climits>
20 #include <hdf_base.h>
21 #include <hdf_log.h>
22 #include <sys/mman.h>
23 #include <sys/types.h>
24 #include <unistd.h>
25
26 #include "ddk_device_manager.h"
27 #include "ddk_pnp_listener_mgr.h"
28 #include "hitrace_meter.h"
29 #include "ipc_skeleton.h"
30 #include "libusb_adapter.h"
31 #include "parameter.h"
32 #include "parameters.h"
33 #include "usb_sa_subscriber.h"
34 #include "usbd_accessory.h"
35 #include "usbd_function.h"
36 #include "usbd_wrapper.h"
37
38 #define HDF_LOG_TAG UsbDeviceImpl
39 using namespace OHOS::HiviewDFX;
40 namespace OHOS {
41 namespace HDI {
42 namespace Usb {
43 namespace V2_0 {
44 HdfDevEventlistener UsbDeviceImpl::listenerForLoadService_ = {nullptr};
45 V1_2::UsbdLoadService UsbDeviceImpl::loadUsbService_ = {USB_SYSTEM_ABILITY_ID};
46 V1_2::UsbdLoadService UsbDeviceImpl::loadHdfEdm_ = {HDF_EXTERNAL_DEVICE_MANAGER_SA_ID};
47 UsbdSubscriber UsbDeviceImpl::subscribers_[MAX_SUBSCRIBER] = {{0}};
48 bool UsbDeviceImpl::isGadgetConnected_ = false;
UsbDeviceInterfaceImplGetInstance(void)49 extern "C" IUsbDeviceInterface *UsbDeviceInterfaceImplGetInstance(void)
50 {
51 using OHOS::HDI::Usb::V2_0::UsbDeviceImpl;
52 UsbDeviceImpl *service = new (std::nothrow) UsbDeviceImpl();
53 if (service == nullptr) {
54 return nullptr;
55 }
56 return service;
57 }
58
UsbDeviceImpl()59 UsbDeviceImpl::UsbDeviceImpl()
60 {
61 OsalMutexInit(&lockSetFunc_);
62 if (OHOS::system::GetBoolParameter("const.security.developermode.state", true)) {
63 loadUsbService_.LoadService();
64 }
65 }
66
~UsbDeviceImpl()67 UsbDeviceImpl::~UsbDeviceImpl()
68 {
69 OsalMutexDestroy(&lockSetFunc_);
70 }
71
GetCurrentFunctions(int32_t & funcs)72 int32_t UsbDeviceImpl::GetCurrentFunctions(int32_t &funcs)
73 {
74 HDF_LOGI("%{public}s: enter", __func__);
75 funcs = V1_2::UsbdFunction::UsbdGetFunction();
76 return HDF_SUCCESS;
77 }
78
SetCurrentFunctions(int32_t funcs)79 int32_t UsbDeviceImpl::SetCurrentFunctions(int32_t funcs)
80 {
81 HDF_LOGI("%{public}s: enter", __func__);
82 OsalMutexLock(&lockSetFunc_);
83 int32_t ret = V1_2::UsbdFunction::UsbdSetFunction(funcs);
84 if (ret != HDF_SUCCESS) {
85 HDF_LOGE("%{public}s:UsbdSetFunction failed, ret:%{public}d", __func__, ret);
86 OsalMutexUnlock(&lockSetFunc_);
87 return ret;
88 }
89 OsalMutexUnlock(&lockSetFunc_);
90 return HDF_SUCCESS;
91 }
92
GetAccessoryInfo(std::vector<std::string> & accessoryInfo)93 int32_t UsbDeviceImpl::GetAccessoryInfo(std::vector<std::string> &accessoryInfo)
94 {
95 HDF_LOGI("%{public}s: enter", __func__);
96 return V1_2::UsbdAccessory::GetInstance().GetAccessoryInfo(accessoryInfo);
97 }
98
OpenAccessory(int32_t & fd)99 int32_t UsbDeviceImpl::OpenAccessory(int32_t &fd)
100 {
101 HDF_LOGI("%{public}s: enter", __func__);
102 return V1_2::UsbdAccessory::GetInstance().OpenAccessory(fd);
103 }
104
CloseAccessory(int32_t fd)105 int32_t UsbDeviceImpl::CloseAccessory(int32_t fd)
106 {
107 HDF_LOGI("%{public}s: enter", __func__);
108 return V1_2::UsbdAccessory::GetInstance().CloseAccessory(fd);
109 }
110
UsbdPnpLoaderEventReceived(void * priv,uint32_t id,HdfSBuf * data)111 int32_t UsbDeviceImpl::UsbdPnpLoaderEventReceived(void *priv, uint32_t id, HdfSBuf *data)
112 {
113 HDF_LOGI("%{public}s: enter %{public}u", __func__, id);
114 UsbdSubscriber *usbdSubscriber = static_cast<UsbdSubscriber *>(priv);
115 const sptr<IUsbdSubscriber> subscriber = usbdSubscriber->subscriber;
116
117 int32_t ret = HDF_SUCCESS;
118 if (id == USB_PNP_DRIVER_GADGET_ADD) {
119 HITRACE_METER_NAME(HITRACE_TAG_HDF, "USB_PNP_DRIVER_GADGET_ADD");
120 isGadgetConnected_ = true;
121 USBDeviceInfo info = {ACT_UPDEVICE, 0, 0};
122 if (subscriber == nullptr) {
123 HDF_LOGE("%{public}s: subscriber is nullptr, %{public}d", __func__, __LINE__);
124 return HDF_FAILURE;
125 }
126 ret = subscriber->DeviceEvent(info);
127 } else if (id == USB_PNP_DRIVER_GADGET_REMOVE) {
128 HITRACE_METER_NAME(HITRACE_TAG_HDF, "USB_PNP_DRIVER_GADGET_REMOVE");
129 isGadgetConnected_ = false;
130 USBDeviceInfo info = {ACT_DOWNDEVICE, 0, 0};
131 if (subscriber == nullptr) {
132 HDF_LOGE("%{public}s: subscriber is nullptr, %{public}d", __func__, __LINE__);
133 return HDF_FAILURE;
134 }
135 V1_2::UsbdAccessory::GetInstance().HandleEvent(ACT_DOWNDEVICE);
136 ret = subscriber->DeviceEvent(info);
137 } else if (id == USB_ACCESSORY_START) {
138 if (subscriber == nullptr) {
139 HDF_LOGE("%{public}s: subscriber is nullptr, %{public}d", __func__, __LINE__);
140 return HDF_FAILURE;
141 }
142 HITRACE_METER_NAME(HITRACE_TAG_HDF, "USB_ACCESSORY_START");
143 USBDeviceInfo info = {ACT_ACCESSORYUP, 0, 0};
144 ret = subscriber->DeviceEvent(info);
145 } else if (id == USB_ACCESSORY_SEND) {
146 if (subscriber == nullptr) {
147 HDF_LOGE("%{public}s: subsciber is nullptr, %{public}d", __func__, __LINE__);
148 return HDF_FAILURE;
149 }
150 HITRACE_METER_NAME(HITRACE_TAG_HDF, "USB_ACCESSORY_SEND");
151 USBDeviceInfo info = {ACT_ACCESSORYSEND, 0, 0};
152 ret = subscriber->DeviceEvent(info);
153 } else {
154 HDF_LOGW("%{public}s: device not support this id:%{public}u , %{public}d", __func__, id, __LINE__);
155 return HDF_ERR_NOT_SUPPORT;
156 }
157 HDF_LOGI("%{public}s: out", __func__);
158 return ret;
159 }
160
OnRemoteDied(const wptr<IRemoteObject> & object)161 void UsbDeviceImpl::UsbDeathRecipient::OnRemoteDied(const wptr<IRemoteObject> &object)
162 {
163 int32_t i;
164 for (i = 0; i < MAX_SUBSCRIBER; i++) {
165 if (UsbDeviceImpl::subscribers_[i].subscriber == deathSubscriber_) {
166 break;
167 }
168 }
169 if (i == MAX_SUBSCRIBER) {
170 HDF_LOGE("%{public}s: current subscriber not bind", __func__);
171 return;
172 }
173 UsbDeviceImpl::subscribers_[i].subscriber = nullptr;
174 subscribers_[i].remote = nullptr;
175 subscribers_[i].deathRecipient = nullptr;
176 if (DdkListenerMgrRemove(&UsbDeviceImpl::subscribers_[i].usbPnpListener) != HDF_SUCCESS) {
177 HDF_LOGE("%{public}s: remove listerer failed", __func__);
178 }
179 }
180
BindUsbdDeviceSubscriber(const sptr<IUsbdSubscriber> & subscriber)181 int32_t UsbDeviceImpl::BindUsbdDeviceSubscriber(const sptr<IUsbdSubscriber> &subscriber)
182 {
183 int32_t i;
184 if (subscriber == nullptr) {
185 HDF_LOGE("%{public}s:subscriber is null", __func__);
186 return HDF_ERR_INVALID_PARAM;
187 }
188 const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<IUsbdSubscriber>(subscriber);
189 for (i = 0; i < MAX_SUBSCRIBER; i++) {
190 if (subscribers_[i].remote == remote) {
191 break;
192 }
193 }
194 if (i < MAX_SUBSCRIBER) {
195 HDF_LOGI("%{public}s: current subscriber was bind", __func__);
196 return HDF_SUCCESS;
197 }
198 for (i = 0; i < MAX_SUBSCRIBER; i++) {
199 if (subscribers_[i].subscriber == nullptr) {
200 subscribers_[i].subscriber = subscriber;
201 subscribers_[i].impl = this;
202 subscribers_[i].usbPnpListener.callBack = UsbdPnpLoaderEventReceived;
203 subscribers_[i].usbPnpListener.priv = &subscribers_[i];
204 subscribers_[i].remote = remote;
205 subscribers_[i].deathRecipient = new UsbDeviceImpl::UsbDeathRecipient(subscriber);
206 if (subscribers_[i].deathRecipient == nullptr) {
207 HDF_LOGE("%{public}s: new deathRecipient failed", __func__);
208 return HDF_FAILURE;
209 }
210 bool result = subscribers_[i].remote->AddDeathRecipient(
211 static_cast<UsbDeathRecipient *>(subscribers_[i].deathRecipient));
212 if (!result) {
213 HDF_LOGE("%{public}s:AddUsbDeathRecipient failed", __func__);
214 return HDF_FAILURE;
215 }
216
217 HDF_LOGI("%{public}s: index = %{public}d", __func__, i);
218 break;
219 }
220 }
221 if (i == MAX_SUBSCRIBER) {
222 HDF_LOGE("%{public}s: too many listeners", __func__);
223 return HDF_ERR_OUT_OF_RANGE;
224 }
225
226 if (DdkListenerMgrAdd(&subscribers_[i].usbPnpListener) != HDF_SUCCESS) {
227 HDF_LOGE("%{public}s: register listerer failed", __func__);
228 return HDF_FAILURE;
229 }
230 return HDF_SUCCESS;
231 }
232
UnbindUsbdDeviceSubscriber(const sptr<IUsbdSubscriber> & subscriber)233 int32_t UsbDeviceImpl::UnbindUsbdDeviceSubscriber(const sptr<IUsbdSubscriber> &subscriber)
234 {
235 if (subscriber == nullptr) {
236 HDF_LOGE("%{public}s:subscriber is null", __func__);
237 return HDF_ERR_INVALID_PARAM;
238 }
239 int32_t i;
240 const sptr<IRemoteObject> &remote = OHOS::HDI::hdi_objcast<IUsbdSubscriber>(subscriber);
241 for (i = 0; i < MAX_SUBSCRIBER; i++) {
242 if (subscribers_[i].remote == remote) {
243 break;
244 }
245 }
246 if (i == MAX_SUBSCRIBER) {
247 HDF_LOGE("%{public}s: current subscriber not bind", __func__);
248 return HDF_DEV_ERR_NO_DEVICE;
249 }
250 bool result = remote->RemoveDeathRecipient(static_cast<UsbDeathRecipient *>(subscribers_[i].deathRecipient));
251 if (!result) {
252 HDF_LOGE("%{public}s:RemoveUsbDeathRecipient failed", __func__);
253 return HDF_FAILURE;
254 }
255
256 subscribers_[i].subscriber = nullptr;
257 subscribers_[i].remote = nullptr;
258 subscribers_[i].deathRecipient = nullptr;
259 if (DdkListenerMgrRemove(&subscribers_[i].usbPnpListener) != HDF_SUCCESS) {
260 HDF_LOGE("%{public}s: remove listerer failed", __func__);
261 return HDF_FAILURE;
262 }
263 return HDF_SUCCESS;
264 }
265
UsbdLoadServiceCallback(void * priv,uint32_t id,HdfSBuf * data)266 int32_t UsbDeviceImpl::UsbdLoadServiceCallback(void *priv, uint32_t id, HdfSBuf *data)
267 {
268 HDF_LOGI("%{public}s: enter", __func__);
269 (void)priv;
270 (void)data;
271 if (id == USB_PNP_DRIVER_GADGET_ADD) {
272 if (loadUsbService_.LoadService() != 0) {
273 HDF_LOGE("loadUsbService_ LoadService error");
274 return HDF_FAILURE;
275 }
276 }
277 return HDF_SUCCESS;
278 }
279
UsbdEventHandle(void)280 int32_t UsbDeviceImpl::UsbdEventHandle(void)
281 {
282 HDF_LOGI("%{public}s: enter", __func__);
283 listenerForLoadService_.callBack = UsbdLoadServiceCallback;
284 int32_t ret = DdkListenerMgrAdd(&listenerForLoadService_);
285 if (ret != HDF_SUCCESS) {
286 HDF_LOGE("%{public}s: register listerer failed", __func__);
287 return HDF_FAILURE;
288 }
289 sptr<V1_2::LibUsbSaSubscriber> libUsbSaSubscriber = new (std::nothrow) V1_2::UsbSaSubscriber();
290 if (libUsbSaSubscriber == nullptr) {
291 HDF_LOGE("%{public}s: register listerer failed", __func__);
292 return HDF_FAILURE;
293 }
294 ret = V1_2::LibusbAdapter::GetInstance()->SetLoadUsbSaSubscriber(libUsbSaSubscriber);
295 return ret;
296 }
297
UsbdEventHandleRelease(void)298 int32_t UsbDeviceImpl::UsbdEventHandleRelease(void)
299 {
300 HDF_LOGI("%{public}s: enter", __func__);
301 int32_t ret = DdkListenerMgrRemove(&listenerForLoadService_);
302 if (ret != HDF_SUCCESS) {
303 HDF_LOGE("%{public}s: DdkListenerMgrRemove failed", __func__);
304 }
305 listenerForLoadService_.callBack = nullptr;
306 listenerForLoadService_.priv = nullptr;
307 return ret;
308 }
309 } // namespace v2_0
310 } // namespace Usb
311 } // namespace HDI
312 } // namespace OHOS