RSE: mhu_wrapper_v3_x: Relax 4-byte align in buffer size

The MHU wrapper handles the data from and to the driver
with a 4-byte alignment.
This may not fit the caller, which may need to transfer
a buffer or arbitrary size.
Add some logic to internally handle the case where the
buffer size is not multiple of 4 bytes.

Signed-off-by: Nicola Mazzucato <nicola.mazzucato@arm.com>
Change-Id: I93d0853078e69a4ae5ca83983fd1b4d3d8ed4454

Author: nicola-mazzucato-arm

platform/ext/target/arm/rse/common/native_drivers/mhu.h

@@ -82,9 +82,9 @@ enum mhu_error_t mhu_init_receiver(void *mhu_receiver_dev);
  *
  * \return Returns mhu_error_t error code.
  *
- * \note The send_buffer must be 4-byte aligned and its length must be at least
- *       (4 - (size % 4)) bytes bigger than the data size to prevent buffer
- *       over-reading.
+ * \note For MHUv2, the send_buffer must be 4-byte aligned and its length must
+ *       be at least (4 - (size % 4)) bytes bigger than the data size to
+ *       prevent buffer over-reading.
  */
 enum mhu_error_t mhu_send_data(void *mhu_sender_dev,
                                const uint8_t *send_buffer,
@@ -111,12 +111,12 @@ enum mhu_error_t mhu_wait_data(void *mhu_receiver_dev);
  * \param[in,out] size              As input the size of the receive_buffer,
  *                                  as output the number of bytes received.
  *                                  As a limitation, the size of the buffer
- *                                  must be a multiple of 4.
+ *                                  must be a multiple of 4 for MHUv2.
  *
  * \return Returns mhu_error_t error code.
  *
- * \note The receive_buffer must be 4-byte aligned and its length must be a
- *       multiple of 4.
+ * \note For MHUv2, the receive_buffer must be 4-byte aligned and its length
+ *       must be a multiple of 4.
  */
 enum mhu_error_t mhu_receive_data(void *mhu_receiver_dev,
                                   uint8_t *receive_buffer,

platform/ext/target/arm/rse/common/native_drivers/mhu_wrapper_v3_x.c

@@ -156,14 +156,12 @@ enum mhu_error_t clear_and_wait_for_signal (
 /**
  * @brief For simplicity, require:
  *          - the buffer address to be 4-byte aligned.
- *          - the buffer size to be a multiple of 4.
  */
 static enum mhu_error_t validate_buffer_params(uintptr_t buf_addr,
                                                size_t buf_size)
 {
     if ((buf_addr == 0) ||
         (!IS_ALIGNED(buf_addr, 4)) ||
-        (!IS_ALIGNED(buf_size, 4)) ||
         (buf_size == 0)) {
         return MHU_ERR_VALIDATE_BUFFER_PARAMS_INVALID_ARG;
     }
@@ -284,6 +282,8 @@ enum mhu_error_t mhu_send_data(void *mhu_sender_dev, const uint8_t *send_buffer,
     uint8_t num_channels;
     uint8_t chan = 0;
     uint32_t *buffer;
+    uint32_t t_buffer;
+    size_t bytes_left;
 
     assert(dev != NULL);
     assert(dev->base != (uintptr_t)NULL);
@@ -307,11 +307,23 @@ enum mhu_error_t mhu_send_data(void *mhu_sender_dev, const uint8_t *send_buffer,
     chan++;
 
     buffer = (uint32_t *)send_buffer;
-    for (size_t i = 0; i < size; i += 4) {
-        mhu_v3_err = mhu_v3_x_doorbell_write(dev, chan, *buffer++);
+    bytes_left = size;
+    while (bytes_left > 0) {
+        if (bytes_left >= 4) {
+            t_buffer = *buffer++;
+            bytes_left -= 4;
+        } else {
+            /* a few bytes still to send, pad the remaining bytes */
+            t_buffer = 0;
+            memcpy(&t_buffer, (uint32_t *)buffer, bytes_left);
+
+            bytes_left = 0;
+        }
+        mhu_v3_err = mhu_v3_x_doorbell_write(dev, chan, t_buffer);
         if (mhu_v3_err != MHU_V_3_X_ERR_NONE) {
             return mhu_v3_err;
         }
+
         if (++chan == (num_channels - 1)) {
             /* Using the last channel for notifications */
             mhu_err = signal_and_wait_for_clear(dev, MHU_NOTIFY_VALUE);
@@ -368,6 +380,8 @@ enum mhu_error_t mhu_receive_data(void *mhu_receiver_dev,
     uint8_t num_channels;
     uint8_t chan = 0;
     uint32_t *buffer;
+    uint32_t t_buffer;
+    size_t bytes_left;
 
     assert(dev != NULL);
     assert(dev->base != (uintptr_t)NULL);
@@ -401,14 +415,25 @@ enum mhu_error_t mhu_receive_data(void *mhu_receiver_dev,
     }
 
     buffer = (uint32_t *)receive_buffer;
-    for (size_t i = 0; i < msg_len; i += 4) {
-        mhu_v3_err = mhu_v3_x_doorbell_read(dev, chan, buffer++);
+    bytes_left = msg_len;
+    while (bytes_left > 0) {
+        if (bytes_left >= 4) {
+            mhu_v3_err = mhu_v3_x_doorbell_read(dev, chan, buffer++);
+            bytes_left -= 4;
+        } else {
+            /* a few bytes still to receive, pad the remaining bytes */
+            t_buffer = 0;
+            mhu_v3_err = mhu_v3_x_doorbell_read(dev, chan, &t_buffer);
+
+            memcpy((uint32_t *)buffer, &t_buffer, bytes_left);
+            bytes_left = 0;
+        }
         if (mhu_v3_err != MHU_V_3_X_ERR_NONE) {
             return mhu_v3_err;
         }
 
         /* Only wait for next transfer if there is still missing data. */
-        if (++chan == (num_channels - 1) && (msg_len - i) > 4) {
+        if ((++chan == (num_channels - 1)) && (bytes_left > 0)) {
             /* Busy wait for next transfer */
             mhu_err = clear_and_wait_for_signal(dev, MHU_NOTIFY_VALUE);
             if (mhu_err != MHU_ERR_NONE) {