crypto: ccp - Refactoring: symbol cleanup
authorGary R Hook <gary.hook@amd.com>
Wed, 27 Jul 2016 00:09:40 +0000 (19:09 -0500)
committerHerbert Xu <herbert@gondor.apana.org.au>
Tue, 9 Aug 2016 10:47:08 +0000 (18:47 +0800)
Form and use of the local storage block in the CCP is
particular to the device version. Much of the code that
accesses the storage block can treat it as a virtual
resource, and will under go some renaming. Device-specific
access to the memory will be moved into device file.
Service functions will be added to the actions
structure.

Signed-off-by: Gary R Hook <gary.hook@amd.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
drivers/crypto/ccp/ccp-dev-v3.c
drivers/crypto/ccp/ccp-dev.c
drivers/crypto/ccp/ccp-dev.h
drivers/crypto/ccp/ccp-ops.c

index 1a94d2ea4ff122a889c655f934008a9eed54258e..19eafb85708f96b532f5ff8e5d0921f0d598359f 100644 (file)
@@ -100,10 +100,10 @@ static int ccp_perform_aes(struct ccp_op *op)
                | (op->u.aes.type << REQ1_AES_TYPE_SHIFT)
                | (op->u.aes.mode << REQ1_AES_MODE_SHIFT)
                | (op->u.aes.action << REQ1_AES_ACTION_SHIFT)
-               | (op->ksb_key << REQ1_KEY_KSB_SHIFT);
+               | (op->sb_key << REQ1_KEY_KSB_SHIFT);
        cr[1] = op->src.u.dma.length - 1;
        cr[2] = ccp_addr_lo(&op->src.u.dma);
-       cr[3] = (op->ksb_ctx << REQ4_KSB_SHIFT)
+       cr[3] = (op->sb_ctx << REQ4_KSB_SHIFT)
                | (CCP_MEMTYPE_SYSTEM << REQ4_MEMTYPE_SHIFT)
                | ccp_addr_hi(&op->src.u.dma);
        cr[4] = ccp_addr_lo(&op->dst.u.dma);
@@ -130,10 +130,10 @@ static int ccp_perform_xts_aes(struct ccp_op *op)
        cr[0] = (CCP_ENGINE_XTS_AES_128 << REQ1_ENGINE_SHIFT)
                | (op->u.xts.action << REQ1_AES_ACTION_SHIFT)
                | (op->u.xts.unit_size << REQ1_XTS_AES_SIZE_SHIFT)
-               | (op->ksb_key << REQ1_KEY_KSB_SHIFT);
+               | (op->sb_key << REQ1_KEY_KSB_SHIFT);
        cr[1] = op->src.u.dma.length - 1;
        cr[2] = ccp_addr_lo(&op->src.u.dma);
-       cr[3] = (op->ksb_ctx << REQ4_KSB_SHIFT)
+       cr[3] = (op->sb_ctx << REQ4_KSB_SHIFT)
                | (CCP_MEMTYPE_SYSTEM << REQ4_MEMTYPE_SHIFT)
                | ccp_addr_hi(&op->src.u.dma);
        cr[4] = ccp_addr_lo(&op->dst.u.dma);
@@ -159,7 +159,7 @@ static int ccp_perform_sha(struct ccp_op *op)
                | REQ1_INIT;
        cr[1] = op->src.u.dma.length - 1;
        cr[2] = ccp_addr_lo(&op->src.u.dma);
-       cr[3] = (op->ksb_ctx << REQ4_KSB_SHIFT)
+       cr[3] = (op->sb_ctx << REQ4_KSB_SHIFT)
                | (CCP_MEMTYPE_SYSTEM << REQ4_MEMTYPE_SHIFT)
                | ccp_addr_hi(&op->src.u.dma);
 
@@ -182,11 +182,11 @@ static int ccp_perform_rsa(struct ccp_op *op)
        /* Fill out the register contents for REQ1 through REQ6 */
        cr[0] = (CCP_ENGINE_RSA << REQ1_ENGINE_SHIFT)
                | (op->u.rsa.mod_size << REQ1_RSA_MOD_SIZE_SHIFT)
-               | (op->ksb_key << REQ1_KEY_KSB_SHIFT)
+               | (op->sb_key << REQ1_KEY_KSB_SHIFT)
                | REQ1_EOM;
        cr[1] = op->u.rsa.input_len - 1;
        cr[2] = ccp_addr_lo(&op->src.u.dma);
-       cr[3] = (op->ksb_ctx << REQ4_KSB_SHIFT)
+       cr[3] = (op->sb_ctx << REQ4_KSB_SHIFT)
                | (CCP_MEMTYPE_SYSTEM << REQ4_MEMTYPE_SHIFT)
                | ccp_addr_hi(&op->src.u.dma);
        cr[4] = ccp_addr_lo(&op->dst.u.dma);
@@ -216,10 +216,10 @@ static int ccp_perform_passthru(struct ccp_op *op)
                        | ccp_addr_hi(&op->src.u.dma);
 
                if (op->u.passthru.bit_mod != CCP_PASSTHRU_BITWISE_NOOP)
-                       cr[3] |= (op->ksb_key << REQ4_KSB_SHIFT);
+                       cr[3] |= (op->sb_key << REQ4_KSB_SHIFT);
        } else {
-               cr[2] = op->src.u.ksb * CCP_KSB_BYTES;
-               cr[3] = (CCP_MEMTYPE_KSB << REQ4_MEMTYPE_SHIFT);
+               cr[2] = op->src.u.sb * CCP_SB_BYTES;
+               cr[3] = (CCP_MEMTYPE_SB << REQ4_MEMTYPE_SHIFT);
        }
 
        if (op->dst.type == CCP_MEMTYPE_SYSTEM) {
@@ -227,8 +227,8 @@ static int ccp_perform_passthru(struct ccp_op *op)
                cr[5] = (CCP_MEMTYPE_SYSTEM << REQ6_MEMTYPE_SHIFT)
                        | ccp_addr_hi(&op->dst.u.dma);
        } else {
-               cr[4] = op->dst.u.ksb * CCP_KSB_BYTES;
-               cr[5] = (CCP_MEMTYPE_KSB << REQ6_MEMTYPE_SHIFT);
+               cr[4] = op->dst.u.sb * CCP_SB_BYTES;
+               cr[5] = (CCP_MEMTYPE_SB << REQ6_MEMTYPE_SHIFT);
        }
 
        if (op->eom)
