Re: [U-Boot] [PATCH 1/4 v3] Exynos: Add hardware accelerated SHA 256

Hi Akshay,

On Fri, Mar 1, 2013 at 8:16 AM, Akshay Saraswat akshay.s@samsung.com wrote:

SHA-256 and SHA-1 accelerated using ACE hardware.

Tested with command "hash sha256 0x40008000 0x2B 0x40009000". Used mm and md to write a standard string to memory location 0x40008000 and ran the above command to verify the output.

Signed-off-by: ARUN MANKUZHI arun.m@samsung.com Signed-off-by: Akshay Saraswat akshay.s@samsung.com

---

Changes since v2: - Added falling back to software sha256 in case length exceeds buffer limit. - Reduced one tab at lines 533, 559 and 571 in this patch. - Removed space after a cast at line 506 in this patch. - Removed blank line at line 561 in this patch. - Removed space before semicolon at line 576 in this patch.

Makefile | 1 + arch/arm/include/asm/arch-exynos/cpu.h | 4 + drivers/crypto/Makefile | 47 +++++ drivers/crypto/ace_sfr.h | 310 +++++++++++++++++++++++++++++++++ drivers/crypto/ace_sha.c | 127 ++++++++++++++ include/ace_sha.h | 42 +++++ 6 files changed, 531 insertions(+) create mode 100644 drivers/crypto/Makefile create mode 100644 drivers/crypto/ace_sfr.h create mode 100644 drivers/crypto/ace_sha.c create mode 100644 include/ace_sha.h

[...]

+++ b/drivers/crypto/ace_sha.c @@ -0,0 +1,127 @@ +/*

• • Advanced Crypto Engine - SHA Firmware
• • Copyright (c) 2012 Samsung Electronics
• • This program is free software; you can redistribute it and/or modify
• • it under the terms of the GNU General Public License as published by
• • the Free Software Foundation; either version 2 of the License, or
• • (at your option) any later version.
• • This program is distributed in the hope that it will be useful,
• • but WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
• • GNU General Public License for more details.
• • You should have received a copy of the GNU General Public License
• • along with this program; if not, write to the Free Software
• • Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
• */

+#include <common.h> +#include <sha256.h> +#include <sha1.h> +#include <ace_sha.h> +#include "ace_sfr.h"

+/* Timeout for data size above 8MB */ +#define TIMEOUT_MS 100 +/* Maximum input data size is 8 MB */ +#define BUF_LIMIT 8*1024*1024

brackets around this spaces around *

+/* SHA1 value for the message of zero length */ +static const unsigned char sha1_digest_emptymsg[SHA1_SUM_LEN] = {

•   0xDA, 0x39, 0xA3, 0xEE, 0x5E, 0x6B, 0x4B, 0x0D,
  

•   0x32, 0x55, 0xBF, 0xFF, 0x95, 0x60, 0x18, 0x90,
  

•   0xAF, 0xD8, 0x07, 0x09};
  

+/* SHA256 value for the message of zero length */ +static const unsigned char sha256_digest_emptymsg[SHA256_SUM_LEN] = {

•   0xE3, 0xB0, 0xC4, 0x42, 0x98, 0xFC, 0x1C, 0x14,
  

•   0x9A, 0xFB, 0xF4, 0xC8, 0x99, 0x6F, 0xB9, 0x24,
  

•   0x27, 0xAE, 0x41, 0xE4, 0x64, 0x9B, 0x93, 0x4C,
  

•   0xA4, 0x95, 0x99, 0x1B, 0x78, 0x52, 0xB8, 0x55};
  

+int ace_sha_hash_digest(const unsigned char *pbuf, unsigned int buf_len,

•                   unsigned char *pout, unsigned int hash_type)
  

