target/linux/coldfire/patches/011-Add-CAU-driver-for-MCF5445x-and-MCF5441x.patch

   1 From 0419eb27af72bd37c3ef926169fe4db90e8690d3 Mon Sep 17 00:00:00 2001
   2 From: Alison Wang <b18965@freescale.com>
   3 Date: Thu, 4 Aug 2011 09:59:41 +0800
   4 Subject: [PATCH 11/52] Add CAU driver for MCF5445x and MCF5441x
   5
   6 Add CAU driver support for MCF5445x and MCF5441x.
   7
   8 Signed-off-by: Alison Wang <b18965@freescale.com>
   9 ---
  10  crypto/testmgr.c             |   13 +-
  11  drivers/crypto/Kconfig       |   65 +++
  12  drivers/crypto/Makefile      |    5 +
  13  drivers/crypto/mcfcau-aes.c  |  367 ++++++++++++++++
  14  drivers/crypto/mcfcau-des.c  |  525 +++++++++++++++++++++++
  15  drivers/crypto/mcfcau-md5.c  |  972 ++++++++++++++++++++++++++++++++++++++++++
  16  drivers/crypto/mcfcau-sha1.c |  331 ++++++++++++++
  17  drivers/crypto/mcfcau.c      |   33 ++
  18  drivers/crypto/mcfcau.h      |  101 +++++
  19  9 files changed, 2410 insertions(+), 2 deletions(-)
  20  create mode 100644 drivers/crypto/mcfcau-aes.c
  21  create mode 100644 drivers/crypto/mcfcau-des.c
  22  create mode 100644 drivers/crypto/mcfcau-md5.c
  23  create mode 100644 drivers/crypto/mcfcau-sha1.c
  24  create mode 100644 drivers/crypto/mcfcau.c
  25  create mode 100644 drivers/crypto/mcfcau.h
  26
  27 --- a/crypto/testmgr.c
  28 +++ b/crypto/testmgr.c
  29 @@ -705,6 +705,7 @@ static int test_cipher(struct crypto_cip
  30         else
  31                 e = "decryption";
  32
  33 +       printk(KERN_INFO "%s testing %s %s\n", __func__, algo, e);
  34         j = 0;
  35         for (i = 0; i < tcount; i++) {
  36                 if (template[i].np)
  37 @@ -750,7 +751,9 @@ static int test_cipher(struct crypto_cip
  38                         hexdump(q, template[i].rlen);
  39                         ret = -EINVAL;
  40                         goto out;
  41 -               }
  42 +               } else
  43 +                       printk(KERN_INFO "alg: cipher: Test %d pass "
  44 +                               "on %s for %s\n", j, e, algo);
  45         }
  46
  47         ret = 0;
  48 @@ -785,6 +788,7 @@ static int test_skcipher(struct crypto_a
  49         else
  50                 e = "decryption";
  51
  52 +       printk(KERN_INFO "%s testing %s %s\n", __func__, algo, e);
  53         init_completion(&result.completion);
  54
  55         req = ablkcipher_request_alloc(tfm, GFP_KERNEL);
  56 @@ -863,10 +867,13 @@ static int test_skcipher(struct crypto_a
  57                                 hexdump(q, template[i].rlen);
  58                                 ret = -EINVAL;
  59                                 goto out;
  60 -                       }
  61 +                       } else
  62 +                               printk(KERN_INFO "alg: skcipher: Test %d "
  63 +                                       "pass on %s for %s\n", j, e, algo);
  64                 }
  65         }
  66
  67 +       printk(KERN_INFO "\ntesting %s %s across pages (chunking)\n", algo, e);
  68         j = 0;
  69         for (i = 0; i < tcount; i++) {
  70
  71 @@ -2514,6 +2521,8 @@ int alg_test(const char *driver, const c
  72         int j;
  73         int rc;
  74
  75 +       printk(KERN_INFO  "\ntesting %s\n", alg);
  76 +
  77         if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER) {
  78                 char nalg[CRYPTO_MAX_ALG_NAME];
  79
  80 --- a/drivers/crypto/Kconfig
  81 +++ b/drivers/crypto/Kconfig
  82 @@ -61,6 +61,71 @@ config CRYPTO_DEV_GEODE
  83           To compile this driver as a module, choose M here: the module
  84           will be called geode-aes.
  85
  86 +config CRYPTO_DEV_MCFCAU
  87 +       bool "Support for Freescale Coldfire Cryptographic Acceleration Unit (CAU)"
  88 +       depends on M5445X || M5441X
  89 +       select CRYPTO_ALGAPI
  90 +       help
  91 +         The cryptographic acceleration unit (CAU) is a ColdFire coprocessor
  92 +         implementing a set of specialized operations in hardware. For example,
  93 +         you can find it on MCF5445X, or M5441X.
  94 +
  95 +         Say Y here if you want to use CAU.
  96 +
  97 +config CRYPTO_DEV_MCFCAU_DES
  98 +       tristate "DES and Triple DES cipher algorithms (coldfire)"
  99 +       depends on CRYPTO_DEV_MCFCAU
 100 +       select CRYPTO_ALGAPI
 101 +       select CRYPTO_BLKCIPHER
 102 +       help
 103 +         DES cipher algorithm (FIPS 46-2), and Triple DES EDE (FIPS 46-3).
 104 +
 105 +         Say 'Y' here to use the CAU coprocessor for
 106 +         the CryptoAPI DES and 3DES alogrithms.
 107 +
 108 +         To compile this driver as a module, choose M here: the module
 109 +         will be called mcfcau-des.
 110 +
 111 +config CRYPTO_DEV_MCFCAU_AES
 112 +       tristate "AES cipher algorithm (coldfire)"
 113 +       depends on CRYPTO_DEV_MCFCAU
 114 +       select CRYPTO_ALGAPI
 115 +       select CRYPTO_BLKCIPHER
 116 +       help
 117 +         AES cipher algorithm (FIPS 197).
 118 +
 119 +         Say 'Y' here to use the CAU coprocessor for
 120 +         the CryptoAPI AES alogrithm.
 121 +
 122 +         To compile this driver as a module, choose M here: the module
 123 +         will be called mcfcau-aes.
 124 +
 125 +config CRYPTO_DEV_MCFCAU_MD5
 126 +       tristate "MD5 digest algorithm (coldfire)"
 127 +       depends on CRYPTO_DEV_MCFCAU
 128 +       select CRYPTO_ALGAPI
 129 +       help
 130 +         MD5 message digest algorithm (RFC1321).
 131 +
 132 +         Say 'Y' here to use the CAU coprocessor for
 133 +         the CryptoAPI MD5 alogrithm.
 134 +
 135 +         To compile this driver as a module, choose M here:
 136 +         the module will be called mcfcau-md5.
 137 +
 138 +config CRYPTO_DEV_MCFCAU_SHA1
 139 +       tristate "SHA1 digest algorithm (coldfire)"
 140 +       depends on CRYPTO_DEV_MCFCAU
 141 +       select CRYPTO_ALGAPI
 142 +       help
 143 +         SHA-1 secure hash standard (FIPS 180-1/DFIPS 180-2).
 144 +
 145 +         Say 'Y' here to use the CAU coprocessor for
 146 +         the CryptoAPI SHA1 alogrithm.
 147 +
 148 +         To compile this driver as a module, choose M here: the module
 149 +         will be called mcfcau-sha1.
 150 +
 151  config ZCRYPT
 152         tristate "Support for PCI-attached cryptographic adapters"
 153         depends on S390
 154 --- a/drivers/crypto/Makefile
 155 +++ b/drivers/crypto/Makefile
 156 @@ -7,6 +7,11 @@ obj-$(CONFIG_CRYPTO_DEV_HIFN_795X) += hi
 157  obj-$(CONFIG_CRYPTO_DEV_MV_CESA) += mv_cesa.o
 158  obj-$(CONFIG_CRYPTO_DEV_TALITOS) += talitos.o
 159  obj-$(CONFIG_CRYPTO_DEV_IXP4XX) += ixp4xx_crypto.o
 160 +obj-$(CONFIG_CRYPTO_DEV_MCFCAU) += mcfcau.o
 161 +obj-$(CONFIG_CRYPTO_DEV_MCFCAU_DES) += mcfcau-des.o
 162 +obj-$(CONFIG_CRYPTO_DEV_MCFCAU_AES) += mcfcau-aes.o
 163 +obj-$(CONFIG_CRYPTO_DEV_MCFCAU_MD5) += mcfcau-md5.o
 164 +obj-$(CONFIG_CRYPTO_DEV_MCFCAU_SHA1) += mcfcau-sha1.o
 165  obj-$(CONFIG_CRYPTO_DEV_PPC4XX) += amcc/
 166  obj-$(CONFIG_CRYPTO_DEV_OMAP_SHAM) += omap-sham.o
 167  obj-$(CONFIG_CRYPTO_DEV_OMAP_AES) += omap-aes.o
 168 --- /dev/null
 169 +++ b/drivers/crypto/mcfcau-aes.c
 170 @@ -0,0 +1,367 @@
 171 +/***************************************************************************
 172 + * mcfcau-aes.c - Implementation of AES Cipher Algorithm
 173 + *                for Freescale ColdFire Cryptographic Acceleration Unit (CAU).
 174 + *
 175 + * Copyright (C) 2007-2011 Freescale Semiconductor Inc. All Rights Reserved.
 176 + * Author: Andrey Butok
 177 + *         Shrek Wu B16972@freescale.com
 178 + *
 179 + * NOTE: You can find the ColdFire CAU module on MCF5445X and MCF52235.
 180 + *
 181 + * This program is free software; you can redistribute it and/or modify it
 182 + * under the terms of the GNU General Public License as published by the
 183 + * Free Software Foundation; either version 2 of the License, or (at your
 184 + * option) any later version.
 185 + *
 186 + * This program is distributed in the hope that it will be useful, but
 187 + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 188 + * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 189 + * for more details.
 190 + *
 191 + * You should have received a copy of the GNU General Public License
 192 + * along with this program; if not, write to the Free Software Foundation,
 193 + * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 194 + *
 195 + ***************************************************************************
 196 + * Changes:
 197 + * v0.01       17 September 2007       Andrey Butok
 198 + *             Initial Release - developed on 2.6.20 Linux kernel.
 199 + */
 200 +
 201 +#include <linux/module.h>
 202 +#include <linux/init.h>
 203 +#include <linux/types.h>
 204 +#include <linux/errno.h>
 205 +#include <linux/crypto.h>
 206 +
 207 +/*
 208 +#undef DEBUG
 209 +#define DEBUG 1
 210 +*/
 211 +
 212 +#include "mcfcau.h"
 213 +
 214 +#define MCFCAU_AES_MIN_KEY_SIZE        (16)
 215 +#define MCFCAU_AES_MAX_KEY_SIZE        (32)
 216 +#define MCFCAU_AES_BLOCK_SIZE  (16)
 217 +
 218 +#define        MCFCAU_AES_DRIVER_DESC          "AES ColdFire CAU driver"
 219 +#define        MCFCAU_AES_DRIVER_VERSION       "v0.01"
 220 +
 221 +struct mcfcau_aes_ctx {
 222 +       int Nr_1;
 223 +       u32 buf[120];
 224 +       u32 buf_tmp[16];
 225 +};
 226 +
 227 +static u32 mcfcau_rco_tab[10]
 228 +       = { 0x01000000, 0x02000000, 0x04000000, 0x08000000,
 229 +       0x10000000, 0x20000000, 0x40000000, 0x80000000,
 230 +       0x1b000000, 0x36000000};
 231 +
 232 +int mcfcau_aes_setkey(struct crypto_tfm *tfm, const u8 *in_key,
 233 +                      unsigned int key_len)
 234 +{
 235 +       struct mcfcau_aes_ctx *ctx = crypto_tfm_ctx(tfm);
 236 +       const u32 *key = (const u32 *)in_key;
 237 +       u32 *flags = &tfm->crt_flags;
 238 +       u32 i;
 239 +       u32 *key_sch = (&ctx->buf[0]);
 240 +       u32 *temp_p, *rcon_p;
 241 +       u32 Nx;
 242 +       u32 Nk;
 243 +       unsigned long iflags;
 244 +
 245 +       DBG("mcfcau_aes_setkey\n");
 246 +
 247 +       if (key_len % 8) {
 248 +               *flags |= CRYPTO_TFM_RES_BAD_KEY_LEN;
 249 +               return -EINVAL;
 250 +       }
 251 +
 252 +       Nk = key_len>>2;
 253 +
 254 +       for (i = 0; i < Nk; i++)
 255 +               key_sch[i] = key[i];
 256 +
 257 +       ctx->Nr_1 = Nk+5;
 258 +
 259 +       /* Key Expansion */
 260 +       temp_p = &key_sch[Nk-1];
 261 +       rcon_p = &mcfcau_rco_tab[0];
 262 +
 263 +       spin_lock_irqsave(&mcfcau_lock, iflags);
 264 +
 265 +       asm volatile ("move.l   %0, %%a1"
 266 +               : : "m"(temp_p) : "a1");
 267 +       asm volatile ("move.l   %0, %%a3"
 268 +               : : "m"(rcon_p) : "a3");
 269 +       asm volatile ("move.l   %0, %%a4"
 270 +               : : "m"(key_sch) : "a4");
 271 +
 272 +       Nx = (Nk+7)<<2; /* (Nr+1)*Nb */
 273 +
 274 +       for (i = Nk; i < Nx; i++) {
 275 +               /* temp = key_sch[Nk-1] */
 276 +               asm volatile ("cp0ld.l  (%%a1)+,%%d0,#1,%0"
 277 +                       : : "n"(MCFCAU_LDR+MCFCAU_CAA) : "a1");
 278 +
 279 +               if (i % Nk == 0) {
 280 +                       asm volatile ("moveq    #8, %%d0" : : : "d0");
 281 +                       /* CAA=RotWord(temp) */
 282 +                       asm volatile ("cp0ld.l  %%d0,%%d0,#1,%0"
 283 +                               : : "n"(MCFCAU_ROTL+MCFCAU_CAA) : "d0");
 284 +                       /* SubWord(CAA) */
 285 +                       asm volatile ("cp0ld.l  %%d0,%%d0,#1,%0"
 286 +                               : : "n"(MCFCAU_AESS+MCFCAU_CAA));
 287 +                       /* ACC xor rcon[i/Nk] */
 288 +                       asm volatile ("cp0ld.l  (%%a3)+,%%d0,#1,%0"
 289 +                               : : "n"(MCFCAU_XOR+MCFCAU_CAA) : "a3");
 290 +
 291 +               } else if ((Nk > 6) && (i % Nk == 4)) {
 292 +                       /* SubWord(ACC) */
 293 +                       asm volatile ("cp0ld.l  %%d0,%%d0,#1,%0"
 294 +                               : : "n"(MCFCAU_AESS+MCFCAU_CAA));
 295 +               }
 296 +
 297 +               /* key_sch[i]^=key_sch[i-Nk]; store ACC to key_sch[i] */
 298 +               asm volatile ("cp0ld.l  (%%a4)+,%%d0,#1,%0"
 299 +                       : : "n"(MCFCAU_XOR+MCFCAU_CAA) : "a4");
 300 +               asm volatile ("cp0st.l  %%d0,(%%a1),#1,%0"
 301 +                       : : "n"(MCFCAU_STR+MCFCAU_CAA));
 302 +       }
 303 +       spin_unlock_irqrestore(&mcfcau_lock, iflags);
 304 +
 305 +       return 0;
 306 +}
 307 +
 308 +
 309 +/* encrypt a block of text */
 310 +static void mcfcau_aes_encrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
 311 +{
 312 +       struct mcfcau_aes_ctx *ctx = crypto_tfm_ctx(tfm);
 313 +       const int Nr_1 = ctx->Nr_1;
 314 +
 315 +       u32 *key_sch = &(ctx->buf[0]);
 316 +       u32 i;
 317 +       unsigned long iflags;
 318 +
 319 +       DBG("mcfcau_aes_encrypt\n");
 320 +
 321 +       spin_lock_irqsave(&mcfcau_lock, iflags);
 322 +       asm("move.l     %0, %%a1" : : "m"(in) : "a1");
 323 +       asm("move.l     %0, %%a0" : : "m"(key_sch) : "a0");
 324 +       /* state=in */
 325 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 326 +               : : "n"(MCFCAU_LDR+MCFCAU_CA0) : "a1");
 327 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 328 +               : : "n"(MCFCAU_LDR+MCFCAU_CA1) : "a1");
 329 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 330 +               : : "n"(MCFCAU_LDR+MCFCAU_CA2) : "a1");
 331 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 332 +               : : "n"(MCFCAU_LDR+MCFCAU_CA3) : "a1");
 333 +       /* AddRoundKey() */
 334 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 335 +               : : "n"(MCFCAU_XOR+MCFCAU_CA0) : "a0");
 336 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 337 +               : : "n"(MCFCAU_XOR+MCFCAU_CA1) : "a0");
 338 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 339 +               : : "n"(MCFCAU_XOR+MCFCAU_CA2) : "a0");
 340 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 341 +               : : "n"(MCFCAU_XOR+MCFCAU_CA3) : "a0");
 342 +
 343 +       for (i = Nr_1; i > 0; i--) {
 344 +               /* SubBytes(state) */
 345 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
 346 +                       : : "n"(MCFCAU_AESS+MCFCAU_CA0));
 347 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
 348 +                       : : "n"(MCFCAU_AESS+MCFCAU_CA1));
 349 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
 350 +                       : : "n"(MCFCAU_AESS+MCFCAU_CA2));
 351 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
 352 +                       : : "n"(MCFCAU_AESS+MCFCAU_CA3));
 353 +               /* ShiftRows(state) */
 354 +               asm("cp0ld.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_AESR));
 355 +               /* MixColumns(state); AddRoundKey() */
 356 +               asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 357 +                       : : "n"(MCFCAU_AESC+MCFCAU_CA0) : "a0");
 358 +               asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 359 +                       : : "n"(MCFCAU_AESC+MCFCAU_CA1) : "a0");
 360 +               asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 361 +                       : : "n"(MCFCAU_AESC+MCFCAU_CA2) : "a0");
 362 +               asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 363 +                       : : "n"(MCFCAU_AESC+MCFCAU_CA3) : "a0");
 364 +       }
 365 +       /* SubBytes(state)*/
 366 +       asm("cp0ld.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_AESS+MCFCAU_CA0));
 367 +       asm("cp0ld.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_AESS+MCFCAU_CA1));
 368 +       asm("cp0ld.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_AESS+MCFCAU_CA2));
 369 +       asm("cp0ld.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_AESS+MCFCAU_CA3));
 370 +       /* ShiftRows(state) */
 371 +       asm("cp0ld.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_AESR));
 372 +       /* AddRoundKey() */
 373 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 374 +               : : "n"(MCFCAU_XOR+MCFCAU_CA0) : "a0");
 375 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 376 +               : : "n"(MCFCAU_XOR+MCFCAU_CA1) : "a0");
 377 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 378 +               : : "n"(MCFCAU_XOR+MCFCAU_CA2) : "a0");
 379 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 380 +               : : "n"(MCFCAU_XOR+MCFCAU_CA3) : "a0");
 381 +       /* out = state */
 382 +       asm("move.l     %0, %%a1" : : "m"(out) : "a1");
 383 +       asm("cp0st.l    %%d0,%%d0,#1,%0"
 384 +               : : "n"(MCFCAU_STR+MCFCAU_CA0) : "d0");
 385 +       asm("cp0st.l    %%d0,%%d1,#1,%0"
 386 +               : : "n"(MCFCAU_STR+MCFCAU_CA1) : "d1");
 387 +
 388 +       asm("move.l     %%d0,(%%a1)+" : : : "a1");
 389 +       asm("move.l     %%d1,(%%a1)+" : : : "a1");
 390 +
 391 +       asm("cp0st.l    %%d0,%%d0,#1,%0"
 392 +               : : "n"(MCFCAU_STR+MCFCAU_CA2) : "d0");
 393 +       asm("cp0st.l    %%d0,%%d1,#1,%0"
 394 +               : : "n"(MCFCAU_STR+MCFCAU_CA3) : "d1");
 395 +
 396 +       asm("move.l     %%d0,(%%a1)+" : : : "a1");
 397 +       asm("move.l     %%d1,(%%a1)+" : : : "a1");
 398 +       spin_unlock_irqrestore(&mcfcau_lock, iflags);
 399 +}
 400 +
 401 +
 402 +/* decrypt a block of text */
 403 +static void mcfcau_aes_decrypt(struct crypto_tfm *tfm, u8 *out, const u8 *in)
 404 +{
 405 +       struct mcfcau_aes_ctx *ctx = crypto_tfm_ctx(tfm);
 406 +       u32 *key_sch = &(ctx->buf[0]);
 407 +       u32 i;
 408 +       unsigned long iflags;
 409 +       const int Nr_1 = ctx->Nr_1;
 410 +       key_sch = &key_sch[(Nr_1+2)*4];
 411 +
 412 +       DBG("mcfcau_aes_decrypt\n");
 413 +
 414 +       spin_lock_irqsave(&mcfcau_lock, iflags);
 415 +
 416 +       asm("move.l     %0, %%a1" : : "m"(in) : "a1");
 417 +       asm("move.l     %0, %%a0" : : "m"(key_sch) : "a0");
 418 +       /* state=in */
 419 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 420 +               : : "n"(MCFCAU_LDR+MCFCAU_CA0) : "a1");
 421 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 422 +               : : "n"(MCFCAU_LDR+MCFCAU_CA1) : "a1");
 423 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 424 +               : : "n"(MCFCAU_LDR+MCFCAU_CA2) : "a1");
 425 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 426 +               : : "n"(MCFCAU_LDR+MCFCAU_CA3) : "a1");
 427 +       /* AddRoundKey() */
 428 +       asm("cp0ld.l    -(%%a0),%%d0,#1,%0"
 429 +               : : "n"(MCFCAU_XOR+MCFCAU_CA3) : "a0");
 430 +       asm("cp0ld.l    -(%%a0),%%d0,#1,%0"
 431 +               : : "n"(MCFCAU_XOR+MCFCAU_CA2) : "a0");
 432 +       asm("cp0ld.l    -(%%a0),%%d0,#1,%0"
 433 +               : : "n"(MCFCAU_XOR+MCFCAU_CA1) : "a0");
 434 +       asm("cp0ld.l    -(%%a0),%%d0,#1,%0"
 435 +               : : "n"(MCFCAU_XOR+MCFCAU_CA0) : "a0");
 436 +
 437 +       for (i = Nr_1; i > 0; i--) {
 438 +               /* InvShiftRows(state) */
 439 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
 440 +                       : : "n"(MCFCAU_AESIR));
 441 +               /* InvSubBytes(state) */
 442 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
 443 +                       : : "n"(MCFCAU_AESIS+MCFCAU_CA3));
 444 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
 445 +                       : : "n"(MCFCAU_AESIS+MCFCAU_CA2));
 446 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
 447 +                       : : "n"(MCFCAU_AESIS+MCFCAU_CA1));
 448 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
 449 +                       : : "n"(MCFCAU_AESIS+MCFCAU_CA0));
 450 +               /* InvMixColumns(state); AddRoundKey() */
 451 +               asm("cp0ld.l    -(%%a0),%%d0,#1,%0"
 452 +                       : : "n"(MCFCAU_AESIC+MCFCAU_CA3) : "a0");
 453 +               asm("cp0ld.l    -(%%a0),%%d0,#1,%0"
 454 +                       : : "n"(MCFCAU_AESIC+MCFCAU_CA2) : "a0");
 455 +               asm("cp0ld.l    -(%%a0),%%d0,#1,%0"
 456 +                       : : "n"(MCFCAU_AESIC+MCFCAU_CA1) : "a0");
 457 +               asm("cp0ld.l    -(%%a0),%%d0,#1,%0"
 458 +                       : : "n"(MCFCAU_AESIC+MCFCAU_CA0) : "a0");
 459 +       }
 460 +       /* InvShiftRows(state) */
 461 +       asm("cp0ld.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_AESIR));
 462 +       /* InvSubBytes(state)*/
 463 +       asm("cp0ld.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_AESIS+MCFCAU_CA3));
 464 +       asm("cp0ld.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_AESIS+MCFCAU_CA2));
 465 +       asm("cp0ld.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_AESIS+MCFCAU_CA1));
 466 +       asm("cp0ld.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_AESIS+MCFCAU_CA0));
 467 +       /* AddRoundKey() */
 468 +       asm("cp0ld.l    -(%%a0),%%d0,#1,%0"
 469 +               : : "n"(MCFCAU_XOR+MCFCAU_CA3) : "a0");
 470 +       asm("cp0ld.l    -(%%a0),%%d0,#1,%0"
 471 +               : : "n"(MCFCAU_XOR+MCFCAU_CA2) : "a0");
 472 +       asm("cp0ld.l    -(%%a0),%%d0,#1,%0"
 473 +               : : "n"(MCFCAU_XOR+MCFCAU_CA1) : "a0");
 474 +       asm("cp0ld.l    -(%%a0),%%d0,#1,%0"
 475 +               : : "n"(MCFCAU_XOR+MCFCAU_CA0) : "a0");
 476 +       /* out = state */
 477 +       asm("move.l     %0, %%a1"        : : "m"(out) : "a1");
 478 +       asm("cp0st.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_STR+MCFCAU_CA0) : "d0");
 479 +       asm("cp0st.l    %%d0,%%d1,#1,%0" : : "n"(MCFCAU_STR+MCFCAU_CA1) : "d1");
 480 +
 481 +       asm("move.l     %%d0,(%%a1)+" : : : "a1");
 482 +       asm("move.l     %%d1,(%%a1)+" : : : "a1");
 483 +
 484 +       asm("cp0st.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_STR+MCFCAU_CA2) : "d0");
 485 +       asm("cp0st.l    %%d0,%%d1,#1,%0" : : "n"(MCFCAU_STR+MCFCAU_CA3) : "d1");
 486 +
 487 +       asm("move.l     %%d0,(%%a1)+" : : : "a1");
 488 +       asm("move.l     %%d1,(%%a1)+" : : : "a1");
 489 +       spin_unlock_irqrestore(&mcfcau_lock, iflags);
 490 +
 491 +}
 492 +
 493 +
 494 +static struct crypto_alg mcfcau_aes_alg = {
 495 +       .cra_name               =       "aes",
 496 +       .cra_driver_name        =       "aes-mcfcau",
 497 +       .cra_priority           =       MCFCAU_CRA_PRIORITY,
 498 +       .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 499 +       .cra_blocksize          =       MCFCAU_AES_BLOCK_SIZE,
 500 +       .cra_ctxsize            =       sizeof(struct mcfcau_aes_ctx),
 501 +       .cra_alignmask          =       3,
 502 +       .cra_module             =       THIS_MODULE,
 503 +       .cra_list               =       LIST_HEAD_INIT(mcfcau_aes_alg.cra_list),
 504 +       .cra_u                  =       {
 505 +               .cipher = {
 506 +                       .cia_min_keysize        =       MCFCAU_AES_MIN_KEY_SIZE,
 507 +                       .cia_max_keysize        =       MCFCAU_AES_MAX_KEY_SIZE,
 508 +                       .cia_setkey             =       mcfcau_aes_setkey,
 509 +                       .cia_encrypt            =       mcfcau_aes_encrypt,
 510 +                       .cia_decrypt            =       mcfcau_aes_decrypt
 511 +               }
 512 +       }
 513 +};
 514 +
 515 +static int __init mcfcau_aes_init(void)
 516 +{
 517 +       int ret = crypto_register_alg(&mcfcau_aes_alg);
 518 +
 519 +       printk(KERN_INFO MCFCAU_AES_DRIVER_DESC " "
 520 +               MCFCAU_AES_DRIVER_VERSION " %s.\n",
 521 +               ret ? "failed" : "registered");
 522 +       return ret;
 523 +}
 524 +
 525 +static void __exit mcfcau_aes_fini(void)
 526 +{
 527 +       crypto_unregister_alg(&mcfcau_aes_alg);
 528 +       printk(KERN_INFO MCFCAU_AES_DRIVER_DESC " "
 529 +               MCFCAU_AES_DRIVER_VERSION " unregistered.\n");
 530 +}
 531 +
 532 +module_init(mcfcau_aes_init);
 533 +module_exit(mcfcau_aes_fini);
 534 +
 535 +MODULE_DESCRIPTION(MCFCAU_AES_DRIVER_DESC);
 536 +MODULE_LICENSE("Dual BSD/GPL");
 537 +MODULE_AUTHOR("Andrey Butok");
 538 --- /dev/null
 539 +++ b/drivers/crypto/mcfcau-des.c
 540 @@ -0,0 +1,525 @@
 541 +/***************************************************************************
 542 + * mcfcau-des.c - Implementation of DES & Triple DES EDE Cipher Algorithms
 543 + *                for Freescale ColdFire Cryptographic Acceleration Unit (CAU).
 544 + *
 545 + * Copyright (C) 2007-2011 Freescale Semiconductor, Inc. All Rights Reserved.
 546 + * Author: Andrey Butok
 547 + *         Shrek Wu B16972@freescale.com
 548 + *
 549 + * NOTE: You can find the ColdFire CAU module on MCF5445X and MCF52235.
 550 + *
 551 + * This program is free software; you can redistribute it and/or modify it
 552 + * under the terms of the GNU General Public License as published by the
 553 + * Free Software Foundation; either version 2 of the License, or (at your
 554 + * option) any later version.
 555 + *
 556 + * This program is distributed in the hope that it will be useful, but
 557 + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 558 + * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 559 + * for more details.
 560 + *
 561 + * You should have received a copy of the GNU General Public License
 562 + * along with this program; if not, write to the Free Software Foundation,
 563 + * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 564 + *
 565 + ***************************************************************************
 566 + * Changes:
 567 + * v0.01       14 August 2007  Andrey Butok
 568 + *             Initial Release - developed on 2.6.20 Linux kernel.
 569 + */
 570 +
 571 +#include <linux/init.h>
 572 +#include <linux/module.h>
 573 +#include <linux/errno.h>
 574 +#include <linux/crypto.h>
 575 +#include <linux/types.h>
 576 +
 577 +/*
 578 +#undef DEBUG
 579 +#define DEBUG 1
 580 +*/
 581 +
 582 +#include "mcfcau.h"
 583 +
 584 +#define MCFCAU_DES_KEY_SIZE            (8)
 585 +#define MCFCAU_DES_EXPKEY_WORDS                (32)
 586 +#define MCFCAU_DES_BLOCK_SIZE          (8)
 587 +
 588 +#define MCFCAU_DES3_EDE_KEY_SIZE       (3 * MCFCAU_DES_KEY_SIZE)
 589 +#define MCFCAU_DES3_EDE_EXPKEY_WORDS   (3 * MCFCAU_DES_EXPKEY_WORDS)
 590 +#define MCFCAU_DES3_EDE_BLOCK_SIZE     (MCFCAU_DES_BLOCK_SIZE)
 591 +
 592 +#define        MCFCAU_DES_DRIVER_DESC          "DES & 3DES ColdFire CAU driver"
 593 +#define        MCFCAU_DES_DRIVER_VERSION       "v0.01"
 594 +
 595 +struct mcfcau_des_ctx {
 596 +       u32 expkey[MCFCAU_DES_EXPKEY_WORDS];
 597 +};
 598 +
 599 +struct mcfcau_des3_ede_ctx {
 600 +       u32 expkey[MCFCAU_DES3_EDE_EXPKEY_WORDS];
 601 +};
 602 +
 603 +/* DES round operations */
 604 +static inline void mcfcau_des_encipher(void)
 605 +{
 606 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 607 +               : : "n"(MCFCAU_DESK));
 608 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 609 +               : : "n"(MCFCAU_DESR+MCFCAU_IP+MCFCAU_KSL1));
 610 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 611 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL2));
 612 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 613 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL2));
 614 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 615 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL2));
 616 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 617 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL2));
 618 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 619 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL2));
 620 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 621 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL2));
 622 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 623 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL1));
 624 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 625 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL2));
 626 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 627 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL2));
 628 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 629 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL2));
 630 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 631 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL2));
 632 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 633 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL2));
 634 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 635 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL2));
 636 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 637 +               : : "n"(MCFCAU_DESR+MCFCAU_KSL1));
 638 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 639 +               : : "n"(MCFCAU_DESR+MCFCAU_FP+MCFCAU_KSL1));
 640 +}
 641 +
 642 +static inline void mcfcau_des_decipher(void)
 643 +{
 644 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 645 +               : : "n"(MCFCAU_DESK+MCFCAU_DC));
 646 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 647 +               : : "n"(MCFCAU_DESR+MCFCAU_IP+MCFCAU_KSR1));
 648 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 649 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR2));
 650 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 651 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR2));
 652 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 653 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR2));
 654 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 655 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR2));
 656 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 657 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR2));
 658 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 659 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR2));
 660 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 661 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR1));
 662 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 663 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR2));
 664 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 665 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR2));
 666 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 667 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR2));
 668 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 669 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR2));
 670 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 671 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR2));
 672 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 673 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR2));
 674 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 675 +               : : "n"(MCFCAU_DESR+MCFCAU_KSR1));
 676 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
 677 +               : : "n"(MCFCAU_DESR+MCFCAU_FP+MCFCAU_KSL1));
 678 +}
 679 +
 680 +
 681 +static int mcfcau_des_setkey(struct crypto_tfm *tfm, const u8 *key_p,
 682 +                     unsigned int keylen)
 683 +{
 684 +       struct mcfcau_des_ctx *dctx = crypto_tfm_ctx(tfm);
 685 +       u32 *flags = &tfm->crt_flags;
 686 +       u32 * key = (u32 *) key_p;
 687 +
 688 +       DBG("mcfcau_des_setkey\n");
 689 +
 690 +       /*
 691 +       * RFC2451: Weak key checks SHOULD be performed.
 692 +       *
 693 +       * FIPS 74:
 694 +       *   Keys having duals are keys which produce all zeros, all ones, or
 695 +       *   alternating zero-one patterns in the C and D registers
 696 +       *   after Permuted
 697 +       *   Choice 1 has operated on the key.
 698 +       *
 699 +       */
 700 +       if (*flags & CRYPTO_TFM_REQ_WEAK_KEY) { /* FIPS 74 */
 701 +               if (key[0] < 0xE001E00l) {
 702 +                       if (key[0] < 0x1FE01FE0) {
 703 +                               if (key[0] < 0x01E001E0) {
 704 +                                       if (((key[0] == 0x01010101) &&
 705 +                                               (key[1] == 0x01010101)) ||
 706 +                                               ((key[0] == 0x011F011F) &&
 707 +                                               (key[1] == 0x010E010E)))
 708 +                                               goto WEAK_KEY;
 709 +                               } else {
 710 +                                       if (((key[0] == 0x01E001E0) &&
 711 +                                               (key[1] == 0x01F101F1)) ||
 712 +                                               ((key[0] == 0x01FE01FE) &&
 713 +                                               (key[1] == 0x01FE01FE)))
 714 +                                               goto WEAK_KEY;
 715 +                               }
 716 +                       } else {
 717 +                               if (key[0] < 0x1F1F1F1F) {
 718 +                                       if (((key[0] == 0x1FE01FE0) &&
 719 +                                               (key[1] == 0x0EF10EF1)) ||
 720 +                                               ((key[0] == 0x1F011F0l) &&
 721 +                                               (key[1] == 0x0E010E01)))
 722 +                                               goto WEAK_KEY;
 723 +                               } else{
 724 +                                       if (((key[0] == 0x1F1F1F1F) &&
 725 +                                               (key[1] == 0x0E0E0E0E)) ||
 726 +                                               ((key[0] == 0x1FFE1FFE) &&
 727 +                                               (key[1] == 0x0EFE0EFE)))
 728 +                                               goto WEAK_KEY;
 729 +                               }
 730 +                       }
 731 +               } else {
 732 +                       if (key[0] < 0xFE01FE01) {
 733 +                               if (key[0] < 0xE0E0E0E0) {
 734 +                                       if (((key[0] == 0xE001E00l) &&
 735 +                                               (key[1] == 0xF101F101)) ||
 736 +                                               ((key[0] == 0xE01FE01F) &&
 737 +                                               (key[1] == 0xF10EF10E)))
 738 +                                               goto WEAK_KEY;
 739 +                               } else {
 740 +                                       if (((key[0] == 0xE0E0E0E0) &&
 741 +                                               (key[1] == 0xF1F1F1F1)) ||
 742 +                                               ((key[0] == 0xE0FEE0FE) &&
 743 +                                               (key[1] == 0xF1FEF1FE)))
 744 +                                               goto WEAK_KEY;
 745 +                               }
 746 +                       } else {
 747 +                               if (key[0] < 0xFEE0FEE0) {
 748 +                                       if (((key[0] == 0xFE01FE01) &&
 749 +                                               (key[1] == 0xFE01FE01)) ||
 750 +                                               ((key[0] == 0xFE1FFE1F) &&
 751 +                                               (key[1] == 0xFE0EFE0E)))
 752 +                                               goto WEAK_KEY;
 753 +                               } else {
 754 +                                       if (((key[0] == 0xFEE0FEE0) &&
 755 +                                               (key[1] == 0xFEF1FEF1)) ||
 756 +                                               ((key[0] == 0xFEFEFEFE)
 757 +                                               && (key[1] == 0xFEFEFEFE)))
 758 +                                               goto WEAK_KEY;
 759 +                               }
 760 +                       }
 761 +               }
 762 +       }
 763 +       memcpy(dctx->expkey, key_p, keylen);
 764 +       return 0;
 765 +WEAK_KEY:
 766 +       *flags |= CRYPTO_TFM_RES_WEAK_KEY;
 767 +       return -EINVAL;
 768 +}
 769 +
 770 +
 771 +void mcfcau_des_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
 772 +{
 773 +       struct mcfcau_des_ctx *ctx = crypto_tfm_ctx(tfm);
 774 +       u32 *des_key_tmp = ctx->expkey;
 775 +       unsigned long iflags;
 776 +
 777 +       DBG("mcfcau_des_encrypt\n");
 778 +
 779 +       spin_lock_irqsave(&mcfcau_lock, iflags);
 780 +
 781 +       asm("move.l     %0, %%a0" : : "m"(src) : "a0");
 782 +       asm("move.l     %0, %%a1" : : "m"(des_key_tmp) : "a1");
 783 +
 784 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 785 +               : : "n"(MCFCAU_LDR+MCFCAU_CA2) : "a0");
 786 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
 787 +               : : "n"(MCFCAU_LDR+MCFCAU_CA3));
 788 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 789 +               : : "n"(MCFCAU_LDR+MCFCAU_CA0) : "a1");
 790 +       asm("cp0ld.l    (%%a1),%%d0,#1,%0"
 791 +               : : "n"(MCFCAU_LDR+MCFCAU_CA1));
 792 +
 793 +       mcfcau_des_encipher();
 794 +
 795 +       asm("cp0st.l    %%d0,%%d0,#1,%0"
 796 +               : : "n"(MCFCAU_STR+MCFCAU_CA2) : "d0");
 797 +       asm("cp0st.l    %%d0,%%d1,#1,%0"
 798 +               : : "n"(MCFCAU_STR+MCFCAU_CA3) : "d1");
 799 +       asm("move.l     %0, %%a1" : : "m"(dst) : "a1");
 800 +       asm("move.l     %d0,(%a1)+");
 801 +       asm("move.l     %d1,(%a1)");
 802 +
 803 +       spin_unlock_irqrestore(&mcfcau_lock, iflags);
 804 +}
 805 +
 806 +
 807 +void mcfcau_des_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
 808 +{
 809 +       struct mcfcau_des_ctx *ctx = crypto_tfm_ctx(tfm);
 810 +       u32 *des_key_tmp = ctx->expkey;
 811 +       unsigned long iflags;
 812 +
 813 +       DBG("mcfcau_des_decrypt\n");
 814 +
 815 +       spin_lock_irqsave(&mcfcau_lock, iflags);
 816 +
 817 +       asm("move.l     %0, %%a0" : : "m"(src) : "a0");
 818 +       asm("move.l     %0, %%a1" : : "m"(des_key_tmp) : "a1");
 819 +
 820 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 821 +               : : "n"(MCFCAU_LDR+MCFCAU_CA2) : "a0");
 822 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
 823 +               : : "n"(MCFCAU_LDR+MCFCAU_CA3));
 824 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 825 +               : : "n"(MCFCAU_LDR+MCFCAU_CA0) : "a1");
 826 +       asm("cp0ld.l    (%%a1),%%d0,#1,%0"
 827 +               : : "n"(MCFCAU_LDR+MCFCAU_CA1));
 828 +
 829 +       mcfcau_des_decipher();
 830 +
 831 +       asm("move.l     %0, %%a1" : : "m"(dst) : "a1");
 832 +       asm("cp0st.l    %%d0,%%d0,#1,%0"
 833 +               : : "n"(MCFCAU_STR+MCFCAU_CA2) : "d0");
 834 +       asm("cp0st.l    %%d0,%%d1,#1,%0"
 835 +               : : "n"(MCFCAU_STR+MCFCAU_CA3) : "d1");
 836 +       asm("move.l     %d0,(%a1)+");
 837 +       asm("move.l     %d1,(%a1)");
 838 +
 839 +       spin_unlock_irqrestore(&mcfcau_lock, iflags);
 840 +}
 841 +
 842 +
 843 +/*
 844 + * RFC2451:
 845 + *
 846 + *   For DES-EDE3, there is no known need to reject weak or
 847 + *   complementation keys.  Any weakness is obviated by the use of
 848 + *   multiple keys.
 849 + *
 850 + *   However, if the first two or last two independent 64-bit keys are
 851 + *   equal (k1 == k2 or k2 == k3), then the DES3 operation is simply the
 852 + *   same as DES.  Implementers MUST reject keys that exhibit this
 853 + *   property.
 854 + *
 855 + */
 856 +
 857 +static int mcfcau_des3_ede_setkey(
 858 +       struct crypto_tfm *tfm, const u8 *key_p, unsigned int keylen)
 859 +{
 860 +       const u32 *key = (const u32 *)key_p;
 861 +       struct mcfcau_des3_ede_ctx *dctx = crypto_tfm_ctx(tfm);
 862 +       u32 *flags = &tfm->crt_flags;
 863 +
 864 +       DBG("mcfcau_des3_ede_setkey\n");
 865 +
 866 +       if (unlikely(!((key[0] ^ key[2]) | (key[1] ^ key[3])) ||
 867 +                    !((key[2] ^ key[4]) | (key[3] ^ key[5])))) {
 868 +               *flags |= CRYPTO_TFM_RES_BAD_KEY_SCHED;
 869 +               return -EINVAL;
 870 +       }
 871 +
 872 +       memcpy(dctx->expkey, key_p, keylen);
 873 +
 874 +       return 0;
 875 +}
 876 +
 877 +static void mcfcau_des3_ede_encrypt(
 878 +       struct crypto_tfm *tfm, u8 *dst, const u8 *src)
 879 +{
 880 +       struct mcfcau_des3_ede_ctx *dctx = crypto_tfm_ctx(tfm);
 881 +       const u32 *des_key_tmp = dctx->expkey;
 882 +       unsigned long iflags;
 883 +
 884 +       DBG("mcfcau_des3_ede_encrypt\n");
 885 +
 886 +       spin_lock_irqsave(&mcfcau_lock, iflags);
 887 +
 888 +       /*EK1*/
 889 +       asm("move.l     %0, %%a0"
 890 +               : : "m"(src) : "a0");
 891 +       asm("move.l     %0, %%a1"
 892 +               : : "m"(des_key_tmp) : "a1");
 893 +
 894 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 895 +               : : "n"(MCFCAU_LDR+MCFCAU_CA2) : "a0");
 896 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
 897 +               : : "n"(MCFCAU_LDR+MCFCAU_CA3));
 898 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 899 +               : : "n"(MCFCAU_LDR+MCFCAU_CA0) : "a1");
 900 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 901 +               : : "n"(MCFCAU_LDR+MCFCAU_CA1) : "a1");
 902 +
 903 +       mcfcau_des_encipher();
 904 +
 905 +       /*DK2*/
 906 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 907 +               : : "n"(MCFCAU_LDR+MCFCAU_CA0) : "a1");
 908 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 909 +               : : "n"(MCFCAU_LDR+MCFCAU_CA1) : "a1");
 910 +
 911 +       mcfcau_des_decipher();
 912 +
 913 +       /*EK3*/
 914 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 915 +               : : "n"(MCFCAU_LDR+MCFCAU_CA0) : "a1");
 916 +       asm("cp0ld.l    (%%a1),%%d0,#1,%0"
 917 +               : : "n"(MCFCAU_LDR+MCFCAU_CA1));
 918 +
 919 +       mcfcau_des_encipher();
 920 +
 921 +       asm("move.l     %0, %%a1"
 922 +               : : "m"(dst) : "a1");
 923 +       asm("cp0st.l    %%d0,%%d0,#1,%0"
 924 +               : : "n"(MCFCAU_STR+MCFCAU_CA2) : "d0");
 925 +       asm("cp0st.l    %%d0,%%d1,#1,%0"
 926 +               : : "n"(MCFCAU_STR+MCFCAU_CA3) : "d1");
 927 +       asm("move.l     %d0,(%a1)+");
 928 +       asm("move.l     %d1,(%a1)");
 929 +
 930 +       spin_unlock_irqrestore(&mcfcau_lock, iflags);
 931 +}
 932 +
 933 +static void mcfcau_des3_ede_decrypt(
 934 +       struct crypto_tfm *tfm, u8 *dst, const u8 *src)
 935 +{
 936 +       struct mcfcau_des3_ede_ctx *dctx = crypto_tfm_ctx(tfm);
 937 +       const u32 *des_key_tmp = dctx->expkey + 6 - 2;
 938 +       unsigned long iflags;
 939 +
 940 +       DBG("mcfcau_des3_ede_decrypt\n");
 941 +
 942 +       spin_lock_irqsave(&mcfcau_lock, iflags);
 943 +
 944 +       /*DK3*/
 945 +       asm("move.l     %0, %%a0"
 946 +               : : "m"(src) : "a0");
 947 +       asm("move.l     %0, %%a1"
 948 +               : : "m"(des_key_tmp) : "a1");
 949 +
 950 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
 951 +               : : "n"(MCFCAU_LDR+MCFCAU_CA2) : "a0");
 952 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
 953 +               : : "n"(MCFCAU_LDR+MCFCAU_CA3));
 954 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 955 +               : : "n"(MCFCAU_LDR+MCFCAU_CA0) : "a1");
 956 +       asm("cp0ld.l    (%%a1),%%d0,#1,%0"
 957 +               : : "n"(MCFCAU_LDR+MCFCAU_CA1));
 958 +
 959 +       mcfcau_des_decipher();
 960 +
 961 +       /*EK2*/
 962 +       asm("suba.l     #12,%a1");      /*dec key pointer*/
 963 +
 964 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 965 +               : : "n"(MCFCAU_LDR+MCFCAU_CA0) : "a1");
 966 +       asm("cp0ld.l    (%%a1),%%d0,#1,%0"
 967 +               : : "n"(MCFCAU_LDR+MCFCAU_CA1));
 968 +
 969 +       mcfcau_des_encipher();
 970 +
 971 +       /*DK1*/
 972 +       asm("suba.l     #12,%a1");      /*dec key pointer*/
 973 +
 974 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
 975 +               : : "n"(MCFCAU_LDR+MCFCAU_CA0) : "a1");
 976 +       asm("cp0ld.l    (%%a1),%%d0,#1,%0"
 977 +               : : "n"(MCFCAU_LDR+MCFCAU_CA1));
 978 +
 979 +       mcfcau_des_decipher();
 980 +
 981 +       asm("move.l     %0, %%a1"
 982 +               : : "m"(dst) : "a1");
 983 +       asm("cp0st.l    %%d0,%%d0,#1,%0"
 984 +               : : "n"(MCFCAU_STR+MCFCAU_CA2) : "d0");
 985 +       asm("cp0st.l    %%d0,%%d1,#1,%0"
 986 +               : : "n"(MCFCAU_STR+MCFCAU_CA3) : "d1");
 987 +       asm("move.l     %d0,(%a1)+");
 988 +       asm("move.l     %d1,(%a1)");
 989 +
 990 +       spin_unlock_irqrestore(&mcfcau_lock, iflags);
 991 +}
 992 +
 993 +
 994 +static struct crypto_alg mcfcau_des_alg = {
 995 +       .cra_name               =       "des",
 996 +       .cra_driver_name        =       "des-mcfcau",
 997 +       .cra_priority           =       MCFCAU_CRA_PRIORITY,
 998 +       .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 999 +       .cra_blocksize          =       MCFCAU_DES_BLOCK_SIZE,
1000 +       .cra_ctxsize            =       sizeof(struct mcfcau_des_ctx),
1001 +       .cra_module             =       THIS_MODULE,
1002 +       .cra_alignmask          =       3,
1003 +       .cra_list               =       LIST_HEAD_INIT(mcfcau_des_alg.cra_list),
1004 +       .cra_u                  =       { .cipher = {
1005 +       .cia_min_keysize        =       MCFCAU_DES_KEY_SIZE,
1006 +       .cia_max_keysize        =       MCFCAU_DES_KEY_SIZE,
1007 +       .cia_setkey             =       mcfcau_des_setkey,
1008 +       .cia_encrypt            =       mcfcau_des_encrypt,
1009 +       .cia_decrypt            =       mcfcau_des_decrypt } }
1010 +};
1011 +
1012 +static struct crypto_alg mcfcau_des3_ede_alg = {
1013 +       .cra_name               =       "des3_ede",
1014 +       .cra_driver_name        =       "des3_ede-mcfcau",
1015 +       .cra_priority           =       MCFCAU_CRA_PRIORITY,
1016 +       .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
1017 +       .cra_blocksize          =       MCFCAU_DES3_EDE_BLOCK_SIZE,
1018 +       .cra_ctxsize            =       sizeof(struct mcfcau_des3_ede_ctx),
1019 +       .cra_module             =       THIS_MODULE,
1020 +       .cra_alignmask          =       3,
1021 +       .cra_list               =
1022 +                       LIST_HEAD_INIT(mcfcau_des3_ede_alg.cra_list),
1023 +       .cra_u                  =       { .cipher = {
1024 +       .cia_min_keysize        =       MCFCAU_DES3_EDE_KEY_SIZE,
1025 +       .cia_max_keysize        =       MCFCAU_DES3_EDE_KEY_SIZE,
1026 +       .cia_setkey             =       mcfcau_des3_ede_setkey,
1027 +       .cia_encrypt            =       mcfcau_des3_ede_encrypt,
1028 +       .cia_decrypt            =       mcfcau_des3_ede_decrypt } }
1029 +};
1030 +
1031 +MODULE_ALIAS("mcfcau_des3_ede");
1032 +
1033 +static int __init mcfcau_des_init(void)
1034 +{
1035 +       int ret;
1036 +
1037 +       ret = crypto_register_alg(&mcfcau_des_alg);
1038 +       if (ret < 0)
1039 +               goto out;
1040 +
1041 +       ret = crypto_register_alg(&mcfcau_des3_ede_alg);
1042 +       if (ret < 0)
1043 +               crypto_unregister_alg(&mcfcau_des_alg);
1044 +out:
1045 +       printk(KERN_INFO MCFCAU_DES_DRIVER_DESC " "
1046 +               MCFCAU_DES_DRIVER_VERSION " %s.\n",
1047 +               ret ? "failed" : "registered");
1048 +       return ret;
1049 +}
1050 +
1051 +static void __exit mcfcau_des_exit(void)
1052 +{
1053 +       crypto_unregister_alg(&mcfcau_des3_ede_alg);
1054 +       crypto_unregister_alg(&mcfcau_des_alg);
1055 +
1056 +       printk(KERN_INFO MCFCAU_DES_DRIVER_DESC " "
1057 +               MCFCAU_DES_DRIVER_VERSION " unregistered.\n");
1058 +}
1059 +
1060 +module_init(mcfcau_des_init);
1061 +module_exit(mcfcau_des_exit);
1062 +
1063 +MODULE_LICENSE("GPL");
1064 +MODULE_DESCRIPTION("DES & Triple DES EDE Cipher Algorithms for ColdFire CAU");
1065 +MODULE_AUTHOR("Andrey Butok");
1066 --- /dev/null
1067 +++ b/drivers/crypto/mcfcau-md5.c
1068 @@ -0,0 +1,972 @@
1069 +/***************************************************************************
1070 + * mcfcau-md5.c - Implementation of MD5 Message Digest Algorithm (RFC1321)
1071 + *                for Freescale ColdFire Cryptographic Acceleration Unit (CAU).
1072 + *
1073 + * Copyright (C) 2007-2011 Freescale Semiconductor, Inc. All Rights Reserved.
1074 + * Author: Andrey Butok
1075 + *         Shrek Wu B16972@freescale.com
1076 + *         Alison Wang b18965@freescale.com
1077 + *
1078 + * NOTE: You can find the ColdFire CAU module on MCF5445X and MCF52235.
1079 + *
1080 + * This program is free software; you can redistribute it and/or modify it
1081 + * under the terms of the GNU General Public License as published by the
1082 + * Free Software Foundation; either version 2 of the License, or (at your
1083 + * option) any later version.
1084 + *
1085 + * This program is distributed in the hope that it will be useful, but
1086 + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
1087 + * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
1088 + * for more details.
1089 + *
1090 + * You should have received a copy of the GNU General Public License
1091 + * along with this program; if not, write to the Free Software Foundation,
1092 + * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
1093 + *
1094 + ***************************************************************************
1095 + * Changes:
1096 + * v0.01       30 September 2007       Andrey Butok
1097 + *             Initial Release - developed on 2.6.20 Linux kernel.
1098 + */
1099 +#include <linux/init.h>
1100 +#include <linux/module.h>
1101 +#include <linux/string.h>
1102 +#include <linux/crypto.h>
1103 +#include <linux/types.h>
1104 +#include <crypto/algapi.h>
1105 +#include <crypto/hash.h>
1106 +#include <crypto/internal/hash.h>
1107 +#include <asm/byteorder.h>
1108 +
1109 +#include "mcfcau.h"
1110 +
1111 +#define MCFCAU_MD5_DIGEST_SIZE         (16)
1112 +#define MCFCAU_MD5_HMAC_BLOCK_SIZE     (64)
1113 +#define MCFCAU_MD5_BLOCK_WORDS         (16)
1114 +#define MCFCAU_MD5_HASH_WORDS          (4)
1115 +
1116 +#define        MCFCAU_MD5_DRIVER_DESC          "MD5 ColdFire CAU driver"
1117 +#define        MCFCAU_MD5_DRIVER_VERSION       "v0.01"
1118 +
1119 +
1120 +struct mcfcau_md5_ctx {
1121 +       u32 hash[MCFCAU_MD5_HASH_WORDS];
1122 +       u32 block[MCFCAU_MD5_BLOCK_WORDS];
1123 +       u64 byte_count;
1124 +};
1125 +
1126 +u32 mcfcau_md5_t[64] = {0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
1127 +                       0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
1128 +                       0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
1129 +                       0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
1130 +                       0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
1131 +                       0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
1132 +                       0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
1133 +                       0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
1134 +                       0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
1135 +                       0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
1136 +                       0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
1137 +                       0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
1138 +                       0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
1139 +                       0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
1140 +                       0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
1141 +                       0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391};
1142 +
1143 +
1144 +
1145 +static void mcfcau_md5_transform(u32 *hash, u32 const *in)
1146 +{
1147 +       int i;
1148 +       u32 *md5_t_p = &mcfcau_md5_t[0];
1149 +       unsigned long iflags;
1150 +
1151 +       spin_lock_irqsave(&mcfcau_lock, iflags);
1152 +       asm("move.l     %0, %%a1" : : "m"(hash) : "a1");
1153 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
1154 +               : : "n"(MCFCAU_LDR+MCFCAU_CAA) : "a1");/*a*/
1155 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
1156 +               : : "n"(MCFCAU_LDR+MCFCAU_CA1) : "a1");/*b*/
1157 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
1158 +               : : "n"(MCFCAU_LDR+MCFCAU_CA2) : "a1");/*c*/
1159 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
1160 +               : : "n"(MCFCAU_LDR+MCFCAU_CA3) : "a1");/*d*/
1161 +       asm("move.l     %0, %%a0" : : "m"(in) : "a0");  /* X[] */
1162 +       asm("move.l     %0, %%a3" : : "m"(md5_t_p) : "a3");     /* T[] */
1163 +
1164 +       /*  Round 1 */
1165 +       asm("moveq.l    #7, %%d4" : : : "d4");  /* for rotating by 7 */
1166 +       asm("moveq.l    #12, %%d5" : : : "d5"); /* for rotating by 12 */
1167 +       asm("moveq.l    #17, %%d6" : : : "d6"); /* for rotating by 17 */
1168 +       asm("moveq.l    #22, %%d7" : : : "d7"); /* for rotating by 22 */
1169 +
1170 +       for (i = 0; i < 4; i++) {
1171 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1172 +                       : : "n"(MCFCAU_HASH+MCFCAU_HFF));
1173 +               /* a+F(b,c,d) */
1174 +               asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
1175 +                       : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1176 +               /* add byterev x[i] */
1177 +               asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1178 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1179 +               /* add t[i] */
1180 +               asm("cp0ld.l    %%d4,%%d0,#1,%0"
1181 +                       : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1182 +               /* rotate by 7 */
1183 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1184 +                       : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1185 +               /* add b */
1186 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1187 +                       : : "n"(MCFCAU_MDS));
1188 +               /* register to register shift */
1189 +
1190 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1191 +                       : : "n"(MCFCAU_HASH+MCFCAU_HFF));
1192 +               asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
1193 +                       : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1194 +               asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1195 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1196 +               asm("cp0ld.l    %%d5,%%d0,#1,%0"
1197 +                       : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1198 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1199 +                       : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1200 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1201 +                       : : "n"(MCFCAU_MDS));
1202 +
1203 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1204 +                       : : "n"(MCFCAU_HASH+MCFCAU_HFF));
1205 +               asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
1206 +                       : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1207 +               asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1208 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1209 +               asm("cp0ld.l    %%d6,%%d0,#1,%0"
1210 +                       : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1211 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1212 +                       : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1213 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1214 +                       : : "n"(MCFCAU_MDS));
1215 +
1216 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1217 +                       : : "n"(MCFCAU_HASH+MCFCAU_HFF));
1218 +               asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
1219 +                       : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1220 +               asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1221 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1222 +               asm("cp0ld.l    %%d7,%%d0,#1,%0"
1223 +                       : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1224 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1225 +                       : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1226 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1227 +                       : : "n"(MCFCAU_MDS));
1228 +       };
1229 +
1230 +
1231 +       /* Round 2 */
1232 +       asm("moveq.l    #5, %%d4" : : : "d4");  /* for rotating by 5 */
1233 +       asm("moveq.l    #9, %%d5" : : : "d5");  /* for rotating by 9 */
1234 +       asm("moveq.l    #14, %%d6" : : : "d6"); /* for rotating by 14 */
1235 +       asm("moveq.l    #20, %%d7" : : : "d7"); /* for rotating by 20 */
1236 +
1237 +       asm("lea -60(%%a0),%%a0" : : : "a0");
1238 +
1239 +       for (i = 0; i < 2; i++) {
1240 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1241 +                       : : "n"(MCFCAU_HASH+MCFCAU_HFG));
1242 +               asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1243 +                       : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1244 +               asm("lea        20(%%a0),%%a0"          : : : "a0");
1245 +               asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1246 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1247 +               asm("cp0ld.l    %%d4,%%d0,#1,%0"
1248 +                       : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1249 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1250 +                       : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1251 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1252 +                       : : "n"(MCFCAU_MDS));
1253 +
1254 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1255 +                       : : "n"(MCFCAU_HASH+MCFCAU_HFG));
1256 +               asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1257 +                       : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1258 +               asm("lea        20(%%a0),%%a0"  : : : "a0");
1259 +               asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1260 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1261 +               asm("cp0ld.l    %%d5,%%d0,#1,%0"
1262 +                       : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1263 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1264 +                       : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1265 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"        : : "n"(MCFCAU_MDS));
1266 +
1267 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1268 +                       : : "n"(MCFCAU_HASH+MCFCAU_HFG));
1269 +               asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1270 +                       : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1271 +               asm("lea        -44(%%a0),%%a0"         : : : "a0");
1272 +               asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1273 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1274 +               asm("cp0ld.l    %%d6,%%d0,#1,%0"
1275 +                       : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1276 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1277 +                       : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1278 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1279 +                       : : "n"(MCFCAU_MDS));
1280 +
1281 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1282 +                       : : "n"(MCFCAU_HASH+MCFCAU_HFG));
1283 +               asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1284 +                       : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1285 +               asm("lea        20(%%a0),%%a0"  : : : "a0");
1286 +               asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1287 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1288 +               asm("cp0ld.l    %%d7,%%d0,#1,%0"
1289 +                       : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1290 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1291 +                       : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1292 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
1293 +                       : : "n"(MCFCAU_MDS));
1294 +       };
1295 +
1296 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1297 +               : : "n"(MCFCAU_HASH+MCFCAU_HFG));
1298 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1299 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1300 +       asm("lea        20(%%a0),%%a0"
1301 +               : : : "a0");
1302 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1303 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1304 +       asm("cp0ld.l    %%d4,%%d0,#1,%0"
1305 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1306 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1307 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1308 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1309 +               : : "n"(MCFCAU_MDS));
1310 +
1311 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1312 +               : : "n"(MCFCAU_HASH+MCFCAU_HFG));
1313 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1314 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1315 +       asm("lea        -44(%%a0),%%a0"
1316 +               : : : "a0");
1317 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1318 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1319 +       asm("cp0ld.l    %%d5,%%d0,#1,%0"
1320 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1321 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1322 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1323 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1324 +               : : "n"(MCFCAU_MDS));
1325 +
1326 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1327 +               : : "n"(MCFCAU_HASH+MCFCAU_HFG));
1328 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1329 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1330 +       asm("lea        20(%%a0),%%a0"
1331 +               : : : "a0");
1332 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1333 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1334 +       asm("cp0ld.l    %%d6,%%d0,#1,%0"
1335 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1336 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1337 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1338 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1339 +               : : "n"(MCFCAU_MDS));
1340 +
1341 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1342 +               : : "n"(MCFCAU_HASH+MCFCAU_HFG));
1343 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1344 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1345 +       asm("lea        20(%%a0),%%a0"  : : : "a0");
1346 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1347 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1348 +       asm("cp0ld.l    %%d7,%%d0,#1,%0"
1349 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1350 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1351 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1352 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1353 +               : : "n"(MCFCAU_MDS));
1354 +
1355 +
1356 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1357 +               : : "n"(MCFCAU_HASH+MCFCAU_HFG));
1358 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1359 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1360 +       asm("lea        -44(%%a0),%%a0" : : : "a0");
1361 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1362 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1363 +       asm("cp0ld.l    %%d4,%%d0,#1,%0"
1364 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1365 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1366 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1367 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1368 +               : : "n"(MCFCAU_MDS));
1369 +
1370 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1371 +               : : "n"(MCFCAU_HASH+MCFCAU_HFG));
1372 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1373 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1374 +       asm("lea        20(%%a0),%%a0"  : : : "a0");
1375 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1376 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1377 +       asm("cp0ld.l    %%d5,%%d0,#1,%0"
1378 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1379 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1380 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1381 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1382 +               : : "n"(MCFCAU_MDS));
1383 +
1384 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1385 +               : : "n"(MCFCAU_HASH+MCFCAU_HFG));
1386 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1387 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1388 +       asm("lea        20(%%a0),%%a0"  : : : "a0");
1389 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1390 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1391 +       asm("cp0ld.l    %%d6,%%d0,#1,%0"
1392 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1393 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1394 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1395 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1396 +               : : "n"(MCFCAU_MDS));
1397 +
1398 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1399 +               : : "n"(MCFCAU_HASH+MCFCAU_HFG));
1400 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1401 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1402 +       asm("lea        -28(%%a0),%%a0" : : : "a0");
1403 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1404 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1405 +       asm("cp0ld.l    %%d7,%%d0,#1,%0"
1406 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1407 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1408 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1409 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1410 +               : : "n"(MCFCAU_MDS));
1411 +
1412 +
1413 +       /* Round 3 */
1414 +       asm("moveq.l    #4, %%d4" : : : "d4");  /* for rotating by 5 */
1415 +       asm("moveq.l    #11, %%d5" : : : "d5"); /* for rotating by 9 */
1416 +       asm("moveq.l    #16, %%d6" : : : "d6"); /* for rotating by 14 */
1417 +       asm("moveq.l    #23, %%d7" : : : "d7"); /* for rotating by 20 */
1418 +
1419 +
1420 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1421 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1422 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1423 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1424 +       asm("lea        12(%%a0),%%a0"  : : : "a0");
1425 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1426 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1427 +       asm("cp0ld.l    %%d4,%%d0,#1,%0"
1428 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1429 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1430 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1431 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1432 +               : : "n"(MCFCAU_MDS));
1433 +
1434 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1435 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1436 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1437 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1438 +       asm("lea        12(%%a0),%%a0"  : : : "a0");
1439 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1440 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1441 +       asm("cp0ld.l    %%d5,%%d0,#1,%0"
1442 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1443 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1444 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1445 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1446 +               : : "n"(MCFCAU_MDS));
1447 +
1448 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1449 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1450 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1451 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1452 +       asm("lea        12(%%a0),%%a0"  : : : "a0");
1453 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1454 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1455 +       asm("cp0ld.l    %%d6,%%d0,#1,%0"
1456 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1457 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1458 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1459 +       asm("cp0ld.l    %%d0,%%d0,#1,%0" : : "n"(MCFCAU_MDS));
1460 +
1461 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1462 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1463 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1464 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1465 +       asm("lea        -52(%%a0),%%a0" : : : "a0");
1466 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1467 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1468 +       asm("cp0ld.l    %%d7,%%d0,#1,%0"
1469 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1470 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1471 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1472 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1473 +               : : "n"(MCFCAU_MDS));
1474 +
1475 +
1476 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1477 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1478 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1479 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1480 +       asm("lea        12(%%a0),%%a0"  : : : "a0");
1481 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1482 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1483 +       asm("cp0ld.l    %%d4,%%d0,#1,%0"
1484 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1485 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1486 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1487 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1488 +               : : "n"(MCFCAU_MDS));
1489 +
1490 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1491 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1492 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1493 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1494 +       asm("lea        12(%%a0),%%a0"  : : : "a0");
1495 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1496 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1497 +       asm("cp0ld.l    %%d5,%%d0,#1,%0"
1498 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1499 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1500 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1501 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1502 +               : : "n"(MCFCAU_MDS));
1503 +
1504 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1505 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1506 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1507 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1508 +       asm("lea        12(%%a0),%%a0"  : : : "a0");
1509 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1510 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1511 +       asm("cp0ld.l    %%d6,%%d0,#1,%0"
1512 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1513 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1514 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1515 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1516 +               : : "n"(MCFCAU_MDS));
1517 +
1518 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1519 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1520 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1521 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1522 +       asm("lea        12(%%a0),%%a0"  : : : "a0");
1523 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1524 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1525 +       asm("cp0ld.l    %%d7,%%d0,#1,%0"
1526 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1527 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1528 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1529 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1530 +               : : "n"(MCFCAU_MDS));
1531 +
1532 +
1533 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1534 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1535 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1536 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1537 +       asm("lea        -52(%%a0),%%a0" : : : "a0");
1538 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1539 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1540 +       asm("cp0ld.l    %%d4,%%d0,#1,%0"
1541 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1542 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1543 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1544 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1545 +               : : "n"(MCFCAU_MDS));
1546 +
1547 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1548 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1549 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1550 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1551 +       asm("lea        12(%%a0),%%a0"  : : : "a0");
1552 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1553 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1554 +       asm("cp0ld.l    %%d5,%%d0,#1,%0"
1555 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1556 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1557 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1558 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1559 +               : : "n"(MCFCAU_MDS));
1560 +
1561 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1562 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1563 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1564 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1565 +       asm("lea        12(%%a0),%%a0"  : : : "a0");
1566 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1567 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1568 +       asm("cp0ld.l    %%d6,%%d0,#1,%0"
1569 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1570 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1571 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1572 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1573 +               : : "n"(MCFCAU_MDS));
1574 +
1575 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1576 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1577 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1578 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1579 +       asm("lea        12(%%a0),%%a0"  : : : "a0");
1580 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1581 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1582 +       asm("cp0ld.l    %%d7,%%d0,#1,%0"
1583 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1584 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1585 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1586 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1587 +               : : "n"(MCFCAU_MDS));
1588 +
1589 +
1590 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1591 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1592 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1593 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1594 +       asm("lea        12(%%a0),%%a0"  : : : "a0");
1595 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1596 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1597 +       asm("cp0ld.l    %%d4,%%d0,#1,%0"
1598 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1599 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1600 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1601 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1602 +               : : "n"(MCFCAU_MDS));
1603 +
1604 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1605 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1606 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1607 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1608 +       asm("lea        12(%%a0),%%a0"  : : : "a0");
1609 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1610 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1611 +       asm("cp0ld.l    %%d5,%%d0,#1,%0"
1612 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1613 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1614 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1615 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1616 +               : : "n"(MCFCAU_MDS));
1617 +
1618 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1619 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1620 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1621 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1622 +       asm("lea        -52(%%a0),%%a0" : : : "a0");
1623 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1624 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1625 +       asm("cp0ld.l    %%d6,%%d0,#1,%0"
1626 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1627 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1628 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1629 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1630 +               : : "n"(MCFCAU_MDS));
1631 +
1632 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1633 +               : : "n"(MCFCAU_HASH+MCFCAU_HFH));
1634 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1635 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1636 +       asm("lea        -8(%%a0),%%a0"  : : : "a0");
1637 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1638 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1639 +       asm("cp0ld.l    %%d7,%%d0,#1,%0"
1640 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1641 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1642 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1643 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1644 +               : : "n"(MCFCAU_MDS));
1645 +
1646 +       /* Round 4 */
1647 +       asm("moveq.l    #6, %%d4" : : : "d4");  /* for rotating by 6 */
1648 +       asm("moveq.l    #10, %%d5" : : : "d5"); /* for rotating by 10 */
1649 +       asm("moveq.l    #15, %%d6" : : : "d6"); /* for rotating by 15 */
1650 +       asm("moveq.l    #21, %%d7" : : : "d7"); /* for rotating by 21 */
1651 +
1652 +
1653 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1654 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1655 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1656 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1657 +       asm("lea        28(%%a0),%%a0"  : : : "a0");
1658 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1659 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1660 +       asm("cp0ld.l    %%d4,%%d0,#1,%0"
1661 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1662 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1663 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1664 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1665 +               : : "n"(MCFCAU_MDS));
1666 +
1667 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1668 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1669 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1670 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1671 +       asm("lea        28(%%a0),%%a0"  : : : "a0");
1672 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1673 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1674 +       asm("cp0ld.l    %%d5,%%d0,#1,%0"
1675 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1676 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1677 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1678 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1679 +               : : "n"(MCFCAU_MDS));
1680 +
1681 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1682 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1683 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1684 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1685 +       asm("lea        -36(%%a0),%%a0" : : : "a0");
1686 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1687 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1688 +       asm("cp0ld.l    %%d6,%%d0,#1,%0"
1689 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1690 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1691 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1692 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1693 +               : : "n"(MCFCAU_MDS));
1694 +
1695 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1696 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1697 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1698 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1699 +       asm("lea        28(%%a0),%%a0"  : : : "a0");
1700 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1701 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1702 +       asm("cp0ld.l    %%d7,%%d0,#1,%0"
1703 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1704 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1705 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1706 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1707 +               : : "n"(MCFCAU_MDS));
1708 +
1709 +
1710 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1711 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1712 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1713 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1714 +       asm("lea        -36(%%a0),%%a0" : : : "a0");
1715 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1716 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1717 +       asm("cp0ld.l    %%d4,%%d0,#1,%0"
1718 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1719 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1720 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1721 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1722 +               : : "n"(MCFCAU_MDS));
1723 +
1724 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1725 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1726 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1727 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1728 +       asm("lea        28(%%a0),%%a0"  : : : "a0");
1729 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1730 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1731 +       asm("cp0ld.l    %%d5,%%d0,#1,%0"
1732 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1733 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1734 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1735 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1736 +               : : "n"(MCFCAU_MDS));
1737 +
1738 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1739 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1740 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1741 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1742 +       asm("lea        -36(%%a0),%%a0" : : : "a0");
1743 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1744 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1745 +       asm("cp0ld.l    %%d6,%%d0,#1,%0"
1746 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1747 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1748 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1749 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1750 +               : : "n"(MCFCAU_MDS));
1751 +
1752 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1753 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1754 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1755 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1756 +       asm("lea        28(%%a0),%%a0"  : : : "a0");
1757 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1758 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1759 +       asm("cp0ld.l    %%d7,%%d0,#1,%0"
1760 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1761 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1762 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1763 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1764 +               : : "n"(MCFCAU_MDS));
1765 +
1766 +
1767 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1768 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1769 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1770 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1771 +       asm("lea        28(%%a0),%%a0"  : : : "a0");
1772 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1773 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1774 +       asm("cp0ld.l    %%d4,%%d0,#1,%0"
1775 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1776 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1777 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1778 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1779 +               : : "n"(MCFCAU_MDS));
1780 +
1781 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1782 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1783 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1784 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1785 +       asm("lea        -36(%%a0),%%a0" : : : "a0");
1786 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1787 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1788 +       asm("cp0ld.l    %%d5,%%d0,#1,%0"
1789 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1790 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1791 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1792 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1793 +               : : "n"(MCFCAU_MDS));
1794 +
1795 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1796 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1797 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1798 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1799 +       asm("lea        28(%%a0),%%a0"  : : : "a0");
1800 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1801 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1802 +       asm("cp0ld.l    %%d6,%%d0,#1,%0"
1803 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1804 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1805 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1806 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1807 +               : : "n"(MCFCAU_MDS));
1808 +
1809 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1810 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1811 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1812 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1813 +       asm("lea        -36(%%a0),%%a0" : : : "a0");
1814 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1815 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1816 +       asm("cp0ld.l    %%d7,%%d0,#1,%0"
1817 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1818 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1819 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1820 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1821 +               : : "n"(MCFCAU_MDS));
1822 +
1823 +
1824 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1825 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1826 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1827 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1828 +       asm("lea        28(%%a0),%%a0"
1829 +               : : : "a0");
1830 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1831 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1832 +       asm("cp0ld.l    %%d4,%%d0,#1,%0"
1833 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1834 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1835 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1836 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1837 +               : : "n"(MCFCAU_MDS));
1838 +
1839 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1840 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1841 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1842 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1843 +       asm("lea        -36(%%a0),%%a0"
1844 +               : : : "a0");
1845 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1846 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1847 +       asm("cp0ld.l    %%d5,%%d0,#1,%0"
1848 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1849 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1850 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1851 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1852 +               : : "n"(MCFCAU_MDS));
1853 +
1854 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1855 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1856 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1857 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1858 +       asm("lea        28(%%a0),%%a0"
1859 +               : : : "a0");
1860 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1861 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1862 +       asm("cp0ld.l    %%d6,%%d0,#1,%0"
1863 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1864 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1865 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1866 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1867 +               : : "n"(MCFCAU_MDS));
1868 +
1869 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1870 +               : : "n"(MCFCAU_HASH+MCFCAU_HFI));
1871 +       asm("cp0ld.l    (%%a0),%%d0,#1,%0"
1872 +               : : "n"(MCFCAU_RADR+MCFCAU_CAA) : "a0");
1873 +       asm("lea        28(%%a0),%%a0"          : : : "a0");
1874 +       asm("cp0ld.l    (%%a3)+,%%d0,#1,%0"
1875 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a3");
1876 +       asm("cp0ld.l    %%d7,%%d0,#1,%0"
1877 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA));
1878 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1879 +               : : "n"(MCFCAU_ADRA+MCFCAU_CA1));
1880 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
1881 +               : : "n"(MCFCAU_MDS));
1882 +
1883 +
1884 +       asm("move.l     %0, %%a1" : : "m"(hash) : "a1");
1885 +
1886 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
1887 +               : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a1");/*a*/
1888 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
1889 +               : : "n"(MCFCAU_ADR+MCFCAU_CA1) : "a1");/*b*/
1890 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
1891 +               : : "n"(MCFCAU_ADR+MCFCAU_CA2) : "a1");/*c*/
1892 +       asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
1893 +               : : "n"(MCFCAU_ADR+MCFCAU_CA3) : "a1");/*d*/
1894 +
1895 +       asm("cp0st.l    %%d0,-(%%a1),#1,%0"
1896 +               : : "n"(MCFCAU_STR+MCFCAU_CA3) : "a1");/*d*/
1897 +       asm("cp0st.l    %%d0,-(%%a1),#1,%0"
1898 +               : : "n"(MCFCAU_STR+MCFCAU_CA2) : "a1");/*c*/
1899 +       asm("cp0st.l    %%d0,-(%%a1),#1,%0"
1900 +               : : "n"(MCFCAU_STR+MCFCAU_CA1) : "a1");/*b*/
1901 +       asm("cp0st.l    %%d0,-(%%a1),#1,%0"
1902 +               : : "n"(MCFCAU_STR+MCFCAU_CAA) : "a1");/*a*/
1903 +       spin_unlock_irqrestore(&mcfcau_lock, iflags);
1904 +}
1905 +
1906 +static inline void le32_to_cpu_array(u32 *buf, unsigned int words)
1907 +{
1908 +       while (words--) {
1909 +               __le32_to_cpus(buf);
1910 +               buf++;
1911 +       }
1912 +}
1913 +
1914 +static inline void cpu_to_le32_array(u32 *buf, unsigned int words)
1915 +{
1916 +       while (words--) {
1917 +               __cpu_to_le32s(buf);
1918 +               buf++;
1919 +       }
1920 +}
1921 +
1922 +static int mcfcau_md5_initialization(struct shash_desc *desc)
1923 +{
1924 +       struct mcfcau_md5_ctx *mctx = shash_desc_ctx(desc);
1925 +
1926 +       DBG("mcfcau_md5_initialization\n");
1927 +       mctx->hash[0] = 0x67452301;
1928 +       mctx->hash[1] = 0xefcdab89;
1929 +       mctx->hash[2] = 0x98badcfe;
1930 +       mctx->hash[3] = 0x10325476;
1931 +       mctx->byte_count = 0;
1932 +
1933 +       return 0;
1934 +}
1935 +
1936 +static int mcfcau_md5_update(struct shash_desc *desc,
1937 +               const u8 *data, unsigned int len)
1938 +{
1939 +       struct mcfcau_md5_ctx *mctx = shash_desc_ctx(desc);
1940 +       const u32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
1941 +
1942 +       DBG("mcfcau_md5_update\n");
1943 +       mctx->byte_count += len;
1944 +
1945 +       if (avail > len) {
1946 +               memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
1947 +                      data, len);
1948 +       } else {
1949 +               memcpy((char *)mctx->block +
1950 +                       (sizeof(mctx->block) - avail), data, avail);
1951 +
1952 +               mcfcau_md5_transform(mctx->hash, mctx->block);
1953 +               data += avail;
1954 +               len -= avail;
1955 +
1956 +               while (len >= sizeof(mctx->block)) {
1957 +                       memcpy(mctx->block, data, sizeof(mctx->block));
1958 +                       mcfcau_md5_transform(mctx->hash, mctx->block);
1959 +                       data += sizeof(mctx->block);
1960 +                       len -= sizeof(mctx->block);
1961 +               }
1962 +
1963 +               memcpy(mctx->block, data, len);
1964 +       }
1965 +
1966 +       return 0;
1967 +}
1968 +
1969 +static int mcfcau_md5_final(struct shash_desc *desc, u8 *out)
1970 +{
1971 +       struct mcfcau_md5_ctx *mctx = shash_desc_ctx(desc);
1972 +       const unsigned int offset = mctx->byte_count & 0x3f;
1973 +       char *p = (char *)mctx->block + offset;
1974 +       int padding = 56 - (offset + 1);
1975 +
1976 +       DBG("mcfcau_md5_final\n");
1977 +
1978 +       *p++ = 0x80;
1979 +       if (padding < 0) {
1980 +               memset(p, 0x00, padding + sizeof(u64));
1981 +               mcfcau_md5_transform(mctx->hash, mctx->block);
1982 +               p = (char *)mctx->block;
1983 +               padding = 56;
1984 +       }
1985 +
1986 +       memset(p, 0, padding);
1987 +       mctx->block[14] = mctx->byte_count << 3;
1988 +       mctx->block[15] = mctx->byte_count >> 29;
1989 +       le32_to_cpu_array(&mctx->block[14], 2);
1990 +
1991 +       mcfcau_md5_transform(mctx->hash, mctx->block);
1992 +
1993 +       cpu_to_le32_array(mctx->hash, sizeof(mctx->hash) / sizeof(u32));
1994 +       memcpy(out, mctx->hash, sizeof(mctx->hash));
1995 +       memset(mctx, 0, sizeof(*mctx));
1996 +
1997 +       return 0;
1998 +}
1999 +
2000 +static struct shash_alg mcfcau_md5_alg = {
2001 +       .init = mcfcau_md5_initialization,
2002 +       .update = mcfcau_md5_update,
2003 +       .final = mcfcau_md5_final,
2004 +       .digestsize = MCFCAU_MD5_DIGEST_SIZE,
2005 +       .descsize = sizeof(struct mcfcau_md5_ctx),
2006 +       .statesize = sizeof(struct mcfcau_md5_ctx),
2007 +       .base = {
2008 +               .cra_name = "md5",
2009 +               .cra_driver_name = "md5-mcfcau",
2010 +               .cra_blocksize = MCFCAU_MD5_HMAC_BLOCK_SIZE,
2011 +               .cra_flags = CRYPTO_ALG_TYPE_SHASH,
2012 +               .cra_priority = MCFCAU_CRA_PRIORITY,
2013 +               .cra_module = THIS_MODULE
2014 +       }
2015 +};
2016 +
2017 +static int __init mcfcau_md5_init(void)
2018 +{
2019 +       int ret = 0;
2020 +
2021 +       ret = crypto_register_shash(&mcfcau_md5_alg);
2022 +       printk(KERN_INFO MCFCAU_MD5_DRIVER_DESC " "
2023 +               MCFCAU_MD5_DRIVER_VERSION " %s.\n",
2024 +               ret ? "failed" : "registered");
2025 +       return ret;
2026 +}
2027 +
2028 +static void __exit mcfcau_md5_exit(void)
2029 +{
2030 +       crypto_unregister_shash(&mcfcau_md5_alg);
2031 +       printk(KERN_INFO MCFCAU_MD5_DRIVER_DESC " "
2032 +               MCFCAU_MD5_DRIVER_VERSION " unregistered.\n");
2033 +}
2034 +
2035 +module_init(mcfcau_md5_init);
2036 +module_exit(mcfcau_md5_exit);
2037 +
2038 +MODULE_LICENSE("GPL");
2039 +MODULE_DESCRIPTION(MCFCAU_MD5_DRIVER_DESC);
2040 +MODULE_AUTHOR("Andrey Butok");
2041 --- /dev/null
2042 +++ b/drivers/crypto/mcfcau-sha1.c
2043 @@ -0,0 +1,331 @@
2044 +/***************************************************************************
2045 + * mcfcau-sha1.c - Implementation of SHA1 Secure Hash Algorithm
2046 + *                for Freescale ColdFire Cryptographic Acceleration Unit (CAU).
2047 + *
2048 + * Copyright (C) 2007-2011 Freescale Semiconductor, Inc. All Rights Reserved.
2049 + * Author: Andrey Butok
2050 + *         Shrek Wu B16972@freescale.com
2051 + *         Alison Wang b18965@freescale.com
2052 + *
2053 + * NOTE: You can find the ColdFire CAU module on MCF5445X and MCF52235.
2054 + *
2055 + * This program is free software; you can redistribute it and/or modify it
2056 + * under the terms of the GNU General Public License as published by the
2057 + * Free Software Foundation; either version 2 of the License, or (at your
2058 + * option) any later version.
2059 + *
2060 + * This program is distributed in the hope that it will be useful, but
2061 + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
2062 + * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
2063 + * for more details.
2064 + *
2065 + * You should have received a copy of the GNU General Public License
2066 + * along with this program; if not, write to the Free Software Foundation,
2067 + * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
2068 + *
2069 + ***************************************************************************
2070 + * Changes:
2071 + * v0.01       15 October 2007 Andrey Butok
2072 + *             Initial Release - developed on 2.6.20 Linux kernel.
2073 + */
2074 +
2075 +#include <linux/init.h>
2076 +#include <linux/module.h>
2077 +#include <linux/mm.h>
2078 +#include <linux/crypto.h>
2079 +#include <linux/types.h>
2080 +#include <crypto/algapi.h>
2081 +#include <crypto/hash.h>
2082 +#include <crypto/internal/hash.h>
2083 +
2084 +#include "mcfcau.h"
2085 +
2086 +#define MCFCAU_SHA1_DIGEST_WORDS       (5)
2087 +#define MCFCAU_SHA1_WORKSPACE_WORDS    (80)
2088 +
2089 +#define MCFCAU_SHA1_DIGEST_SIZE                (20)
2090 +#define MCFCAU_SHA1_HMAC_BLOCK_SIZE    (64)
2091 +
2092 +#define        MCFCAU_SHA1_DRIVER_DESC         "SHA1 ColdFire CAU driver"
2093 +#define        MCFCAU_SHA1_DRIVER_VERSION      "v0.01"
2094 +
2095 +static const u32 K[4] = {0x5A827999L,  /* Rounds  0-19: sqrt(2) * 2^30 */
2096 +                       0x6ED9EBA1L,    /* Rounds 20-39: sqrt(3) * 2^30 */
2097 +                       0x8F1BBCDCL,    /* Rounds 40-59: sqrt(5) * 2^30 */
2098 +                       0xCA62C1D6L};   /* Rounds 60-79: sqrt(10) * 2^30 */
2099 +
2100 +struct mcfcau_sha1_ctx {
2101 +       u64 count;
2102 +       u32 state[5];
2103 +       u8 buffer[64];
2104 +};
2105 +
2106 +static void mcfcau_sha1_transform(__u32 *digest, const char *in, __u32 *W)
2107 +{
2108 +       int i;
2109 +       u32 *tmp_p;
2110 +       unsigned long iflags;
2111 +
2112 +       /* (a) Devide M(i) into 16 words W */
2113 +       for (i = 0; i < 16; i++)
2114 +               W[i] = ((const u32 *)in)[i];
2115 +
2116 +       /* (b) W[i+16] = S^1(W[i+13] ^ W[i+8] ^ W[i+2] ^ W[i]) */
2117 +       tmp_p = &W[16];
2118 +
2119 +       spin_lock_irqsave(&mcfcau_lock, iflags);
2120 +       asm("move.l     %0, %%a0" : : "m"(tmp_p) : "a0");
2121 +       asm("moveq.l    #1, %%d3" : : : "d3");
2122 +
2123 +       for (i = 0; i < 64; i++) {
2124 +               asm("cp0ld.l    -64(%%a0),%%d0,#1,%0"
2125 +                       : : "n"(MCFCAU_LDR+MCFCAU_CA0));
2126 +               asm("cp0ld.l    -56(%%a0),%%d0,#1,%0"
2127 +                       : : "n"(MCFCAU_XOR+MCFCAU_CA0));
2128 +               asm("cp0ld.l    -32(%%a0),%%d0,#1,%0"
2129 +                       : : "n"(MCFCAU_XOR+MCFCAU_CA0));
2130 +               asm("cp0ld.l    -12(%%a0),%%d0,#1,%0"
2131 +                       : : "n"(MCFCAU_XOR+MCFCAU_CA0));
2132 +               asm("cp0ld.l    %%d3,%%d0,#1,%0"
2133 +                       : : "n"(MCFCAU_ROTL+MCFCAU_CA0) : "d3");
2134 +               asm("cp0st.l    %%d0,(%%a0)+,#1,%0"
2135 +                       : : "n"(MCFCAU_STR+MCFCAU_CA0));
2136 +       }
2137 +
2138 +       /* (c) */
2139 +       asm("move.l     %0, %%a0" : : "m"(digest) : "a0");
2140 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
2141 +               : : "n"(MCFCAU_LDR+MCFCAU_CA0) : "a0"); /* a */
2142 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
2143 +               : : "n"(MCFCAU_LDR+MCFCAU_CA1) : "a0"); /* b */
2144 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
2145 +               : : "n"(MCFCAU_LDR+MCFCAU_CA2) : "a0"); /* c */
2146 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
2147 +               : : "n"(MCFCAU_LDR+MCFCAU_CA3) : "a0"); /* d */
2148 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
2149 +               : : "n"(MCFCAU_LDR+MCFCAU_CA4) : "a0"); /* e */
2150 +
2151 +       /* (d) */
2152 +       asm("moveq.l    #5, %%d0" : : : "d0");
2153 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
2154 +               : : "n"(MCFCAU_MVRA+MCFCAU_CA0));
2155 +       asm("cp0ld.l    %%d0,%%d0,#1,%0"
2156 +               : : "n"(MCFCAU_ROTL+MCFCAU_CAA)); /*S^5(A)*/
2157 +
2158 +       tmp_p = (u32 *)K;
2159 +       asm("move.l     %0, %%a0" : : "m"(tmp_p) : "a0");
2160 +       asm("move.l     %0, %%a1" : : "m"(W) : "a1");
2161 +
2162 +       for (i = 0; i < 20; i++) {
2163 +               /* t = f1(b, c, d) + K1 + rol32(a, 5) + e + W[i]; */
2164 +               /* e = d; d = c; c = rol32(b, 30); b = a; a = t; */
2165 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
2166 +                       : : "n"(MCFCAU_HASH+MCFCAU_HFC)); /*f(b,c,d)*/
2167 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
2168 +                       : : "n"(MCFCAU_ADRA+MCFCAU_CA4)); /*+e*/
2169 +               asm("cp0ld.l    (%%a0),%%d0,#1,%0"
2170 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA)); /*+K*/
2171 +               asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
2172 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a1"); /*+W*/
2173 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
2174 +                       : : "n"(MCFCAU_SHS));
2175 +       }
2176 +
2177 +       asm("add.l #4,%%a0"     : : : "a0"); /* update K */
2178 +
2179 +       for (; i < 40; i++) {
2180 +               /* t = f2(b, c, d) + K2 + rol32(a, 5) + e + W[i]; */
2181 +               /* e = d; d = c; c = rol32(b, 30); b = a; a = t; */
2182 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
2183 +                       : : "n"(MCFCAU_HASH+MCFCAU_HFH)); /*f(b,c,d)*/
2184 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
2185 +                       : : "n"(MCFCAU_ADRA+MCFCAU_CA4)); /*+e*/
2186 +               asm("cp0ld.l    (%%a0),%%d0,#1,%0"
2187 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA)); /*+K*/
2188 +               asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
2189 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a1"); /*+W*/
2190 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
2191 +                       : : "n"(MCFCAU_SHS));
2192 +       }
2193 +
2194 +       asm("add.l #4,%%a0"      : : : "a0"); /* update K */
2195 +
2196 +       for (; i < 60; i++) {
2197 +               /* t = f3(b, c, d) + K3 + rol32(a, 5) + e + W[i]; */
2198 +               /* e = d; d = c; c = rol32(b, 30); b = a; a = t; */
2199 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
2200 +                       : : "n"(MCFCAU_HASH+MCFCAU_HFM)); /*f(b,c,d)*/
2201 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
2202 +                       : : "n"(MCFCAU_ADRA+MCFCAU_CA4)); /*+e*/
2203 +               asm("cp0ld.l    (%%a0),%%d0,#1,%0"
2204 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA)); /*+K*/
2205 +               asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
2206 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a1"); /*+W*/
2207 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
2208 +                       : : "n"(MCFCAU_SHS));
2209 +       }
2210 +
2211 +       asm("add.l #4,%%a0"     : : : "a0"); /* update K */
2212 +
2213 +       for (; i < 80; i++) {
2214 +               /* t = f2(b, c, d) + K4 + rol32(a, 5) + e + W[i]; */
2215 +               /* e = d; d = c; c = rol32(b, 30); b = a; a = t; */
2216 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
2217 +                       : : "n"(MCFCAU_HASH+MCFCAU_HFH)); /*f(b,c,d)*/
2218 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
2219 +                       : : "n"(MCFCAU_ADRA+MCFCAU_CA4)); /*+e*/
2220 +               asm("cp0ld.l    (%%a0),%%d0,#1,%0"
2221 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA)); /*+K*/
2222 +               asm("cp0ld.l    (%%a1)+,%%d0,#1,%0"
2223 +                       : : "n"(MCFCAU_ADR+MCFCAU_CAA) : "a1"); /*+W*/
2224 +               asm("cp0ld.l    %%d0,%%d0,#1,%0"
2225 +                       : : "n"(MCFCAU_SHS));
2226 +       }
2227 +
2228 +       /* (e) */
2229 +       asm("move.l     %0, %%a0" : : "m"(digest) : "a0");
2230 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
2231 +               : : "n"(MCFCAU_ADR+MCFCAU_CA0) : "a0"); /* +a */
2232 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
2233 +               : : "n"(MCFCAU_ADR+MCFCAU_CA1) : "a0"); /* +b */
2234 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
2235 +               : : "n"(MCFCAU_ADR+MCFCAU_CA2) : "a0"); /* +c */
2236 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
2237 +               : : "n"(MCFCAU_ADR+MCFCAU_CA3) : "a0"); /* +d */
2238 +       asm("cp0ld.l    (%%a0)+,%%d0,#1,%0"
2239 +               : : "n"(MCFCAU_ADR+MCFCAU_CA4) : "a0"); /* +e */
2240 +
2241 +       asm("cp0st.l    %%d0,-(%%a0),#1,%0"
2242 +               : : "n"(MCFCAU_STR+MCFCAU_CA4) : "a0");
2243 +       asm("cp0st.l    %%d0,-(%%a0),#1,%0"
2244 +               : : "n"(MCFCAU_STR+MCFCAU_CA3) : "a0");
2245 +       asm("cp0st.l    %%d0,-(%%a0),#1,%0"
2246 +               : : "n"(MCFCAU_STR+MCFCAU_CA2) : "a0");
2247 +       asm("cp0st.l    %%d0,-(%%a0),#1,%0"
2248 +               : : "n"(MCFCAU_STR+MCFCAU_CA1) : "a0");
2249 +       asm("cp0st.l    %%d0,-(%%a0),#1,%0"
2250 +               : : "n"(MCFCAU_STR+MCFCAU_CA0) : "a0");
2251 +       spin_unlock_irqrestore(&mcfcau_lock, iflags);
2252 +}
2253 +
2254 +static int mcfcau_sha1_init(struct shash_desc *desc)
2255 +{
2256 +       struct mcfcau_sha1_ctx *sctx = shash_desc_ctx(desc);
2257 +       static const struct mcfcau_sha1_ctx initstate = {
2258 +         0,
2259 +         { 0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 },
2260 +         { 0, }
2261 +       };
2262 +
2263 +       DBG("mcfcau_sha1_init\n");
2264 +       *sctx = initstate;
2265 +
2266 +       return 0;
2267 +}
2268 +
2269 +static int mcfcau_sha1_update(struct shash_desc *desc, const u8 *data,
2270 +                               unsigned int len)
2271 +{
2272 +       struct mcfcau_sha1_ctx *sctx = shash_desc_ctx(desc);
2273 +       unsigned int partial, done;
2274 +       const u8 *src;
2275 +
2276 +       DBG("mcfcau_sha1_update\n");
2277 +       partial = sctx->count & 0x3f;
2278 +       sctx->count += len;
2279 +       done = 0;
2280 +       src = data;
2281 +
2282 +       if ((partial + len) > 63) {
2283 +               u32 temp[MCFCAU_SHA1_WORKSPACE_WORDS];
2284 +
2285 +               if (partial) {
2286 +                       done = -partial;
2287 +                       memcpy(sctx->buffer + partial, data, done + 64);
2288 +                       src = sctx->buffer;
2289 +               }
2290 +
2291 +               do {
2292 +                       mcfcau_sha1_transform(sctx->state, src, temp);
2293 +                       done += 64;
2294 +                       src = data + done;
2295 +               } while (done + 63 < len);
2296 +
2297 +               memset(temp, 0, sizeof(temp));
2298 +               partial = 0;
2299 +       }
2300 +       memcpy(sctx->buffer + partial, src, len - done);
2301 +       return 0;
2302 +}
2303 +
2304 +
2305 +/* Add padding and return the message digest. */
2306 +static int mcfcau_sha1_final(struct shash_desc *desc, u8 *out)
2307 +{
2308 +       struct mcfcau_sha1_ctx *sctx = shash_desc_ctx(desc);
2309 +       u32 *dst = (u32 *)out;
2310 +       u32 i, index, padlen;
2311 +       u64 bits;
2312 +       static const u8 padding[64] = { 0x80, };
2313 +
2314 +       DBG("mcfcau_sha1_final\n");
2315 +       bits = sctx->count << 3;
2316 +
2317 +       /* Pad out to 56 mod 64 */
2318 +       index = sctx->count & 0x3f;
2319 +       padlen = (index < 56) ? (56 - index) : ((64+56) - index);
2320 +       mcfcau_sha1_update(desc, padding, padlen);
2321 +
2322 +       /* Append length */
2323 +       mcfcau_sha1_update(desc, (const u8 *)&bits, sizeof(bits));
2324 +
2325 +       /* Store state in digest */
2326 +       for (i = 0; i < 5; i++)
2327 +               dst[i] = sctx->state[i];
2328 +
2329 +       /* Wipe context */
2330 +       memset(sctx, 0, sizeof *sctx);
2331 +
2332 +       return 0;
2333 +}
2334 +
2335 +static struct shash_alg mcfcau_sha1_alg = {
2336 +       .init           =       mcfcau_sha1_init,
2337 +       .update         =       mcfcau_sha1_update,
2338 +       .final          =       mcfcau_sha1_final,
2339 +       .digestsize     =       MCFCAU_SHA1_DIGEST_SIZE,
2340 +       .descsize       =       sizeof(struct mcfcau_sha1_ctx),
2341 +       .statesize      =       sizeof(struct mcfcau_sha1_ctx),
2342 +       .base   =       {
2343 +               .cra_name        =      "sha1",
2344 +               .cra_driver_name =      "sha1-mcfcau",
2345 +               .cra_priority    =      MCFCAU_CRA_PRIORITY,
2346 +               .cra_flags       =      CRYPTO_ALG_TYPE_SHASH,
2347 +               .cra_blocksize   =      MCFCAU_SHA1_HMAC_BLOCK_SIZE,
2348 +               .cra_module      =      THIS_MODULE,
2349 +               .cra_alignmask   =      3,
2350 +       }
2351 +};
2352 +
2353 +static int __init init(void)
2354 +{
2355 +       int ret = crypto_register_shash(&mcfcau_sha1_alg);
2356 +       printk(KERN_INFO MCFCAU_SHA1_DRIVER_DESC " "
2357 +               MCFCAU_SHA1_DRIVER_VERSION " %s.\n",
2358 +               ret ? "failed" : "registered");
2359 +       return ret;
2360 +}
2361 +
2362 +static void __exit fini(void)
2363 +{
2364 +       crypto_unregister_shash(&mcfcau_sha1_alg);
2365 +       printk(KERN_INFO MCFCAU_SHA1_DRIVER_DESC " "
2366 +               MCFCAU_SHA1_DRIVER_VERSION " unregistered.\n");
2367 +}
2368 +
2369 +module_init(init);
2370 +module_exit(fini);
2371 +
2372 +MODULE_LICENSE("GPL");
2373 +MODULE_DESCRIPTION(MCFCAU_SHA1_DRIVER_DESC);
2374 +MODULE_AUTHOR("Andrey Butok");
2375 --- /dev/null
2376 +++ b/drivers/crypto/mcfcau.c
2377 @@ -0,0 +1,33 @@
2378 +/***************************************************************************
2379 + * mcfcau.c - Implementation of DES & Triple DES EDE Cipher Algorithms
2380 + *                for Freescale ColdFire Cryptographic Acceleration Unit (CAU).
2381 + *
2382 + * Copyright (C) 2007-2011 Freescale Semiconductor Inc. All Rights Reserved.
2383 + * Author: Andrey Butok
2384 + *         Shrek Wu B16972@freescale.com
2385 + *
2386 + * NOTE: You can find the ColdFire CAU module on MCF5445X and MCF52235.
2387 + *
2388 + * This program is free software; you can redistribute it and/or modify it
2389 + * under the terms of the GNU General Public License as published by the
2390 + * Free Software Foundation; either version 2 of the License, or (at your
2391 + * option) any later version.
2392 + *
2393 + * This program is distributed in the hope that it will be useful, but
2394 + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
2395 + * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
2396 + * for more details.
2397 + *
2398 + * You should have received a copy of the GNU General Public License
2399 + * along with this program; if not, write to the Free Software Foundation,
2400 + * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
2401 + *
2402 + ***************************************************************************
2403 + * Changes:
2404 + * v0.01       28 September 2006       Andrey Butok
2405 + *             Initial Release - developed on 2.6.20 Linux kernel.
2406 + */
2407 +#include <linux/module.h>
2408 +
2409 +DEFINE_SPINLOCK(mcfcau_lock);
2410 +EXPORT_SYMBOL(mcfcau_lock);
2411 --- /dev/null
2412 +++ b/drivers/crypto/mcfcau.h
2413 @@ -0,0 +1,101 @@
2414 +/***************************************************************************
2415 + * mcfcau.h - Common header file for Freescale ColdFire
2416 + *            Cryptographic Acceleration Unit (CAU) drivers.
2417 + *
2418 + * Copyright (C) 2007-2011 Freescale Semiconductor, Inc. All Rights Reserved.
2419 + * Author: Andrey Butok
2420 + *         Shrek Wu B16972@freescale.com
2421 + *
2422 + * NOTE: You can find the ColdFire CAU module on MCF5445X and MCF52235.
2423 + *
2424 + * This program is free software; you can redistribute it and/or modify it
2425 + * under the terms of the GNU General Public License as published by the
2426 + * Free Software Foundation; either version 2 of the License, or (at your
2427 + * option) any later version.
2428 + *
2429 + * This program is distributed in the hope that it will be useful, but
2430 + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
2431 + * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
2432 + * for more details.
2433 + *
2434 + * You should have received a copy of the GNU General Public License
2435 + * along with this program; if not, write to the Free Software Foundation,
2436 + * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
2437 + *
2438 + ***************************************************************************
2439 + * Changes:
2440 + * v0.01       14 August 2007  Andrey Butok
2441 + */
2442 +
2443 +#ifndef MCFCAU_H
2444 +#define MCFCAU_H
2445 +
2446 +#include <linux/spinlock.h>
2447 +
2448 +/* CAU Registers (CAx) */
2449 +#define MCFCAU_CASR            (0x0)
2450 +#define MCFCAU_CAA             (0x1)
2451 +#define MCFCAU_CA0             (0x2)
2452 +#define MCFCAU_CA1             (0x3)
2453 +#define MCFCAU_CA2             (0x4)
2454 +#define MCFCAU_CA3             (0x5)
2455 +#define MCFCAU_CA4             (0x6)
2456 +#define MCFCAU_CA5             (0x7)
2457 +
2458 + /* CAU Commands */
2459 +#define MCFCAU_CNOP            (0x000)
2460 +#define MCFCAU_LDR             (0x010)
2461 +#define MCFCAU_STR             (0x020)
2462 +#define MCFCAU_ADR             (0x030)
2463 +#define MCFCAU_RADR            (0x040)
2464 +#define MCFCAU_ADRA            (0x050)
2465 +#define MCFCAU_XOR             (0x060)
2466 +#define MCFCAU_ROTL            (0x070)
2467 +#define MCFCAU_MVRA            (0x080)
2468 +#define MCFCAU_MVAR            (0x090)
2469 +#define MCFCAU_AESS            (0x0A0)
2470 +#define MCFCAU_AESIS           (0x0B0)
2471 +#define MCFCAU_AESC            (0x0C0)
2472 +#define MCFCAU_AESIC           (0x0D0)
2473 +#define MCFCAU_AESR            (0x0E0)
2474 +#define MCFCAU_AESIR           (0x0F0)
2475 +#define MCFCAU_DESR            (0x100)
2476 +#define MCFCAU_DESK            (0x110)
2477 +#define MCFCAU_HASH            (0x120)
2478 +#define MCFCAU_SHS             (0x130)
2479 +#define MCFCAU_MDS             (0x140)
2480 +#define MCFCAU_ILL             (0x1F0)
2481 +
2482 +/* DESR Fields */
2483 +#define MCFCAU_IP              (0x08)  /* initial permutation */
2484 +#define MCFCAU_FP              (0x04)  /* final permutation */
2485 +#define MCFCAU_KSL1            (0x00)  /* key schedule left 1 bit */
2486 +#define MCFCAU_KSL2            (0x01)  /* key schedule left 2 bits */
2487 +#define MCFCAU_KSR1            (0x02)  /* key schedule right 1 bit */
2488 +#define MCFCAU_KSR2            (0x03)  /* key schedule right 2 bits */
2489 +
2490 +/* DESK Field */
2491 +#define MCFCAU_DC              (0x01)  /* decrypt key schedule */
2492 +#define MCFCAU_CP              (0x02)  /* check parity */
2493 +
2494 +/* HASH Functions Codes */
2495 +#define MCFCAU_HFF             (0x0)   /* MD5 F() CA1&CA2 | ~CA1&CA3 */
2496 +#define MCFCAU_HFG             (0x1)   /* MD5 G() CA1&CA3 | CA2&~CA3 */
2497 +#define MCFCAU_HFH             (0x2)   /* MD5 H(), SHA Parity() CA1^CA2^CA3 */
2498 +#define MCFCAU_HFI             (0x3)   /* MD5 I() CA2^(CA1|~CA3) */
2499 +#define MCFCAU_HFC             (0x4)   /* SHA Ch() CA1&CA2 ^ ~CA1&CA3 */
2500 +#define MCFCAU_HFM             (0x5)
2501 +/* SHA Maj() CA1&CA2 ^ CA1&CA3 ^ CA2&CA3 */
2502 +
2503 +#define MCFCAU_CRA_PRIORITY    (300)
2504 +
2505 +extern spinlock_t mcfcau_lock;
2506 +
2507 +#ifdef DEBUG
2508 +#define DBG(fmt, args...) printk(KERN_INFO "[%s]  " fmt ,\
2509 +                       __func__, ## args)
2510 +#else
2511 +#define DBG(fmt, args...) do {} while (0)
2512 +#endif
2513 +
2514 +#endif