@@ -322,9 +322,9 @@ static int ccp_init(struct ccp_device *ccp)
                cmd_q->dma_pool = dma_pool;
 
                /* Reserve 2 KSB regions for the queue */
-               cmd_q->ksb_key = KSB_START + ccp->ksb_start++;
-               cmd_q->ksb_ctx = KSB_START + ccp->ksb_start++;
-               ccp->ksb_count -= 2;
+               cmd_q->sb_key = KSB_START + ccp->sb_start++;
+               cmd_q->sb_ctx = KSB_START + ccp->sb_start++;
+               ccp->sb_count -= 2;
 
                /* Preset some register values and masks that are queue
                 * number dependent
@@ -376,7 +376,7 @@ static int ccp_init(struct ccp_device *ccp)
        }
 
        /* Initialize the queues used to wait for KSB space and suspend */
-       init_waitqueue_head(&ccp->ksb_queue);
+       init_waitqueue_head(&ccp->sb_queue);
        init_waitqueue_head(&ccp->suspend_queue);
 
        /* Create a kthread for each queue */
index 87b9f2bfa623b1c6a2752519fffcdb5957646874..9c8cfbb6841faa2aacc92150cc627f712eb0fe78 100644 (file)
@@ -4,6 +4,7 @@
  * Copyright (C) 2013,2016 Advanced Micro Devices, Inc.
  *
  * Author: Tom Lendacky <thomas.lendacky@amd.com>
+ * Author: Gary R Hook <gary.hook@amd.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -397,9 +398,9 @@ struct ccp_device *ccp_alloc_struct(struct device *dev)
 
        spin_lock_init(&ccp->cmd_lock);
        mutex_init(&ccp->req_mutex);
-       mutex_init(&ccp->ksb_mutex);
-       ccp->ksb_count = KSB_COUNT;
-       ccp->ksb_start = 0;
+       mutex_init(&ccp->sb_mutex);
+       ccp->sb_count = KSB_COUNT;
+       ccp->sb_start = 0;
 
        ccp->ord = ccp_increment_unit_ordinal();
        snprintf(ccp->name, MAX_CCP_NAME_LEN, "ccp-%u", ccp->ord);
index 46d3ef30c6e9ee6768527e7a3a756fd4a46d7fb1..1e30568d7c0412454a73a8e09971768f66b1baa0 100644 (file)
 #define KSB_START                      77
 #define KSB_END                                127
 #define KSB_COUNT                      (KSB_END - KSB_START + 1)
-#define CCP_KSB_BITS                   256
-#define CCP_KSB_BYTES                  32
+#define CCP_SB_BITS                    256
 
 #define CCP_JOBID_MASK                 0x0000003f
 
 
 #define CCP_REVERSE_BUF_SIZE           64
 
-#define CCP_AES_KEY_KSB_COUNT          1
-#define CCP_AES_CTX_KSB_COUNT          1
+#define CCP_AES_KEY_SB_COUNT           1
+#define CCP_AES_CTX_SB_COUNT           1
 
-#define CCP_XTS_AES_KEY_KSB_COUNT      1
-#define CCP_XTS_AES_CTX_KSB_COUNT      1
+#define CCP_XTS_AES_KEY_SB_COUNT       1
+#define CCP_XTS_AES_CTX_SB_COUNT       1
 
-#define CCP_SHA_KSB_COUNT              1
+#define CCP_SHA_SB_COUNT               1
 
 #define CCP_RSA_MAX_WIDTH              4096
 
 #define CCP_PASSTHRU_BLOCKSIZE         256
 #define CCP_PASSTHRU_MASKSIZE          32
-#define CCP_PASSTHRU_KSB_COUNT         1
+#define CCP_PASSTHRU_SB_COUNT          1
 
 #define CCP_ECC_MODULUS_BYTES          48      /* 384-bits */
 #define CCP_ECC_MAX_OPERANDS           6
 #define CCP_ECC_RESULT_OFFSET          60
 #define CCP_ECC_RESULT_SUCCESS         0x0001
 
+#define CCP_SB_BYTES                   32
+
 struct ccp_op;
 
 /* Structure for computation functions that are device-specific */