+{

•   unsigned int i, reg, len;
  

•   unsigned int *pdigest;
  

•   ulong start;
  

•   struct exynos_ace_sfr *ace_sha_reg =
  

•           (struct exynos_ace_sfr *)samsung_get_base_ace_sfr();
  

•   if (buf_len == 0) {
  

•           /* ACE H/W cannot compute hash value for empty string */
  

•           if (hash_type == ACE_SHA_TYPE_SHA1)
  

•                   memcpy(pout, sha1_digest_emptymsg, SHA1_SUM_LEN);
  

•           else
  

•                   memcpy(pout, sha256_digest_emptymsg, SHA256_SUM_LEN);
  

•           return 0;
  

•   } else if (buf_len > BUF_LIMIT) {
  

•           /*
  

•            * ACE H/W cannot compute hash value for buffer > 8 MB.
  

•            * Falling back to software.
  

•            */
  

•           if (hash_type == ACE_SHA_TYPE_SHA1)
  

•                   sha1_csum_wd(pbuf, buf_len, pout, CHUNKSZ_SHA1);
  

•           else
  

•                   sha256_csum_wd(pbuf, buf_len, pout, CHUNKSZ_SHA256);
  

This is kind-of odd, but I suppose it is OK for now. Perhaps we should support dealing with errors and falling back to the next available algorithm in hash.c. But for now this is OK.

•           return 0;
  

•   }
  

•   /* Flush HRDMA */
  

•   writel(ACE_FC_HRDMACFLUSH_ON, &ace_sha_reg->fc_hrdmac);
  

•   writel(ACE_FC_HRDMACFLUSH_OFF, &ace_sha_reg->fc_hrdmac);
  

•   /* Set byte swap of data in */
  

•   writel(ACE_HASH_SWAPDI_ON | ACE_HASH_SWAPDO_ON | ACE_HASH_SWAPIV_ON,
  

•           &ace_sha_reg->hash_byteswap);
  

•   /* Select Hash input mux as external source */
  

•   reg = readl(&ace_sha_reg->fc_fifoctrl);
  

•   reg = (reg & ~ACE_FC_SELHASH_MASK) | ACE_FC_SELHASH_EXOUT;
  

•   writel(reg, &ace_sha_reg->fc_fifoctrl);
  

•   /* Set Hash as SHA1 or SHA256 and start Hash engine */
  

•   reg = (hash_type == ACE_SHA_TYPE_SHA1) ?
  

•           ACE_HASH_ENGSEL_SHA1HASH : ACE_HASH_ENGSEL_SHA256HASH;
  

•   reg |= ACE_HASH_STARTBIT_ON;
  

•   writel(reg, &ace_sha_reg->hash_control);
  

•   /* Enable FIFO mode */
  

•   writel(ACE_HASH_FIFO_ON, &ace_sha_reg->hash_fifo_mode);
  

•   /* Set message length */
  

•   writel(buf_len, &ace_sha_reg->hash_msgsize_low);
  

•   writel(0, &ace_sha_reg->hash_msgsize_high);
  

•   /* Set HRDMA */
  

•   writel((unsigned int)pbuf, &ace_sha_reg->fc_hrdmas);
  

•   writel(buf_len, &ace_sha_reg->fc_hrdmal);
  

•   start = get_timer(0);
  

•   while ((readl(&ace_sha_reg->hash_status) & ACE_HASH_MSGDONE_MASK) ==
  

•           ACE_HASH_MSGDONE_OFF) {
  

•           if (get_timer(start) > TIMEOUT_MS) {
  

•                   debug("%s: Timeout waiting for ACE\n", __func__);
  

•                   return -1;
  

return -ETIMEDOUT;

You need into #include <asm/errno.h>

•           }
  

•   }
  

•   /* Clear MSG_DONE bit */
  

•   writel(ACE_HASH_MSGDONE_ON, &ace_sha_reg->hash_status);
  

•   /* Read hash result */
  

•   pdigest = (unsigned int *)pout;
  

•   len = (hash_type == ACE_SHA_TYPE_SHA1) ? SHA1_SUM_LEN / 4
  

•           : SHA256_SUM_LEN / 4;
  

Suggest removing / 4 here...

•   for (i = 0; i < len; i++)
  

...and putting i += 4 here

•           pdigest[i] = readl(&ace_sha_reg->hash_result[i]);
  

•   /* Clear HRDMA pending bit */
  

•   writel(ACE_FC_HRDMA, &ace_sha_reg->fc_intpend);
  

•   return 0;
  

+} diff --git a/include/ace_sha.h b/include/ace_sha.h new file mode 100644 index 0000000..5c1ce48 --- /dev/null +++ b/include/ace_sha.h @@ -0,0 +1,42 @@ +/*

• • Header file for SHA firmware
• • Copyright (c) 2012 Samsung Electronics
• • This program is free software; you can redistribute it and/or modify
• • it under the terms of the GNU General Public License as published by
• • the Free Software Foundation; either version 2 of the License, or
• • (at your option) any later version.
• • This program is distributed in the hope that it will be useful,
• • but WITHOUT ANY WARRANTY; without even the implied warranty of
• • MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
• • GNU General Public License for more details.
• • You should have received a copy of the GNU General Public License
• • along with this program; if not, write to the Free Software
• • Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
• */

+#ifndef __ACE_FW_SHA1_H +#define __ACE_FW_SHA1_H

+#define ACE_SHA_TYPE_SHA1 1 +#define ACE_SHA_TYPE_SHA256 2

+/**

• • Computes hash value of input pbuf using ACE
• • @param in_addr A pointer to the input buffer
• • @param bufleni Byte length of input buffer
• • @param out_addr A pointer to the output buffer. When complete

• •                 32 bytes are copied to pout[0]...pout[31]. Thus, a user
    

• •                 should allocate at least 32 bytes at pOut in advance.
    

• • @param hash_type SHA1 or SHA256
• • @return 0 Success

-1 on failure (timeout)

• */

+int ace_sha_hash_digest(const uchar *in_addr, uint buflen,

•                   uchar *out_addr, uint hash_type);
  

+#endif

1.8.0

Regards, Simon