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 "serial_impl.h"
17
18 #include <hdf_base.h>
19 #include <hdf_log.h>
20
21 #include "hisysevent.h"
22 #include "hitrace_meter.h"
23 #include "usbd_wrapper.h"
24 #ifdef LINUX_SERIAL
25 #include "linux_serial.h"
26 #else
27 #include "libusb_serial.h"
28 #endif
29
30 #define HDF_LOG_TAG serial_interface_service
31
32 namespace OHOS {
33 namespace HDI {
34 namespace Usb {
35 namespace Serial {
36 namespace V1_0 {
37
SerialInterfaceImplGetInstance(void)38 extern "C" ISerialInterface* SerialInterfaceImplGetInstance(void)
39 {
40 using OHOS::HDI::Usb::Serial::V1_0::SerialImpl;
41 SerialImpl *service = new (std::nothrow) SerialImpl();
42 if (service == nullptr) {
43 return nullptr;
44 }
45
46 return service;
47 }
48
SerialImpl()49 SerialImpl::SerialImpl()
50 {
51 HDF_LOGI("into SerialImpl construct");
52 #ifdef LINUX_SERIAL
53 LinuxSerial::GetInstance();
54 #else
55 LibusbSerial::GetInstance();
56 #endif
57 }
58
~SerialImpl()59 SerialImpl::~SerialImpl()
60 {
61 HDF_LOGE("%{public}s:~SerialImpl", __func__);
62 }
63
SerialOpen(int32_t portId)64 int32_t SerialImpl::SerialOpen(int32_t portId)
65 {
66 HDF_LOGI("SerialImpl::SerialOpen start");
67 #ifdef LINUX_SERIAL
68 int32_t ret = LinuxSerial::GetInstance().SerialOpen(portId);
69 #else
70 int32_t ret = LibusbSerial::GetInstance().SerialOpen(portId);
71 #endif
72 if (ret != HDF_SUCCESS) {
73 HDF_LOGE("%{public}s:SerialOpen failed, ret:%{public}d", __func__, ret);
74 }
75
76 return ret;
77 }
78
SerialClose(int32_t portId)79 int32_t SerialImpl::SerialClose(int32_t portId)
80 {
81 HDF_LOGI("SerialImpl::SerialClose start");
82 #ifdef LINUX_SERIAL
83 int32_t ret = LinuxSerial::GetInstance().SerialClose(portId);
84 #else
85 int32_t ret = LibusbSerial::GetInstance().SerialClose(portId);
86 #endif
87 if (ret != HDF_SUCCESS) {
88 HDF_LOGE("%{public}s:SerialClose failed, ret:%{public}d", __func__, ret);
89 }
90
91 return ret;
92 }
93
SerialRead(int32_t portId,std::vector<uint8_t> & data,uint32_t size,uint32_t timeout)94 int32_t SerialImpl::SerialRead(int32_t portId, std::vector<uint8_t>& data, uint32_t size, uint32_t timeout)
95 {
96 StartTrace(HITRACE_TAG_HDF, "SerialRead");
97 #ifdef LINUX_SERIAL
98 int32_t ret = LinuxSerial::GetInstance().SerialRead(portId, data, size, timeout);
99 #else
100 int32_t ret = LibusbSerial::GetInstance().SerialRead(portId, data, size, timeout);
101 #endif
102 FinishTrace(HITRACE_TAG_HDF);
103 if (ret != HDF_SUCCESS) {
104 HDF_LOGE("%{public}s:SerialRead failed, ret:%{public}d", __func__, ret);
105 }
106
107 return ret;
108 }
109
SerialWrite(int32_t portId,const std::vector<uint8_t> & data,uint32_t size,uint32_t timeout)110 int32_t SerialImpl::SerialWrite(int32_t portId, const std::vector<uint8_t>& data, uint32_t size, uint32_t timeout)
111 {
112 StartTrace(HITRACE_TAG_HDF, "SerialWrite");
113 #ifdef LINUX_SERIAL
114 int32_t ret = LinuxSerial::GetInstance().SerialWrite(portId, data, size, timeout);
115 #else
116 int32_t ret = LibusbSerial::GetInstance().SerialWrite(portId, data, size, timeout);
117 #endif
118 FinishTrace(HITRACE_TAG_HDF);
119 if (ret != HDF_SUCCESS) {
120 HDF_LOGE("%{public}s:SerialWrite failed, ret:%{public}d", __func__, ret);
121 }
122
123 return ret;
124 }
125
SerialSetAttribute(int32_t portId,const SerialAttribute & attribute)126 int32_t SerialImpl::SerialSetAttribute(int32_t portId, const SerialAttribute& attribute)
127 {
128 HDF_LOGI("SerialImpl::SerialSetAttribute start");
129 #ifdef LINUX_SERIAL
130 int32_t ret = LinuxSerial::GetInstance().SerialSetAttribute(portId, attribute);
131 #else
132 int32_t ret = LibusbSerial::GetInstance().SerialSetAttribute(portId, attribute);
133 #endif
134 if (ret != HDF_SUCCESS) {
135 HDF_LOGE("%{public}s:SerialSetAttribute failed, ret:%{public}d", __func__, ret);
136 }
137
138 return ret;
139 }
140
SerialGetAttribute(int32_t portId,SerialAttribute & attribute)141 int32_t SerialImpl::SerialGetAttribute(int32_t portId, SerialAttribute& attribute)
142 {
143 HDF_LOGI("SerialImpl::SerialGetAttribute start");
144 #ifdef LINUX_SERIAL
145 int32_t ret = LinuxSerial::GetInstance().SerialGetAttribute(portId, attribute);
146 #else
147 int32_t ret = LibusbSerial::GetInstance().SerialGetAttribute(portId, attribute);
148 #endif
149 if (ret != HDF_SUCCESS) {
150 HDF_LOGE("%{public}s:SerialGetAttribute failed, ret:%{public}d", __func__, ret);
151 }
152
153 return ret;
154 }
155
SerialGetPortList(std::vector<SerialPort> & portList)156 int32_t SerialImpl::SerialGetPortList(std::vector<SerialPort>& portList)
157 {
158 HDF_LOGI("SerialImpl::SerialGetPortList start");
159 #ifdef LINUX_SERIAL
160 int32_t ret = LinuxSerial::GetInstance().SerialGetPortList(portList);
161 #else
162 int32_t ret = LibusbSerial::GetInstance().SerialGetPortList(portList);
163 #endif
164 if (ret != HDF_SUCCESS) {
165 HDF_LOGE("%{public}s:SerialGetPortList failed, ret:%{public}d", __func__, ret);
166 }
167
168 return ret;
169 }
170 } // V1_0
171 } // Serial
172 } // Usb
173 } // HDI
174 } // OHOS
175