rpc: port to new architecture

Author: facchinm

src/rpc.c

@@ -24,14 +24,16 @@
 #include "arduino_openamp.h"
 #include "stm32h7xx_hal.h"
 #include "ringbuffer.h"
+#include "stm32h7xx_ll_rcc.h"
+#include "debug.h"
 
 /**************************************************************************************
  * TYPEDEF
  **************************************************************************************/
 
 enum endpoints_t {
   ENDPOINT_RAW = 0,
-  ENDPOINT_RESPONSE
+  ENDPOINT_RPC
 };
 
 /**************************************************************************************
@@ -48,50 +50,49 @@ extern ring_buffer_t virtual_uart_ring_buffer;
 int rpmsg_recv_raw_callback(struct rpmsg_endpoint *ept, void *data,
                                        size_t len, uint32_t src, void *priv)
 {
-/*
-  printf("raw: received %d bytes from M4, content:", len);
-  for (int i = 0; i<len; i++) {
-    printf("%x ", ((uint8_t*)data)[i]);
-  }
-  printf("\n");
-*/
   ring_buffer_queue_arr(&virtual_uart_ring_buffer, (const char *)data, len);
 
   return 0;
 }
 
 void new_service_cb(struct rpmsg_device *rdev, const char *name, uint32_t dest)
 {
-  if (strcmp(name, "raw") == 0) {
-    OPENAMP_create_endpoint(&rp_endpoints[ENDPOINT_RAW], name, dest, rpmsg_recv_raw_callback, NULL);
-  }
+  uint8_t buffer[1] = {0};
+  struct rpmsg_endpoint *ept = NULL;
+
   if (strcmp(name, "rpc") == 0) {
-    OPENAMP_create_endpoint(&rp_endpoints[ENDPOINT_RESPONSE], name, dest, rpmsg_recv_raw_callback, NULL);
+      ept = &rp_endpoints[ENDPOINT_RPC];
+  } else if (strcmp(name, "raw") == 0) {
+      ept = &rp_endpoints[ENDPOINT_RAW];
+  }
+
+  if (ept) {
+      OPENAMP_create_endpoint(ept, name, dest, rpmsg_recv_raw_callback, NULL);
+      OPENAMP_send(ept, buffer, sizeof(buffer));
   }
 }
 
 int serial_rpc_begin() {
 
   /* Initialize OpenAmp and libmetal libraries */
-  if (MX_OPENAMP_Init(RPMSG_MASTER, new_service_cb) !=  HAL_OK) {
+  if (MX_OPENAMP_Init(RPMSG_HOST, new_service_cb) !=  HAL_OK) {
     return 0;
   }
 
   /* Initialize the rpmsg endpoint to set default addresses to RPMSG_ADDR_ANY */
-  rpmsg_init_ept(&rp_endpoints[0], "raw", RPMSG_ADDR_ANY, RPMSG_ADDR_ANY, NULL, NULL);
-  rpmsg_init_ept(&rp_endpoints[1], "rpc", RPMSG_ADDR_ANY, RPMSG_ADDR_ANY, NULL, NULL);
+  memset(rp_endpoints, 0, sizeof(rp_endpoints));
 
   /*
   * The rpmsg service is initiate by the remote processor, on H7 new_service_cb
   * callback is received on service creation. Wait for the callback
   */
-  OPENAMP_Wait_EndPointready(&rp_endpoints[0], HAL_GetTick() + 500);
-  OPENAMP_Wait_EndPointready(&rp_endpoints[1], HAL_GetTick() + 500);
-
-  // Send first dummy message to enable the channel
-  int message = 0x00;
-  OPENAMP_send(&rp_endpoints[0], &message, sizeof(message));
-  OPENAMP_send(&rp_endpoints[1], &message, sizeof(message));
+  uint32_t millis_start = HAL_GetTick();
+  while (rp_endpoints[0].rdev == NULL || rp_endpoints[1].rdev == NULL) {
+    if ((HAL_GetTick() - millis_start) >= 1000) {
+      dbg_printf("M4 RPC timeout\n");
+      return 0;
+    }
+  }
 
   return 1;
 }
@@ -102,7 +103,7 @@ void serial_rpc_available() {
 
 void serial_rpc_write(uint8_t const * buf, size_t len) {
   // we'll only get rpc requests from "upstairs"
-  OPENAMP_send(&rp_endpoints[1], buf, len);
+  OPENAMP_send(&rp_endpoints[ENDPOINT_RPC], buf, len);
 }
 
 void HSEM1_IRQHandler(void)

src/system.c

@@ -162,11 +162,12 @@ static void MPU_Config(void)
   MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
   MPU_InitStruct.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
   MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE;
-  MPU_InitStruct.IsShareable = MPU_ACCESS_SHAREABLE;
+  MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
   MPU_InitStruct.Number = MPU_REGION_NUMBER3;
-  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
+  MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL1;
   MPU_InitStruct.SubRegionDisable = 0x00;
   MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
+
   HAL_MPU_ConfigRegion(&MPU_InitStruct);
 
   /* Enable MPU */