1 /*
2 * Copyright (c) 2021 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_device_desc.h>
17 #include <hdf_device_object.h>
18 #include <hdf_log.h>
19 #include <message_parcel.h>
20 #include <osal_mem.h>
21
22 #include "hdf_sbuf_ipc.h"
23 #include "sample_hdi.h"
24
25 using OHOS::HDI::Base::SharedMemQueueMeta;
26
SampleServiceStubPing(struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)27 static int32_t SampleServiceStubPing(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
28 {
29 if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
30 return HDF_ERR_INVALID_PARAM;
31 }
32 char *outInfo = NULL;
33 const char *info = HdfSbufReadString(data);
34
35 int32_t ret = SampleHdiImplInstance()->ping(client->device, info, &outInfo);
36
37 HdfSbufWriteString(reply, outInfo);
38 OsalMemFree(outInfo);
39 return ret;
40 }
41
SampleServiceStubSum(struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)42 static int32_t SampleServiceStubSum(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
43 {
44 int32_t parm0;
45 int32_t parm1;
46 int32_t result;
47 if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
48 return HDF_ERR_INVALID_PARAM;
49 }
50 if (!HdfSbufReadInt32(data, &parm0)) {
51 HDF_LOGE("SampleHdi.sum: miss parm0");
52 return HDF_ERR_INVALID_PARAM;
53 }
54
55 if (!HdfSbufReadInt32(data, &parm1)) {
56 HDF_LOGE("SampleHdi.sum: miss parm1");
57 return HDF_ERR_INVALID_PARAM;
58 }
59
60 int32_t ret = SampleHdiImplInstance()->sum(client->device, parm0, parm1, &result);
61 if (ret == HDF_SUCCESS) {
62 if (!HdfSbufWriteInt32(reply, result)) {
63 HDF_LOGE("SampleHdi.sum: failed to write result ");
64 return HDF_FAILURE;
65 }
66 }
67
68 return ret;
69 }
70
SampleServiceStubCallback(struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)71 static int32_t SampleServiceStubCallback(struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
72 {
73 int32_t code;
74 if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
75 return HDF_ERR_INVALID_PARAM;
76 }
77 if (!HdfSbufReadInt32(data, &code)) {
78 HDF_LOGE("SampleHdi.callback: miss parameter code");
79 return HDF_ERR_INVALID_PARAM;
80 }
81
82 struct HdfRemoteService *callback = HdfSbufReadRemoteService(data);
83 if (callback == NULL) {
84 HDF_LOGE("SampleHdi.callback: miss parameter callback");
85 return HDF_ERR_INVALID_PARAM;
86 }
87 return SampleHdiImplInstance()->callback(client->device, callback, code);
88 }
89
SampleServiceStubStructTrans(struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)90 static int32_t SampleServiceStubStructTrans(
91 struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
92 {
93 HDF_LOGI("SampleServiceStubStructTrans: in");
94 if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
95 return HDF_ERR_INVALID_PARAM;
96 }
97 struct DataBlock *dataBlock = DataBlockBlockUnmarshalling(data);
98 if (dataBlock == NULL) {
99 HDF_LOGE("SampleServiceStubStructTrans: failed to read dataBlock");
100 return HDF_ERR_INVALID_PARAM;
101 }
102
103 int32_t ret = HDF_SUCCESS;
104 if (!DataBlockBlockMarshalling(dataBlock, reply)) {
105 HDF_LOGE("SampleServiceStubStructTrans: failed to write dataBlock");
106 ret = HDF_ERR_INVALID_PARAM;
107 } else {
108 HDF_LOGI("SampleServiceStubStructTrans: good return");
109 }
110 DataBlockFree(dataBlock);
111 return ret;
112 }
113
SampleServiceStubBufferTrans(struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)114 static int32_t SampleServiceStubBufferTrans(
115 struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
116 {
117 HDF_LOGI("SampleServiceStubBufferTrans: in");
118 if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
119 return HDF_ERR_INVALID_PARAM;
120 }
121 constexpr int SAMPLE_TEST_BUFFER_SIZE = 10;
122 const uint8_t *buffer = HdfSbufReadUnpadBuffer(data, SAMPLE_TEST_BUFFER_SIZE);
123 if (buffer == NULL) {
124 HDF_LOGI("SampleServiceStubBufferTrans: read buffer failed");
125 return HDF_ERR_INVALID_PARAM;
126 }
127
128 if (!HdfSbufWriteUnpadBuffer(reply, buffer, SAMPLE_TEST_BUFFER_SIZE)) {
129 HDF_LOGE("SampleServiceStubBufferTrans: failed to write buffer");
130 return HDF_ERR_INVALID_PARAM;
131 } else {
132 HDF_LOGI("SampleServiceStubBufferTrans: good return");
133 }
134
135 return HDF_SUCCESS;
136 }
137
SampleServiceRegisterDevice(struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)138 static int32_t SampleServiceRegisterDevice(
139 struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
140 {
141 if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
142 return HDF_ERR_INVALID_PARAM;
143 }
144 (void)reply;
145 const char *deviceName = HdfSbufReadString(data);
146 if (deviceName == NULL) {
147 return HDF_ERR_INVALID_PARAM;
148 }
149
150 return SampleHdiImplInstance()->registerDevice(client->device, deviceName);
151 }
152
SampleServiceUnregisterDevice(struct HdfDeviceIoClient * client,struct HdfSBuf * data,struct HdfSBuf * reply)153 static int32_t SampleServiceUnregisterDevice(
154 struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply)
155 {
156 (void)reply;
157 if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
158 return HDF_ERR_INVALID_PARAM;
159 }
160 const char *deviceName = HdfSbufReadString(data);
161 if (deviceName == NULL) {
162 return HDF_ERR_INVALID_PARAM;
163 }
164
165 return SampleHdiImplInstance()->unregisterDevice(client->device, deviceName);
166 }
167
SampleServiceUpdateDevice(struct HdfDeviceIoClient * client,struct HdfSBuf * data)168 static int32_t SampleServiceUpdateDevice(struct HdfDeviceIoClient *client, struct HdfSBuf *data)
169 {
170 if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
171 return HDF_ERR_INVALID_PARAM;
172 }
173 const char *servInfo = HdfSbufReadString(data);
174 if (servInfo == NULL) {
175 return HDF_ERR_INVALID_PARAM;
176 }
177
178 return SampleHdiImplInstance()->updateService(client->device, servInfo);
179 }
180
SampleServiceSmqTrans(struct HdfDeviceIoClient * client,struct HdfSBuf * data)181 static int32_t SampleServiceSmqTrans(struct HdfDeviceIoClient *client, struct HdfSBuf *data)
182 {
183 if (!HdfDeviceObjectCheckInterfaceDesc(client->device, data)) {
184 return HDF_ERR_INVALID_PARAM;
185 }
186 OHOS::MessageParcel *parcel = nullptr;
187 if (SbufToParcel(data, &parcel) != HDF_SUCCESS) {
188 return HDF_FAILURE;
189 }
190 std::shared_ptr<SharedMemQueueMeta<SampleSmqElement>> smqMeta =
191 SharedMemQueueMeta<SampleSmqElement>::UnMarshalling(*parcel);
192 if (smqMeta == nullptr) {
193 HDF_LOGE("failed to read smq meta form parcel");
194 return HDF_ERR_INVALID_PARAM;
195 }
196
197 uint32_t element = parcel->ReadUint32();
198
199 return SampleHdiImplInstance()->tansSmq(client->device, smqMeta.get(), element);
200 }
201
SampleServiceOnRemoteRequest(struct HdfDeviceIoClient * client,int cmdId,struct HdfSBuf * data,struct HdfSBuf * reply)202 int32_t SampleServiceOnRemoteRequest(
203 struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply)
204 {
205 HDF_LOGI("SampleServiceDispatch: cmd %{public}d", cmdId);
206 switch (cmdId) {
207 case SAMPLE_SERVICE_PING:
208 return SampleServiceStubPing(client, data, reply);
209 case SAMPLE_SERVICE_SUM:
210 return SampleServiceStubSum(client, data, reply);
211 case SAMPLE_SERVICE_CALLBACK:
212 return SampleServiceStubCallback(client, data, reply);
213 case SAMPLE_STRUCT_TRANS:
214 return SampleServiceStubStructTrans(client, data, reply);
215 case SAMPLE_BUFFER_TRANS:
216 return SampleServiceStubBufferTrans(client, data, reply);
217 case SAMPLE_REGISTER_DEVICE:
218 return SampleServiceRegisterDevice(client, data, reply);
219 case SAMPLE_UNREGISTER_DEVICE:
220 return SampleServiceUnregisterDevice(client, data, reply);
221 case SAMPLE_UPDATE_SERVIE:
222 return SampleServiceUpdateDevice(client, data);
223 case SAMPLE_TRANS_SMQ:
224 return SampleServiceSmqTrans(client, data);
225 default:
226 HDF_LOGE("SampleServiceDispatch: not support cmd %{public}d", cmdId);
227 return HDF_ERR_INVALID_PARAM;
228 }
229 }