1 files changed, 48 insertions, 116 deletions

diff --git a/drivers/crypto/ccp/ccp-crypto-main.c b/drivers/crypto/ccp/ccp-crypto-main.c
index b3f22b07b5bd..010fded5d46b 100644
--- a/drivers/crypto/ccp/ccp-crypto-main.c
+++ b/drivers/crypto/ccp/ccp-crypto-main.c
@@ -38,23 +38,20 @@ MODULE_PARM_DESC(sha_disable, "Disable use of SHA - any non-zero value");
 static LIST_HEAD(hash_algs);
 static LIST_HEAD(cipher_algs);
 
-/* For any tfm, requests for that tfm on the same CPU must be returned
- * in the order received.  With multiple queues available, the CCP can
- * process more than one cmd at a time.  Therefore we must maintain
- * a cmd list to insure the proper ordering of requests on a given tfm/cpu
- * combination.
+/* For any tfm, requests for that tfm must be returned on the order
+ * received.  With multiple queues available, the CCP can process more
+ * than one cmd at a time.  Therefore we must maintain a cmd list to insure
+ * the proper ordering of requests on a given tfm.
  */
-struct ccp_crypto_cpu_queue {
+struct ccp_crypto_queue {
         struct list_head cmds;
         struct list_head *backlog;
         unsigned int cmd_count;
 };
-#define CCP_CRYPTO_MAX_QLEN     50
+#define CCP_CRYPTO_MAX_QLEN     100
 
-struct ccp_crypto_percpu_queue {
-        struct ccp_crypto_cpu_queue __percpu *cpu_queue;
-};
-static struct ccp_crypto_percpu_queue req_queue;
+static struct ccp_crypto_queue req_queue;
+static spinlock_t req_queue_lock;
 
 struct ccp_crypto_cmd {
         struct list_head entry;
@@ -71,8 +68,6 @@ struct ccp_crypto_cmd {
 
         /* Used for held command processing to determine state */
         int ret;
-
-        int cpu;
 };
 
 struct ccp_crypto_cpu {
@@ -91,25 +86,21 @@ static inline bool ccp_crypto_success(int err)
         return true;
 }
 
-/*
- * ccp_crypto_cmd_complete must be called while running on the appropriate
- * cpu and the caller must have done a get_cpu to disable preemption
- */
 static struct ccp_crypto_cmd *ccp_crypto_cmd_complete(
         struct ccp_crypto_cmd *crypto_cmd, struct ccp_crypto_cmd **backlog)
 {
-        struct ccp_crypto_cpu_queue *cpu_queue;
         struct ccp_crypto_cmd *held = NULL, *tmp;
+        unsigned long flags;
 
         *backlog = NULL;
 
-        cpu_queue = this_cpu_ptr(req_queue.cpu_queue);
+        spin_lock_irqsave(&req_queue_lock, flags);
 
         /* Held cmds will be after the current cmd in the queue so start
          * searching for a cmd with a matching tfm for submission.
          */
         tmp = crypto_cmd;
-        list_for_each_entry_continue(tmp, &cpu_queue->cmds, entry) {
+        list_for_each_entry_continue(tmp, &req_queue.cmds, entry) {
                 if (crypto_cmd->tfm != tmp->tfm)
                         continue;
                 held = tmp;
@@ -120,47 +111,45 @@ static struct ccp_crypto_cmd *ccp_crypto_cmd_complete(
          *   Because cmds can be executed from any point in the cmd list
          *   special precautions have to be taken when handling the backlog.
          */
-        if (cpu_queue->backlog != &cpu_queue->cmds) {
+        if (req_queue.backlog != &req_queue.cmds) {
                 /* Skip over this cmd if it is the next backlog cmd */
-                if (cpu_queue->backlog == &crypto_cmd->entry)
-                        cpu_queue->backlog = crypto_cmd->entry.next;
+                if (req_queue.backlog == &crypto_cmd->entry)
+                        req_queue.backlog = crypto_cmd->entry.next;
 
-                *backlog = container_of(cpu_queue->backlog,
+                *backlog = container_of(req_queue.backlog,
                                         struct ccp_crypto_cmd, entry);
-                cpu_queue->backlog = cpu_queue->backlog->next;
+                req_queue.backlog = req_queue.backlog->next;
 
                 /* Skip over this cmd if it is now the next backlog cmd */
-                if (cpu_queue->backlog == &crypto_cmd->entry)
-                        cpu_queue->backlog = crypto_cmd->entry.next;
+                if (req_queue.backlog == &crypto_cmd->entry)
+                        req_queue.backlog = crypto_cmd->entry.next;
         }
 
         /* Remove the cmd entry from the list of cmds */
-        cpu_queue->cmd_count--;
+        req_queue.cmd_count--;
         list_del(&crypto_cmd->entry);
 
+        spin_unlock_irqrestore(&req_queue_lock, flags);
+
         return held;
 }
 
-static void ccp_crypto_complete_on_cpu(struct work_struct *work)
+static void ccp_crypto_complete(void *data, int err)
 {
-        struct ccp_crypto_cpu *cpu_work =
-                container_of(work, struct ccp_crypto_cpu, work);
-        struct ccp_crypto_cmd *crypto_cmd = cpu_work->crypto_cmd;
+        struct ccp_crypto_cmd *crypto_cmd = data;
         struct ccp_crypto_cmd *held, *next, *backlog;
         struct crypto_async_request *req = crypto_cmd->req;
         struct ccp_ctx *ctx = crypto_tfm_ctx(req->tfm);
-        int cpu, ret;
-
-        cpu = get_cpu();
+        int ret;
 
-        if (cpu_work->err == -EINPROGRESS) {
+        if (err == -EINPROGRESS) {
                 /* Only propogate the -EINPROGRESS if necessary */
                 if (crypto_cmd->ret == -EBUSY) {
                         crypto_cmd->ret = -EINPROGRESS;
                         req->complete(req, -EINPROGRESS);
                 }
 
-                goto e_cpu;
+                return;
         }
 
         /* Operation has completed - update the queue before invoking
@@ -178,7 +167,7 @@ static void ccp_crypto_complete_on_cpu(struct work_struct *work)
                 req->complete(req, -EINPROGRESS);
 
         /* Completion callbacks */
-        ret = cpu_work->err;
+        ret = err;
         if (ctx->complete)
                 ret = ctx->complete(req, ret);
         req->complete(req, ret);
@@ -203,52 +192,28 @@ static void ccp_crypto_complete_on_cpu(struct work_struct *work)
         }
 
         kfree(crypto_cmd);
-
-e_cpu:
-        put_cpu();
-
-        complete(&cpu_work->completion);
-}
-
-static void ccp_crypto_complete(void *data, int err)