1 /*
2 * Copyright 2020, 2022-2023 NXP
3 * All rights reserved.
4 *
5 *
6 * SPDX-License-Identifier: BSD-3-Clause
7 */
8
9 #include "fsl_common.h"
10 #include "rpmsg_lite.h"
11 #include "fsl_component_generic_list.h"
12 #include "fsl_adapter_rpmsg.h"
13 #include "mcmgr.h"
14
15 /*******************************************************************************
16 * Definitions
17 ******************************************************************************/
18 /* Weak function. */
19 #if defined(__GNUC__)
20 #define __WEAK_FUNC __attribute__((weak))
21 #elif defined(__ICCARM__)
22 #define __WEAK_FUNC __weak
23 #elif defined(__CC_ARM) || defined(__ARMCC_VERSION)
24 #define __WEAK_FUNC __attribute__((weak))
25 #elif defined(__DSC__) || defined(__CW__)
26 #define __WEAK_FUNC __attribute__((weak))
27 #endif
28
29 typedef struct _hal_rpmsg_rx_state
30 {
31 rpmsg_rx_callback_t callback;
32 void *param;
33 } hal_rpmsg_rx_state_t;
34
35 /*! @brief rpmsg state structure. */
36 typedef struct _hal_rpmsg_state
37 {
38 uint8_t local_addr;
39 uint8_t remote_addr;
40 volatile uint8_t rpmsg_lite_peer_ept_is_ready;
41 #if defined(RL_USE_STATIC_API) && (RL_USE_STATIC_API == 1)
42 struct rpmsg_lite_ept_static_context endpoint;
43 #endif
44 struct rpmsg_lite_endpoint *pEndpoint;
45 hal_rpmsg_rx_state_t rx;
46 } hal_rpmsg_state_t;
47
48 typedef struct _hal_rpmsg_peer_ept_state
49 {
50 list_element_t link;
51 hal_rpmsg_state_t *rpmsgHandle;
52 } hal_rpmsg_peer_ept_state;
53
54 #ifndef RPMSG_GLOBAL_VARIABLE_ALLOC
55 #if (defined(HAL_RPMSG_SELECT_ROLE) && (HAL_RPMSG_SELECT_ROLE == 0U))
56 #define SH_MEM_TOTAL_SIZE (6144U)
57 #if defined(__ICCARM__) /* IAR Workbench */
58 #pragma location = "rpmsg_sh_mem_section"
59 static char rpmsg_lite_base[SH_MEM_TOTAL_SIZE];
60 #elif defined(__CC_ARM) || defined(__ARMCC_VERSION) /* Keil MDK */
61 static char rpmsg_lite_base[SH_MEM_TOTAL_SIZE] __attribute__((section("rpmsg_sh_mem_section")));
62 #elif defined(__GNUC__)
63 static char rpmsg_lite_base[SH_MEM_TOTAL_SIZE] __attribute__((section(".noinit.$rpmsg_sh_mem")));
64 #else
65 #error "RPMsg: Please provide your definition of rpmsg_lite_base[]!"
66 #endif
67 #endif /* HAL_RPMSG_SELECT_ROLE */
68
69 extern uint32_t rpmsg_sh_mem_start[];
70 extern uint32_t rpmsg_sh_mem_end[];
71 #else
72
73 #if (defined(HAL_RPMSG_SELECT_ROLE) && (HAL_RPMSG_SELECT_ROLE == 0U))
74 #define SH_MEM_TOTAL_SIZE (6144U)
75 extern char *rpmsg_lite_base;
76 #endif /* HAL_RPMSG_SELECT_ROLE */
77
78 extern uint32_t rpmsg_sh_mem_start[];
79 extern uint32_t rpmsg_sh_mem_end[];
80 #endif /* RPMSG_GLOBAL_VARIABLE_ALLOC */
81
82 #define RPMSG_LITE_LINK_ID (0U)
83
84 #define APP_RPMSG_COREUP_EVENT_DATA (0U)
85 #define APP_RPMSG_READY_EVENT_DATA (1U)
86 #define APP_RPMSG_EP_READY_EVENT_DATA (2U)
87
88 #ifndef RPMSG_REMOTE_READY_RETRY_COUNT
89 #define RPMSG_REMOTE_READY_RETRY_COUNT 10000000U
90 #endif
91
92 static int32_t s_rpmsgEptCount = -1;
93 static uint8_t s_peerRpmsgEptCount = 0U;
94 static struct rpmsg_lite_instance *s_rpmsgContext = NULL;
95 #if defined(RL_USE_STATIC_API) && (RL_USE_STATIC_API == 1)
96 static struct rpmsg_lite_instance s_context = {0};
97 #endif
98 static uint8_t s_rpmsg_init_golbal = 0U;
99 static list_label_t s_rpmsgEpList = {0};
100 static volatile uint8_t s_rpmsgPeerEptData[MAX_EP_COUNT] = {0};
101 static hal_rpmsg_peer_ept_state s_rpmsgPeerEptStat[MAX_EP_COUNT] = {0};
102 /*******************************************************************************
103 * Code
104 ******************************************************************************/
105 /*
106 * This function is used for periodic check if the rpmsg endpoint is ready, and will be called in rpmsg send..
107 * RPMsg_EpReadyTimeDelay is a weak function, so it could be re-implemented by
108 * upper layer.
109 */
110 __WEAK_FUNC void RPMsg_EpReadyTimeDelay(uint32_t ms);
RPMsg_EpReadyTimeDelay(uint32_t ms)111 __WEAK_FUNC void RPMsg_EpReadyTimeDelay(uint32_t ms)
112 {
113 /* Reserved*/
114 }
115 #if 0 /* Reserved API */
116 static uint16_t rpmsg_lite_recv_ack_flag;
117
118 void rpmsg_ack_init(void)
119 {
120 rpmsg_lite_recv_ack_flag = 0U;
121 (void)MCMGR_RegisterEvent(kMCMGR_RemoteApplicationEvent, RPMsgPeerReadyEventHandler,
122 (void *)&rpmsg_lite_recv_ack_flag);
123 }
124
125 void rpmsg_recv_ack(void)
126 {
127 (void)MCMGR_TriggerEvent(kMCMGR_RemoteApplicationEvent, 1U);
128 }
129
130 void rpmsg_wait_ack(void)
131 {
132 while (1U != rpmsg_lite_recv_ack_flag)
133 ;
134 }
135 #endif /* Reserved API */
136
rpmsg_ept_read_cb(void * payload,uint32_t payload_len,uint32_t src,void * priv)137 static int32_t rpmsg_ept_read_cb(void *payload, uint32_t payload_len, uint32_t src, void *priv)
138 {
139 hal_rpmsg_state_t *rpmsgHandle;
140
141 rpmsgHandle = (hal_rpmsg_state_t *)priv;
142 assert(NULL != rpmsgHandle->rx.callback);
143
144 return rpmsgHandle->rx.callback(rpmsgHandle->rx.param, payload, payload_len);
145 }
146
RPMsgPeerReadyEventHandler(uint16_t eventData,void * context)147 static void RPMsgPeerReadyEventHandler(uint16_t eventData, void *context)
148 {
149 uint16_t *data = (uint16_t *)context;
150 list_element_handle_t list_element;
151 hal_rpmsg_peer_ept_state *rpmsgPeerEptState;
152 uint8_t address = 0U;
153
154 if ((eventData & 0xff00U) == APP_RPMSG_EP_READY_EVENT_DATA << 0x8U)
155 {
156 address = eventData & 0xffU;
157 s_rpmsgPeerEptData[s_peerRpmsgEptCount++] = address;
158 }
159
160 list_element = LIST_GetHead(&s_rpmsgEpList);
161 while (NULL != list_element)
162 {
163 rpmsgPeerEptState = (hal_rpmsg_peer_ept_state *)(void *)list_element;
164
165 if (rpmsgPeerEptState->rpmsgHandle->remote_addr == address)
166 {
167 rpmsgPeerEptState->rpmsgHandle->rpmsg_lite_peer_ept_is_ready = 1U;
168 }
169 list_element = LIST_GetNext(list_element);
170 }
171
172 *data = eventData;
173 }
174
175 #if (defined(HAL_RPMSG_SELECT_ROLE) && (HAL_RPMSG_SELECT_ROLE == 0U))
HAL_RpmsgMcmgrMasterInit(void)176 static hal_rpmsg_status_t HAL_RpmsgMcmgrMasterInit(void)
177 {
178 static volatile uint16_t RPMsgRemoteReadyEventData = 0;
179 volatile uint32_t timeout = RPMSG_REMOTE_READY_RETRY_COUNT;
180
181 if (0 > s_rpmsgEptCount)
182 {
183 if (0U == s_rpmsg_init_golbal)
184 {
185 s_rpmsg_init_golbal = 1U;
186 LIST_Init((&s_rpmsgEpList), 0);
187 (void)MCMGR_RegisterEvent(kMCMGR_RemoteApplicationEvent, RPMsgPeerReadyEventHandler,
188 (void *)&RPMsgRemoteReadyEventData);
189 (void)MCMGR_Init();
190 if (MCMGR_StartCore(kMCMGR_Core1, (void *)(char *)REMOTE_CORE_BOOT_ADDRESS, 2, kMCMGR_Start_Asynchronous) !=
191 kStatus_MCMGR_Success)
192 {
193 return kStatus_HAL_RpmsgError;
194 }
195 }
196
197 while ((APP_RPMSG_READY_EVENT_DATA != RPMsgRemoteReadyEventData) && (--timeout != 0u))
198 {
199 };
200 RPMsgRemoteReadyEventData = 0;
201 if (timeout == 0u)
202 {
203 return kStatus_HAL_RpmsgTimeout;
204 }
205
206 /* Master init */
207 #if defined(RL_USE_STATIC_API) && (RL_USE_STATIC_API == 1)
208 s_rpmsgContext = rpmsg_lite_master_init((void *)rpmsg_lite_base, SH_MEM_TOTAL_SIZE, RPMSG_LITE_LINK_ID,
209 RL_NO_FLAGS, &s_context);
210 #else
211 s_rpmsgContext =
212 rpmsg_lite_master_init((void *)rpmsg_lite_base, SH_MEM_TOTAL_SIZE, RPMSG_LITE_LINK_ID, RL_NO_FLAGS);
213 #endif
214 if (RL_NULL == s_rpmsgContext)
215 {
216 return kStatus_HAL_RpmsgError;
217 }
218
219 s_rpmsgEptCount = 0;
220 }
221
222 return kStatus_HAL_RpmsgSuccess;
223 }
HAL_RpmsgMasterInit(hal_rpmsg_handle_t handle,hal_rpmsg_config_t * config)224 static hal_rpmsg_status_t HAL_RpmsgMasterInit(hal_rpmsg_handle_t handle, hal_rpmsg_config_t *config)
225 {
226 hal_rpmsg_state_t *rpmsgHandle;
227 rpmsgHandle = (hal_rpmsg_state_t *)handle;
228
229 rpmsgHandle->local_addr = config->local_addr;
230 rpmsgHandle->remote_addr = config->remote_addr;
231
232 rpmsgHandle->rx.callback = NULL;
233 rpmsgHandle->rx.param = NULL;
234 #if defined(RL_USE_STATIC_API) && (RL_USE_STATIC_API == 1)
235 rpmsgHandle->pEndpoint = rpmsg_lite_create_ept(s_rpmsgContext, rpmsgHandle->local_addr, rpmsg_ept_read_cb,
236 rpmsgHandle, &rpmsgHandle->endpoint);
237 #else
238 rpmsgHandle->pEndpoint =
239 rpmsg_lite_create_ept(s_rpmsgContext, rpmsgHandle->local_addr, rpmsg_ept_read_cb, rpmsgHandle);
240 #endif
241 if (RL_NULL == rpmsgHandle->pEndpoint)
242 {
243 return kStatus_HAL_RpmsgError;
244 }
245
246 return kStatus_HAL_RpmsgSuccess;
247 }
248 #endif /* HAL_RPMSG_SELECT_ROLE */
249
250 #if (defined(HAL_RPMSG_SELECT_ROLE) && (HAL_RPMSG_SELECT_ROLE == 1U))
HAL_RpmsgMcmgrRemoteInit()251 static hal_rpmsg_status_t HAL_RpmsgMcmgrRemoteInit()
252 {
253 uint32_t startupData;
254 mcmgr_status_t status;
255 volatile static uint16_t RPMsgRemoteReadyEventData = 0;
256
257 if (0 > s_rpmsgEptCount)
258 {
259 if (0U == s_rpmsg_init_golbal)
260 {
261 LIST_Init((&s_rpmsgEpList), 0);
262 s_rpmsg_init_golbal = 1U;
263 (void)MCMGR_RegisterEvent(kMCMGR_RemoteApplicationEvent, RPMsgPeerReadyEventHandler,
264 (void *)&RPMsgRemoteReadyEventData);
265 (void)MCMGR_Init();
266 do
267 {
268 status = MCMGR_GetStartupData(&startupData);
269 } while (status != kStatus_MCMGR_Success);
270 }
271 #if defined(RL_USE_STATIC_API) && (RL_USE_STATIC_API == 1)
272 s_rpmsgContext =
273 rpmsg_lite_remote_init((void *)(char *)rpmsg_sh_mem_start, RPMSG_LITE_LINK_ID, RL_NO_FLAGS, &s_context);
274 #else
275 s_rpmsgContext = rpmsg_lite_remote_init((void *)(char *)rpmsg_sh_mem_start, RPMSG_LITE_LINK_ID, RL_NO_FLAGS);
276
277 #endif
278 if (RL_NULL == s_rpmsgContext)
279 {
280 return kStatus_HAL_RpmsgError;
281 }
282
283 /* Trigger event notify master */
284 (void)MCMGR_TriggerEvent(kMCMGR_RemoteApplicationEvent, APP_RPMSG_READY_EVENT_DATA);
285 do
286 {
287 } while (RL_TRUE != rpmsg_lite_is_link_up(s_rpmsgContext));
288
289 /* rpmsg initialized */
290 s_rpmsgEptCount = 0;
291 }
292 return kStatus_HAL_RpmsgSuccess;
293 }
HAL_RpmsgRemoteInit(hal_rpmsg_handle_t handle,hal_rpmsg_config_t * config)294 static hal_rpmsg_status_t HAL_RpmsgRemoteInit(hal_rpmsg_handle_t handle, hal_rpmsg_config_t *config)
295 {
296 hal_rpmsg_state_t *rpmsgHandle;
297
298 rpmsgHandle = (hal_rpmsg_state_t *)handle;
299
300 /* Set local/remote addr */
301 rpmsgHandle->local_addr = config->local_addr;
302 rpmsgHandle->remote_addr = config->remote_addr;
303
304 rpmsgHandle->rx.callback = NULL;
305 rpmsgHandle->rx.param = NULL;
306 #if defined(RL_USE_STATIC_API) && (RL_USE_STATIC_API == 1)
307 rpmsgHandle->pEndpoint = rpmsg_lite_create_ept(s_rpmsgContext, rpmsgHandle->local_addr, rpmsg_ept_read_cb,
308 rpmsgHandle, &rpmsgHandle->endpoint);
309 #else
310 rpmsgHandle->pEndpoint =
311 rpmsg_lite_create_ept(s_rpmsgContext, rpmsgHandle->local_addr, rpmsg_ept_read_cb, rpmsgHandle);
312 #endif
313
314 if (RL_NULL == rpmsgHandle->pEndpoint)
315 {
316 return kStatus_HAL_RpmsgError;
317 }
318
319 return kStatus_HAL_RpmsgSuccess;
320 }
321 #endif /* HAL_RPMSG_SELECT_ROLE */
322
HAL_RpmsgMcmgrInit(void)323 hal_rpmsg_status_t HAL_RpmsgMcmgrInit(void)
324 {
325 hal_rpmsg_status_t state;
326 if (0U == s_rpmsg_init_golbal)
327 {
328 (void)MCMGR_EarlyInit();
329 }
330
331 #if (defined(HAL_RPMSG_SELECT_ROLE) && (HAL_RPMSG_SELECT_ROLE == 0U))
332 state = HAL_RpmsgMcmgrMasterInit();
333 #elif (defined(HAL_RPMSG_SELECT_ROLE) && (HAL_RPMSG_SELECT_ROLE == 1U))
334 state = HAL_RpmsgMcmgrRemoteInit();
335 #endif /* HAL_RPMSG_SELECT_ROLE */
336
337 return state;
338 }
HAL_RpmsgInit(hal_rpmsg_handle_t handle,hal_rpmsg_config_t * config)339 hal_rpmsg_status_t HAL_RpmsgInit(hal_rpmsg_handle_t handle, hal_rpmsg_config_t *config)
340 {
341 hal_rpmsg_status_t state;
342 hal_rpmsg_state_t *rpmsgHandle;
343 uint8_t count = 0;
344
345 assert(HAL_RPMSG_HANDLE_SIZE >= sizeof(hal_rpmsg_state_t));
346 assert(NULL != handle);
347 rpmsgHandle = (hal_rpmsg_state_t *)handle;
348
349 #if (defined(HAL_RPMSG_SELECT_ROLE) && (HAL_RPMSG_SELECT_ROLE == 0U))
350 state = HAL_RpmsgMasterInit(handle, config);
351 #elif (defined(HAL_RPMSG_SELECT_ROLE) && (HAL_RPMSG_SELECT_ROLE == 1U))
352 state = HAL_RpmsgRemoteInit(handle, config);
353 #endif /* HAL_RPMSG_SELECT_ROLE */
354 rpmsgHandle->rx.callback = config->callback;
355 rpmsgHandle->rx.param = config->param;
356
357 /* Send peer Edpt ready to peer device */
358 (void)MCMGR_TriggerEvent(kMCMGR_RemoteApplicationEvent, APP_RPMSG_EP_READY_EVENT_DATA << 0x8U | config->local_addr);
359 s_rpmsgPeerEptStat[s_rpmsgEptCount].rpmsgHandle = rpmsgHandle;
360 (void)LIST_AddTail(&s_rpmsgEpList, (list_element_handle_t)&s_rpmsgPeerEptStat[s_rpmsgEptCount]);
361 s_rpmsgEptCount++;
362
363 while (count < s_peerRpmsgEptCount)
364 {
365 if (rpmsgHandle->remote_addr == s_rpmsgPeerEptData[count++])
366 {
367 rpmsgHandle->rpmsg_lite_peer_ept_is_ready = 1U;
368 }
369 }
370
371 return state;
372 }
373
HAL_RpmsgDeinit(hal_rpmsg_handle_t handle)374 hal_rpmsg_status_t HAL_RpmsgDeinit(hal_rpmsg_handle_t handle)
375 {
376 hal_rpmsg_state_t *rpmsgHandle;
377
378 rpmsgHandle = (hal_rpmsg_state_t *)handle;
379
380 if (s_rpmsgEptCount > 0)
381 {
382 (void)rpmsg_lite_destroy_ept(s_rpmsgContext, rpmsgHandle->pEndpoint);
383 s_rpmsgEptCount--;
384 }
385
386 if (0 == s_rpmsgEptCount)
387 {
388 s_rpmsgEptCount = -1;
389 (void)rpmsg_lite_deinit(s_rpmsgContext);
390 for (int i = 0; i < MAX_EP_COUNT; i++)
391 {
392 s_rpmsgPeerEptData[i] = 0U;
393 }
394 }
395
396 return kStatus_HAL_RpmsgSuccess;
397 }
398
HAL_RpmsgSendTimeout(hal_rpmsg_handle_t handle,uint8_t * data,uint32_t length,uint32_t timeout)399 hal_rpmsg_status_t HAL_RpmsgSendTimeout(hal_rpmsg_handle_t handle, uint8_t *data, uint32_t length, uint32_t timeout)
400 {
401 hal_rpmsg_state_t *rpmsgHandle;
402 hal_rpmsg_status_t status = kStatus_HAL_RpmsgSuccess;
403
404 #if defined(HDI_MODE) && (HDI_MODE == 1)
405 uint32_t primask;
406 #endif
407
408 int32_t rpmsgStatus;
409 volatile uint32_t epTimeout = RPMSG_REMOTE_READY_RETRY_COUNT;
410 assert(NULL != data);
411
412 rpmsgHandle = (hal_rpmsg_state_t *)handle;
413 /* loop check peer device rpmsg endpoint is ready */
414 while ((0 == rpmsgHandle->rpmsg_lite_peer_ept_is_ready) && (--epTimeout != 0u))
415 {
416 }
417 if (epTimeout == 0u)
418 {
419 return kStatus_HAL_RpmsgTimeout;
420 }
421
422 #if defined(HDI_MODE) && (HDI_MODE == 1)
423 /* In HDI mode this function can be called from ISR therefore,
424 * we need to disable interrupt when this configuration is enabled */
425 primask = DisableGlobalIRQ();
426 #endif
427
428 do
429 {
430 if (RL_TRUE != rpmsg_lite_is_link_up(s_rpmsgContext))
431 {
432 status = kStatus_HAL_RpmsgError;
433 break;
434 }
435 rpmsgStatus = rpmsg_lite_send(s_rpmsgContext, rpmsgHandle->pEndpoint, rpmsgHandle->remote_addr, (char *)data,
436 length, timeout);
437 if (RL_SUCCESS != rpmsgStatus)
438 {
439 if (RL_ERR_NO_MEM == rpmsgStatus)
440 {
441 status = kStatus_HAL_RpmsgTimeout;
442 }
443 else
444 {
445 status = kStatus_HAL_RpmsgError;
446 }
447 break;
448 }
449 } while (false);
450
451 #if defined(HDI_MODE) && (HDI_MODE == 1)
452 EnableGlobalIRQ(primask);
453 #endif
454
455 return status;
456 }
HAL_RpmsgSend(hal_rpmsg_handle_t handle,uint8_t * data,uint32_t length)457 hal_rpmsg_status_t HAL_RpmsgSend(hal_rpmsg_handle_t handle, uint8_t *data, uint32_t length)
458 {
459 return HAL_RpmsgSendTimeout(handle, data, length, RPMSG_WAITFOREVER);
460 }
461
HAL_RpmsgAllocTxBuffer(hal_rpmsg_handle_t handle,uint32_t size)462 void *HAL_RpmsgAllocTxBuffer(hal_rpmsg_handle_t handle, uint32_t size)
463 {
464 return HAL_RpmsgAllocTxBufferTimeout(handle, size, RPMSG_WAITFOREVER);
465 }
466
HAL_RpmsgAllocTxBufferTimeout(hal_rpmsg_handle_t handle,uint32_t size,uint32_t timeout)467 void *HAL_RpmsgAllocTxBufferTimeout(hal_rpmsg_handle_t handle, uint32_t size, uint32_t timeout)
468 {
469 void *buf = NULL;
470 uint32_t primask;
471 primask = DisableGlobalIRQ();
472 buf = rpmsg_lite_alloc_tx_buffer(s_rpmsgContext, &size, timeout);
473 EnableGlobalIRQ(primask);
474 return buf;
475 }
476
HAL_RpmsgFreeRxBuffer(hal_rpmsg_handle_t handle,uint8_t * data)477 hal_rpmsg_status_t HAL_RpmsgFreeRxBuffer(hal_rpmsg_handle_t handle, uint8_t *data)
478 {
479 hal_rpmsg_status_t status = kStatus_HAL_RpmsgSuccess;
480 uint32_t primask;
481 primask = DisableGlobalIRQ();
482 if (RL_SUCCESS != rpmsg_lite_release_rx_buffer(s_rpmsgContext, data))
483 {
484 status = kStatus_HAL_RpmsgError;
485 }
486 EnableGlobalIRQ(primask);
487 return status;
488 }
489
HAL_RpmsgNoCopySend(hal_rpmsg_handle_t handle,uint8_t * data,uint32_t length)490 hal_rpmsg_status_t HAL_RpmsgNoCopySend(hal_rpmsg_handle_t handle, uint8_t *data, uint32_t length)
491 {
492 hal_rpmsg_state_t *rpmsgHandle;
493 hal_rpmsg_status_t status = kStatus_HAL_RpmsgSuccess;
494 uint32_t primask;
495 rpmsgHandle = (hal_rpmsg_state_t *)handle;
496 volatile uint32_t epTimeout = RPMSG_REMOTE_READY_RETRY_COUNT;
497
498 /* loop check peer device rpmsg endpoint is ready */
499 while ((0 == rpmsgHandle->rpmsg_lite_peer_ept_is_ready) && (--epTimeout != 0u))
500 {
501 }
502
503 if (epTimeout == 0u)
504 {
505 return kStatus_HAL_RpmsgTimeout;
506 }
507
508 primask = DisableGlobalIRQ();
509 assert(NULL != data);
510
511 do
512 {
513 if (RL_TRUE != rpmsg_lite_is_link_up(s_rpmsgContext))
514 {
515 status = kStatus_HAL_RpmsgError;
516 break;
517 }
518
519 if (RL_SUCCESS != rpmsg_lite_send_nocopy(s_rpmsgContext, rpmsgHandle->pEndpoint, rpmsgHandle->remote_addr,
520 (char *)data, length))
521 {
522 status = kStatus_HAL_RpmsgError;
523 break;
524 }
525 } while (false);
526
527 EnableGlobalIRQ(primask);
528
529 return status;
530 }
HAL_RpmsgInstallRxCallback(hal_rpmsg_handle_t handle,rpmsg_rx_callback_t callback,void * param)531 hal_rpmsg_status_t HAL_RpmsgInstallRxCallback(hal_rpmsg_handle_t handle, rpmsg_rx_callback_t callback, void *param)
532 {
533 hal_rpmsg_state_t *rpmsgHandle;
534
535 rpmsgHandle = (hal_rpmsg_state_t *)handle;
536
537 rpmsgHandle->rx.callback = callback;
538 rpmsgHandle->rx.param = param;
539
540 return kStatus_HAL_RpmsgSuccess;
541 }
542
HAL_RpmsgEnterLowpower(hal_rpmsg_handle_t handle)543 hal_rpmsg_status_t HAL_RpmsgEnterLowpower(hal_rpmsg_handle_t handle)
544 {
545 return kStatus_HAL_RpmsgError;
546 }
547
HAL_RpmsgExitLowpower(hal_rpmsg_handle_t handle)548 hal_rpmsg_status_t HAL_RpmsgExitLowpower(hal_rpmsg_handle_t handle)
549 {
550 return kStatus_HAL_RpmsgError;
551 }
552
