1 /*
2 * Copyright (c) 2024 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 "napi/native_api.h"
17 #include "native_common.h"
18 #include "usb/usb_ddk_api.h"
19 #include "usb/usb_ddk_types.h"
20 #include "scsi_peripheral/scsi_peripheral_api.h"
21 #include "scsi_peripheral/scsi_peripheral_types.h"
22 #include "ddk/ddk_api.h"
23 #include <cstdlib>
24 #include <js_native_api_types.h>
25 #include <tuple>
26 #include <unistd.h>
27 #include "hid/hid_ddk_api.h"
28 #include "hid/hid_ddk_types.h"
29 #include <vector>
30 #include "usb_serial/usb_serial_api.h"
31
32 using namespace std;
33 #define ENDPOINT 0
34 #define SLEEP 2
35 #define PARAM_8 8
36 #define USB_DDK_TEST_BUF_SIZE 100
37 #define USB_DDK_ENDPOINT_DIR_MASK 0x80
38 #define USB_DDK_DIR_IN 0x80
39 #define USB_DDK_ENDPOINT_XFERTYPE_MASK 0x03
40 #define USB_DDK_ENDPOINT_XFER_INT 0x03
41 #define USB_DDK_ERR_NOPERM 201
42 #define PARAM_0 0
43 #define PARAM_1 1
44 #define PARAM_10 10
45 #define PARAM_32 32
46 #define PARAM_48 48
47 static uint8_t configIndex = 0;
48 static uint8_t interfaceIndex = 0;
49 static uint64_t interfaceHandle = 0;
50 static uint8_t settingIndex = 0;
51 static uint32_t timeout = 1000;
52 static uint32_t g_timeout = 100;
53 constexpr size_t MAX_USB_DEVICE_NUM = 128;
54 const uint32_t CDB_LENGTH = 1;
55
56 const uint32_t DATA_BUFF_SIZE = 1024;
57 const uint32_t READ_TIME_OUT = 10000;
58 const uint32_t SIXTEEN_BIT = 16;
59 const uint32_t THIRTYTWO_BIT = 32;
60 const uint32_t BUS_NUM_MASK = 0xFFFF0000;
61 const uint32_t DEVICE_NUM_MASK = 0x0000FFFF;
62
63 constexpr uint32_t USB_SERIAL_TEST_BAUDRATE = 9600;
64 constexpr uint8_t USB_SERIAL_TEST_DATA_BITS = 8;
65
66 struct Hid_DeviceHandle {
67 int32_t fd = -1;
68 int32_t nonBlock = 0;
69 };
70
NewHidDeviceHandle()71 Hid_DeviceHandle *NewHidDeviceHandle()
72 {
73 return new Hid_DeviceHandle;
74 }
75
DeleteHidDeviceHandle(Hid_DeviceHandle ** dev)76 void DeleteHidDeviceHandle(Hid_DeviceHandle **dev)
77 {
78 if (*dev != nullptr) {
79 delete *dev;
80 *dev = nullptr;
81 }
82 }
83
84 struct ScsiPeripheral_Device {
85 int32_t devFd = -1;
86 int32_t memMapFd = -1;
87 int32_t lbLength = 0;
88 };
89
NewScsiPeripheralDevice()90 static ScsiPeripheral_Device *NewScsiPeripheralDevice()
91 {
92 return new ScsiPeripheral_Device;
93 }
94
DeleteScsiPeripheralDevice(ScsiPeripheral_Device ** dev)95 static void DeleteScsiPeripheralDevice(ScsiPeripheral_Device **dev)
96 {
97 if (*dev != nullptr) {
98 delete *dev;
99 *dev = nullptr;
100 }
101 }
102
103 struct UsbSerial_Device {
104 int32_t fd = -1;
105 };
106
NewSerialDeviceHandle()107 static UsbSerial_Device *NewSerialDeviceHandle()
108 {
109 return new UsbSerial_Device;
110 }
111
DeleteUsbSerialDeviceHandle(UsbSerial_Device ** dev)112 static void DeleteUsbSerialDeviceHandle(UsbSerial_Device **dev)
113 {
114 if (*dev != nullptr) {
115 delete *dev;
116 *dev = nullptr;
117 }
118 }
119
IsInterruptInEndpoint(const UsbEndpointDescriptor & epDesc)120 static bool IsInterruptInEndpoint(const UsbEndpointDescriptor &epDesc)
121 {
122 return (((epDesc.bEndpointAddress & USB_DDK_ENDPOINT_DIR_MASK) == USB_DDK_DIR_IN) &&
123 ((epDesc.bmAttributes & USB_DDK_ENDPOINT_XFERTYPE_MASK) == USB_DDK_ENDPOINT_XFER_INT));
124 }
125
FindForEachInterface(const UsbDdkInterface & interface)126 static std::tuple<bool, uint8_t, uint8_t, uint16_t> FindForEachInterface(const UsbDdkInterface &interface)
127 {
128 struct UsbDdkInterfaceDescriptor *intDesc = interface.altsetting;
129 uint32_t numSetting = interface.numAltsetting;
130 for (uint32_t setIdx = PARAM_0; setIdx < numSetting; ++setIdx) {
131 uint32_t numEp = intDesc[setIdx].interfaceDescriptor.bNumEndpoints;
132 struct UsbDdkEndpointDescriptor *epDesc = intDesc[setIdx].endPoint;
133 for (uint32_t epIdx = PARAM_0; epIdx < numEp; ++epIdx) {
134 if (IsInterruptInEndpoint(epDesc[epIdx].endpointDescriptor)) {
135 return {true, intDesc[setIdx].interfaceDescriptor.bInterfaceNumber,
136 epDesc[epIdx].endpointDescriptor.bEndpointAddress,
137 epDesc[epIdx].endpointDescriptor.wMaxPacketSize};
138 }
139 }
140 }
141
142 return {false, {}, {}, {}};
143 }
144
GetEndpointInfo(const struct UsbDdkConfigDescriptor * config)145 static std::tuple<bool, uint8_t, uint8_t, uint16_t> GetEndpointInfo(const struct UsbDdkConfigDescriptor *config)
146 {
147 for (uint32_t intIdx = PARAM_0; intIdx < config->configDescriptor.bNumInterfaces; ++intIdx) {
148 auto result = FindForEachInterface(config->interface[intIdx]);
149 if (std::get<0>(result)) {
150 return result;
151 }
152 }
153 return {false, {}, {}, {}};
154 }
155
UsbInit(napi_env env,napi_callback_info info)156 static napi_value UsbInit(napi_env env, napi_callback_info info)
157 {
158 int32_t returnValue = OH_Usb_Init();
159 OH_Usb_Release();
160 napi_value result = nullptr;
161 napi_create_int32(env, returnValue, &result);
162 return result;
163 }
164
UsbRelease(napi_env env,napi_callback_info info)165 static napi_value UsbRelease(napi_env env, napi_callback_info info)
166 {
167 int32_t usbInitReturnValue = OH_Usb_Init();
168 NAPI_ASSERT(env, usbInitReturnValue == USB_DDK_ERR_NOPERM, "OH_Usb_Init failed, no permission");
169 OH_Usb_Release();
170 napi_value result = nullptr;
171 napi_create_int32(env, USB_DDK_ERR_NOPERM, &result);
172 return result;
173 }
174
UsbReleaseResource(napi_env env,napi_callback_info info)175 static napi_value UsbReleaseResource(napi_env env, napi_callback_info info)
176 {
177 int32_t usbInitReturnValue = OH_Usb_Init();
178 NAPI_ASSERT(env, usbInitReturnValue == USB_DDK_ERR_NOPERM, "OH_Usb_Init failed, no permission");
179 int32_t returnValue = OH_Usb_ReleaseResource();
180 napi_value result = nullptr;
181 napi_create_int32(env, returnValue, &result);
182 return result;
183 }
184
UsbGetDeviceDescriptor(napi_env env,napi_callback_info info)185 static napi_value UsbGetDeviceDescriptor(napi_env env, napi_callback_info info)
186 {
187 size_t argc = PARAM_1;
188 napi_value args[PARAM_1] = {nullptr};
189 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
190 int64_t deviceId64;
191 napi_get_value_int64(env, args[PARAM_0], &deviceId64);
192 uint64_t deviceId = static_cast<uint64_t>(deviceId64);
193
194 int32_t usbInitReturnValue = OH_Usb_Init();
195 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
196 struct UsbDeviceDescriptor devDesc;
197 int32_t returnValue = OH_Usb_GetDeviceDescriptor(deviceId, &devDesc);
198 napi_value result = nullptr;
199 napi_create_int32(env, returnValue, &result);
200 return result;
201 }
202
UsbGetConfigDescriptor(napi_env env,napi_callback_info info)203 static napi_value UsbGetConfigDescriptor(napi_env env, napi_callback_info info)
204 {
205 size_t argc = PARAM_1;
206 napi_value args[PARAM_1] = {nullptr};
207 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
208 int64_t deviceId64;
209 napi_get_value_int64(env, args[PARAM_0], &deviceId64);
210 uint64_t deviceId = static_cast<uint64_t>(deviceId64);
211 int32_t usbInitReturnValue = OH_Usb_Init();
212 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
213 struct UsbDdkConfigDescriptor *config = nullptr;
214 int32_t returnValue = OH_Usb_GetConfigDescriptor(deviceId, configIndex, &config);
215 OH_Usb_FreeConfigDescriptor(config);
216 napi_value result = nullptr;
217 napi_create_int32(env, returnValue, &result);
218 return result;
219 }
220
UsbFreeConfigDescriptor(napi_env env,napi_callback_info info)221 static napi_value UsbFreeConfigDescriptor(napi_env env, napi_callback_info info)
222 {
223 size_t argc = PARAM_1;
224 napi_value args[PARAM_1] = {nullptr};
225 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
226 int64_t deviceId64;
227 napi_get_value_int64(env, args[PARAM_0], &deviceId64);
228 uint64_t deviceId = static_cast<uint64_t>(deviceId64);
229 int32_t usbInitReturnValue = OH_Usb_Init();
230 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
231 struct UsbDdkConfigDescriptor *config = nullptr;
232 int32_t returnValue = OH_Usb_GetConfigDescriptor(deviceId, configIndex, &config);
233 NAPI_ASSERT(env, returnValue == PARAM_0, "OH_Usb_GetConfigDescriptor failed");
234 OH_Usb_FreeConfigDescriptor(config);
235 napi_value result = nullptr;
236 napi_create_int32(env, true, &result);
237 return result;
238 }
239
UsbClaimInterface(napi_env env,napi_callback_info info)240 static napi_value UsbClaimInterface(napi_env env, napi_callback_info info)
241 {
242 size_t argc = PARAM_1;
243 napi_value args[PARAM_1] = {nullptr};
244 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
245 int64_t deviceId64;
246 napi_get_value_int64(env, args[PARAM_0], &deviceId64);
247 uint64_t deviceId = static_cast<uint64_t>(deviceId64);
248 int32_t usbInitReturnValue = OH_Usb_Init();
249 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
250 int32_t returnValue = OH_Usb_ClaimInterface(deviceId, interfaceIndex, &interfaceHandle);
251 napi_value result = nullptr;
252 napi_create_int32(env, returnValue, &result);
253 return result;
254 }
255
UsbReleaseInterface(napi_env env,napi_callback_info info)256 static napi_value UsbReleaseInterface(napi_env env, napi_callback_info info)
257 {
258 size_t argc = PARAM_1;
259 napi_value args[PARAM_1] = {nullptr};
260 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
261 int64_t deviceId64;
262 napi_get_value_int64(env, args[PARAM_0], &deviceId64);
263 uint64_t deviceId = static_cast<uint64_t>(deviceId64);
264 int32_t usbInitReturnValue = OH_Usb_Init();
265 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
266 int32_t usbClaimInterfaceValue = OH_Usb_ClaimInterface(deviceId, interfaceIndex, &interfaceHandle);
267 NAPI_ASSERT(env, usbClaimInterfaceValue == PARAM_0, "Usb_ClaimInterface failed");
268 int32_t returnValue = OH_Usb_ReleaseInterface(interfaceHandle);
269 napi_value result = nullptr;
270 napi_create_int32(env, returnValue, &result);
271 return result;
272 }
273
UsbSelectInterfaceSetting(napi_env env,napi_callback_info info)274 static napi_value UsbSelectInterfaceSetting(napi_env env, napi_callback_info info)
275 {
276 size_t argc = PARAM_1;
277 napi_value args[PARAM_1] = {nullptr};
278 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
279 int64_t deviceId64;
280 napi_get_value_int64(env, args[PARAM_0], &deviceId64);
281 uint64_t deviceId = static_cast<uint64_t>(deviceId64);
282 int32_t usbInitReturnValue = OH_Usb_Init();
283 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
284 int32_t usbClaimInterfaceValue = OH_Usb_ClaimInterface(deviceId, interfaceIndex, &interfaceHandle);
285 NAPI_ASSERT(env, usbClaimInterfaceValue == PARAM_0, "Usb_ClaimInterface failed");
286 int32_t returnValue = OH_Usb_SelectInterfaceSetting(interfaceHandle, settingIndex);
287 napi_value result = nullptr;
288 napi_create_int32(env, returnValue, &result);
289 return result;
290 }
291
UsbGetCurrentInterfaceSetting(napi_env env,napi_callback_info info)292 static napi_value UsbGetCurrentInterfaceSetting(napi_env env, napi_callback_info info)
293 {
294 size_t argc = PARAM_1;
295 napi_value args[PARAM_1] = {nullptr};
296 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
297 int64_t deviceId64;
298 napi_get_value_int64(env, args[PARAM_0], &deviceId64);
299 uint64_t deviceId = static_cast<uint64_t>(deviceId64);
300 int32_t usbInitReturnValue = OH_Usb_Init();
301 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
302 int32_t usbClaimInterfaceValue = OH_Usb_ClaimInterface(deviceId, interfaceIndex, &interfaceHandle);
303 NAPI_ASSERT(env, usbClaimInterfaceValue == PARAM_0, "OH_Usb_ClaimInterface failed");
304 int32_t usbSelectInterfaceSettingReturnValue = OH_Usb_SelectInterfaceSetting(interfaceHandle, settingIndex);
305 NAPI_ASSERT(env, usbSelectInterfaceSettingReturnValue == PARAM_0, "OH_Usb_SelectInterfaceSetting failed");
306 int32_t returnValue = OH_Usb_GetCurrentInterfaceSetting(interfaceHandle, &settingIndex);
307 napi_value result = nullptr;
308 napi_create_int32(env, returnValue, &result);
309 return result;
310 }
311
UsbSendControlReadRequest(napi_env env,napi_callback_info info)312 static napi_value UsbSendControlReadRequest(napi_env env, napi_callback_info info)
313 {
314 size_t argc = PARAM_1;
315 napi_value args[PARAM_1] = {nullptr};
316 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
317 int64_t deviceId64;
318 napi_get_value_int64(env, args[PARAM_0], &deviceId64);
319 uint64_t deviceId = static_cast<uint64_t>(deviceId64);
320 int32_t usbInitReturnValue = OH_Usb_Init();
321 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
322 int32_t usbClaimInterfaceValue = OH_Usb_ClaimInterface(deviceId, interfaceIndex, &interfaceHandle);
323 NAPI_ASSERT(env, usbClaimInterfaceValue == PARAM_0, "Usb_ClaimInterface failed");
324 struct UsbControlRequestSetup setup;
325 uint8_t data[USB_DDK_TEST_BUF_SIZE] = {PARAM_0};
326 uint32_t dataLen = USB_DDK_TEST_BUF_SIZE;
327 setup.bmRequestType = 0x80;
328 setup.bRequest = 0x06;
329 setup.wValue = (0x03 << PARAM_8) | 0x01;
330 setup.wIndex = 0x409;
331 setup.wLength = dataLen;
332 int32_t returnValue = OH_Usb_SendControlReadRequest(interfaceHandle, &setup, UINT32_MAX, data, &dataLen);
333 napi_value result = nullptr;
334 napi_create_int32(env, returnValue, &result);
335 return result;
336 }
337
UsbSendControlWriteRequest(napi_env env,napi_callback_info info)338 static napi_value UsbSendControlWriteRequest(napi_env env, napi_callback_info info)
339 {
340 size_t argc = PARAM_1;
341 napi_value args[PARAM_1] = {nullptr};
342 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
343 int64_t deviceId64;
344 napi_get_value_int64(env, args[PARAM_0], &deviceId64);
345 uint64_t deviceId = static_cast<uint64_t>(deviceId64);
346 int32_t usbInitReturnValue = OH_Usb_Init();
347 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
348 int32_t usbClaimInterfaceValue = OH_Usb_ClaimInterface(deviceId, interfaceIndex, &interfaceHandle);
349 NAPI_ASSERT(env, usbClaimInterfaceValue == PARAM_0, "Usb_ClaimInterface failed");
350 struct UsbControlRequestSetup setup;
351 uint8_t data = PARAM_10;
352 uint32_t dataLen = PARAM_10;
353 int32_t returnValue = OH_Usb_SendControlWriteRequest(interfaceHandle, &setup, timeout, &data, dataLen);
354 napi_value result = nullptr;
355 napi_create_int32(env, returnValue, &result);
356 return result;
357 }
358
JsDeviceIdToNative(uint64_t deviceId)359 uint64_t JsDeviceIdToNative(uint64_t deviceId)
360 {
361 uint32_t busNum = (uint32_t)(deviceId >> PARAM_48);
362 uint32_t devNum = (uint32_t)((deviceId & 0x0000FFFF00000000) >> PARAM_32);
363 return (((static_cast<uint64_t>(busNum)) << PARAM_32) | devNum);
364 }
365
UsbSendPipeRequest(napi_env env,napi_callback_info info)366 static napi_value UsbSendPipeRequest(napi_env env, napi_callback_info info)
367 {
368 size_t argc = PARAM_1;
369 napi_value args[PARAM_1] = {nullptr};
370 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
371 int64_t deviceId64;
372 napi_get_value_int64(env, args[PARAM_0], &deviceId64);
373 uint64_t deviceId = JsDeviceIdToNative(static_cast<uint64_t>(deviceId64));
374 int32_t usbInitReturnValue = OH_Usb_Init();
375 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
376 struct UsbDeviceDescriptor devDesc;
377 int32_t usbGetDeviceDescriptorReturnValue = OH_Usb_GetDeviceDescriptor(deviceId, &devDesc);
378 NAPI_ASSERT(env, usbGetDeviceDescriptorReturnValue == PARAM_0, "OH_Usb_GetDeviceDescriptor failed");
379 struct UsbDdkConfigDescriptor *config = nullptr;
380 int32_t usbGetConfigDescriptorReturnValue = OH_Usb_GetConfigDescriptor(deviceId, configIndex, &config);
381 NAPI_ASSERT(env, usbGetConfigDescriptorReturnValue == PARAM_0, "OH_Usb_GetConfigDescriptor failed");
382 auto [result1, interface1, endpoint1, maxPktSize1] = GetEndpointInfo(config);
383 OH_Usb_FreeConfigDescriptor(config);
384 int32_t usbClaimInterfaceValue = OH_Usb_ClaimInterface(deviceId, interfaceIndex, &interfaceHandle);
385 NAPI_ASSERT(env, usbClaimInterfaceValue == PARAM_0, "Usb_ClaimInterface failed");
386 struct UsbDeviceMemMap *devMemMap = nullptr;
387 size_t bufferLen = PARAM_10;
388 int32_t usbCreateDeviceMemMapReturnValue = OH_Usb_CreateDeviceMemMap(deviceId, bufferLen, &devMemMap);
389 NAPI_ASSERT(env, usbCreateDeviceMemMapReturnValue == PARAM_0, "OH_Usb_CreateDeviceMemMap failed");
390 NAPI_ASSERT(env, devMemMap != nullptr, "OH_Usb_CreateDeviceMemMap failed");
391 struct UsbRequestPipe pipe;
392 pipe.interfaceHandle = interfaceHandle;
393 pipe.endpoint = endpoint1;
394 pipe.timeout = UINT32_MAX;
395 int32_t returnValue = OH_Usb_SendPipeRequest(&pipe, devMemMap);
396 OH_Usb_DestroyDeviceMemMap(devMemMap);
397 napi_value result = nullptr;
398 napi_create_int32(env, returnValue, &result);
399 return result;
400 }
401
UsbCreateDeviceMemMap(napi_env env,napi_callback_info info)402 static napi_value UsbCreateDeviceMemMap(napi_env env, napi_callback_info info)
403 {
404 size_t argc = PARAM_1;
405 napi_value args[PARAM_1] = {nullptr};
406 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
407 int64_t deviceId64;
408 napi_get_value_int64(env, args[PARAM_0], &deviceId64);
409 uint64_t deviceId = static_cast<uint64_t>(deviceId64);
410 int32_t usbInitReturnValue = OH_Usb_Init();
411 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
412 struct UsbDeviceDescriptor devDesc;
413 int32_t usbGetDeviceDescriptorReturnValue = OH_Usb_GetDeviceDescriptor(deviceId, &devDesc);
414 NAPI_ASSERT(env, usbGetDeviceDescriptorReturnValue == PARAM_0, "OH_Usb_GetDeviceDescriptor failed");
415 struct UsbDdkConfigDescriptor *config = nullptr;
416 int32_t usbGetConfigDescriptorReturnValue = OH_Usb_GetConfigDescriptor(deviceId, configIndex, &config);
417 NAPI_ASSERT(env, usbGetConfigDescriptorReturnValue == PARAM_0, "OH_Usb_GetConfigDescriptor failed");
418 OH_Usb_FreeConfigDescriptor(config);
419 struct UsbDeviceMemMap *devMemMap = nullptr;
420 size_t bufferLen = PARAM_10;
421 int32_t returnValue = OH_Usb_CreateDeviceMemMap(deviceId, bufferLen, &devMemMap);
422 OH_Usb_DestroyDeviceMemMap(devMemMap);
423 napi_value result = nullptr;
424 napi_create_int32(env, returnValue, &result);
425 return result;
426 }
427
UsbDestroyDeviceMemMap(napi_env env,napi_callback_info info)428 static napi_value UsbDestroyDeviceMemMap(napi_env env, napi_callback_info info)
429 {
430 size_t argc = PARAM_1;
431 napi_value args[PARAM_1] = {nullptr};
432 napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
433 int64_t deviceId64;
434 napi_get_value_int64(env, args[PARAM_0], &deviceId64);
435 uint64_t deviceId = static_cast<uint64_t>(deviceId64);
436 int32_t usbInitReturnValue = OH_Usb_Init();
437 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
438 struct UsbDeviceDescriptor devDesc;
439 int32_t usbGetDeviceDescriptorReturnValue = OH_Usb_GetDeviceDescriptor(deviceId, &devDesc);
440 NAPI_ASSERT(env, usbGetDeviceDescriptorReturnValue == PARAM_0, "OH_Usb_GetDeviceDescriptor failed");
441 struct UsbDdkConfigDescriptor *config = nullptr;
442 int32_t usbGetConfigDescriptorReturnValue = OH_Usb_GetConfigDescriptor(deviceId, configIndex, &config);
443 NAPI_ASSERT(env, usbGetConfigDescriptorReturnValue == PARAM_0, "OH_Usb_GetConfigDescriptor failed");
444 OH_Usb_FreeConfigDescriptor(config);
445 struct UsbDeviceMemMap *devMemMap = nullptr;
446 size_t bufferLen = PARAM_10;
447 OH_Usb_CreateDeviceMemMap(deviceId, bufferLen, &devMemMap);
448 OH_Usb_DestroyDeviceMemMap(devMemMap);
449 napi_value result = nullptr;
450 napi_create_int32(env, true, &result);
451 return result;
452 }
453
UsbSendPipeRequestWithAshmem(napi_env env,napi_callback_info info)454 static napi_value UsbSendPipeRequestWithAshmem(napi_env env, napi_callback_info info)
455 {
456 size_t argc = PARAM_1;
457 napi_value args[PARAM_1] = {nullptr};
458 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
459 int64_t deviceId64;
460 NAPI_CALL(env, napi_get_value_int64(env, args[PARAM_0], &deviceId64));
461 uint64_t deviceId = JsDeviceIdToNative(static_cast<uint64_t>(deviceId64));
462 int32_t usbInitReturnValue = OH_Usb_Init();
463 NAPI_ASSERT(env, usbInitReturnValue == PARAM_0, "OH_Usb_Init failed");
464 struct UsbDeviceDescriptor devDesc;
465 int32_t usbGetDeviceDescriptorReturnValue = OH_Usb_GetDeviceDescriptor(deviceId, &devDesc);
466 NAPI_ASSERT(env, usbGetDeviceDescriptorReturnValue == PARAM_0, "OH_Usb_GetDeviceDescriptor failed");
467 struct UsbDdkConfigDescriptor *config = nullptr;
468 int32_t usbGetConfigDescriptorReturnValue = OH_Usb_GetConfigDescriptor(deviceId, configIndex, &config);
469 NAPI_ASSERT(env, usbGetConfigDescriptorReturnValue == PARAM_0, "OH_Usb_GetConfigDescriptor failed");
470 auto [result1, interface1, endpoint1, maxPktSize1] = GetEndpointInfo(config);
471 OH_Usb_FreeConfigDescriptor(config);
472 int32_t usbClaimInterfaceValue = OH_Usb_ClaimInterface(deviceId, interfaceIndex, &interfaceHandle);
473 NAPI_ASSERT(env, usbClaimInterfaceValue == PARAM_0, "Usb_ClaimInterface failed");
474 size_t bufferLen = PARAM_10;
475 const uint8_t name[100] = "TestAshmem";
476 DDK_Ashmem *ashmem = nullptr;
477 int32_t createAshmemValue = OH_DDK_CreateAshmem(name, bufferLen, &ashmem);
478 NAPI_ASSERT(env, createAshmemValue == PARAM_0, "OH_DDK_CreateAshmem failed");
479 const uint8_t ashmemMapType = 0x03;
480 int32_t mapAshmemValue = OH_DDK_MapAshmem(ashmem, ashmemMapType);
481 NAPI_ASSERT(env, mapAshmemValue == PARAM_0, "OH_DDK_MapAshmem failed");
482 struct UsbRequestPipe pipe;
483 pipe.interfaceHandle = interfaceHandle;
484 pipe.endpoint = endpoint1;
485 pipe.timeout = UINT32_MAX;
486 int32_t returnValue = OH_Usb_SendPipeRequestWithAshmem(&pipe, ashmem);
487 OH_DDK_DestroyAshmem(ashmem);
488 napi_value result = nullptr;
489 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
490 return result;
491 }
492
UsbGetDevices(napi_env env,napi_callback_info info)493 static napi_value UsbGetDevices(napi_env env, napi_callback_info info)
494 {
495 int32_t usbInitReturnValue = OH_Usb_Init();
496 NAPI_ASSERT(env, usbInitReturnValue == USB_DDK_NO_PERM, "OH_Usb_Init failed, no permission");
497 struct Usb_DeviceArray deviceArray;
498 deviceArray.deviceIds = new uint64_t[MAX_USB_DEVICE_NUM];
499 int32_t returnValue = OH_Usb_GetDevices(&deviceArray);
500 OH_Usb_Release();
501 delete[] deviceArray.deviceIds;
502 napi_value result = nullptr;
503 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
504 return result;
505 }
506
ScsiPeripheralInit(napi_env env,napi_callback_info info)507 static napi_value ScsiPeripheralInit(napi_env env, napi_callback_info info)
508 {
509 int32_t returnValue = OH_ScsiPeripheral_Init();
510 int32_t releaseRetVal = OH_ScsiPeripheral_Release();
511 NAPI_ASSERT(env, releaseRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Release failed, no permission");
512 napi_value result = nullptr;
513 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
514 return result;
515 }
516
ScsiPeripheralRelease(napi_env env,napi_callback_info info)517 static napi_value ScsiPeripheralRelease(napi_env env, napi_callback_info info)
518 {
519 int32_t initRetVal = OH_ScsiPeripheral_Init();
520 NAPI_ASSERT(env, initRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Init failed, no permission");
521 int32_t returnValue = OH_ScsiPeripheral_Release();
522 napi_value result = nullptr;
523 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
524 return result;
525 }
526
ScsiPeripheralOpen(napi_env env,napi_callback_info info)527 static napi_value ScsiPeripheralOpen(napi_env env, napi_callback_info info)
528 {
529 int32_t initRetVal = OH_ScsiPeripheral_Init();
530 NAPI_ASSERT(env, initRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Init failed, no permission");
531 ScsiPeripheral_Device *dev = NewScsiPeripheralDevice();
532 int32_t returnValue = OH_ScsiPeripheral_Open(0, 0, &dev);
533 NAPI_ASSERT(env, returnValue == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Open failed, no permission");
534 napi_value result = nullptr;
535 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
536 OH_ScsiPeripheral_Close(&dev);
537 OH_ScsiPeripheral_Release();
538 return result;
539 }
540
ScsiPeripheralClose(napi_env env,napi_callback_info info)541 static napi_value ScsiPeripheralClose(napi_env env, napi_callback_info info)
542 {
543 int32_t initRetVal = OH_ScsiPeripheral_Init();
544 NAPI_ASSERT(env, initRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Init failed, no permission");
545 ScsiPeripheral_Device *dev = NewScsiPeripheralDevice();
546 int32_t returnValue = OH_ScsiPeripheral_Open(0, 0, &dev);
547 NAPI_ASSERT(env, returnValue == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Open failed, no permission");
548 returnValue = OH_ScsiPeripheral_Close(&dev);
549 NAPI_ASSERT(env, returnValue == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Close failed, no permission");
550 napi_value result = nullptr;
551 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
552 OH_ScsiPeripheral_Release();
553 return result;
554 }
555
ScsiPeripheralTestUnitReady(napi_env env,napi_callback_info info)556 static napi_value ScsiPeripheralTestUnitReady(napi_env env, napi_callback_info info)
557 {
558 int32_t initRetVal = OH_ScsiPeripheral_Init();
559 NAPI_ASSERT(env, initRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Init failed, no permission");
560
561 ScsiPeripheral_Device *dev = NewScsiPeripheralDevice();
562 ScsiPeripheral_TestUnitReadyRequest request = {0};
563 ScsiPeripheral_Response response = {{0}};
564 int32_t returnValue = OH_ScsiPeripheral_TestUnitReady(dev, &request, &response);
565 napi_value result = nullptr;
566 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
567 DeleteScsiPeripheralDevice(&dev);
568 int32_t releaseRetVal = OH_ScsiPeripheral_Release();
569 NAPI_ASSERT(env, releaseRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Release failed, no permission");
570 return result;
571 }
572
ScsiPeripheralInquiry(napi_env env,napi_callback_info info)573 static napi_value ScsiPeripheralInquiry(napi_env env, napi_callback_info info)
574 {
575 int32_t initRetVal = OH_ScsiPeripheral_Init();
576 NAPI_ASSERT(env, initRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Init failed, no permission");
577
578 ScsiPeripheral_Device *dev = NewScsiPeripheralDevice();
579 ScsiPeripheral_InquiryRequest request = {0};
580 ScsiPeripheral_InquiryInfo inquiryInfo = {0};
581 uint8_t buff;
582 ScsiPeripheral_DeviceMemMap devMmap({&buff, sizeof(buff), 0, sizeof(buff), 0});
583 inquiryInfo.data = &devMmap;
584 ScsiPeripheral_Response response = {{0}};
585 int32_t returnValue = OH_ScsiPeripheral_Inquiry(dev, &request, &inquiryInfo, &response);
586 napi_value result = nullptr;
587 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
588 DeleteScsiPeripheralDevice(&dev);
589 int32_t releaseRetVal = OH_ScsiPeripheral_Release();
590 NAPI_ASSERT(env, releaseRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Release failed, no permission");
591 return result;
592 }
593
ScsiPeripheralReadCapacity10(napi_env env,napi_callback_info info)594 static napi_value ScsiPeripheralReadCapacity10(napi_env env, napi_callback_info info)
595 {
596 int32_t initRetVal = OH_ScsiPeripheral_Init();
597 NAPI_ASSERT(env, initRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Init failed, no permission");
598
599 ScsiPeripheral_Device *dev = NewScsiPeripheralDevice();
600 ScsiPeripheral_ReadCapacityRequest request = {0};
601 ScsiPeripheral_CapacityInfo capacityInfo = {0};
602 ScsiPeripheral_Response response = {{0}};
603 int32_t returnValue = OH_ScsiPeripheral_ReadCapacity10(dev, &request, &capacityInfo, &response);
604 napi_value result = nullptr;
605 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
606 DeleteScsiPeripheralDevice(&dev);
607 int32_t releaseRetVal = OH_ScsiPeripheral_Release();
608 NAPI_ASSERT(env, releaseRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Release failed, no permission");
609 return result;
610 }
611
ScsiPeripheralRequestSense(napi_env env,napi_callback_info info)612 static napi_value ScsiPeripheralRequestSense(napi_env env, napi_callback_info info)
613 {
614 int32_t initRetVal = OH_ScsiPeripheral_Init();
615 NAPI_ASSERT(env, initRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Init failed, no permission");
616
617 ScsiPeripheral_Device *dev = NewScsiPeripheralDevice();
618 ScsiPeripheral_RequestSenseRequest request = {0};
619 ScsiPeripheral_Response response = {{0}};
620 int32_t returnValue = OH_ScsiPeripheral_RequestSense(dev, &request, &response);
621 napi_value result = nullptr;
622 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
623 DeleteScsiPeripheralDevice(&dev);
624 int32_t releaseRetVal = OH_ScsiPeripheral_Release();
625 NAPI_ASSERT(env, releaseRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Release failed, no permission");
626 return result;
627 }
628
ScsiPeripheralRead10(napi_env env,napi_callback_info info)629 static napi_value ScsiPeripheralRead10(napi_env env, napi_callback_info info)
630 {
631 int32_t initRetVal = OH_ScsiPeripheral_Init();
632 NAPI_ASSERT(env, initRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Init failed, no permission");
633
634 ScsiPeripheral_Device *dev = NewScsiPeripheralDevice();
635 ScsiPeripheral_IORequest request = {0};
636 uint8_t buff;
637 ScsiPeripheral_DeviceMemMap devMmap({&buff, sizeof(buff), 0, sizeof(buff), 0});
638 request.data = &devMmap;
639 ScsiPeripheral_Response response = {{0}};
640 int32_t returnValue = OH_ScsiPeripheral_Read10(dev, &request, &response);
641 napi_value result = nullptr;
642 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
643 DeleteScsiPeripheralDevice(&dev);
644 int32_t releaseRetVal = OH_ScsiPeripheral_Release();
645 NAPI_ASSERT(env, releaseRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Release failed, no permission");
646 return result;
647 }
648
ScsiPeripheralWrite10(napi_env env,napi_callback_info info)649 static napi_value ScsiPeripheralWrite10(napi_env env, napi_callback_info info)
650 {
651 int32_t initRetVal = OH_ScsiPeripheral_Init();
652 NAPI_ASSERT(env, initRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Init failed, no permission");
653
654 ScsiPeripheral_Device *dev = NewScsiPeripheralDevice();
655 ScsiPeripheral_IORequest request = {0};
656 uint8_t buff;
657 ScsiPeripheral_DeviceMemMap devMmap({&buff, sizeof(buff), 0, sizeof(buff), 0});
658 request.data = &devMmap;
659 ScsiPeripheral_Response response = {{0}};
660 int32_t returnValue = OH_ScsiPeripheral_Write10(dev, &request, &response);
661 napi_value result = nullptr;
662 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
663 DeleteScsiPeripheralDevice(&dev);
664 int32_t releaseRetVal = OH_ScsiPeripheral_Release();
665 NAPI_ASSERT(env, releaseRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Release failed, no permission");
666 return result;
667 }
668
ScsiPeripheralVerify10(napi_env env,napi_callback_info info)669 static napi_value ScsiPeripheralVerify10(napi_env env, napi_callback_info info)
670 {
671 int32_t initRetVal = OH_ScsiPeripheral_Init();
672 NAPI_ASSERT(env, initRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Init failed, no permission");
673
674 ScsiPeripheral_Device *dev = NewScsiPeripheralDevice();
675 ScsiPeripheral_VerifyRequest request = {0};
676 ScsiPeripheral_Response response = {{0}};
677 int32_t returnValue = OH_ScsiPeripheral_Verify10(dev, &request, &response);
678 napi_value result = nullptr;
679 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
680 DeleteScsiPeripheralDevice(&dev);
681 int32_t releaseRetVal = OH_ScsiPeripheral_Release();
682 NAPI_ASSERT(env, releaseRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Release failed, no permission");
683 return result;
684 }
685
ScsiPeripheralSendRequestByCDB(napi_env env,napi_callback_info info)686 static napi_value ScsiPeripheralSendRequestByCDB(napi_env env, napi_callback_info info)
687 {
688 int32_t initRetVal = OH_ScsiPeripheral_Init();
689 NAPI_ASSERT(env, initRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Init failed, no permission");
690
691 ScsiPeripheral_Device *dev = NewScsiPeripheralDevice();
692 ScsiPeripheral_Request request = {{0}};
693 uint8_t buff;
694 ScsiPeripheral_DeviceMemMap devMmap({&buff, sizeof(buff), 0, sizeof(buff), 0});
695 request.data = &devMmap;
696 request.cdbLength = CDB_LENGTH;
697 ScsiPeripheral_Response response = {{0}};
698 int32_t returnValue = OH_ScsiPeripheral_SendRequestByCdb(dev, &request, &response);
699 napi_value result = nullptr;
700 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
701 DeleteScsiPeripheralDevice(&dev);
702 int32_t releaseRetVal = OH_ScsiPeripheral_Release();
703 NAPI_ASSERT(env, releaseRetVal == SCSIPERIPHERAL_DDK_NO_PERM, "OH_ScsiPeripheral_Release failed, no permission");
704 return result;
705 }
706
HidInit(napi_env env,napi_callback_info info)707 static napi_value HidInit(napi_env env, napi_callback_info info)
708 {
709 int32_t returnValue = OH_Hid_Init();
710 int32_t releaseRetVal = OH_Hid_Release();
711 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
712 napi_value result = nullptr;
713 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
714 return result;
715 }
716
HidRelease(napi_env env,napi_callback_info info)717 static napi_value HidRelease(napi_env env, napi_callback_info info)
718 {
719 int32_t initRetVal = OH_Hid_Init();
720 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
721 int32_t returnValue = OH_Hid_Release();
722 napi_value result = nullptr;
723 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
724 return result;
725 }
726
HidOpen(napi_env env,napi_callback_info info)727 static napi_value HidOpen(napi_env env, napi_callback_info info)
728 {
729 size_t argc = PARAM_1;
730 napi_value args[PARAM_1] = {nullptr};
731 NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
732
733 int32_t initRetVal = OH_Hid_Init();
734 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
735
736 int64_t deviceId64;
737 NAPI_CALL(env, napi_get_value_int64(env, args[PARAM_0], &deviceId64));
738 int32_t deviceId32 = static_cast<int32_t>(deviceId64 >> THIRTYTWO_BIT);
739 uint32_t busNum = ((deviceId32 & BUS_NUM_MASK) >> SIXTEEN_BIT);
740 uint32_t deviceNum = deviceId32 & DEVICE_NUM_MASK;
741 uint64_t deviceId = (static_cast<uint64_t>(busNum) << THIRTYTWO_BIT) | deviceNum;
742
743 struct Hid_DeviceHandle *dev = nullptr;
744 int32_t returnValue = OH_Hid_Open(deviceId, 0, &dev);
745 napi_value result = nullptr;
746 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
747 OH_Hid_Close(&dev);
748 int32_t releaseRetVal = OH_Hid_Release();
749 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
750 return result;
751 }
752
HidClose(napi_env env,napi_callback_info info)753 static napi_value HidClose(napi_env env, napi_callback_info info)
754 {
755 int32_t initRetVal = OH_Hid_Init();
756 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
757
758 Hid_DeviceHandle *dev = NewHidDeviceHandle();
759 int32_t returnValue = OH_Hid_Close(&dev);
760 napi_value result = nullptr;
761 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
762 int32_t releaseRetVal = OH_Hid_Release();
763 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
764 return result;
765 }
766
HidWrite(napi_env env,napi_callback_info info)767 static napi_value HidWrite(napi_env env, napi_callback_info info)
768 {
769 int32_t initRetVal = OH_Hid_Init();
770 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
771
772 Hid_DeviceHandle *dev = NewHidDeviceHandle();
773 uint8_t data[] = {0x02, 0x02};
774 uint32_t bytesWritten = 0;
775 int32_t returnValue = OH_Hid_Write(dev, data, sizeof(data), &bytesWritten);
776 napi_value result = nullptr;
777 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
778 DeleteHidDeviceHandle(&dev);
779 int32_t releaseRetVal = OH_Hid_Release();
780 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
781 return result;
782 }
783
HidReadTimeout(napi_env env,napi_callback_info info)784 static napi_value HidReadTimeout(napi_env env, napi_callback_info info)
785 {
786 int32_t initRetVal = OH_Hid_Init();
787 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
788
789 Hid_DeviceHandle *dev = NewHidDeviceHandle();
790 uint8_t data[DATA_BUFF_SIZE] = {0};
791 uint32_t bytesRead = 0;
792 int32_t returnValue = OH_Hid_ReadTimeout(dev, data, DATA_BUFF_SIZE, READ_TIME_OUT, &bytesRead);
793 napi_value result = nullptr;
794 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
795 DeleteHidDeviceHandle(&dev);
796 int32_t releaseRetVal = OH_Hid_Release();
797 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
798 return result;
799 }
800
HidRead(napi_env env,napi_callback_info info)801 static napi_value HidRead(napi_env env, napi_callback_info info)
802 {
803 int32_t initRetVal = OH_Hid_Init();
804 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
805
806 Hid_DeviceHandle *dev = NewHidDeviceHandle();
807 uint8_t data[DATA_BUFF_SIZE] = {0};
808 uint32_t bytesRead = 0;
809 int32_t returnValue = OH_Hid_Read(dev, data, DATA_BUFF_SIZE, &bytesRead);
810 napi_value result = nullptr;
811 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
812 DeleteHidDeviceHandle(&dev);
813 int32_t releaseRetVal = OH_Hid_Release();
814 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
815 return result;
816 }
817
HidSetNonBlocking(napi_env env,napi_callback_info info)818 static napi_value HidSetNonBlocking(napi_env env, napi_callback_info info)
819 {
820 int32_t initRetVal = OH_Hid_Init();
821 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
822
823 Hid_DeviceHandle *dev = NewHidDeviceHandle();
824 int32_t returnValue = OH_Hid_SetNonBlocking(dev, 0);
825 napi_value result = nullptr;
826 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
827 DeleteHidDeviceHandle(&dev);
828 int32_t releaseRetVal = OH_Hid_Release();
829 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
830 return result;
831 }
832
HidGetRawInfo(napi_env env,napi_callback_info info)833 static napi_value HidGetRawInfo(napi_env env, napi_callback_info info)
834 {
835 int32_t initRetVal = OH_Hid_Init();
836 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
837
838 Hid_DeviceHandle *dev = NewHidDeviceHandle();
839 Hid_RawDevInfo rawDevInfo = {0};
840 int32_t returnValue = OH_Hid_GetRawInfo(dev, &rawDevInfo);
841 napi_value result = nullptr;
842 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
843 DeleteHidDeviceHandle(&dev);
844 int32_t releaseRetVal = OH_Hid_Release();
845 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
846 return result;
847 }
848
HidGetRawName(napi_env env,napi_callback_info info)849 static napi_value HidGetRawName(napi_env env, napi_callback_info info)
850 {
851 int32_t initRetVal = OH_Hid_Init();
852 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
853
854 Hid_DeviceHandle *dev = NewHidDeviceHandle();
855 char data[DATA_BUFF_SIZE] = {0};
856 int32_t returnValue = OH_Hid_GetRawName(dev, data, DATA_BUFF_SIZE);
857 napi_value result = nullptr;
858 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
859 DeleteHidDeviceHandle(&dev);
860 int32_t releaseRetVal = OH_Hid_Release();
861 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
862 return result;
863 }
864
HidGetPhysicalAddress(napi_env env,napi_callback_info info)865 static napi_value HidGetPhysicalAddress(napi_env env, napi_callback_info info)
866 {
867 int32_t initRetVal = OH_Hid_Init();
868 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
869
870 Hid_DeviceHandle *dev = NewHidDeviceHandle();
871 char data[DATA_BUFF_SIZE] = {0};
872 int32_t returnValue = OH_Hid_GetPhysicalAddress(dev, data, DATA_BUFF_SIZE);
873 napi_value result = nullptr;
874 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
875 DeleteHidDeviceHandle(&dev);
876 int32_t releaseRetVal = OH_Hid_Release();
877 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
878 return result;
879 }
880
HidGetRawUniqueId(napi_env env,napi_callback_info info)881 static napi_value HidGetRawUniqueId(napi_env env, napi_callback_info info)
882 {
883 int32_t initRetVal = OH_Hid_Init();
884 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
885
886 Hid_DeviceHandle *dev = NewHidDeviceHandle();
887 uint8_t data[DATA_BUFF_SIZE] = {0};
888 int32_t returnValue = OH_Hid_GetRawUniqueId(dev, data, DATA_BUFF_SIZE);
889 napi_value result = nullptr;
890 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
891 DeleteHidDeviceHandle(&dev);
892 int32_t releaseRetVal = OH_Hid_Release();
893 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
894 return result;
895 }
896
HidSendReport(napi_env env,napi_callback_info info)897 static napi_value HidSendReport(napi_env env, napi_callback_info info)
898 {
899 int32_t initRetVal = OH_Hid_Init();
900 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
901
902 Hid_DeviceHandle *dev = NewHidDeviceHandle();
903 uint8_t data[DATA_BUFF_SIZE] = {0};
904 int32_t returnValue = OH_Hid_SendReport(dev, HID_FEATURE_REPORT, data, DATA_BUFF_SIZE);
905 napi_value result = nullptr;
906 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
907 DeleteHidDeviceHandle(&dev);
908 int32_t releaseRetVal = OH_Hid_Release();
909 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
910 return result;
911 }
912
HidGetReport(napi_env env,napi_callback_info info)913 static napi_value HidGetReport(napi_env env, napi_callback_info info)
914 {
915 int32_t initRetVal = OH_Hid_Init();
916 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
917
918 Hid_DeviceHandle *dev = NewHidDeviceHandle();
919 uint8_t data[DATA_BUFF_SIZE] = {0};
920 int32_t returnValue = OH_Hid_GetReport(dev, HID_FEATURE_REPORT, data, DATA_BUFF_SIZE);
921 napi_value result = nullptr;
922 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
923 DeleteHidDeviceHandle(&dev);
924 int32_t releaseRetVal = OH_Hid_Release();
925 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
926 return result;
927 }
928
HidGetReportDescriptor(napi_env env,napi_callback_info info)929 static napi_value HidGetReportDescriptor(napi_env env, napi_callback_info info)
930 {
931 int32_t initRetVal = OH_Hid_Init();
932 NAPI_ASSERT(env, initRetVal == USB_DDK_NO_PERM, "OH_Hid_Init failed, no permission");
933
934 Hid_DeviceHandle *dev = NewHidDeviceHandle();
935 uint8_t data[DATA_BUFF_SIZE] = {0};
936 uint32_t bytesRead = 0;
937 int32_t returnValue = OH_Hid_GetReportDescriptor(dev, data, DATA_BUFF_SIZE, &bytesRead);
938 napi_value result = nullptr;
939 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
940 DeleteHidDeviceHandle(&dev);
941 int32_t releaseRetVal = OH_Hid_Release();
942 NAPI_ASSERT(env, releaseRetVal == USB_DDK_NO_PERM, "OH_Hid_Release failed, no permission");
943 return result;
944 }
945
InitializeAndCreateDeviceHandle(napi_env env)946 UsbSerial_Device *InitializeAndCreateDeviceHandle(napi_env env)
947 {
948 int32_t usbSerialInitReturnValue = OH_UsbSerial_Init();
949 if (usbSerialInitReturnValue != USB_SERIAL_DDK_NO_PERM) {
950 OH_UsbSerial_Release();
951 }
952 NAPI_ASSERT(env, usbSerialInitReturnValue == USB_SERIAL_DDK_NO_PERM, "OH_UsbSerial_Init, no permission");
953 return NewSerialDeviceHandle();
954 }
955
UsbSerialInit(napi_env env,napi_callback_info info)956 static napi_value UsbSerialInit(napi_env env, napi_callback_info info)
957 {
958 int32_t returnValue = OH_UsbSerial_Init();
959 napi_value result = nullptr;
960 NAPI_CALL(env, napi_create_int32(env, returnValue, &result));
961 return result;
962 }
963
UsbSerialRelease(napi_env env,napi_callback_info info)964 static napi_value UsbSerialRelease(napi_env env, napi_callback_info info)
965 {
966 int32_t usbSerialInitReturnValue = OH_UsbSerial_Init();
967 NAPI_ASSERT(env, usbSerialInitReturnValue == USB_SERIAL_DDK_NO_PERM, "OH_UsbSerial_Init, no permission");
968 int32_t returnValue = OH_UsbSerial_Release();
969 napi_value result = nullptr;
970 napi_create_int32(env, returnValue, &result);
971 return result;
972 }
973
UsbSerialOpen(napi_env env,napi_callback_info info)974 static napi_value UsbSerialOpen(napi_env env, napi_callback_info info)
975 {
976 int32_t usbSerialInitReturnValue = OH_UsbSerial_Init();
977 NAPI_ASSERT(env, usbSerialInitReturnValue == USB_SERIAL_DDK_NO_PERM, "OH_UsbSerial_Init, no permission");
978 UsbSerial_Device *deviceHandle = nullptr;
979 int32_t returnValue = OH_UsbSerial_Open(0, 0, &deviceHandle);
980 napi_value result = nullptr;
981 napi_create_int32(env, returnValue, &result);
982 DeleteUsbSerialDeviceHandle(&deviceHandle);
983 return result;
984 }
985
UsbSerialClose(napi_env env,napi_callback_info info)986 static napi_value UsbSerialClose(napi_env env, napi_callback_info info)
987 {
988 UsbSerial_Device *deviceHandle = InitializeAndCreateDeviceHandle(env);
989 int32_t returnValue = OH_UsbSerial_Close(&deviceHandle);
990 napi_value result = nullptr;
991 napi_create_int32(env, returnValue, &result);
992 return result;
993 }
994
UsbSerialRead(napi_env env,napi_callback_info info)995 static napi_value UsbSerialRead(napi_env env, napi_callback_info info)
996 {
997 UsbSerial_Device *deviceHandle = InitializeAndCreateDeviceHandle(env);
998 uint8_t dataBuff[8];
999 uint32_t bytesRead;
1000 int32_t retrunValue = OH_UsbSerial_Read(deviceHandle, dataBuff, sizeof(dataBuff), &bytesRead);
1001 napi_value result = nullptr;
1002 napi_create_int32(env, retrunValue, &result);
1003 DeleteUsbSerialDeviceHandle(&deviceHandle);
1004 return result;
1005 }
1006
UsbSerialWrite(napi_env env,napi_callback_info info)1007 static napi_value UsbSerialWrite(napi_env env, napi_callback_info info)
1008 {
1009 UsbSerial_Device *deviceHandle = InitializeAndCreateDeviceHandle(env);
1010 uint8_t buff[] = {0x01, 0x03, 0x00, 0x00, 0x00, 0x01, 0x84, 0x0A};
1011 uint32_t bytesWritten;
1012 int32_t retrunValue = OH_UsbSerial_Write(deviceHandle, buff, sizeof(buff), &bytesWritten);
1013 napi_value result = nullptr;
1014 napi_create_int32(env, retrunValue, &result);
1015 DeleteUsbSerialDeviceHandle(&deviceHandle);
1016 return result;
1017 }
1018
UsbSerialSetBaudRate(napi_env env,napi_callback_info info)1019 static napi_value UsbSerialSetBaudRate(napi_env env, napi_callback_info info)
1020 {
1021 UsbSerial_Device *deviceHandle = InitializeAndCreateDeviceHandle(env);
1022 uint32_t baudRate = 9600;
1023 int32_t retrunValue = OH_UsbSerial_SetBaudRate(deviceHandle, baudRate);
1024 napi_value result = nullptr;
1025 napi_create_int32(env, retrunValue, &result);
1026 DeleteUsbSerialDeviceHandle(&deviceHandle);
1027 return result;
1028 }
1029
UsbSerialSetParams(napi_env env,napi_callback_info info)1030 static napi_value UsbSerialSetParams(napi_env env, napi_callback_info info)
1031 {
1032 UsbSerial_Device *deviceHandle = InitializeAndCreateDeviceHandle(env);
1033 UsbSerial_Parity parity = USB_SERIAL_PARITY_ODD;
1034 UsbSerial_Params serialParams;
1035 serialParams.baudRate = USB_SERIAL_TEST_BAUDRATE;
1036 serialParams.nDataBits = USB_SERIAL_TEST_DATA_BITS;
1037 serialParams.nStopBits = 1;
1038 serialParams.parity = parity;
1039 int32_t retrunValue = OH_UsbSerial_SetParams(deviceHandle, &serialParams);
1040 napi_value result = nullptr;
1041 napi_create_int32(env, retrunValue, &result);
1042 DeleteUsbSerialDeviceHandle(&deviceHandle);
1043 return result;
1044 }
1045
UsbSerialSetTimeout(napi_env env,napi_callback_info info)1046 static napi_value UsbSerialSetTimeout(napi_env env, napi_callback_info info)
1047 {
1048 UsbSerial_Device *deviceHandle = InitializeAndCreateDeviceHandle(env);
1049 timeout = g_timeout;
1050 int32_t retrunValue = OH_UsbSerial_SetTimeout(deviceHandle, timeout);
1051 napi_value result = nullptr;
1052 napi_create_int32(env, retrunValue, &result);
1053 DeleteUsbSerialDeviceHandle(&deviceHandle);
1054 return result;
1055 }
1056
UsbSerialSetFlowControl(napi_env env,napi_callback_info info)1057 static napi_value UsbSerialSetFlowControl(napi_env env, napi_callback_info info)
1058 {
1059 UsbSerial_Device *deviceHandle = InitializeAndCreateDeviceHandle(env);
1060 UsbSerial_FlowControl flowControl = USB_SERIAL_SOFTWARE_FLOW_CONTROL;
1061 int32_t retrunValue = OH_UsbSerial_SetFlowControl(deviceHandle, flowControl);
1062 napi_value result;
1063 napi_create_int32(env, retrunValue, &result);
1064 DeleteUsbSerialDeviceHandle(&deviceHandle);
1065 return result;
1066 }
1067
UsbSerialFlush(napi_env env,napi_callback_info info)1068 static napi_value UsbSerialFlush(napi_env env, napi_callback_info info)
1069 {
1070 UsbSerial_Device *deviceHandle = InitializeAndCreateDeviceHandle(env);
1071 int32_t retrunValue = OH_UsbSerial_Flush(deviceHandle);
1072 napi_value result;
1073 napi_create_int32(env, retrunValue, &result);
1074 DeleteUsbSerialDeviceHandle(&deviceHandle);
1075 return result;
1076 }
1077
UsbSerialFlushInput(napi_env env,napi_callback_info info)1078 static napi_value UsbSerialFlushInput(napi_env env, napi_callback_info info)
1079 {
1080 UsbSerial_Device *deviceHandle = InitializeAndCreateDeviceHandle(env);
1081 int32_t retrunValue = OH_UsbSerial_FlushInput(deviceHandle);
1082 napi_value result;
1083 napi_create_int32(env, retrunValue, &result);
1084 DeleteUsbSerialDeviceHandle(&deviceHandle);
1085 return result;
1086 }
1087
UsbSerialFlushOutput(napi_env env,napi_callback_info info)1088 static napi_value UsbSerialFlushOutput(napi_env env, napi_callback_info info)
1089 {
1090 UsbSerial_Device *deviceHandle = InitializeAndCreateDeviceHandle(env);
1091 int32_t retrunValue = OH_UsbSerial_FlushOutput(deviceHandle);
1092 napi_value result;
1093 napi_create_int32(env, retrunValue, &result);
1094 DeleteUsbSerialDeviceHandle(&deviceHandle);
1095 return result;
1096 }
1097
1098 EXTERN_C_START
Init(napi_env env,napi_value exports)1099 static napi_value Init(napi_env env, napi_value exports)
1100 {
1101 napi_property_descriptor desc[] = {
1102 {"usbInit", nullptr, UsbInit, nullptr, nullptr, nullptr, napi_default, nullptr},
1103 {"usbRelease", nullptr, UsbRelease, nullptr, nullptr, nullptr, napi_default, nullptr},
1104 {"usbReleaseResource", nullptr, UsbReleaseResource, nullptr, nullptr, nullptr, napi_default, nullptr},
1105 {"usbGetDeviceDescriptor", nullptr, UsbGetDeviceDescriptor, nullptr, nullptr, nullptr, napi_default, nullptr},
1106 {"usbGetConfigDescriptor", nullptr, UsbGetConfigDescriptor, nullptr, nullptr, nullptr, napi_default, nullptr},
1107 {"usbFreeConfigDescriptor", nullptr, UsbFreeConfigDescriptor, nullptr, nullptr, nullptr, napi_default,
1108 nullptr},
1109 {"usbClaimInterface", nullptr, UsbClaimInterface, nullptr, nullptr, nullptr, napi_default, nullptr},
1110 {"usbReleaseInterface", nullptr, UsbReleaseInterface, nullptr, nullptr, nullptr, napi_default, nullptr},
1111 {"usbSelectInterfaceSetting", nullptr, UsbSelectInterfaceSetting, nullptr, nullptr, nullptr,
1112 napi_default, nullptr},
1113 {"usbGetCurrentInterfaceSetting", nullptr, UsbGetCurrentInterfaceSetting, nullptr, nullptr, nullptr,
1114 napi_default, nullptr},
1115 {"usbSendControlReadRequest", nullptr, UsbSendControlReadRequest, nullptr, nullptr, nullptr,
1116 napi_default, nullptr},
1117 {"usbSendControlWriteRequest", nullptr, UsbSendControlWriteRequest, nullptr, nullptr, nullptr,
1118 napi_default, nullptr},
1119 {"usbSendPipeRequest", nullptr, UsbSendPipeRequest, nullptr, nullptr, nullptr, napi_default, nullptr},
1120 {"usbCreateDeviceMemMap", nullptr, UsbCreateDeviceMemMap, nullptr, nullptr, nullptr, napi_default, nullptr},
1121 {"usbDestroyDeviceMemMap", nullptr, UsbDestroyDeviceMemMap, nullptr, nullptr, nullptr, napi_default, nullptr},
1122 {"usbSendPipeRequestWithAshmem", nullptr, UsbSendPipeRequestWithAshmem, nullptr, nullptr, nullptr,
1123 napi_default, nullptr},
1124 {"usbGetDevices", nullptr, UsbGetDevices, nullptr, nullptr, nullptr, napi_default, nullptr},
1125 {"scsiPeripheralInit", nullptr, ScsiPeripheralInit, nullptr, nullptr, nullptr, napi_default, nullptr},
1126 {"scsiPeripheralRelease", nullptr, ScsiPeripheralRelease, nullptr, nullptr, nullptr, napi_default, nullptr},
1127 {"scsiPeripheralOpen", nullptr, ScsiPeripheralOpen, nullptr, nullptr, nullptr, napi_default, nullptr},
1128 {"scsiPeripheralClose", nullptr, ScsiPeripheralClose, nullptr, nullptr, nullptr, napi_default, nullptr},
1129 {"scsiPeripheralTestUnitReady", nullptr, ScsiPeripheralTestUnitReady, nullptr, nullptr, nullptr,
1130 napi_default, nullptr},
1131 {"scsiPeripheralInquiry", nullptr, ScsiPeripheralInquiry, nullptr, nullptr, nullptr, napi_default, nullptr},
1132 {"scsiPeripheralReadCapacity10", nullptr, ScsiPeripheralReadCapacity10, nullptr, nullptr, nullptr,
1133 napi_default, nullptr},
1134 {"scsiPeripheralRequestSense", nullptr, ScsiPeripheralRequestSense, nullptr, nullptr, nullptr,
1135 napi_default, nullptr},
1136 {"scsiPeripheralRead10", nullptr, ScsiPeripheralRead10, nullptr, nullptr, nullptr, napi_default, nullptr},
1137 {"scsiPeripheralWrite10", nullptr, ScsiPeripheralWrite10, nullptr, nullptr, nullptr, napi_default, nullptr},
1138 {"scsiPeripheralVerify10", nullptr, ScsiPeripheralVerify10, nullptr, nullptr, nullptr, napi_default, nullptr},
1139 {"scsiPeripheralSendRequestByCDB", nullptr, ScsiPeripheralSendRequestByCDB, nullptr, nullptr, nullptr,
1140 napi_default, nullptr},
1141 {"hidInit", nullptr, HidInit, nullptr, nullptr, nullptr, napi_default, nullptr},
1142 {"hidRelease", nullptr, HidRelease, nullptr, nullptr, nullptr, napi_default, nullptr},
1143 {"hidOpen", nullptr, HidOpen, nullptr, nullptr, nullptr, napi_default, nullptr},
1144 {"hidClose", nullptr, HidClose, nullptr, nullptr, nullptr, napi_default, nullptr},
1145 {"hidWrite", nullptr, HidWrite, nullptr, nullptr, nullptr, napi_default, nullptr},
1146 {"hidReadTimeout", nullptr, HidReadTimeout, nullptr, nullptr, nullptr, napi_default, nullptr},
1147 {"hidRead", nullptr, HidRead, nullptr, nullptr, nullptr, napi_default, nullptr},
1148 {"hidSetNonBlocking", nullptr, HidSetNonBlocking, nullptr, nullptr, nullptr, napi_default, nullptr},
1149 {"hidGetRawInfo", nullptr, HidGetRawInfo, nullptr, nullptr, nullptr, napi_default, nullptr},
1150 {"hidGetRawName", nullptr, HidGetRawName, nullptr, nullptr, nullptr, napi_default, nullptr},
1151 {"hidGetPhysicalAddress", nullptr, HidGetPhysicalAddress, nullptr, nullptr, nullptr, napi_default, nullptr},
1152 {"hidGetRawUniqueId", nullptr, HidGetRawUniqueId, nullptr, nullptr, nullptr, napi_default, nullptr},
1153 {"hidSendReport", nullptr, HidSendReport, nullptr, nullptr, nullptr, napi_default, nullptr},
1154 {"hidGetReport", nullptr, HidGetReport, nullptr, nullptr, nullptr, napi_default, nullptr},
1155 {"hidGetReportDescriptor", nullptr, HidGetReportDescriptor, nullptr, nullptr, nullptr, napi_default, nullptr},
1156 {"usbSerialInit", nullptr, UsbSerialInit, nullptr, nullptr, nullptr, napi_default, nullptr},
1157 {"usbSerialRelease", nullptr, UsbSerialRelease, nullptr, nullptr, nullptr, napi_default, nullptr},
1158 {"usbSerialOpen", nullptr, UsbSerialOpen, nullptr, nullptr, nullptr, napi_default, nullptr},
1159 {"usbSerialClose", nullptr, UsbSerialClose, nullptr, nullptr, nullptr, napi_default, nullptr},
1160 {"usbSerialRead", nullptr, UsbSerialRead, nullptr, nullptr, nullptr, napi_default, nullptr},
1161 {"usbSerialWrite", nullptr, UsbSerialWrite, nullptr, nullptr, nullptr, napi_default, nullptr},
1162 {"usbSerialSetBaudRate", nullptr, UsbSerialSetBaudRate, nullptr, nullptr, nullptr, napi_default, nullptr},
1163 {"usbSerialSetParams", nullptr, UsbSerialSetParams, nullptr, nullptr, nullptr, napi_default, nullptr},
1164 {"usbSerialSetTimeout", nullptr, UsbSerialSetTimeout, nullptr, nullptr, nullptr, napi_default, nullptr},
1165 {"usbSerialSetFlowControl", nullptr, UsbSerialSetFlowControl, nullptr, nullptr, nullptr, napi_default, nullptr},
1166 {"usbSerialFlush", nullptr, UsbSerialFlush, nullptr, nullptr, nullptr, napi_default, nullptr},
1167 {"usbSerialFlushInput", nullptr, UsbSerialFlushInput, nullptr, nullptr, nullptr, napi_default, nullptr},
1168 {"usbSerialFlushOutput", nullptr, UsbSerialFlushOutput, nullptr, nullptr, nullptr, napi_default, nullptr},
1169 };
1170
1171 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1172 return exports;
1173 }
1174 EXTERN_C_END
1175
1176 static napi_module demoModule = {
1177 .nm_version = 1,
1178 .nm_flags = 0,
1179 .nm_filename = nullptr,
1180 .nm_register_func = Init,
1181 .nm_modname = "libusbddk",
1182 .nm_priv = ((void *)0),
1183 .reserved = {0},
1184 };
1185
RegisterModule(void)1186 extern "C" __attribute__((constructor)) void RegisterModule(void) { napi_module_register(&demoModule); }
1187