tee: optee: support tracking system threads

[linux-2.6-microblaze.git] / drivers / tee / optee / call.c

diff --git a/drivers/tee/optee/call.c b/drivers/tee/optee/call.c
index 152ae9b..b04c49c 100644 (file)
--- a/drivers/tee/optee/call.c
+++ b/drivers/tee/optee/call.c
@@ -39,9 +39,29 @@ struct optee_shm_arg_entry {
        DECLARE_BITMAP(map, MAX_ARG_COUNT_PER_ENTRY);
 };
 
+void optee_cq_init(struct optee_call_queue *cq, int thread_count)
+{
+       mutex_init(&cq->mutex);
+       INIT_LIST_HEAD(&cq->waiters);
+
+       /*
+        * If cq->total_thread_count is 0 then we're not trying to keep
+        * track of how many free threads we have, instead we're relying on
+        * the secure world to tell us when we're out of thread and have to
+        * wait for another thread to become available.
+        */
+       cq->total_thread_count = thread_count;
+       cq->free_thread_count = thread_count;
+}
+
 void optee_cq_wait_init(struct optee_call_queue *cq,
                        struct optee_call_waiter *w, bool sys_thread)
 {
+       unsigned int free_thread_threshold;
+       bool need_wait = false;
+
+       memset(w, 0, sizeof(*w));
+
        /*
         * We're preparing to make a call to secure world. In case we can't
         * allocate a thread in secure world we'll end up waiting in
@@ -60,8 +80,38 @@ void optee_cq_wait_init(struct optee_call_queue *cq,
         */
        init_completion(&w->c);
        list_add_tail(&w->list_node, &cq->waiters);
+       w->sys_thread = sys_thread;
+
+       if (cq->total_thread_count) {
+               if (sys_thread || !cq->sys_thread_req_count)
+                       free_thread_threshold = 0;
+               else
+                       free_thread_threshold = 1;
+
+               if (cq->free_thread_count > free_thread_threshold)
+                       cq->free_thread_count--;
+               else
+                       need_wait = true;
+       }
 
        mutex_unlock(&cq->mutex);
+
+       while (need_wait) {
+               optee_cq_wait_for_completion(cq, w);
+               mutex_lock(&cq->mutex);
+
+               if (sys_thread || !cq->sys_thread_req_count)
+                       free_thread_threshold = 0;
+               else
+                       free_thread_threshold = 1;
+
+               if (cq->free_thread_count > free_thread_threshold) {
+                       cq->free_thread_count--;
+                       need_wait = false;
+               }
+
+               mutex_unlock(&cq->mutex);
+       }
 }
 
 void optee_cq_wait_for_completion(struct optee_call_queue *cq,
@@ -83,6 +133,14 @@ static void optee_cq_complete_one(struct optee_call_queue *cq)
 {
        struct optee_call_waiter *w;
 
+       /* Wake a waiting system session if any, prior to a normal session */
+       list_for_each_entry(w, &cq->waiters, list_node) {
+               if (w->sys_thread && !completion_done(&w->c)) {
+                       complete(&w->c);
+                       return;
+               }
+       }
+
        list_for_each_entry(w, &cq->waiters, list_node) {
                if (!completion_done(&w->c)) {
                        complete(&w->c);
@@ -104,6 +162,8 @@ void optee_cq_wait_final(struct optee_call_queue *cq,
        /* Get out of the list */
        list_del(&w->list_node);
 
+       cq->free_thread_count++;
+
        /* Wake up one eventual waiting task */
        optee_cq_complete_one(cq);
 
@@ -119,6 +179,28 @@ void optee_cq_wait_final(struct optee_call_queue *cq,
        mutex_unlock(&cq->mutex);
 }
 
+/* Count registered system sessions to reserved a system thread or not */
+static bool optee_cq_incr_sys_thread_count(struct optee_call_queue *cq)
+{
+       if (cq->total_thread_count <= 1)
+               return false;
+
+       mutex_lock(&cq->mutex);
+       cq->sys_thread_req_count++;
+       mutex_unlock(&cq->mutex);
+
+       return true;
+}
+
+static void optee_cq_decr_sys_thread_count(struct optee_call_queue *cq)
+{
+       mutex_lock(&cq->mutex);
+       cq->sys_thread_req_count--;
+       /* If there's someone waiting, let it resume */
+       optee_cq_complete_one(cq);
+       mutex_unlock(&cq->mutex);
+}
+
 /* Requires the filpstate mutex to be held */
 static struct optee_session *find_session(struct optee_context_data *ctxdata,
                                          u32 session_id)
@@ -361,6 +443,27 @@ out:
        return rc;
 }
 
+int optee_system_session(struct tee_context *ctx, u32 session)
+{
+       struct optee *optee = tee_get_drvdata(ctx->teedev);
+       struct optee_context_data *ctxdata = ctx->data;
+       struct optee_session *sess;
+       int rc = -EINVAL;
+
+       mutex_lock(&ctxdata->mutex);
+
+       sess = find_session(ctxdata, session);
+       if (sess && (sess->use_sys_thread ||
+                    optee_cq_incr_sys_thread_count(&optee->call_queue))) {
+               sess->use_sys_thread = true;
+               rc = 0;
+       }
+
+       mutex_unlock(&ctxdata->mutex);
+
+       return rc;
+}
+
 int optee_close_session_helper(struct tee_context *ctx, u32 session,
                               bool system_thread)
 {
@@ -380,6 +483,9 @@ int optee_close_session_helper(struct tee_context *ctx, u32 session,
 
        optee_free_msg_arg(ctx, entry, offs);
 
+       if (system_thread)
+               optee_cq_decr_sys_thread_count(&optee->call_queue);
+
        return 0;
 }