rpmsg proxy: Use hil_proc poll to wait

[processor-sdk/open-amp.git] / lib / proxy / rpmsg_retarget.c

diff --git a/lib/proxy/rpmsg_retarget.c b/lib/proxy/rpmsg_retarget.c
index c0e8cceb145bc127f62a538658c3b6707034ca2c..661876e6df08bc8693df854631351e0bc8f699af 100644 (file)
--- a/lib/proxy/rpmsg_retarget.c
+++ b/lib/proxy/rpmsg_retarget.c
@@ -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,17 +40,15 @@ 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));
 
        /* Create a mutex for synchronization */
-       status = env_create_mutex(&rpc_data->rpc_lock, 1);
+       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)
@@ -72,8 +67,7 @@ int rpmsg_retarget_deinit(struct rpmsg_channel *rp_chnl)
 
        env_free_memory(rpc_data->rpc);
        env_free_memory(rpc_data->rpc_response);
-       env_delete_mutex(rpc_data->rpc_lock);
-       env_delete_sync_lock(rpc_data->sync_lock);
+       metal_mutex_deinit(&rpc_data->rpc_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
@@ -114,12 +116,12 @@ int _open(const char *filename, int flags, int mode)
        memcpy(&rpc_data->rpc->sys_call_args.data, filename, filename_len);
 
        /* Transmit rpc request */
-       env_lock_mutex(rpc_data->rpc_lock);
+       metal_mutex_acquire(&rpc_data->rpc_lock);
        send_rpc((void *)rpc_data->rpc, payload_size);
-       env_unlock_mutex(rpc_data->rpc_lock);
+       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) {
@@ -155,13 +157,12 @@ int _read(int fd, char *buffer, int buflen)
        rpc_data->rpc->sys_call_args.data_len = 0;      /*not used */
 
        /* Transmit rpc request */
-       env_lock_mutex(rpc_data->rpc_lock);
-       get_response = 0;
+       metal_mutex_acquire(&rpc_data->rpc_lock);
        send_rpc((void *)rpc_data->rpc, payload_size);
-       env_unlock_mutex(rpc_data->rpc_lock);
+       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) {
@@ -208,11 +209,12 @@ int _write(int fd, const char *ptr, int len)
                    0;
        }
 
-       env_lock_mutex(rpc_data->rpc_lock);
+       metal_mutex_acquire(&rpc_data->rpc_lock);
        send_rpc((void *)rpc_data->rpc, payload_size);
-       env_unlock_mutex(rpc_data->rpc_lock);
+       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;
@@ -243,12 +245,12 @@ int _close(int fd)
        rpc_data->rpc->sys_call_args.int_field2 = 0;    /*not used */
        rpc_data->rpc->sys_call_args.data_len = 0;      /*not used */
 
-       env_lock_mutex(rpc_data->rpc_lock);
+       metal_mutex_acquire(&rpc_data->rpc_lock);
        send_rpc((void *)rpc_data->rpc, payload_size);
-       env_unlock_mutex(rpc_data->rpc_lock);
+       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;