1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #include "gpio_if.h"
10 #include "gpio/gpio_service.h"
11 #include "hdf_base.h"
12 #include "hdf_io_service_if.h"
13 #include "platform_core.h"
14
15 #define PLAT_LOG_TAG gpio_if_u
16
GpioManagerServiceGet(void)17 static void *GpioManagerServiceGet(void)
18 {
19 static void *manager = NULL;
20
21 if (manager != NULL) {
22 return manager;
23 }
24 manager = (void *)HdfIoServiceBind("HDF_PLATFORM_GPIO_MANAGER");
25 if (manager == NULL) {
26 HDF_LOGE("%s: fail to get gpio manager service!", __func__);
27 }
28 return manager;
29 }
30
GpioRead(uint16_t gpio,uint16_t * val)31 int32_t GpioRead(uint16_t gpio, uint16_t *val)
32 {
33 int32_t ret;
34 struct HdfIoService *service = NULL;
35 struct HdfSBuf *data = NULL;
36 struct HdfSBuf *reply = NULL;
37
38 service = (struct HdfIoService *)GpioManagerServiceGet();
39 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
40 HDF_LOGE("%s: get gpio manager service fail!", __func__);
41 return HDF_PLT_ERR_DEV_GET;
42 }
43
44 data = HdfSbufObtainDefaultSize();
45 if (data == NULL) {
46 HDF_LOGE("%s: fail to obtain data", __func__);
47 return HDF_ERR_MALLOC_FAIL;
48 }
49
50 reply = HdfSbufObtainDefaultSize();
51 if (reply == NULL) {
52 HDF_LOGE("%s: fail to obtain reply", __func__);
53 HdfSbufRecycle(data);
54 return HDF_ERR_MALLOC_FAIL;
55 }
56
57 if (!HdfSbufWriteUint16(data, (uint16_t)gpio)) {
58 HDF_LOGE("%s: write gpio number fail!", __func__);
59 HdfSbufRecycle(data);
60 HdfSbufRecycle(reply);
61 return HDF_ERR_IO;
62 }
63
64 ret = service->dispatcher->Dispatch(&service->object, GPIO_IO_READ, data, reply);
65 if (ret != HDF_SUCCESS) {
66 HDF_LOGE("%s: service call fail:%d", __func__, ret);
67 HdfSbufRecycle(data);
68 HdfSbufRecycle(reply);
69 return ret;
70 }
71
72 if (!HdfSbufReadUint16(reply, val)) {
73 HDF_LOGE("%s: read sbuf fail", __func__);
74 HdfSbufRecycle(data);
75 HdfSbufRecycle(reply);
76 return HDF_ERR_IO;
77 }
78
79 HdfSbufRecycle(data);
80 HdfSbufRecycle(reply);
81 return HDF_SUCCESS;
82 }
83
GpioWrite(uint16_t gpio,uint16_t val)84 int32_t GpioWrite(uint16_t gpio, uint16_t val)
85 {
86 int32_t ret;
87 struct HdfIoService *service = NULL;
88 struct HdfSBuf *data = NULL;
89
90 service = (struct HdfIoService *)GpioManagerServiceGet();
91 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
92 HDF_LOGE("%s: get gpio manager service fail!", __func__);
93 return HDF_PLT_ERR_DEV_GET;
94 }
95
96 data = HdfSbufObtainDefaultSize();
97 if (data == NULL) {
98 HDF_LOGE("%s: fail to obtain data", __func__);
99 return HDF_ERR_MALLOC_FAIL;
100 }
101
102 if (!HdfSbufWriteUint16(data, (uint16_t)gpio)) {
103 HDF_LOGE("%s: write gpio number fail!", __func__);
104 HdfSbufRecycle(data);
105 return HDF_ERR_IO;
106 }
107
108 if (!HdfSbufWriteUint16(data, (uint16_t)val)) {
109 HDF_LOGE("%s: write gpio value fail!", __func__);
110 HdfSbufRecycle(data);
111 return HDF_ERR_IO;
112 }
113
114 ret = service->dispatcher->Dispatch(&service->object, GPIO_IO_WRITE, data, NULL);
115 if (ret != HDF_SUCCESS) {
116 HDF_LOGE("%s: service call fail:%d", __func__, ret);
117 HdfSbufRecycle(data);
118 return ret;
119 }
120
121 HdfSbufRecycle(data);
122 return HDF_SUCCESS;
123 }
124
GpioGetDir(uint16_t gpio,uint16_t * dir)125 int32_t GpioGetDir(uint16_t gpio, uint16_t *dir)
126 {
127 int32_t ret;
128 struct HdfIoService *service = NULL;
129 struct HdfSBuf *data = NULL;
130 struct HdfSBuf *reply = NULL;
131
132 if (dir == NULL) {
133 HDF_LOGE("%s: dir is NULL", __func__);
134 return HDF_ERR_INVALID_OBJECT;
135 }
136
137 service = (struct HdfIoService *)GpioManagerServiceGet();
138 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
139 HDF_LOGE("%s: get gpio manager service fail!", __func__);
140 return HDF_PLT_ERR_DEV_GET;
141 }
142
143 data = HdfSbufObtainDefaultSize();
144 if (data == NULL) {
145 HDF_LOGE("%s: fail to obtain data", __func__);
146 return HDF_ERR_MALLOC_FAIL;
147 }
148
149 reply = HdfSbufObtainDefaultSize();
150 if (reply == NULL) {
151 HDF_LOGE("%s: fail to obtain reply", __func__);
152 HdfSbufRecycle(data);
153 return HDF_ERR_MALLOC_FAIL;
154 }
155
156 if (!HdfSbufWriteUint16(data, (uint16_t)gpio)) {
157 HDF_LOGE("%s: write gpio number fail!", __func__);
158 HdfSbufRecycle(data);
159 HdfSbufRecycle(reply);
160 return HDF_ERR_IO;
161 }
162
163 ret = service->dispatcher->Dispatch(&service->object, GPIO_IO_GETDIR, data, reply);
164 if (ret != HDF_SUCCESS) {
165 HDF_LOGE("%s: service call fail:%d", __func__, ret);
166 HdfSbufRecycle(data);
167 HdfSbufRecycle(reply);
168 return ret;
169 }
170
171 if (!HdfSbufReadUint16(reply, dir)) {
172 HDF_LOGE("%s: read sbuf fail", __func__);
173 HdfSbufRecycle(data);
174 HdfSbufRecycle(reply);
175 return HDF_ERR_IO;
176 }
177
178 HdfSbufRecycle(data);
179 HdfSbufRecycle(reply);
180 return HDF_SUCCESS;
181 }
182
GpioSetDir(uint16_t gpio,uint16_t dir)183 int32_t GpioSetDir(uint16_t gpio, uint16_t dir)
184 {
185 int32_t ret;
186 struct HdfIoService *service = NULL;
187 struct HdfSBuf *data = NULL;
188
189 service = (struct HdfIoService *)GpioManagerServiceGet();
190 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
191 HDF_LOGE("%s: get gpio manager service fail!", __func__);
192 return HDF_PLT_ERR_DEV_GET;
193 }
194
195 data = HdfSbufObtainDefaultSize();
196 if (data == NULL) {
197 HDF_LOGE("%s: fail to obtain data", __func__);
198 return HDF_ERR_MALLOC_FAIL;
199 }
200
201 if (!HdfSbufWriteUint16(data, (uint16_t)gpio)) {
202 HDF_LOGE("%s: write gpio number fail!", __func__);
203 HdfSbufRecycle(data);
204 return HDF_ERR_IO;
205 }
206
207 if (!HdfSbufWriteUint16(data, (uint16_t)dir)) {
208 HDF_LOGE("%s: write gpio value fail!", __func__);
209 HdfSbufRecycle(data);
210 return HDF_ERR_IO;
211 }
212
213 ret = service->dispatcher->Dispatch(&service->object, GPIO_IO_SETDIR, data, NULL);
214 if (ret != HDF_SUCCESS) {
215 HDF_LOGE("%s: service call fail:%d", __func__, ret);
216 HdfSbufRecycle(data);
217 return ret;
218 }
219
220 HdfSbufRecycle(data);
221 return HDF_SUCCESS;
222 }
GpioSetIrq(uint16_t gpio,uint16_t mode,GpioIrqFunc func,void * arg)223 int32_t GpioSetIrq(uint16_t gpio, uint16_t mode, GpioIrqFunc func, void *arg)
224 {
225 int32_t ret;
226 struct HdfIoService *service = NULL;
227 struct HdfSBuf *data = NULL;
228 (void) func;
229 (void) arg;
230
231 service = (struct HdfIoService *)GpioManagerServiceGet();
232 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
233 HDF_LOGE("%s: get gpio manager service fail!", __func__);
234 return HDF_PLT_ERR_DEV_GET;
235 }
236
237 data = HdfSbufObtainDefaultSize();
238 if (data == NULL) {
239 HDF_LOGE("%s: fail to obtain data", __func__);
240 return HDF_ERR_MALLOC_FAIL;
241 }
242
243 if (!HdfSbufWriteUint16(data, gpio)) {
244 HDF_LOGE("%s: write gpio number fail!", __func__);
245 HdfSbufRecycle(data);
246 return HDF_ERR_IO;
247 }
248
249 if (!HdfSbufWriteUint16(data, mode)) {
250 HDF_LOGE("%s: write gpio mode fail!", __func__);
251 HdfSbufRecycle(data);
252 return HDF_ERR_IO;
253 }
254
255 ret = service->dispatcher->Dispatch(&service->object, GPIO_IO_SETIRQ, data, NULL);
256 if (ret != HDF_SUCCESS) {
257 HDF_LOGE("%s: service call fail:%d", __func__, ret);
258 HdfSbufRecycle(data);
259 return ret;
260 }
261
262 HdfSbufRecycle(data);
263 return HDF_SUCCESS;
264 }
265
GpioUnsetIrq(uint16_t gpio,void * arg)266 int32_t GpioUnsetIrq(uint16_t gpio, void *arg)
267 {
268 int32_t ret;
269 struct HdfIoService *service = NULL;
270 struct HdfSBuf *data = NULL;
271 (void) arg;
272 service = (struct HdfIoService *)GpioManagerServiceGet();
273 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
274 HDF_LOGE("%s: get gpio manager service fail!", __func__);
275 return HDF_PLT_ERR_DEV_GET;
276 }
277
278 data = HdfSbufObtainDefaultSize();
279 if (data == NULL) {
280 HDF_LOGE("%s: fail to obtain data", __func__);
281 return HDF_ERR_MALLOC_FAIL;
282 }
283
284 if (!HdfSbufWriteUint16(data, gpio)) {
285 HDF_LOGE("%s: write gpio number fail!", __func__);
286 HdfSbufRecycle(data);
287 return HDF_ERR_IO;
288 }
289
290 ret = service->dispatcher->Dispatch(&service->object, GPIO_IO_UNSETIRQ, data, NULL);
291 if (ret != HDF_SUCCESS) {
292 HDF_LOGE("%s: service call fail:%d", __func__, ret);
293 HdfSbufRecycle(data);
294 return ret;
295 }
296
297 HdfSbufRecycle(data);
298 return HDF_SUCCESS;
299 }
300
GpioEnableIrq(uint16_t gpio)301 int32_t GpioEnableIrq(uint16_t gpio)
302 {
303 int32_t ret;
304 struct HdfIoService *service = NULL;
305 struct HdfSBuf *data = NULL;
306
307 service = (struct HdfIoService *)GpioManagerServiceGet();
308 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
309 HDF_LOGE("%s: get gpio manager service fail!", __func__);
310 return HDF_PLT_ERR_DEV_GET;
311 }
312
313 data = HdfSbufObtainDefaultSize();
314 if (data == NULL) {
315 HDF_LOGE("%s: fail to obtain data", __func__);
316 return HDF_ERR_MALLOC_FAIL;
317 }
318
319 if (!HdfSbufWriteUint16(data, (uint16_t)gpio)) {
320 HDF_LOGE("%s: write gpio number fail!", __func__);
321 HdfSbufRecycle(data);
322 return HDF_ERR_IO;
323 }
324
325 ret = service->dispatcher->Dispatch(&service->object, GPIO_IO_ENABLEIRQ, data, NULL);
326 if (ret != HDF_SUCCESS) {
327 HDF_LOGE("%s: service call fail:%d", __func__, ret);
328 HdfSbufRecycle(data);
329 return ret;
330 }
331
332 HdfSbufRecycle(data);
333 return HDF_SUCCESS;
334 }
335
GpioDisableIrq(uint16_t gpio)336 int32_t GpioDisableIrq(uint16_t gpio)
337 {
338 int32_t ret;
339 struct HdfIoService *service = NULL;
340 struct HdfSBuf *data = NULL;
341
342 service = (struct HdfIoService *)GpioManagerServiceGet();
343 if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) {
344 HDF_LOGE("%s: get gpio manager service fail!", __func__);
345 return HDF_PLT_ERR_DEV_GET;
346 }
347
348 data = HdfSbufObtainDefaultSize();
349 if (data == NULL) {
350 HDF_LOGE("%s: fail to obtain data", __func__);
351 return HDF_ERR_MALLOC_FAIL;
352 }
353
354 if (!HdfSbufWriteUint16(data, (uint16_t)gpio)) {
355 HDF_LOGE("%s: write gpio number fail!", __func__);
356 HdfSbufRecycle(data);
357 return HDF_ERR_IO;
358 }
359
360 ret = service->dispatcher->Dispatch(&service->object, GPIO_IO_DISABLEIRQ, data, NULL);
361 if (ret != HDF_SUCCESS) {
362 HDF_LOGE("%s: service call fail:%d", __func__, ret);
363 HdfSbufRecycle(data);
364 return ret;
365 }
366
367 HdfSbufRecycle(data);
368 return HDF_SUCCESS;
369 }
370