1 /*
2 * Copyright 2020 NXP
3 * All rights reserved.
4 *
5 *
6 * SPDX-License-Identifier: BSD-3-Clause
7 */
8
9 #include "fsl_common.h"
10 #include "fsl_component_serial_manager.h"
11 #include "fsl_component_serial_port_internal.h"
12
13 #if (defined(SERIAL_PORT_TYPE_RPMSG) && (SERIAL_PORT_TYPE_RPMSG > 0U))
14 #include "fsl_adapter_rpmsg.h"
15
16 #include "fsl_component_serial_port_rpmsg.h"
17
18 /*******************************************************************************
19 * Definitions
20 ******************************************************************************/
21 #ifndef NDEBUG
22 #if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U))
23 #undef assert
24 #define assert(n)
25 #else
26 /* MISRA C-2012 Rule 17.2 */
27 #undef assert
28 #define assert(n) \
29 while (!(n)) \
30 { \
31 ; \
32 }
33 #endif
34 #endif
35
36 typedef struct _serial_rpmsg_send_state
37 {
38 serial_manager_callback_t callback;
39 void *param;
40 } serial_rpmsg_send_state_t;
41
42 typedef struct _serial_rpmsg_recv_state
43 {
44 serial_manager_callback_t callback;
45 void *param;
46 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
47 #else /* !SERIAL_MANAGER_NON_BLOCKING_MODE */
48 volatile uint8_t *data;
49 volatile uint32_t len;
50 volatile uint32_t sofar;
51 volatile uint32_t remain;
52 #endif /* SERIAL_MANAGER_NON_BLOCKING_MODE */
53 } serial_rpmsg_recv_state_t;
54
55 typedef struct _serial_rpmsg_state
56 {
57 RPMSG_HANDLE_DEFINE(rpmsgHandleBuffer);
58 serial_rpmsg_recv_state_t rx;
59 serial_rpmsg_send_state_t tx;
60 } serial_rpmsg_state_t;
61
62 /*******************************************************************************
63 * Prototypes
64 ******************************************************************************/
65
66 /*******************************************************************************
67 * Code
68 ******************************************************************************/
69
Serial_RpmsgRxCallback(void * param,uint8_t * data,uint32_t len)70 static hal_rpmsg_return_status_t Serial_RpmsgRxCallback(void *param, uint8_t *data, uint32_t len)
71 {
72 serial_rpmsg_state_t *serialRpmsgHandle;
73 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
74 serial_manager_callback_message_t msg;
75 #else /* !SERIAL_MANAGER_NON_BLOCKING_MODE */
76 uint32_t bytes;
77 #endif /* SERIAL_MANAGER_NON_BLOCKING_MODE */
78
79 if (NULL == param)
80 {
81 return kStatus_HAL_RL_RELEASE;
82 }
83
84 serialRpmsgHandle = (serial_rpmsg_state_t *)param;
85
86 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
87 /* Rx Idle */
88 if ((NULL != serialRpmsgHandle->rx.callback))
89 {
90 msg.buffer = data;
91 msg.length = len;
92 serialRpmsgHandle->rx.callback(serialRpmsgHandle->rx.param, &msg, kStatus_SerialManager_Success);
93 }
94 #else /* !SERIAL_MANAGER_NON_BLOCKING_MODE */
95 /* Receive buffer is ready */
96 if (NULL != serialRpmsgHandle->rx.data)
97 {
98 bytes = (len <= (serialRpmsgHandle->rx.len - serialRpmsgHandle->rx.sofar)) ?
99 (len) :
100 (serialRpmsgHandle->rx.len - serialRpmsgHandle->rx.sofar);
101 /* read out the last bytes */
102 (void)memcpy((uint8_t *)&serialRpmsgHandle->rx.data[serialRpmsgHandle->rx.sofar], data, bytes);
103 serialRpmsgHandle->rx.sofar += bytes;
104 if (serialRpmsgHandle->rx.len == serialRpmsgHandle->rx.sofar)
105 {
106 serialRpmsgHandle->rx.data = NULL;
107 serialRpmsgHandle->rx.remain = len - bytes;
108 }
109 }
110 #endif /* SERIAL_MANAGER_NON_BLOCKING_MODE */
111 return kStatus_HAL_RL_RELEASE;
112 }
113
Serial_RpmsgInit(serial_handle_t serialHandle,void * serialConfig)114 serial_manager_status_t Serial_RpmsgInit(serial_handle_t serialHandle, void *serialConfig)
115 {
116 serial_rpmsg_state_t *serialRpmsgHandle;
117 serial_manager_config_t *serialRpmsgConfig;
118
119 assert(serialConfig);
120 assert(serialHandle);
121
122 serialRpmsgHandle = (serial_rpmsg_state_t *)serialHandle;
123 serialRpmsgConfig = (serial_manager_config_t *)serialConfig;
124
125 if (kStatus_HAL_RpmsgSuccess != HAL_RpmsgInit((hal_rpmsg_handle_t)serialRpmsgHandle->rpmsgHandleBuffer,
126 (hal_rpmsg_config_t *)serialRpmsgConfig->portConfig))
127 {
128 return kStatus_SerialManager_Error;
129 }
130
131 if (kStatus_HAL_RpmsgSuccess != HAL_RpmsgInstallRxCallback((hal_rpmsg_handle_t)serialRpmsgHandle->rpmsgHandleBuffer,
132 Serial_RpmsgRxCallback, serialHandle))
133 {
134 return kStatus_SerialManager_Error;
135 }
136
137 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
138 #endif /* SERIAL_MANAGER_NON_BLOCKING_MODE */
139
140 return kStatus_SerialManager_Success;
141 }
142
Serial_RpmsgDeinit(serial_handle_t serialHandle)143 serial_manager_status_t Serial_RpmsgDeinit(serial_handle_t serialHandle)
144 {
145 serial_rpmsg_state_t *serialRpmsgHandle;
146
147 assert(serialHandle);
148
149 serialRpmsgHandle = (serial_rpmsg_state_t *)serialHandle;
150
151 (void)HAL_RpmsgDeinit((hal_rpmsg_handle_t)serialRpmsgHandle->rpmsgHandleBuffer);
152
153 return kStatus_SerialManager_Success;
154 }
155
156 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
157
Serial_RpmsgWrite(serial_handle_t serialHandle,uint8_t * buffer,uint32_t length)158 serial_manager_status_t Serial_RpmsgWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
159 {
160 serial_manager_callback_message_t msg;
161 serial_rpmsg_state_t *serialRpmsgHandle;
162
163 assert(serialHandle);
164 assert(buffer);
165 assert(length);
166
167 serialRpmsgHandle = (serial_rpmsg_state_t *)serialHandle;
168
169 if (kStatus_HAL_RpmsgSuccess !=
170 HAL_RpmsgSend((hal_rpmsg_handle_t)serialRpmsgHandle->rpmsgHandleBuffer, buffer, length))
171 {
172 return kStatus_SerialManager_Error;
173 }
174
175 if (NULL != serialRpmsgHandle->tx.callback)
176 {
177 msg.buffer = buffer;
178 msg.length = length;
179 serialRpmsgHandle->tx.callback(serialRpmsgHandle->tx.param, &msg, kStatus_SerialManager_Success);
180 }
181
182 return kStatus_SerialManager_Success;
183 }
184
Serial_RpmsgWriteBlocking(serial_handle_t serialHandle,uint8_t * buffer,uint32_t length)185 serial_manager_status_t Serial_RpmsgWriteBlocking(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
186 {
187 serial_rpmsg_state_t *serialRpmsgHandle;
188
189 assert(serialHandle);
190 assert(buffer);
191 assert(length);
192
193 serialRpmsgHandle = (serial_rpmsg_state_t *)serialHandle;
194
195 if (kStatus_HAL_RpmsgSuccess !=
196 HAL_RpmsgSend((hal_rpmsg_handle_t)serialRpmsgHandle->rpmsgHandleBuffer, buffer, length))
197 {
198 return kStatus_SerialManager_Error;
199 }
200
201 return kStatus_SerialManager_Success;
202 }
203
204 #else /* !SERIAL_MANAGER_NON_BLOCKING_MODE */
205
Serial_RpmsgWrite(serial_handle_t serialHandle,uint8_t * buffer,uint32_t length)206 serial_manager_status_t Serial_RpmsgWrite(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
207 {
208 serial_rpmsg_state_t *serialRpmsgHandle;
209
210 assert(serialHandle);
211 assert(buffer);
212 assert(length);
213
214 serialRpmsgHandle = (serial_rpmsg_state_t *)serialHandle;
215
216 if (kStatus_HAL_RpmsgSuccess !=
217 HAL_RpmsgSend((hal_rpmsg_handle_t)serialRpmsgHandle->rpmsgHandleBuffer, buffer, length))
218 {
219 return kStatus_SerialManager_Error;
220 }
221
222 return kStatus_SerialManager_Success;
223 }
224
Serial_RpmsgRead(serial_handle_t serialHandle,uint8_t * buffer,uint32_t length)225 serial_manager_status_t Serial_RpmsgRead(serial_handle_t serialHandle, uint8_t *buffer, uint32_t length)
226 {
227 serial_rpmsg_state_t *serialRpmsgHandle;
228
229 assert(serialHandle);
230 assert(buffer);
231 assert(length);
232
233 serialRpmsgHandle = (serial_rpmsg_state_t *)serialHandle;
234
235 serialRpmsgHandle->rx.data = buffer;
236 serialRpmsgHandle->rx.len = length;
237 serialRpmsgHandle->rx.sofar = 0;
238
239 while (serialRpmsgHandle->rx.sofar < serialRpmsgHandle->rx.len)
240 ;
241
242 if (0U < serialRpmsgHandle->rx.remain)
243 {
244 /* The received bytes not equal to request. */
245 return kStatus_SerialManager_Error;
246 }
247
248 return kStatus_SerialManager_Success;
249 }
250 #endif /* SERIAL_MANAGER_NON_BLOCKING_MODE */
251
252 #if (defined(SERIAL_MANAGER_NON_BLOCKING_MODE) && (SERIAL_MANAGER_NON_BLOCKING_MODE > 0U))
Serial_RpmsgCancelWrite(serial_handle_t serialHandle)253 serial_manager_status_t Serial_RpmsgCancelWrite(serial_handle_t serialHandle)
254 {
255 assert(serialHandle);
256
257 return kStatus_SerialManager_Success;
258 }
259
Serial_RpmsgInstallTxCallback(serial_handle_t serialHandle,serial_manager_callback_t callback,void * callbackParam)260 serial_manager_status_t Serial_RpmsgInstallTxCallback(serial_handle_t serialHandle,
261 serial_manager_callback_t callback,
262 void *callbackParam)
263 {
264 serial_rpmsg_state_t *serialRpmsgHandle;
265
266 assert(serialHandle);
267
268 serialRpmsgHandle = (serial_rpmsg_state_t *)serialHandle;
269
270 serialRpmsgHandle->tx.callback = callback;
271 serialRpmsgHandle->tx.param = callbackParam;
272
273 return kStatus_SerialManager_Success;
274 }
275
Serial_RpmsgInstallRxCallback(serial_handle_t serialHandle,serial_manager_callback_t callback,void * callbackParam)276 serial_manager_status_t Serial_RpmsgInstallRxCallback(serial_handle_t serialHandle,
277 serial_manager_callback_t callback,
278 void *callbackParam)
279 {
280 serial_rpmsg_state_t *serialRpmsgHandle;
281
282 assert(serialHandle);
283
284 serialRpmsgHandle = (serial_rpmsg_state_t *)serialHandle;
285
286 serialRpmsgHandle->rx.callback = callback;
287 serialRpmsgHandle->rx.param = callbackParam;
288
289 return kStatus_SerialManager_Success;
290 }
291 #endif /* SERIAL_MANAGER_NON_BLOCKING_MODE */
292
Serial_RpmsgEnterLowpower(serial_handle_t serialHandle)293 serial_manager_status_t Serial_RpmsgEnterLowpower(serial_handle_t serialHandle)
294 {
295 serial_rpmsg_state_t *serialRpmsgHandle;
296
297 assert(serialHandle);
298
299 serialRpmsgHandle = (serial_rpmsg_state_t *)serialHandle;
300
301 if (kStatus_HAL_RpmsgSuccess != HAL_RpmsgEnterLowpower((hal_rpmsg_handle_t)serialRpmsgHandle->rpmsgHandleBuffer))
302 {
303 return kStatus_SerialManager_Error;
304 }
305
306 return kStatus_SerialManager_Success;
307 }
308
Serial_RpmsgExitLowpower(serial_handle_t serialHandle)309 serial_manager_status_t Serial_RpmsgExitLowpower(serial_handle_t serialHandle)
310 {
311 serial_rpmsg_state_t *serialRpmsgHandle;
312 assert(serialHandle);
313
314 serialRpmsgHandle = (serial_rpmsg_state_t *)serialHandle;
315
316 if (kStatus_HAL_RpmsgSuccess != HAL_RpmsgExitLowpower((hal_rpmsg_handle_t)serialRpmsgHandle->rpmsgHandleBuffer))
317 {
318 return kStatus_SerialManager_Error;
319 }
320
321 return kStatus_SerialManager_Success;
322 }
323
324 #endif
325