@@ -215,9 +216,9 @@ struct ccp_cmd_queue {
        /* Queue dma pool */
        struct dma_pool *dma_pool;
 
-       /* Queue reserved KSB regions */
-       u32 ksb_key;
-       u32 ksb_ctx;
+       /* Per-queue reserved storage block(s) */
+       u32 sb_key;
+       u32 sb_ctx;
 
        /* Queue processing thread */
        struct task_struct *kthread;
@@ -313,12 +314,12 @@ struct ccp_device {
         * to avoid allocation contention.  This will reserve at most 10 KSB
         * entries, leaving 40 KSB entries available for dynamic allocation.
         */
-       struct mutex ksb_mutex ____cacheline_aligned;
-       DECLARE_BITMAP(ksb, KSB_COUNT);
-       wait_queue_head_t ksb_queue;
-       unsigned int ksb_avail;
-       unsigned int ksb_count;
-       u32 ksb_start;
+       struct mutex sb_mutex ____cacheline_aligned;
+       DECLARE_BITMAP(sb, KSB_COUNT);
+       wait_queue_head_t sb_queue;
+       unsigned int sb_avail;
+       unsigned int sb_count;
+       u32 sb_start;
 
        /* Suspend support */
        unsigned int suspending;
@@ -330,7 +331,7 @@ struct ccp_device {
 
 enum ccp_memtype {
        CCP_MEMTYPE_SYSTEM = 0,
-       CCP_MEMTYPE_KSB,
+       CCP_MEMTYPE_SB,
        CCP_MEMTYPE_LOCAL,
        CCP_MEMTYPE__LAST,
 };
@@ -374,7 +375,7 @@ struct ccp_mem {
        enum ccp_memtype type;
        union {
                struct ccp_dma_info dma;
-               u32 ksb;
+               u32 sb;
        } u;
 };
 
@@ -414,8 +415,8 @@ struct ccp_op {
        u32 jobid;
        u32 ioc;
        u32 soc;
-       u32 ksb_key;
-       u32 ksb_ctx;
+       u32 sb_key;
+       u32 sb_ctx;
        u32 init;
        u32 eom;
 
index d1024771e926cee6792ebd5af98d304a33380d25..2c2890a4c2e2e4f62538d42097a5a540009a18ab 100644 (file)
@@ -46,25 +46,25 @@ static u32 ccp_alloc_ksb(struct ccp_device *ccp, unsigned int count)
        int start;
 
        for (;;) {
-               mutex_lock(&ccp->ksb_mutex);
+               mutex_lock(&ccp->sb_mutex);
 
-               start = (u32)bitmap_find_next_zero_area(ccp->ksb,
-                                                       ccp->ksb_count,
-                                                       ccp->ksb_start,
+               start = (u32)bitmap_find_next_zero_area(ccp->sb,
+                                                       ccp->sb_count,
+                                                       ccp->sb_start,
                                                        count, 0);
-               if (start <= ccp->ksb_count) {
-                       bitmap_set(ccp->ksb, start, count);
+               if (start <= ccp->sb_count) {
+                       bitmap_set(ccp->sb, start, count);
 
-                       mutex_unlock(&ccp->ksb_mutex);
+                       mutex_unlock(&ccp->sb_mutex);
                        break;
                }
 
-               ccp->ksb_avail = 0;
+               ccp->sb_avail = 0;
 
-               mutex_unlock(&ccp->ksb_mutex);
+               mutex_unlock(&ccp->sb_mutex);
 
                /* Wait for KSB entries to become available */
-               if (wait_event_interruptible(ccp->ksb_queue, ccp->ksb_avail))
+               if (wait_event_interruptible(ccp->sb_queue, ccp->sb_avail))
                        return 0;
        }
 
@@ -77,15 +77,15 @@ static void ccp_free_ksb(struct ccp_device *ccp, unsigned int start,
        if (!start)
                return;
 
-       mutex_lock(&ccp->ksb_mutex);
+       mutex_lock(&ccp->sb_mutex);
 
-       bitmap_clear(ccp->ksb, start - KSB_START, count);
+       bitmap_clear(ccp->sb, start - KSB_START, count);
 
-       ccp->ksb_avail = 1;
+       ccp->sb_avail = 1;
 
-       mutex_unlock(&ccp->ksb_mutex);
+       mutex_unlock(&ccp->sb_mutex);
 
-       wake_up_interruptible_all(&ccp->ksb_queue);
+       wake_up_interruptible_all(&ccp->sb_queue);
 }
 
 static u32 ccp_gen_jobid(struct ccp_device *ccp)
@@ -232,7 +232,7 @@ static int ccp_reverse_set_dm_area(struct ccp_dm_workarea *wa,
                                   unsigned int len, unsigned int se_len,
                                   bool sign_extend)
 {
-       unsigned int nbytes, sg_offset, dm_offset, ksb_len, i;
+       unsigned int nbytes, sg_offset, dm_offset, sb_len, i;
        u8 buffer[CCP_REVERSE_BUF_SIZE];
 
        if (WARN_ON(se_len > sizeof(buffer)))
@@ -242,21 +242,21 @@ static int ccp_reverse_set_dm_area(struct ccp_dm_workarea *wa,
        dm_offset = 0;
        nbytes = len;
        while (nbytes) {
-               ksb_len = min_t(unsigned int, nbytes, se_len);
-               sg_offset -= ksb_len;
+               sb_len = min_t(unsigned int, nbytes, se_len);
+               sg_offset -= sb_len;
 
-               scatterwalk_map_and_copy(buffer, sg, sg_offset, ksb_len, 0);
-               for (i = 0; i < ksb_len; i++)
-                       wa->address[dm_offset + i] = buffer[ksb_len - i - 1];
+               scatterwalk_map_and_copy(buffer, sg, sg_offset, sb_len, 0);
+               for (i = 0; i < sb_len; i++)
+                       wa->address[dm_offset + i] = buffer[sb_len - i - 1];
 
-               dm_offset += ksb_len;
-               nbytes -= ksb_len;
+               dm_offset += sb_len;
+               nbytes -= sb_len;
 
-               if ((ksb_len != se_len) && sign_extend) {
+               if ((sb_len != se_len) && sign_extend) {
                        /* Must sign-extend to nearest sign-extend length */
                        if (wa->address[dm_offset - 1] & 0x80)
                                memset(wa->address + dm_offset, 0xff,
-                                      se_len - ksb_len);
+                                      se_len - sb_len);
                }
        }
 
@@ -267,22 +267,22 @@ static void ccp_reverse_get_dm_area(struct ccp_dm_workarea *wa,
                                    struct scatterlist *sg,
                                    unsigned int len)
 {
-       unsigned int nbytes, sg_offset, dm_offset, ksb_len, i;
+       unsigned int nbytes, sg_offset, dm_offset, sb_len, i;
        u8 buffer[CCP_REVERSE_BUF_SIZE];
 
        sg_offset = 0;
        dm_offset = len;
        nbytes = len;
        while (nbytes) {
-               ksb_len = min_t(unsigned int, nbytes, sizeof(buffer));
-               dm_offset -= ksb_len;
+               sb_len = min_t(unsigned int, nbytes, sizeof(buffer));
+               dm_offset -= sb_len;
 
-               for (i = 0; i < ksb_len; i++)
-                       buffer[ksb_len - i - 1] = wa->address[dm_offset + i];
-               scatterwalk_map_and_copy(buffer, sg, sg_offset, ksb_len, 1);
+               for (i = 0; i < sb_len; i++)
+                       buffer[sb_len - i - 1] = wa->address[dm_offset + i];
+               scatterwalk_map_and_copy(buffer, sg, sg_offset, sb_len, 1);
 
-               sg_offset += ksb_len;
-               nbytes -= ksb_len;
+               sg_offset += sb_len;
+               nbytes -= sb_len;
        }
 }
 
@@ -450,9 +450,9 @@ static void ccp_process_data(struct ccp_data *src, struct ccp_data *dst,
        }
 }
 
-static int ccp_copy_to_from_ksb(struct ccp_cmd_queue *cmd_q,
-                               struct ccp_dm_workarea *wa, u32 jobid, u32 ksb,
-                               u32 byte_swap, bool from)
+static int ccp_copy_to_from_sb(struct ccp_cmd_queue *cmd_q,
+                              struct ccp_dm_workarea *wa, u32 jobid, u32 sb,
+                              u32 byte_swap, bool from)
 {
        struct ccp_op op;
 
@@ -464,8 +464,8 @@ static int ccp_copy_to_from_ksb(struct ccp_cmd_queue *cmd_q,
 
        if (from) {
                op.soc = 1;
-               op.src.type = CCP_MEMTYPE_KSB;
-               op.src.u.ksb = ksb;
+               op.src.type = CCP_MEMTYPE_SB;
+               op.src.u.sb = sb;
                op.dst.type = CCP_MEMTYPE_SYSTEM;
                op.dst.u.dma.address = wa->dma.address;
                op.dst.u.dma.length = wa->length;
@@ -473,8 +473,8 @@ static int ccp_copy_to_from_ksb(struct ccp_cmd_queue *cmd_q,
                op.src.type = CCP_MEMTYPE_SYSTEM;
                op.src.u.dma.address = wa->dma.address;
                op.src.u.dma.length = wa->length;
-               op.dst.type = CCP_MEMTYPE_KSB;
-               op.dst.u.ksb = ksb;
+               op.dst.type = CCP_MEMTYPE_SB;
+               op.dst.u.sb = sb;
        }
 
        op.u.passthru.byte_swap = byte_swap;
@@ -482,18 +482,18 @@ static int ccp_copy_to_from_ksb(struct ccp_cmd_queue *cmd_q,
        return cmd_q->ccp->vdata->perform->passthru(&op);
 }
 
-static int ccp_copy_to_ksb(struct ccp_cmd_queue *cmd_q,
-                          struct ccp_dm_workarea *wa, u32 jobid, u32 ksb,
-                          u32 byte_swap)
+static int ccp_copy_to_sb(struct ccp_cmd_queue *cmd_q,
+                         struct ccp_dm_workarea *wa, u32 jobid, u32 sb,
+                         u32 byte_swap)
 {
-       return ccp_copy_to_from_ksb(cmd_q, wa, jobid, ksb, byte_swap, false);
+       return ccp_copy_to_from_sb(cmd_q, wa, jobid, sb, byte_swap, false);
 }
 
-static int ccp_copy_from_ksb(struct ccp_cmd_queue *cmd_q,
-                            struct ccp_dm_workarea *wa, u32 jobid, u32 ksb,
-                            u32 byte_swap)
+static int ccp_copy_from_sb(struct ccp_cmd_queue *cmd_q,
+                           struct ccp_dm_workarea *wa, u32 jobid, u32 sb,
+                           u32 byte_swap)
 {
-       return ccp_copy_to_from_ksb(cmd_q, wa, jobid, ksb, byte_swap, true);
+       return ccp_copy_to_from_sb(cmd_q, wa, jobid, sb, byte_swap, true);
 }
 
 static int ccp_run_aes_cmac_cmd(struct ccp_cmd_queue *cmd_q,
@@ -528,54 +528,54 @@ static int ccp_run_aes_cmac_cmd(struct ccp_cmd_queue *cmd_q,
                        return -EINVAL;
        }
 
-       BUILD_BUG_ON(CCP_AES_KEY_KSB_COUNT != 1);
-       BUILD_BUG_ON(CCP_AES_CTX_KSB_COUNT != 1);
+       BUILD_BUG_ON(CCP_AES_KEY_SB_COUNT != 1);
+       BUILD_BUG_ON(CCP_AES_CTX_SB_COUNT != 1);
 
        ret = -EIO;
        memset(&op, 0, sizeof(op));
        op.cmd_q = cmd_q;
        op.jobid = ccp_gen_jobid(cmd_q->ccp);
-       op.ksb_key = cmd_q->ksb_key;
-       op.ksb_ctx = cmd_q->ksb_ctx;
+       op.sb_key = cmd_q->sb_key;
+       op.sb_ctx = cmd_q->sb_ctx;
        op.init = 1;
        op.u.aes.type = aes->type;
        op.u.aes.mode = aes->mode;
        op.u.aes.action = aes->action;
 
-       /* All supported key sizes fit in a single (32-byte) KSB entry
+       /* All supported key sizes fit in a single (32-byte) SB entry
         * and must be in little endian format. Use the 256-bit byte
         * swap passthru option to convert from big endian to little
         * endian.
         */
        ret = ccp_init_dm_workarea(&key, cmd_q,
-                                  CCP_AES_KEY_KSB_COUNT * CCP_KSB_BYTES,
+                                  CCP_AES_KEY_SB_COUNT * CCP_SB_BYTES,
                                   DMA_TO_DEVICE);
        if (ret)
                return ret;
 
-       dm_offset = CCP_KSB_BYTES - aes->key_len;
+       dm_offset = CCP_SB_BYTES - aes->key_len;
        ccp_set_dm_area(&key, dm_offset, aes->key, 0, aes->key_len);
-       ret = ccp_copy_to_ksb(cmd_q, &key, op.jobid, op.ksb_key,
-                             CCP_PASSTHRU_BYTESWAP_256BIT);
+       ret = ccp_copy_to_sb(cmd_q, &key, op.jobid, op.sb_key,
+                            CCP_PASSTHRU_BYTESWAP_256BIT);
        if (ret) {
                cmd->engine_error = cmd_q->cmd_error;
                goto e_key;
        }
 
-       /* The AES context fits in a single (32-byte) KSB entry and
+       /* The AES context fits in a single (32-byte) SB entry and
         * must be in little endian format. Use the 256-bit byte swap
         * passthru option to convert from big endian to little endian.
         */
        ret = ccp_init_dm_workarea(&ctx, cmd_q,
-                                  CCP_AES_CTX_KSB_COUNT * CCP_KSB_BYTES,
+                                  CCP_AES_CTX_SB_COUNT * CCP_SB_BYTES,
                                   DMA_BIDIRECTIONAL);
        if (ret)
                goto e_key;
 
-       dm_offset = CCP_KSB_BYTES - AES_BLOCK_SIZE;
+       dm_offset = CCP_SB_BYTES - AES_BLOCK_SIZE;
        ccp_set_dm_area(&ctx, dm_offset, aes->iv, 0, aes->iv_len);
-       ret = ccp_copy_to_ksb(cmd_q, &ctx, op.jobid, op.ksb_ctx,
-                             CCP_PASSTHRU_BYTESWAP_256BIT);
+       ret = ccp_copy_to_sb(cmd_q, &ctx, op.jobid, op.sb_ctx,
+                            CCP_PASSTHRU_BYTESWAP_256BIT);
        if (ret) {
                cmd->engine_error = cmd_q->cmd_error;
                goto e_ctx;
@@ -593,9 +593,9 @@ static int ccp_run_aes_cmac_cmd(struct ccp_cmd_queue *cmd_q,
                        op.eom = 1;
 
                        /* Push the K1/K2 key to the CCP now */
-                       ret = ccp_copy_from_ksb(cmd_q, &ctx, op.jobid,
-                                               op.ksb_ctx,
-                                               CCP_PASSTHRU_BYTESWAP_256BIT);
+                       ret = ccp_copy_from_sb(cmd_q, &ctx, op.jobid,
+                                              op.sb_ctx,
+                                              CCP_PASSTHRU_BYTESWAP_256BIT);
                        if (ret) {
                                cmd->engine_error = cmd_q->cmd_error;
                                goto e_src;
@@ -603,8 +603,8 @@ static int ccp_run_aes_cmac_cmd(struct ccp_cmd_queue *cmd_q,
 
                        ccp_set_dm_area(&ctx, 0, aes->cmac_key, 0,
                                        aes->cmac_key_len);
-                       ret = ccp_copy_to_ksb(cmd_q, &ctx, op.jobid, op.ksb_ctx,
-                                             CCP_PASSTHRU_BYTESWAP_256BIT);
+                       ret = ccp_copy_to_sb(cmd_q, &ctx, op.jobid, op.sb_ctx,
+                                            CCP_PASSTHRU_BYTESWAP_256BIT);
                        if (ret) {
                                cmd->engine_error = cmd_q->cmd_error;
                                goto e_src;
@@ -623,15 +623,15 @@ static int ccp_run_aes_cmac_cmd(struct ccp_cmd_queue *cmd_q,
        /* Retrieve the AES context - convert from LE to BE using
         * 32-byte (256-bit) byteswapping
         */
-       ret = ccp_copy_from_ksb(cmd_q, &ctx, op.jobid, op.ksb_ctx,
-                               CCP_PASSTHRU_BYTESWAP_256BIT);
+       ret = ccp_copy_from_sb(cmd_q, &ctx, op.jobid, op.sb_ctx,
+                              CCP_PASSTHRU_BYTESWAP_256BIT);
        if (ret) {
                cmd->engine_error = cmd_q->cmd_error;
                goto e_src;
        }
 
        /* ...but we only need AES_BLOCK_SIZE bytes */
-       dm_offset = CCP_KSB_BYTES - AES_BLOCK_SIZE;
+       dm_offset = CCP_SB_BYTES - AES_BLOCK_SIZE;
        ccp_get_dm_area(&ctx, dm_offset, aes->iv, 0, aes->iv_len);
 
 e_src:
@@ -681,56 +681,56 @@ static int ccp_run_aes_cmd(struct ccp_cmd_queue *cmd_q, struct ccp_cmd *cmd)
                        return -EINVAL;
        }
 
-       BUILD_BUG_ON(CCP_AES_KEY_KSB_COUNT != 1);
-       BUILD_BUG_ON(CCP_AES_CTX_KSB_COUNT != 1);
+       BUILD_BUG_ON(CCP_AES_KEY_SB_COUNT != 1);
+       BUILD_BUG_ON(CCP_AES_CTX_SB_COUNT != 1);
 
        ret = -EIO;
        memset(&op, 0, sizeof(op));
        op.cmd_q = cmd_q;
        op.jobid = ccp_gen_jobid(cmd_q->ccp);
-       op.ksb_key = cmd_q->ksb_key;
-       op.ksb_ctx = cmd_q->ksb_ctx;
+       op.sb_key = cmd_q->sb_key;
+       op.sb_ctx = cmd_q->sb_ctx;
        op.init = (aes->mode == CCP_AES_MODE_ECB) ? 0 : 1;
        op.u.aes.type = aes->type;
        op.u.aes.mode = aes->mode;
        op.u.aes.action = aes->action;
 
-       /* All supported key sizes fit in a single (32-byte) KSB entry
+       /* All supported key sizes fit in a single (32-byte) SB entry
         * and must be in little endian format. Use the 256-bit byte
         * swap passthru option to convert from big endian to little
         * endian.
         */
        ret = ccp_init_dm_workarea(&key, cmd_q,
-                                  CCP_AES_KEY_KSB_COUNT * CCP_KSB_BYTES,
+                                  CCP_AES_KEY_SB_COUNT * CCP_SB_BYTES,
                                   DMA_TO_DEVICE);
        if (ret)
                return ret;
 
-       dm_offset = CCP_KSB_BYTES - aes->key_len;
+       dm_offset = CCP_SB_BYTES - aes->key_len;
        ccp_set_dm_area(&key, dm_offset, aes->key, 0, aes->key_len);
-       ret = ccp_copy_to_ksb(cmd_q, &key, op.jobid, op.ksb_key,
-                             CCP_PASSTHRU_BYTESWAP_256BIT);
+       ret = ccp_copy_to_sb(cmd_q, &key, op.jobid, op.sb_key,
+                            CCP_PASSTHRU_BYTESWAP_256BIT);
        if (ret) {
                cmd->engine_error = cmd_q->cmd_error;
                goto e_key;
        }
 
-       /* The AES context fits in a single (32-byte) KSB entry and
+       /* The AES context fits in a single (32-byte) SB entry and
         * must be in little endian format. Use the 256-bit byte swap
         * passthru option to convert from big endian to little endian.
         */
        ret = ccp_init_dm_workarea(&ctx, cmd_q,
-                                  CCP_AES_CTX_KSB_COUNT * CCP_KSB_BYTES,
+                                  CCP_AES_CTX_SB_COUNT * CCP_SB_BYTES,
                                   DMA_BIDIRECTIONAL);
        if (ret)
                goto e_key;
 
        if (aes->mode != CCP_AES_MODE_ECB) {
                /* Load the AES context - conver to LE */
-               dm_offset = CCP_KSB_BYTES - AES_BLOCK_SIZE;
+               dm_offset = CCP_SB_BYTES - AES_BLOCK_SIZE;
                ccp_set_dm_area(&ctx, dm_offset, aes->iv, 0, aes->iv_len);
-               ret = ccp_copy_to_ksb(cmd_q, &ctx, op.jobid, op.ksb_ctx,
-                                     CCP_PASSTHRU_BYTESWAP_256BIT);
+               ret = ccp_copy_to_sb(cmd_q, &ctx, op.jobid, op.sb_ctx,
+                                    CCP_PASSTHRU_BYTESWAP_256BIT);
                if (ret) {
                        cmd->engine_error = cmd_q->cmd_error;
                        goto e_ctx;
@@ -786,15 +786,15 @@ static int ccp_run_aes_cmd(struct ccp_cmd_queue *cmd_q, struct ccp_cmd *cmd)
                /* Retrieve the AES context - convert from LE to BE using
                 * 32-byte (256-bit) byteswapping
                 */
-               ret = ccp_copy_from_ksb(cmd_q, &ctx, op.jobid, op.ksb_ctx,
-                                       CCP_PASSTHRU_BYTESWAP_256BIT);
+               ret = ccp_copy_from_sb(cmd_q, &ctx, op.jobid, op.sb_ctx,
+                                      CCP_PASSTHRU_BYTESWAP_256BIT);
                if (ret) {
                        cmd->engine_error = cmd_q->cmd_error;
                        goto e_dst;
                }
 
                /* ...but we only need AES_BLOCK_SIZE bytes */
-               dm_offset = CCP_KSB_BYTES - AES_BLOCK_SIZE;
+               dm_offset = CCP_SB_BYTES - AES_BLOCK_SIZE;
                ccp_get_dm_area(&ctx, dm_offset, aes->iv, 0, aes->iv_len);
        }
 
@@ -858,53 +858,53 @@ static int ccp_run_xts_aes_cmd(struct ccp_cmd_queue *cmd_q,
        if (!xts->key || !xts->iv || !xts->src || !xts->dst)
                return -EINVAL;
 
-       BUILD_BUG_ON(CCP_XTS_AES_KEY_KSB_COUNT != 1);
-       BUILD_BUG_ON(CCP_XTS_AES_CTX_KSB_COUNT != 1);
+       BUILD_BUG_ON(CCP_XTS_AES_KEY_SB_COUNT != 1);
+       BUILD_BUG_ON(CCP_XTS_AES_CTX_SB_COUNT != 1);
 
        ret = -EIO;
        memset(&op, 0, sizeof(op));
        op.cmd_q = cmd_q;
        op.jobid = ccp_gen_jobid(cmd_q->ccp);
-       op.ksb_key = cmd_q->ksb_key;
-       op.ksb_ctx = cmd_q->ksb_ctx;
+       op.sb_key = cmd_q->sb_key;
+       op.sb_ctx = cmd_q->sb_ctx;
        op.init = 1;
        op.u.xts.action = xts->action;
        op.u.xts.unit_size = xts->unit_size;
 
-       /* All supported key sizes fit in a single (32-byte) KSB entry
+       /* All supported key sizes fit in a single (32-byte) SB entry
         * and must be in little endian format. Use the 256-bit byte
         * swap passthru option to convert from big endian to little
         * endian.
         */
        ret = ccp_init_dm_workarea(&key, cmd_q,
-                                  CCP_XTS_AES_KEY_KSB_COUNT * CCP_KSB_BYTES,
+                                  CCP_XTS_AES_KEY_SB_COUNT * CCP_SB_BYTES,
                                   DMA_TO_DEVICE);
        if (ret)
                return ret;
 
-       dm_offset = CCP_KSB_BYTES - AES_KEYSIZE_128;
+       dm_offset = CCP_SB_BYTES - AES_KEYSIZE_128;
        ccp_set_dm_area(&key, dm_offset, xts->key, 0, xts->key_len);
        ccp_set_dm_area(&key, 0, xts->key, dm_offset, xts->key_len);
-       ret = ccp_copy_to_ksb(cmd_q, &key, op.jobid, op.ksb_key,
-                             CCP_PASSTHRU_BYTESWAP_256BIT);
+       ret = ccp_copy_to_sb(cmd_q, &key, op.jobid, op.sb_key,
+                            CCP_PASSTHRU_BYTESWAP_256BIT);
        if (ret) {
                cmd->engine_error = cmd_q->cmd_error;
                goto e_key;
        }
 
-       /* The AES context fits in a single (32-byte) KSB entry and
+       /* The AES context fits in a single (32-byte) SB entry and
         * for XTS is already in little endian format so no byte swapping
         * is needed.
         */
        ret = ccp_init_dm_workarea(&ctx, cmd_q,
-                                  CCP_XTS_AES_CTX_KSB_COUNT * CCP_KSB_BYTES,
+                                  CCP_XTS_AES_CTX_SB_COUNT * CCP_SB_BYTES,
                                   DMA_BIDIRECTIONAL);
        if (ret)
                goto e_key;
 
        ccp_set_dm_area(&ctx, 0, xts->iv, 0, xts->iv_len);
-       ret = ccp_copy_to_ksb(cmd_q, &ctx, op.jobid, op.ksb_ctx,
-                             CCP_PASSTHRU_BYTESWAP_NOOP);
+       ret = ccp_copy_to_sb(cmd_q, &ctx, op.jobid, op.sb_ctx,
+                            CCP_PASSTHRU_BYTESWAP_NOOP);
        if (ret) {
                cmd->engine_error = cmd_q->cmd_error;
                goto e_ctx;
@@ -950,15 +950,15 @@ static int ccp_run_xts_aes_cmd(struct ccp_cmd_queue *cmd_q,
        /* Retrieve the AES context - convert from LE to BE using
         * 32-byte (256-bit) byteswapping
         */
-       ret = ccp_copy_from_ksb(cmd_q, &ctx, op.jobid, op.ksb_ctx,
-                               CCP_PASSTHRU_BYTESWAP_256BIT);
+       ret = ccp_copy_from_sb(cmd_q, &ctx, op.jobid, op.sb_ctx,
+                              CCP_PASSTHRU_BYTESWAP_256BIT);
        if (ret) {
                cmd->engine_error = cmd_q->cmd_error;
                goto e_dst;
        }
 
        /* ...but we only need AES_BLOCK_SIZE bytes */
-       dm_offset = CCP_KSB_BYTES - AES_BLOCK_SIZE;
+       dm_offset = CCP_SB_BYTES - AES_BLOCK_SIZE;
        ccp_get_dm_area(&ctx, dm_offset, xts->iv, 0, xts->iv_len);
 
 e_dst:
@@ -1036,21 +1036,21 @@ static int ccp_run_sha_cmd(struct ccp_cmd_queue *cmd_q, struct ccp_cmd *cmd)
        if (!sha->src)
                return -EINVAL;
 
-       BUILD_BUG_ON(CCP_SHA_KSB_COUNT != 1);
+       BUILD_BUG_ON(CCP_SHA_SB_COUNT != 1);
 
        memset(&op, 0, sizeof(op));
        op.cmd_q = cmd_q;
        op.jobid = ccp_gen_jobid(cmd_q->ccp);
-       op.ksb_ctx = cmd_q->ksb_ctx;
+       op.sb_ctx = cmd_q->sb_ctx;
        op.u.sha.type = sha->type;
        op.u.sha.msg_bits = sha->msg_bits;
 
-       /* The SHA context fits in a single (32-byte) KSB entry and
+       /* The SHA context fits in a single (32-byte) SB entry and
         * must be in little endian format. Use the 256-bit byte swap
         * passthru option to convert from big endian to little endian.
         */
        ret = ccp_init_dm_workarea(&ctx, cmd_q,
-                                  CCP_SHA_KSB_COUNT * CCP_KSB_BYTES,
+                                  CCP_SHA_SB_COUNT * CCP_SB_BYTES,
                                   DMA_BIDIRECTIONAL);
        if (ret)
                return ret;
@@ -1077,8 +1077,8 @@ static int ccp_run_sha_cmd(struct ccp_cmd_queue *cmd_q, struct ccp_cmd *cmd)
                ccp_set_dm_area(&ctx, 0, sha->ctx, 0, sha->ctx_len);
        }
 
-       ret = ccp_copy_to_ksb(cmd_q, &ctx, op.jobid, op.ksb_ctx,
-                             CCP_PASSTHRU_BYTESWAP_256BIT);
+       ret = ccp_copy_to_sb(cmd_q, &ctx, op.jobid, op.sb_ctx,
+                            CCP_PASSTHRU_BYTESWAP_256BIT);
        if (ret) {
                cmd->engine_error = cmd_q->cmd_error;
                goto e_ctx;
@@ -1107,8 +1107,8 @@ static int ccp_run_sha_cmd(struct ccp_cmd_queue *cmd_q, struct ccp_cmd *cmd)
        /* Retrieve the SHA context - convert from LE to BE using
         * 32-byte (256-bit) byteswapping to BE
         */
-       ret = ccp_copy_from_ksb(cmd_q, &ctx, op.jobid, op.ksb_ctx,
-                               CCP_PASSTHRU_BYTESWAP_256BIT);
+       ret = ccp_copy_from_sb(cmd_q, &ctx, op.jobid, op.sb_ctx,
+                              CCP_PASSTHRU_BYTESWAP_256BIT);
        if (ret) {
                cmd->engine_error = cmd_q->cmd_error;
                goto e_data;
@@ -1191,7 +1191,7 @@ static int ccp_run_rsa_cmd(struct ccp_cmd_queue *cmd_q, struct ccp_cmd *cmd)
        struct ccp_dm_workarea exp, src;
        struct ccp_data dst;
        struct ccp_op op;
-       unsigned int ksb_count, i_len, o_len;
+       unsigned int sb_count, i_len, o_len;
        int ret;
 
        if (rsa->key_size > CCP_RSA_MAX_WIDTH)
@@ -1209,16 +1209,16 @@ static int ccp_run_rsa_cmd(struct ccp_cmd_queue *cmd_q, struct ccp_cmd *cmd)
        o_len = ((rsa->key_size + 255) / 256) * 32;
        i_len = o_len * 2;
 
-       ksb_count = o_len / CCP_KSB_BYTES;
+       sb_count = o_len / CCP_SB_BYTES;
 
        memset(&op, 0, sizeof(op));
        op.cmd_q = cmd_q;
        op.jobid = ccp_gen_jobid(cmd_q->ccp);
-       op.ksb_key = ccp_alloc_ksb(cmd_q->ccp, ksb_count);
-       if (!op.ksb_key)
+       op.sb_key = ccp_alloc_ksb(cmd_q->ccp, sb_count);
+       if (!op.sb_key)
                return -EIO;
 
-       /* The RSA exponent may span multiple (32-byte) KSB entries and must
+       /* The RSA exponent may span multiple (32-byte) SB entries and must
         * be in little endian format. Reverse copy each 32-byte chunk
         * of the exponent (En chunk to E0 chunk, E(n-1) chunk to E1 chunk)
         * and each byte within that chunk and do not perform any byte swap
@@ -1226,14 +1226,14 @@ static int ccp_run_rsa_cmd(struct ccp_cmd_queue *cmd_q, struct ccp_cmd *cmd)
         */
        ret = ccp_init_dm_workarea(&exp, cmd_q, o_len, DMA_TO_DEVICE);
        if (ret)
-               goto e_ksb;
+               goto e_sb;
 
        ret = ccp_reverse_set_dm_area(&exp, rsa->exp, rsa->exp_len,
-                                     CCP_KSB_BYTES, false);
+                                     CCP_SB_BYTES, false);
        if (ret)
                goto e_exp;
-       ret = ccp_copy_to_ksb(cmd_q, &exp, op.jobid, op.ksb_key,
-                             CCP_PASSTHRU_BYTESWAP_NOOP);
+       ret = ccp_copy_to_sb(cmd_q, &exp, op.jobid, op.sb_key,
+                            CCP_PASSTHRU_BYTESWAP_NOOP);
        if (ret) {
                cmd->engine_error = cmd_q->cmd_error;
                goto e_exp;
@@ -1248,12 +1248,12 @@ static int ccp_run_rsa_cmd(struct ccp_cmd_queue *cmd_q, struct ccp_cmd *cmd)
                goto e_exp;
 
        ret = ccp_reverse_set_dm_area(&src, rsa->mod, rsa->mod_len,
-                                     CCP_KSB_BYTES, false);
+                                     CCP_SB_BYTES, false);
        if (ret)
                goto e_src;
        src.address += o_len;   /* Adjust the address for the copy operation */
        ret = ccp_reverse_set_dm_area(&src, rsa->src, rsa->src_len,
-                                     CCP_KSB_BYTES, false);
+                                     CCP_SB_BYTES, false);
        if (ret)
                goto e_src;
        src.address -= o_len;   /* Reset the address to original value */
@@ -1292,8 +1292,8 @@ e_src:
 e_exp:
        ccp_dm_free(&exp);
 
-e_ksb:
-       ccp_free_ksb(cmd_q->ccp, op.ksb_key, ksb_count);
+e_sb:
+       ccp_free_ksb(cmd_q->ccp, op.sb_key, sb_count);
 
        return ret;
 }
@@ -1322,7 +1322,7 @@ static int ccp_run_passthru_cmd(struct ccp_cmd_queue *cmd_q,
                        return -EINVAL;
        }
 
-       BUILD_BUG_ON(CCP_PASSTHRU_KSB_COUNT != 1);
+       BUILD_BUG_ON(CCP_PASSTHRU_SB_COUNT != 1);
 
        memset(&op, 0, sizeof(op));
        op.cmd_q = cmd_q;
@@ -1330,18 +1330,18 @@ static int ccp_run_passthru_cmd(struct ccp_cmd_queue *cmd_q,
 
        if (pt->bit_mod != CCP_PASSTHRU_BITWISE_NOOP) {
                /* Load the mask */
-               op.ksb_key = cmd_q->ksb_key;
+               op.sb_key = cmd_q->sb_key;
 
                ret = ccp_init_dm_workarea(&mask, cmd_q,
-                                          CCP_PASSTHRU_KSB_COUNT *
-                                          CCP_KSB_BYTES,
+                                          CCP_PASSTHRU_SB_COUNT *
+                                          CCP_SB_BYTES,
                                           DMA_TO_DEVICE);
                if (ret)
                        return ret;
 
                ccp_set_dm_area(&mask, 0, pt->mask, 0, pt->mask_len);
-               ret = ccp_copy_to_ksb(cmd_q, &mask, op.jobid, op.ksb_key,
-                                     CCP_PASSTHRU_BYTESWAP_NOOP);
+               ret = ccp_copy_to_sb(cmd_q, &mask, op.jobid, op.sb_key,
+                                    CCP_PASSTHRU_BYTESWAP_NOOP);
                if (ret) {
                        cmd->engine_error = cmd_q->cmd_error;
                        goto e_mask;
@@ -1449,7 +1449,7 @@ static int ccp_run_passthru_nomap_cmd(struct ccp_cmd_queue *cmd_q,
                        return -EINVAL;
        }
 
-       BUILD_BUG_ON(CCP_PASSTHRU_KSB_COUNT != 1);
+       BUILD_BUG_ON(CCP_PASSTHRU_SB_COUNT != 1);
 
        memset(&op, 0, sizeof(op));
        op.cmd_q = cmd_q;
@@ -1457,13 +1457,13 @@ static int ccp_run_passthru_nomap_cmd(struct ccp_cmd_queue *cmd_q,
 
        if (pt->bit_mod != CCP_PASSTHRU_BITWISE_NOOP) {
                /* Load the mask */
-               op.ksb_key = cmd_q->ksb_key;
+               op.sb_key = cmd_q->sb_key;
 
                mask.length = pt->mask_len;
                mask.dma.address = pt->mask;
                mask.dma.length = pt->mask_len;
 
-               ret = ccp_copy_to_ksb(cmd_q, &mask, op.jobid, op.ksb_key,
+               ret = ccp_copy_to_sb(cmd_q, &mask, op.jobid, op.sb_key,
                                     CCP_PASSTHRU_BYTESWAP_NOOP);
                if (ret) {
                        cmd->engine_error = cmd_q->cmd_error;