rpmsg proxy: Use hil_proc poll to wait
authorWendy Liang <jliang@xilinx.com>
Thu, 4 Aug 2016 16:47:22 +0000 (09:47 -0700)
committerWendy Liang <jliang@xilinx.com>
Thu, 13 Oct 2016 05:01:46 +0000 (22:01 -0700)
Use hil_proc poll() API to wait for remoteproc to be signaled.

Signed-off-by: Wendy Liang <jliang@xilinx.com>
lib/include/openamp/rpmsg_retarget.h
lib/proxy/rpmsg_retarget.c

index 68c1323c0309bbad4921def47a4d094d39edc558..85839ecab7c169d4fd7de8a02e4cc964d70c2d8b 100644 (file)
@@ -1,5 +1,6 @@
 #include "openamp/open_amp.h"
 #include "metal/mutex.h"
+#include "metal/atomic.h"
 
 /* RPC response buffer size */
 #define RPC_BUFF_SIZE 512
@@ -23,7 +24,7 @@ struct _rpc_data {
        struct rpmsg_channel *rpmsg_chnl;
        struct rpmsg_endpoint *rp_ept;
        metal_mutex_t rpc_lock;
-       void *sync_lock;
+       atomic_int sync;
        struct _sys_rpc *rpc;
        struct _sys_rpc *rpc_response;
        rpc_shutdown_cb shutdown_cb;
index 90eca716737d164cdcb906aba57aa0885de8d9d1..661876e6df08bc8693df854631351e0bc8f699af 100644 (file)
@@ -11,8 +11,6 @@
  *************************************************************************/
 static struct _rpc_data *rpc_data;
 
-int get_response = 0;
-
 int send_rpc(void *data, int len);
 
 void rpc_cb(struct rpmsg_channel *rtl_rp_chnl, void *data, int len, void *priv,
@@ -22,9 +20,8 @@ void rpc_cb(struct rpmsg_channel *rtl_rp_chnl, void *data, int len, void *priv,
        (void)src;
 
        memcpy(rpc_data->rpc_response, data, len);
-       env_release_sync_lock(rpc_data->sync_lock);
-       get_response = 1;
 
+       atomic_flag_clear(&rpc_data->sync);
        if (rpc_data->rpc_response->id == TERM_SYSCALL_ID) {
                /* Application terminate signal is received from the proxy app,
                 * so let the application know of terminate message.
@@ -43,8 +40,6 @@ int send_rpc(void *data, int len)
 
 int rpmsg_retarget_init(struct rpmsg_channel *rp_chnl, rpc_shutdown_cb cb)
 {
-       int status;
-
        /* Allocate memory for rpc control block */
        rpc_data =
            (struct _rpc_data *)env_allocate_memory(sizeof(struct _rpc_data));
@@ -53,7 +48,7 @@ int rpmsg_retarget_init(struct rpmsg_channel *rp_chnl, rpc_shutdown_cb cb)
        metal_mutex_init(&rpc_data->rpc_lock);
 
        /* Create a mutex for synchronization */
-       status = env_create_sync_lock(&rpc_data->sync_lock, LOCKED);
+       atomic_store(&rpc_data->sync, 1);
 
        /* Create a endpoint to handle rpc response from master */
        rpc_data->rpmsg_chnl = rp_chnl;
@@ -63,7 +58,7 @@ int rpmsg_retarget_init(struct rpmsg_channel *rp_chnl, rpc_shutdown_cb cb)
        rpc_data->rpc_response = env_allocate_memory(RPC_BUFF_SIZE);
        rpc_data->shutdown_cb = cb;
 
-       return status;
+       return 0;
 }
 
 int rpmsg_retarget_deinit(struct rpmsg_channel *rp_chnl)
@@ -73,7 +68,6 @@ int rpmsg_retarget_deinit(struct rpmsg_channel *rp_chnl)
        env_free_memory(rpc_data->rpc);
        env_free_memory(rpc_data->rpc_response);
        metal_mutex_deinit(&rpc_data->rpc_lock);
-       env_delete_sync_lock(rpc_data->sync_lock);
        rpmsg_destroy_ept(rpc_data->rp_ept);
        env_free_memory(rpc_data);
 
@@ -85,6 +79,14 @@ int rpmsg_retarget_send(void *data, int len)
        return send_rpc(data, len);
 }
 
+static inline void rpmsg_retarget_wait(struct _rpc_data *rpc)
+{
+       struct hil_proc *proc = rpc->rpmsg_chnl->rdev->proc;
+       while (atomic_flag_test_and_set(&rpc->sync)) {
+               hil_poll(proc, 0);
+       }
+}
+
 /*************************************************************************
  *
  *   FUNCTION
@@ -119,7 +121,7 @@ int _open(const char *filename, int flags, int mode)
        metal_mutex_release(&rpc_data->rpc_lock);
 
        /* Wait for response from proxy on master */
-       env_acquire_sync_lock(rpc_data->sync_lock);
+       rpmsg_retarget_wait(rpc_data);
 
        /* Obtain return args and return to caller */
        if (rpc_data->rpc_response->id == OPEN_SYSCALL_ID) {
@@ -156,12 +158,11 @@ int _read(int fd, char *buffer, int buflen)
 
        /* Transmit rpc request */
        metal_mutex_acquire(&rpc_data->rpc_lock);
-       get_response = 0;
        send_rpc((void *)rpc_data->rpc, payload_size);
        metal_mutex_release(&rpc_data->rpc_lock);
 
        /* Wait for response from proxy on master */
-       env_acquire_sync_lock(rpc_data->sync_lock);
+       rpmsg_retarget_wait(rpc_data);
 
        /* Obtain return args and return to caller */
        if (rpc_data->rpc_response->id == READ_SYSCALL_ID) {
@@ -212,7 +213,8 @@ int _write(int fd, const char *ptr, int len)
        send_rpc((void *)rpc_data->rpc, payload_size);
        metal_mutex_release(&rpc_data->rpc_lock);
 
-       env_acquire_sync_lock(rpc_data->sync_lock);
+       /* Wait for response from proxy on master */
+       rpmsg_retarget_wait(rpc_data);
 
        if (rpc_data->rpc_response->id == WRITE_SYSCALL_ID) {
                retval = rpc_data->rpc_response->sys_call_args.int_field1;
@@ -248,7 +250,7 @@ int _close(int fd)
        metal_mutex_release(&rpc_data->rpc_lock);
 
        /* Wait for response from proxy on master */
-       env_acquire_sync_lock(rpc_data->sync_lock);
+       rpmsg_retarget_wait(rpc_data);
 
        if (rpc_data->rpc_response->id == CLOSE_SYSCALL_ID) {
                retval = rpc_data->rpc_response->sys_call_args.int_field1;