1 /*
2 * Copyright (c) 2023-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 "hid_ddk_service.h"
17 #include <hdf_base.h>
18 #include "emit_event_manager.h"
19 #include "hid_ddk_permission.h"
20 #include "input_uhdf_log.h"
21 #include <unistd.h>
22 #include <fcntl.h>
23 #include <iostream>
24 #include <sys/ioctl.h>
25 #include <linux/hiddev.h>
26 #include <linux/hidraw.h>
27 #include <poll.h>
28 #include <memory.h>
29 #include <securec.h>
30 #include "ddk_sysfs_dev_node.h"
31 #ifdef __LITEOS__
32 #include "hid_liteos_adapter.h"
33 #else
34 #include "hid_linux_adapter.h"
35 #endif
36
37 #define HDF_LOG_TAG hid_ddk_service
38
39 namespace OHOS {
40 namespace HDI {
41 namespace Input {
42 namespace Ddk {
43 namespace V1_1 {
44 const uint8_t THIRTY_TWO_BIT = 32;
45 const uint32_t MAX_REPORT_BUFFER_SIZE = 16 * 1024 - 1;
46
GetBusNum(uint64_t devHandle)47 inline uint32_t GetBusNum(uint64_t devHandle)
48 {
49 return static_cast<uint32_t>(devHandle >> THIRTY_TWO_BIT);
50 }
51
GetDevNum(uint64_t devHandle)52 inline uint32_t GetDevNum(uint64_t devHandle)
53 {
54 return static_cast<uint32_t>(devHandle & 0xFFFFFFFF);
55 }
56
57 static const std::string PERMISSION_NAME = "ohos.permission.ACCESS_DDK_HID";
58
HidDdkImplGetInstance(void)59 extern "C" IHidDdk *HidDdkImplGetInstance(void)
60 {
61 std::shared_ptr<HidOsAdapter> osAdapter;
62 #ifdef __LITEOS__
63 osAdapter = std::make_shared<LiteosHidOsAdapter>();
64 #else
65 osAdapter = std::make_shared<LinuxHidOsAdapter>();
66 #endif
67 return new (std::nothrow) HidDdkService(osAdapter);
68 }
69
CreateDevice(const Hid_Device & hidDevice,const Hid_EventProperties & hidEventProperties,uint32_t & deviceId)70 int32_t HidDdkService::CreateDevice(const Hid_Device &hidDevice,
71 const Hid_EventProperties &hidEventProperties, uint32_t &deviceId)
72 {
73 HDF_LOGI("%{public}s create device enter", __func__);
74 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
75 HDF_LOGE("%{public}s: no permission", __func__);
76 return HDF_ERR_NOPERM;
77 }
78
79 int32_t ret = OHOS::ExternalDeviceManager::EmitEventManager::GetInstance()
80 .CreateDevice(hidDevice, hidEventProperties);
81 if (ret < 0) {
82 HDF_LOGE("%{public}s create device faild, ret=%{public}d", __func__, ret);
83 return ret;
84 }
85
86 deviceId = static_cast<uint32_t>(ret);
87 return Hid_DdkErrCode::HID_DDK_SUCCESS;
88 }
89
EmitEvent(uint32_t deviceId,const std::vector<Hid_EmitItem> & items)90 int32_t HidDdkService::EmitEvent(uint32_t deviceId, const std::vector<Hid_EmitItem> &items)
91 {
92 HDF_LOGI("%{public}s emit event enter, the id of device = %{public}d", __func__, deviceId);
93 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
94 HDF_LOGE("%{public}s: no permission", __func__);
95 return HDF_ERR_NOPERM;
96 }
97
98 return OHOS::ExternalDeviceManager::EmitEventManager::GetInstance().EmitEvent(deviceId, items);
99 }
100
DestroyDevice(uint32_t deviceId)101 int32_t HidDdkService::DestroyDevice(uint32_t deviceId)
102 {
103 HDF_LOGI("%{public}s destroy device enter, the id of device = %{public}d", __func__, deviceId);
104 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
105 HDF_LOGE("%{public}s: no permission", __func__);
106 return HDF_ERR_NOPERM;
107 }
108
109 return OHOS::ExternalDeviceManager::EmitEventManager::GetInstance().DestroyDevice(deviceId);
110 }
111
Init()112 int32_t HidDdkService::Init()
113 {
114 HDF_LOGD("%{public}s init enter", __func__);
115 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
116 HDF_LOGE("%{public}s: no permission", __func__);
117 return HID_DDK_NO_PERM;
118 }
119
120 return HID_DDK_SUCCESS;
121 }
122
Release()123 int32_t HidDdkService::Release()
124 {
125 HDF_LOGD("%{public}s release enter", __func__);
126 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
127 HDF_LOGE("%{public}s: no permission", __func__);
128 return HID_DDK_NO_PERM;
129 }
130
131 return HID_DDK_SUCCESS;
132 }
133
Open(uint64_t deviceId,uint8_t interfaceIndex,HidDeviceHandle & dev)134 int32_t HidDdkService::Open(uint64_t deviceId, uint8_t interfaceIndex, HidDeviceHandle& dev)
135 {
136 HDF_LOGD("%{public}s open enter", __func__);
137 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
138 HDF_LOGE("%{public}s: no permission", __func__);
139 return HID_DDK_NO_PERM;
140 }
141
142 uint32_t busNum = GetBusNum(deviceId);
143 uint32_t devNum = GetDevNum(deviceId);
144 SysfsDevNode devNode(busNum, devNum, interfaceIndex, "hidraw");
145 std::string path;
146 int32_t ret = devNode.FindPath(path);
147 if (ret != HID_DDK_SUCCESS) {
148 HDF_LOGE("%{public}s device not found, path=%{public}s", __func__, path.c_str());
149 return HID_DDK_DEVICE_NOT_FOUND;
150 }
151
152 int32_t fd = open(path.c_str(), O_RDWR);
153 if (fd < 0) {
154 HDF_LOGE("%{public}s open failed, path=%{public}s, errno=%{public}d", __func__, path.c_str(), errno);
155 return HID_DDK_IO_ERROR;
156 }
157
158 dev.fd = fd;
159
160 return HID_DDK_SUCCESS;
161 }
162
Close(const HidDeviceHandle & dev)163 int32_t HidDdkService::Close(const HidDeviceHandle& dev)
164 {
165 HDF_LOGD("%{public}s close enter", __func__);
166 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
167 HDF_LOGE("%{public}s: no permission", __func__);
168 return HID_DDK_NO_PERM;
169 }
170
171 int32_t ret = close(dev.fd);
172 if (ret == -1) {
173 HDF_LOGE("%{public}s close failed, errno=%{public}d", __func__, errno);
174 return HID_DDK_IO_ERROR;
175 }
176
177 return HID_DDK_SUCCESS;
178 }
179
Write(const HidDeviceHandle & dev,const std::vector<uint8_t> & data,uint32_t & bytesWritten)180 int32_t HidDdkService::Write(const HidDeviceHandle& dev, const std::vector<uint8_t>& data, uint32_t& bytesWritten)
181 {
182 HDF_LOGD("%{public}s write enter", __func__);
183 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
184 HDF_LOGE("%{public}s: no permission", __func__);
185 return HID_DDK_NO_PERM;
186 }
187
188 int32_t ret = write(dev.fd, data.data(), data.size());
189 if (ret < 0) {
190 HDF_LOGE("%{public}s write failed, errno=%{public}d", __func__, errno);
191 bytesWritten = 0;
192 return HID_DDK_IO_ERROR;
193 }
194
195 bytesWritten = ret;
196 return HID_DDK_SUCCESS;
197 }
198
ReadTimeout(const HidDeviceHandle & dev,std::vector<uint8_t> & data,uint32_t buffSize,int32_t timeout,uint32_t & bytesRead)199 int32_t HidDdkService::ReadTimeout(const HidDeviceHandle& dev, std::vector<uint8_t>& data, uint32_t buffSize,
200 int32_t timeout, uint32_t& bytesRead)
201 {
202 HDF_LOGD("%{public}s read timeout enter", __func__);
203 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
204 HDF_LOGE("%{public}s: no permission", __func__);
205 return HID_DDK_NO_PERM;
206 }
207
208 if (buffSize > MAX_REPORT_BUFFER_SIZE) {
209 HDF_LOGE("%{public}s: invalid parameter", __func__);
210 return HID_DDK_INVALID_PARAMETER;
211 }
212
213 if (timeout >= 0) {
214 int32_t ret;
215 struct pollfd fds;
216
217 fds.fd = dev.fd;
218 fds.events = POLLIN;
219 fds.revents = 0;
220 ret = poll(&fds, 1, timeout);
221 if (ret == 0) {
222 return HID_DDK_TIMEOUT;
223 } else if (ret == -1) {
224 HDF_LOGE("%{public}s poll failed, errno=%{public}d", __func__, errno);
225 return HID_DDK_IO_ERROR;
226 }
227 if (fds.revents & (POLLERR | POLLHUP | POLLNVAL)) {
228 HDF_LOGE("%{public}s poll failed, revents=%{public}d", __func__, fds.revents);
229 return HID_DDK_IO_ERROR;
230 }
231 }
232
233 data.resize(buffSize);
234 int32_t readRet = read(dev.fd, data.data(), data.size());
235 if (readRet < 0) {
236 HDF_LOGE("%{public}s read failed, errno=%{public}d", __func__, errno);
237 bytesRead = 0;
238 return HID_DDK_IO_ERROR;
239 }
240
241 bytesRead = readRet;
242 return HID_DDK_SUCCESS;
243 }
244
SetNonBlocking(const HidDeviceHandle & dev,int32_t nonBlock)245 int32_t HidDdkService::SetNonBlocking(const HidDeviceHandle& dev, int32_t nonBlock)
246 {
247 HDF_LOGD("%{public}s enter", __func__);
248 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
249 HDF_LOGE("%{public}s: no permission", __func__);
250 return HID_DDK_NO_PERM;
251 }
252
253 return HID_DDK_SUCCESS;
254 }
255
GetRawInfo(const HidDeviceHandle & dev,HidRawDevInfo & rawDevInfo)256 int32_t HidDdkService::GetRawInfo(const HidDeviceHandle& dev, HidRawDevInfo& rawDevInfo)
257 {
258 HDF_LOGD("%{public}s enter", __func__);
259 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
260 HDF_LOGE("%{public}s: no permission", __func__);
261 return HID_DDK_NO_PERM;
262 }
263
264 return osAdapter_->GetRawInfo(dev.fd, rawDevInfo);
265 }
266
GetRawName(const HidDeviceHandle & dev,std::vector<uint8_t> & data,uint32_t buffSize)267 int32_t HidDdkService::GetRawName(const HidDeviceHandle& dev, std::vector<uint8_t>& data, uint32_t buffSize)
268 {
269 HDF_LOGD("%{public}s enter", __func__);
270 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
271 HDF_LOGE("%{public}s: no permission", __func__);
272 return HID_DDK_NO_PERM;
273 }
274
275 if (buffSize > MAX_REPORT_BUFFER_SIZE) {
276 HDF_LOGE("%{public}s: invalid parameter", __func__);
277 return HID_DDK_INVALID_PARAMETER;
278 }
279
280 data.resize(buffSize);
281
282 return osAdapter_->GetRawName(dev.fd, data);
283 }
284
GetPhysicalAddress(const HidDeviceHandle & dev,std::vector<uint8_t> & data,uint32_t buffSize)285 int32_t HidDdkService::GetPhysicalAddress(const HidDeviceHandle& dev, std::vector<uint8_t>& data, uint32_t buffSize)
286 {
287 HDF_LOGD("%{public}s enter", __func__);
288 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
289 HDF_LOGE("%{public}s: no permission", __func__);
290 return HID_DDK_NO_PERM;
291 }
292
293 if (buffSize > MAX_REPORT_BUFFER_SIZE) {
294 HDF_LOGE("%{public}s: invalid parameter", __func__);
295 return HID_DDK_INVALID_PARAMETER;
296 }
297
298 data.resize(buffSize);
299
300 return osAdapter_->GetPhysicalAddress(dev.fd, data);
301 }
302
GetRawUniqueId(const HidDeviceHandle & dev,std::vector<uint8_t> & data,uint32_t buffSize)303 int32_t HidDdkService::GetRawUniqueId(const HidDeviceHandle& dev, std::vector<uint8_t>& data, uint32_t buffSize)
304 {
305 HDF_LOGD("%{public}s enter", __func__);
306 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
307 HDF_LOGE("%{public}s: no permission", __func__);
308 return HID_DDK_NO_PERM;
309 }
310
311 if (buffSize > MAX_REPORT_BUFFER_SIZE) {
312 HDF_LOGE("%{public}s: invalid parameter", __func__);
313 return HID_DDK_INVALID_PARAMETER;
314 }
315
316 data.resize(buffSize);
317
318 return osAdapter_->GetRawUniqueId(dev.fd, data);
319 }
320
SendReport(const HidDeviceHandle & dev,HidReportType reportType,const std::vector<uint8_t> & data)321 int32_t HidDdkService::SendReport(const HidDeviceHandle& dev, HidReportType reportType,
322 const std::vector<uint8_t>& data)
323 {
324 HDF_LOGD("%{public}s enter", __func__);
325 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
326 HDF_LOGE("%{public}s: no permission", __func__);
327 return HID_DDK_NO_PERM;
328 }
329
330 return osAdapter_->SendReport(dev.fd, reportType, data);
331 }
332
GetReport(const HidDeviceHandle & dev,HidReportType reportType,uint8_t reportNumber,std::vector<uint8_t> & data,uint32_t buffSize)333 int32_t HidDdkService::GetReport(const HidDeviceHandle& dev, HidReportType reportType, uint8_t reportNumber,
334 std::vector<uint8_t>& data, uint32_t buffSize)
335 {
336 HDF_LOGD("%{public}s enter", __func__);
337 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
338 HDF_LOGE("%{public}s: no permission", __func__);
339 return HID_DDK_NO_PERM;
340 }
341
342 if (buffSize > MAX_REPORT_BUFFER_SIZE) {
343 HDF_LOGE("%{public}s: invalid parameter", __func__);
344 return HID_DDK_INVALID_PARAMETER;
345 }
346
347 data.resize(buffSize);
348 data[0] = reportNumber;
349
350 return osAdapter_->GetReport(dev.fd, reportType, data);
351 }
352
GetReportDescriptor(const HidDeviceHandle & dev,std::vector<uint8_t> & buf,uint32_t buffSize,uint32_t & bytesRead)353 int32_t HidDdkService::GetReportDescriptor(const HidDeviceHandle& dev, std::vector<uint8_t>& buf, uint32_t buffSize,
354 uint32_t& bytesRead)
355 {
356 HDF_LOGD("%{public}s enter", __func__);
357 if (!DdkPermissionManager::VerifyPermission(PERMISSION_NAME)) {
358 HDF_LOGE("%{public}s: no permission", __func__);
359 return HID_DDK_NO_PERM;
360 }
361
362 if (buffSize > MAX_REPORT_BUFFER_SIZE) {
363 HDF_LOGE("%{public}s: invalid parameter", __func__);
364 return HID_DDK_INVALID_PARAMETER;
365 }
366
367 buf.resize(buffSize);
368
369 return osAdapter_->GetReportDescriptor(dev.fd, buf, bytesRead);
370 }
371
372 } // V1_1
373 } // Ddk
374 } // Input
375 } // HDI
376 } // OHOS
377